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. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/csky.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
107 #include "elf/epiphany.h"
108 #include "elf/fr30.h"
110 #include "elf/ft32.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/s12z.h"
126 #include "elf/mcore.h"
128 #include "elf/metag.h"
129 #include "elf/microblaze.h"
130 #include "elf/mips.h"
131 #include "elf/mmix.h"
132 #include "elf/mn10200.h"
133 #include "elf/mn10300.h"
134 #include "elf/moxie.h"
136 #include "elf/msp430.h"
137 #include "elf/nds32.h"
139 #include "elf/nios2.h"
140 #include "elf/or1k.h"
143 #include "elf/ppc64.h"
145 #include "elf/riscv.h"
146 #include "elf/rl78.h"
148 #include "elf/s390.h"
149 #include "elf/score.h"
151 #include "elf/sparc.h"
153 #include "elf/tic6x.h"
154 #include "elf/tilegx.h"
155 #include "elf/tilepro.h"
156 #include "elf/v850.h"
158 #include "elf/visium.h"
159 #include "elf/wasm32.h"
160 #include "elf/x86-64.h"
161 #include "elf/xc16x.h"
162 #include "elf/xgate.h"
163 #include "elf/xstormy16.h"
164 #include "elf/xtensa.h"
168 #include "libiberty.h"
169 #include "safe-ctype.h"
170 #include "filenames.h"
173 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
176 typedef struct elf_section_list
178 Elf_Internal_Shdr
* hdr
;
179 struct elf_section_list
* next
;
182 /* Flag bits indicating particular types of dump. */
183 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
184 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
187 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
190 typedef unsigned char dump_type
;
192 /* A linked list of the section names for which dumps were requested. */
193 struct dump_list_entry
197 struct dump_list_entry
* next
;
200 typedef struct filedata
202 const char * file_name
;
204 bfd_size_type file_size
;
205 Elf_Internal_Ehdr file_header
;
206 Elf_Internal_Shdr
* section_headers
;
207 Elf_Internal_Phdr
* program_headers
;
209 unsigned long string_table_length
;
210 /* A dynamic array of flags indicating for which sections a dump of
211 some kind has been requested. It is reset on a per-object file
212 basis and then initialised from the cmdline_dump_sects array,
213 the results of interpreting the -w switch, and the
214 dump_sects_byname list. */
215 dump_type
* dump_sects
;
216 unsigned int num_dump_sects
;
219 char * program_name
= "readelf";
221 static unsigned long archive_file_offset
;
222 static unsigned long archive_file_size
;
223 static unsigned long dynamic_addr
;
224 static bfd_size_type dynamic_size
;
225 static size_t dynamic_nent
;
226 static char * dynamic_strings
;
227 static unsigned long dynamic_strings_length
;
228 static unsigned long num_dynamic_syms
;
229 static bfd_size_type nbuckets
;
230 static bfd_size_type nchains
;
231 static bfd_vma
*buckets
;
232 static bfd_vma
*chains
;
233 static bfd_vma ngnubuckets
;
234 static bfd_vma
*gnubuckets
;
235 static bfd_vma
*gnuchains
;
236 static bfd_vma
*mipsxlat
;
237 static bfd_size_type ngnuchains
;
238 static bfd_vma gnusymidx
;
239 static Elf_Internal_Sym
* dynamic_symbols
;
240 static Elf_Internal_Syminfo
* dynamic_syminfo
;
241 static unsigned long dynamic_syminfo_offset
;
242 static unsigned int dynamic_syminfo_nent
;
243 static char program_interpreter
[PATH_MAX
];
244 static bfd_vma dynamic_info
[DT_ENCODING
];
245 static bfd_vma dynamic_info_DT_GNU_HASH
;
246 static bfd_vma dynamic_info_DT_MIPS_XHASH
;
247 static bfd_vma version_info
[16];
248 static Elf_Internal_Dyn
* dynamic_section
;
249 static elf_section_list
* symtab_shndx_list
;
250 static bfd_boolean show_name
= FALSE
;
251 static bfd_boolean do_dynamic
= FALSE
;
252 static bfd_boolean do_syms
= FALSE
;
253 static bfd_boolean do_dyn_syms
= FALSE
;
254 static bfd_boolean do_reloc
= FALSE
;
255 static bfd_boolean do_sections
= FALSE
;
256 static bfd_boolean do_section_groups
= FALSE
;
257 static bfd_boolean do_section_details
= FALSE
;
258 static bfd_boolean do_segments
= FALSE
;
259 static bfd_boolean do_unwind
= FALSE
;
260 static bfd_boolean do_using_dynamic
= FALSE
;
261 static bfd_boolean do_header
= FALSE
;
262 static bfd_boolean do_dump
= FALSE
;
263 static bfd_boolean do_version
= FALSE
;
264 static bfd_boolean do_histogram
= FALSE
;
265 static bfd_boolean do_debugging
= FALSE
;
266 static bfd_boolean do_ctf
= FALSE
;
267 static bfd_boolean do_arch
= FALSE
;
268 static bfd_boolean do_notes
= FALSE
;
269 static bfd_boolean do_archive_index
= FALSE
;
270 static bfd_boolean is_32bit_elf
= FALSE
;
271 static bfd_boolean decompress_dumps
= FALSE
;
273 static char *dump_ctf_parent_name
;
274 static char *dump_ctf_symtab_name
;
275 static char *dump_ctf_strtab_name
;
279 struct group_list
* next
;
280 unsigned int section_index
;
285 struct group_list
* root
;
286 unsigned int group_index
;
289 static size_t group_count
;
290 static struct group
* section_groups
;
291 static struct group
** section_headers_groups
;
293 /* A dynamic array of flags indicating for which sections a dump
294 has been requested via command line switches. */
295 static Filedata cmdline
;
297 static struct dump_list_entry
* dump_sects_byname
;
299 /* How to print a vma value. */
300 typedef enum print_mode
312 /* Versioned symbol info. */
313 enum versioned_symbol_info
320 static const char * get_symbol_version_string
321 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
322 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
326 #define SECTION_NAME(X) \
327 ((X) == NULL ? _("<none>") \
328 : filedata->string_table == NULL ? _("<no-strings>") \
329 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
330 : filedata->string_table + (X)->sh_name))
332 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
334 #define GET_ELF_SYMBOLS(file, section, sym_count) \
335 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
336 : get_64bit_elf_symbols (file, section, sym_count))
338 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
339 (strtab != NULL && offset < strtab_size)
340 #define VALID_DYNAMIC_NAME(offset) \
341 VALID_SYMBOL_NAME (dynamic_strings, dynamic_strings_length, offset)
342 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
343 already been called and verified that the string exists. */
344 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
346 #define REMOVE_ARCH_BITS(ADDR) \
349 if (filedata->file_header.e_machine == EM_ARM) \
354 /* Get the correct GNU hash section name. */
355 #define GNU_HASH_SECTION_NAME \
356 dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
358 /* Print a BFD_VMA to an internal buffer, for use in error messages.
359 BFD_FMA_FMT can't be used in translated strings. */
362 bfd_vmatoa (char *fmtch
, bfd_vma value
)
364 /* bfd_vmatoa is used more then once in a printf call for output.
365 Cycle through an array of buffers. */
366 static int buf_pos
= 0;
367 static struct bfd_vmatoa_buf
374 ret
= buf
[buf_pos
++].place
;
375 buf_pos
%= ARRAY_SIZE (buf
);
377 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
378 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
382 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
383 OFFSET + the offset of the current archive member, if we are examining an
384 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
385 allocate a buffer using malloc and fill that. In either case return the
386 pointer to the start of the retrieved data or NULL if something went wrong.
387 If something does go wrong and REASON is not NULL then emit an error
388 message using REASON as part of the context. */
391 get_data (void * var
,
393 unsigned long offset
,
399 bfd_size_type amt
= size
* nmemb
;
401 if (size
== 0 || nmemb
== 0)
404 /* If the size_t type is smaller than the bfd_size_type, eg because
405 you are building a 32-bit tool on a 64-bit host, then make sure
406 that when the sizes are cast to (size_t) no information is lost. */
407 if ((size_t) size
!= size
408 || (size_t) nmemb
!= nmemb
409 || (size_t) amt
!= amt
)
412 error (_("Size truncation prevents reading %s"
413 " elements of size %s for %s\n"),
414 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
418 /* Check for size overflow. */
419 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
422 error (_("Size overflow prevents reading %s"
423 " elements of size %s for %s\n"),
424 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
428 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
429 attempting to allocate memory when the read is bound to fail. */
430 if (archive_file_offset
> filedata
->file_size
431 || offset
> filedata
->file_size
- archive_file_offset
432 || amt
> filedata
->file_size
- archive_file_offset
- offset
)
435 error (_("Reading %s bytes extends past end of file for %s\n"),
436 bfd_vmatoa ("u", amt
), reason
);
440 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
443 error (_("Unable to seek to 0x%lx for %s\n"),
444 archive_file_offset
+ offset
, reason
);
451 /* + 1 so that we can '\0' terminate invalid string table sections. */
452 mvar
= malloc ((size_t) amt
+ 1);
457 error (_("Out of memory allocating %s bytes for %s\n"),
458 bfd_vmatoa ("u", amt
), reason
);
462 ((char *) mvar
)[amt
] = '\0';
465 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
468 error (_("Unable to read in %s bytes of %s\n"),
469 bfd_vmatoa ("u", amt
), reason
);
478 /* Print a VMA value in the MODE specified.
479 Returns the number of characters displayed. */
482 print_vma (bfd_vma vma
, print_mode mode
)
494 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
501 return printf ("%5" BFD_VMA_FMT
"d", vma
);
507 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
510 return printf ("%" BFD_VMA_FMT
"d", vma
);
513 return printf ("%" BFD_VMA_FMT
"u", vma
);
516 /* FIXME: Report unrecognised mode ? */
521 /* Display a symbol on stdout. Handles the display of control characters and
522 multibye characters (assuming the host environment supports them).
524 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
526 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
527 padding as necessary.
529 Returns the number of emitted characters. */
532 print_symbol (signed int width
, const char *symbol
)
534 bfd_boolean extra_padding
= FALSE
;
535 signed int num_printed
= 0;
536 #ifdef HAVE_MBSTATE_T
539 unsigned int width_remaining
;
543 /* Keep the width positive. This helps the code below. */
545 extra_padding
= TRUE
;
551 /* Set the remaining width to a very large value.
552 This simplifies the code below. */
553 width_remaining
= INT_MAX
;
555 width_remaining
= width
;
557 #ifdef HAVE_MBSTATE_T
558 /* Initialise the multibyte conversion state. */
559 memset (& state
, 0, sizeof (state
));
562 while (width_remaining
)
565 const char c
= *symbol
++;
570 /* Do not print control characters directly as they can affect terminal
571 settings. Such characters usually appear in the names generated
572 by the assembler for local labels. */
575 if (width_remaining
< 2)
578 printf ("^%c", c
+ 0x40);
579 width_remaining
-= 2;
582 else if (ISPRINT (c
))
590 #ifdef HAVE_MBSTATE_T
593 /* Let printf do the hard work of displaying multibyte characters. */
594 printf ("%.1s", symbol
- 1);
598 #ifdef HAVE_MBSTATE_T
599 /* Try to find out how many bytes made up the character that was
600 just printed. Advance the symbol pointer past the bytes that
602 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
606 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
611 if (extra_padding
&& num_printed
< width
)
613 /* Fill in the remaining spaces. */
614 printf ("%-*s", width
- num_printed
, " ");
621 /* Returns a pointer to a static buffer containing a printable version of
622 the given section's name. Like print_symbol, except that it does not try
623 to print multibyte characters, it just interprets them as hex values. */
626 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
628 #define MAX_PRINT_SEC_NAME_LEN 128
629 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
630 const char * name
= SECTION_NAME (sec
);
631 char * buf
= sec_name_buf
;
633 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
635 while ((c
= * name
++) != 0)
646 else if (ISPRINT (c
))
653 static char hex
[17] = "0123456789ABCDEF";
658 * buf
++ = hex
[(c
& 0xf0) >> 4];
659 * buf
++ = hex
[c
& 0x0f];
673 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
675 if (ndx
>= filedata
->file_header
.e_shnum
)
676 return _("<corrupt>");
678 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
681 /* Return a pointer to section NAME, or NULL if no such section exists. */
683 static Elf_Internal_Shdr
*
684 find_section (Filedata
* filedata
, const char * name
)
688 if (filedata
->section_headers
== NULL
)
691 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
692 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
693 return filedata
->section_headers
+ i
;
698 /* Return a pointer to a section containing ADDR, or NULL if no such
701 static Elf_Internal_Shdr
*
702 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
706 if (filedata
->section_headers
== NULL
)
709 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
711 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
713 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
720 static Elf_Internal_Shdr
*
721 find_section_by_type (Filedata
* filedata
, unsigned int type
)
725 if (filedata
->section_headers
== NULL
)
728 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
730 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
732 if (sec
->sh_type
== type
)
739 /* Return a pointer to section NAME, or NULL if no such section exists,
740 restricted to the list of sections given in SET. */
742 static Elf_Internal_Shdr
*
743 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
747 if (filedata
->section_headers
== NULL
)
752 while ((i
= *set
++) > 0)
754 /* See PR 21156 for a reproducer. */
755 if (i
>= filedata
->file_header
.e_shnum
)
756 continue; /* FIXME: Should we issue an error message ? */
758 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
759 return filedata
->section_headers
+ i
;
763 return find_section (filedata
, name
);
766 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
767 This OS has so many departures from the ELF standard that we test it at
770 static inline bfd_boolean
771 is_ia64_vms (Filedata
* filedata
)
773 return filedata
->file_header
.e_machine
== EM_IA_64
774 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
777 /* Guess the relocation size commonly used by the specific machines. */
780 guess_is_rela (unsigned int e_machine
)
784 /* Targets that use REL relocations. */
801 /* Targets that use RELA relocations. */
805 case EM_ADAPTEVA_EPIPHANY
:
807 case EM_ALTERA_NIOS2
:
810 case EM_ARC_COMPACT2
:
831 case EM_LATTICEMICO32
:
840 case EM_CYGNUS_MN10200
:
842 case EM_CYGNUS_MN10300
:
878 case EM_MICROBLAZE_OLD
:
900 warn (_("Don't know about relocations on this machine architecture\n"));
905 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
906 Returns TRUE upon success, FALSE otherwise. If successful then a
907 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
908 and the number of relocs loaded is placed in *NRELASP. It is the caller's
909 responsibility to free the allocated buffer. */
912 slurp_rela_relocs (Filedata
* filedata
,
913 unsigned long rel_offset
,
914 unsigned long rel_size
,
915 Elf_Internal_Rela
** relasp
,
916 unsigned long * nrelasp
)
918 Elf_Internal_Rela
* relas
;
924 Elf32_External_Rela
* erelas
;
926 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
927 rel_size
, _("32-bit relocation data"));
931 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
933 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
934 sizeof (Elf_Internal_Rela
));
939 error (_("out of memory parsing relocs\n"));
943 for (i
= 0; i
< nrelas
; i
++)
945 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
946 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
947 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
954 Elf64_External_Rela
* erelas
;
956 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
957 rel_size
, _("64-bit relocation data"));
961 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
963 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
964 sizeof (Elf_Internal_Rela
));
969 error (_("out of memory parsing relocs\n"));
973 for (i
= 0; i
< nrelas
; i
++)
975 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
976 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
977 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
979 /* The #ifdef BFD64 below is to prevent a compile time
980 warning. We know that if we do not have a 64 bit data
981 type that we will never execute this code anyway. */
983 if (filedata
->file_header
.e_machine
== EM_MIPS
984 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
986 /* In little-endian objects, r_info isn't really a
987 64-bit little-endian value: it has a 32-bit
988 little-endian symbol index followed by four
989 individual byte fields. Reorder INFO
991 bfd_vma inf
= relas
[i
].r_info
;
992 inf
= (((inf
& 0xffffffff) << 32)
993 | ((inf
>> 56) & 0xff)
994 | ((inf
>> 40) & 0xff00)
995 | ((inf
>> 24) & 0xff0000)
996 | ((inf
>> 8) & 0xff000000));
997 relas
[i
].r_info
= inf
;
1010 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1011 Returns TRUE upon success, FALSE otherwise. If successful then a
1012 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1013 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1014 responsibility to free the allocated buffer. */
1017 slurp_rel_relocs (Filedata
* filedata
,
1018 unsigned long rel_offset
,
1019 unsigned long rel_size
,
1020 Elf_Internal_Rela
** relsp
,
1021 unsigned long * nrelsp
)
1023 Elf_Internal_Rela
* rels
;
1029 Elf32_External_Rel
* erels
;
1031 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1032 rel_size
, _("32-bit relocation data"));
1036 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1038 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1043 error (_("out of memory parsing relocs\n"));
1047 for (i
= 0; i
< nrels
; i
++)
1049 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1050 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1051 rels
[i
].r_addend
= 0;
1058 Elf64_External_Rel
* erels
;
1060 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1061 rel_size
, _("64-bit relocation data"));
1065 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1067 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1072 error (_("out of memory parsing relocs\n"));
1076 for (i
= 0; i
< nrels
; i
++)
1078 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1079 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1080 rels
[i
].r_addend
= 0;
1082 /* The #ifdef BFD64 below is to prevent a compile time
1083 warning. We know that if we do not have a 64 bit data
1084 type that we will never execute this code anyway. */
1086 if (filedata
->file_header
.e_machine
== EM_MIPS
1087 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1089 /* In little-endian objects, r_info isn't really a
1090 64-bit little-endian value: it has a 32-bit
1091 little-endian symbol index followed by four
1092 individual byte fields. Reorder INFO
1094 bfd_vma inf
= rels
[i
].r_info
;
1095 inf
= (((inf
& 0xffffffff) << 32)
1096 | ((inf
>> 56) & 0xff)
1097 | ((inf
>> 40) & 0xff00)
1098 | ((inf
>> 24) & 0xff0000)
1099 | ((inf
>> 8) & 0xff000000));
1100 rels
[i
].r_info
= inf
;
1113 /* Returns the reloc type extracted from the reloc info field. */
1116 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1119 return ELF32_R_TYPE (reloc_info
);
1121 switch (filedata
->file_header
.e_machine
)
1124 /* Note: We assume that reloc_info has already been adjusted for us. */
1125 return ELF64_MIPS_R_TYPE (reloc_info
);
1128 return ELF64_R_TYPE_ID (reloc_info
);
1131 return ELF64_R_TYPE (reloc_info
);
1135 /* Return the symbol index extracted from the reloc info field. */
1138 get_reloc_symindex (bfd_vma reloc_info
)
1140 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1143 static inline bfd_boolean
1144 uses_msp430x_relocs (Filedata
* filedata
)
1147 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1148 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1149 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1150 /* TI compiler uses ELFOSABI_NONE. */
1151 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1154 /* Display the contents of the relocation data found at the specified
1158 dump_relocations (Filedata
* filedata
,
1159 unsigned long rel_offset
,
1160 unsigned long rel_size
,
1161 Elf_Internal_Sym
* symtab
,
1162 unsigned long nsyms
,
1164 unsigned long strtablen
,
1166 bfd_boolean is_dynsym
)
1169 Elf_Internal_Rela
* rels
;
1170 bfd_boolean res
= TRUE
;
1172 if (is_rela
== UNKNOWN
)
1173 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1177 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1182 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1191 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1193 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1198 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1200 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1208 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1210 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1215 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1217 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1221 for (i
= 0; i
< rel_size
; i
++)
1226 bfd_vma symtab_index
;
1229 offset
= rels
[i
].r_offset
;
1230 inf
= rels
[i
].r_info
;
1232 type
= get_reloc_type (filedata
, inf
);
1233 symtab_index
= get_reloc_symindex (inf
);
1237 printf ("%8.8lx %8.8lx ",
1238 (unsigned long) offset
& 0xffffffff,
1239 (unsigned long) inf
& 0xffffffff);
1243 #if BFD_HOST_64BIT_LONG
1245 ? "%16.16lx %16.16lx "
1246 : "%12.12lx %12.12lx ",
1248 #elif BFD_HOST_64BIT_LONG_LONG
1251 ? "%16.16llx %16.16llx "
1252 : "%12.12llx %12.12llx ",
1256 ? "%16.16I64x %16.16I64x "
1257 : "%12.12I64x %12.12I64x ",
1262 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1263 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1264 _bfd_int64_high (offset
),
1265 _bfd_int64_low (offset
),
1266 _bfd_int64_high (inf
),
1267 _bfd_int64_low (inf
));
1271 switch (filedata
->file_header
.e_machine
)
1278 rtype
= elf_aarch64_reloc_type (type
);
1282 case EM_CYGNUS_M32R
:
1283 rtype
= elf_m32r_reloc_type (type
);
1288 rtype
= elf_i386_reloc_type (type
);
1293 rtype
= elf_m68hc11_reloc_type (type
);
1297 rtype
= elf_s12z_reloc_type (type
);
1301 rtype
= elf_m68k_reloc_type (type
);
1305 rtype
= elf_i960_reloc_type (type
);
1310 rtype
= elf_avr_reloc_type (type
);
1313 case EM_OLD_SPARCV9
:
1314 case EM_SPARC32PLUS
:
1317 rtype
= elf_sparc_reloc_type (type
);
1321 rtype
= elf_spu_reloc_type (type
);
1325 rtype
= v800_reloc_type (type
);
1328 case EM_CYGNUS_V850
:
1329 rtype
= v850_reloc_type (type
);
1333 case EM_CYGNUS_D10V
:
1334 rtype
= elf_d10v_reloc_type (type
);
1338 case EM_CYGNUS_D30V
:
1339 rtype
= elf_d30v_reloc_type (type
);
1343 rtype
= elf_dlx_reloc_type (type
);
1347 rtype
= elf_sh_reloc_type (type
);
1351 case EM_CYGNUS_MN10300
:
1352 rtype
= elf_mn10300_reloc_type (type
);
1356 case EM_CYGNUS_MN10200
:
1357 rtype
= elf_mn10200_reloc_type (type
);
1361 case EM_CYGNUS_FR30
:
1362 rtype
= elf_fr30_reloc_type (type
);
1366 rtype
= elf_frv_reloc_type (type
);
1370 rtype
= elf_csky_reloc_type (type
);
1374 rtype
= elf_ft32_reloc_type (type
);
1378 rtype
= elf_mcore_reloc_type (type
);
1382 rtype
= elf_mmix_reloc_type (type
);
1386 rtype
= elf_moxie_reloc_type (type
);
1390 if (uses_msp430x_relocs (filedata
))
1392 rtype
= elf_msp430x_reloc_type (type
);
1397 rtype
= elf_msp430_reloc_type (type
);
1401 rtype
= elf_nds32_reloc_type (type
);
1405 rtype
= elf_ppc_reloc_type (type
);
1409 rtype
= elf_ppc64_reloc_type (type
);
1413 case EM_MIPS_RS3_LE
:
1414 rtype
= elf_mips_reloc_type (type
);
1418 rtype
= elf_riscv_reloc_type (type
);
1422 rtype
= elf_alpha_reloc_type (type
);
1426 rtype
= elf_arm_reloc_type (type
);
1430 case EM_ARC_COMPACT
:
1431 case EM_ARC_COMPACT2
:
1432 rtype
= elf_arc_reloc_type (type
);
1436 rtype
= elf_hppa_reloc_type (type
);
1442 rtype
= elf_h8_reloc_type (type
);
1446 rtype
= elf_or1k_reloc_type (type
);
1451 rtype
= elf_pj_reloc_type (type
);
1454 rtype
= elf_ia64_reloc_type (type
);
1458 rtype
= elf_cris_reloc_type (type
);
1462 rtype
= elf_i860_reloc_type (type
);
1468 rtype
= elf_x86_64_reloc_type (type
);
1472 rtype
= i370_reloc_type (type
);
1477 rtype
= elf_s390_reloc_type (type
);
1481 rtype
= elf_score_reloc_type (type
);
1485 rtype
= elf_xstormy16_reloc_type (type
);
1489 rtype
= elf_crx_reloc_type (type
);
1493 rtype
= elf_vax_reloc_type (type
);
1497 rtype
= elf_visium_reloc_type (type
);
1501 rtype
= elf_bpf_reloc_type (type
);
1504 case EM_ADAPTEVA_EPIPHANY
:
1505 rtype
= elf_epiphany_reloc_type (type
);
1510 rtype
= elf_ip2k_reloc_type (type
);
1514 rtype
= elf_iq2000_reloc_type (type
);
1519 rtype
= elf_xtensa_reloc_type (type
);
1522 case EM_LATTICEMICO32
:
1523 rtype
= elf_lm32_reloc_type (type
);
1528 rtype
= elf_m32c_reloc_type (type
);
1532 rtype
= elf_mt_reloc_type (type
);
1536 rtype
= elf_bfin_reloc_type (type
);
1540 rtype
= elf_mep_reloc_type (type
);
1544 rtype
= elf_cr16_reloc_type (type
);
1548 case EM_MICROBLAZE_OLD
:
1549 rtype
= elf_microblaze_reloc_type (type
);
1553 rtype
= elf_rl78_reloc_type (type
);
1557 rtype
= elf_rx_reloc_type (type
);
1561 rtype
= elf_metag_reloc_type (type
);
1566 rtype
= elf_xc16x_reloc_type (type
);
1570 rtype
= elf_tic6x_reloc_type (type
);
1574 rtype
= elf_tilegx_reloc_type (type
);
1578 rtype
= elf_tilepro_reloc_type (type
);
1581 case EM_WEBASSEMBLY
:
1582 rtype
= elf_wasm32_reloc_type (type
);
1586 rtype
= elf_xgate_reloc_type (type
);
1589 case EM_ALTERA_NIOS2
:
1590 rtype
= elf_nios2_reloc_type (type
);
1594 rtype
= elf_pru_reloc_type (type
);
1598 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1599 rtype
= elf_nfp3200_reloc_type (type
);
1601 rtype
= elf_nfp_reloc_type (type
);
1605 rtype
= elf_z80_reloc_type (type
);
1610 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1612 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1614 if (filedata
->file_header
.e_machine
== EM_ALPHA
1616 && streq (rtype
, "R_ALPHA_LITUSE")
1619 switch (rels
[i
].r_addend
)
1621 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1622 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1623 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1624 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1625 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1626 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1627 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1628 default: rtype
= NULL
;
1632 printf (" (%s)", rtype
);
1636 printf (_("<unknown addend: %lx>"),
1637 (unsigned long) rels
[i
].r_addend
);
1641 else if (symtab_index
)
1643 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1645 error (_(" bad symbol index: %08lx in reloc\n"),
1646 (unsigned long) symtab_index
);
1651 Elf_Internal_Sym
* psym
;
1652 const char * version_string
;
1653 enum versioned_symbol_info sym_info
;
1654 unsigned short vna_other
;
1656 psym
= symtab
+ symtab_index
;
1659 = get_symbol_version_string (filedata
, is_dynsym
,
1668 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1672 unsigned int width
= is_32bit_elf
? 8 : 14;
1674 /* Relocations against GNU_IFUNC symbols do not use the value
1675 of the symbol as the address to relocate against. Instead
1676 they invoke the function named by the symbol and use its
1677 result as the address for relocation.
1679 To indicate this to the user, do not display the value of
1680 the symbol in the "Symbols's Value" field. Instead show
1681 its name followed by () as a hint that the symbol is
1685 || psym
->st_name
== 0
1686 || psym
->st_name
>= strtablen
)
1689 name
= strtab
+ psym
->st_name
;
1691 len
= print_symbol (width
, name
);
1693 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1695 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1699 print_vma (psym
->st_value
, LONG_HEX
);
1701 printf (is_32bit_elf
? " " : " ");
1704 if (psym
->st_name
== 0)
1706 const char * sec_name
= "<null>";
1709 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1711 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1712 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1713 else if (psym
->st_shndx
== SHN_ABS
)
1715 else if (psym
->st_shndx
== SHN_COMMON
)
1716 sec_name
= "COMMON";
1717 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1718 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1719 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1720 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1721 sec_name
= "SCOMMON";
1722 else if (filedata
->file_header
.e_machine
== EM_MIPS
1723 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1724 sec_name
= "SUNDEF";
1725 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1726 || filedata
->file_header
.e_machine
== EM_L1OM
1727 || filedata
->file_header
.e_machine
== EM_K1OM
)
1728 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1729 sec_name
= "LARGE_COMMON";
1730 else if (filedata
->file_header
.e_machine
== EM_IA_64
1731 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1732 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1733 sec_name
= "ANSI_COM";
1734 else if (is_ia64_vms (filedata
)
1735 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1736 sec_name
= "VMS_SYMVEC";
1739 sprintf (name_buf
, "<section 0x%x>",
1740 (unsigned int) psym
->st_shndx
);
1741 sec_name
= name_buf
;
1744 print_symbol (22, sec_name
);
1746 else if (strtab
== NULL
)
1747 printf (_("<string table index: %3ld>"), psym
->st_name
);
1748 else if (psym
->st_name
>= strtablen
)
1750 error (_("<corrupt string table index: %3ld>\n"),
1756 print_symbol (22, strtab
+ psym
->st_name
);
1758 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1764 bfd_vma off
= rels
[i
].r_addend
;
1766 if ((bfd_signed_vma
) off
< 0)
1767 printf (" - %" BFD_VMA_FMT
"x", - off
);
1769 printf (" + %" BFD_VMA_FMT
"x", off
);
1775 bfd_vma off
= rels
[i
].r_addend
;
1777 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1778 if ((bfd_signed_vma
) off
< 0)
1779 printf ("-%" BFD_VMA_FMT
"x", - off
);
1781 printf ("%" BFD_VMA_FMT
"x", off
);
1784 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1786 && streq (rtype
, "R_SPARC_OLO10"))
1787 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1792 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1794 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1795 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1796 const char * rtype2
= elf_mips_reloc_type (type2
);
1797 const char * rtype3
= elf_mips_reloc_type (type3
);
1799 printf (" Type2: ");
1802 printf (_("unrecognized: %-7lx"),
1803 (unsigned long) type2
& 0xffffffff);
1805 printf ("%-17.17s", rtype2
);
1807 printf ("\n Type3: ");
1810 printf (_("unrecognized: %-7lx"),
1811 (unsigned long) type3
& 0xffffffff);
1813 printf ("%-17.17s", rtype3
);
1826 get_aarch64_dynamic_type (unsigned long type
)
1830 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1831 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1832 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1839 get_mips_dynamic_type (unsigned long type
)
1843 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1844 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1845 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1846 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1847 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1848 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1849 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1850 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1851 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1852 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1853 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1854 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1855 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1856 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1857 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1858 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1859 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1860 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1861 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1862 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1863 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1864 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1865 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1866 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1867 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1868 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1869 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1870 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1871 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1872 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1873 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1874 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1875 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1876 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1877 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1878 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1879 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1880 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1881 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1882 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1883 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1884 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1885 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1886 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1887 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1888 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1889 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1896 get_sparc64_dynamic_type (unsigned long type
)
1900 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1907 get_ppc_dynamic_type (unsigned long type
)
1911 case DT_PPC_GOT
: return "PPC_GOT";
1912 case DT_PPC_OPT
: return "PPC_OPT";
1919 get_ppc64_dynamic_type (unsigned long type
)
1923 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1924 case DT_PPC64_OPD
: return "PPC64_OPD";
1925 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1926 case DT_PPC64_OPT
: return "PPC64_OPT";
1933 get_parisc_dynamic_type (unsigned long type
)
1937 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1938 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1939 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1940 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1941 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1942 case DT_HP_PREINIT
: return "HP_PREINIT";
1943 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1944 case DT_HP_NEEDED
: return "HP_NEEDED";
1945 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1946 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1947 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1948 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1949 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1950 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1951 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1952 case DT_HP_FILTERED
: return "HP_FILTERED";
1953 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1954 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1955 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1956 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1957 case DT_PLT
: return "PLT";
1958 case DT_PLT_SIZE
: return "PLT_SIZE";
1959 case DT_DLT
: return "DLT";
1960 case DT_DLT_SIZE
: return "DLT_SIZE";
1967 get_ia64_dynamic_type (unsigned long type
)
1971 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1972 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1973 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1974 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1975 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1976 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1977 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1978 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1979 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1980 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1981 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1982 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1983 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1984 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1985 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1986 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1987 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1988 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1989 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1990 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1991 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1992 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1993 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1994 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1995 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1996 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1997 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1998 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1999 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2000 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2001 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2008 get_solaris_section_type (unsigned long type
)
2012 case 0x6fffffee: return "SUNW_ancillary";
2013 case 0x6fffffef: return "SUNW_capchain";
2014 case 0x6ffffff0: return "SUNW_capinfo";
2015 case 0x6ffffff1: return "SUNW_symsort";
2016 case 0x6ffffff2: return "SUNW_tlssort";
2017 case 0x6ffffff3: return "SUNW_LDYNSYM";
2018 case 0x6ffffff4: return "SUNW_dof";
2019 case 0x6ffffff5: return "SUNW_cap";
2020 case 0x6ffffff6: return "SUNW_SIGNATURE";
2021 case 0x6ffffff7: return "SUNW_ANNOTATE";
2022 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2023 case 0x6ffffff9: return "SUNW_DEBUG";
2024 case 0x6ffffffa: return "SUNW_move";
2025 case 0x6ffffffb: return "SUNW_COMDAT";
2026 case 0x6ffffffc: return "SUNW_syminfo";
2027 case 0x6ffffffd: return "SUNW_verdef";
2028 case 0x6ffffffe: return "SUNW_verneed";
2029 case 0x6fffffff: return "SUNW_versym";
2030 case 0x70000000: return "SPARC_GOTDATA";
2031 default: return NULL
;
2036 get_alpha_dynamic_type (unsigned long type
)
2040 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2041 default: return NULL
;
2046 get_score_dynamic_type (unsigned long type
)
2050 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2051 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2052 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2053 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2054 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2055 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2056 default: return NULL
;
2061 get_tic6x_dynamic_type (unsigned long type
)
2065 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2066 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2067 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2068 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2069 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2070 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2071 default: return NULL
;
2076 get_nios2_dynamic_type (unsigned long type
)
2080 case DT_NIOS2_GP
: return "NIOS2_GP";
2081 default: return NULL
;
2086 get_solaris_dynamic_type (unsigned long type
)
2090 case 0x6000000d: return "SUNW_AUXILIARY";
2091 case 0x6000000e: return "SUNW_RTLDINF";
2092 case 0x6000000f: return "SUNW_FILTER";
2093 case 0x60000010: return "SUNW_CAP";
2094 case 0x60000011: return "SUNW_SYMTAB";
2095 case 0x60000012: return "SUNW_SYMSZ";
2096 case 0x60000013: return "SUNW_SORTENT";
2097 case 0x60000014: return "SUNW_SYMSORT";
2098 case 0x60000015: return "SUNW_SYMSORTSZ";
2099 case 0x60000016: return "SUNW_TLSSORT";
2100 case 0x60000017: return "SUNW_TLSSORTSZ";
2101 case 0x60000018: return "SUNW_CAPINFO";
2102 case 0x60000019: return "SUNW_STRPAD";
2103 case 0x6000001a: return "SUNW_CAPCHAIN";
2104 case 0x6000001b: return "SUNW_LDMACH";
2105 case 0x6000001d: return "SUNW_CAPCHAINENT";
2106 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2107 case 0x60000021: return "SUNW_PARENT";
2108 case 0x60000023: return "SUNW_ASLR";
2109 case 0x60000025: return "SUNW_RELAX";
2110 case 0x60000029: return "SUNW_NXHEAP";
2111 case 0x6000002b: return "SUNW_NXSTACK";
2113 case 0x70000001: return "SPARC_REGISTER";
2114 case 0x7ffffffd: return "AUXILIARY";
2115 case 0x7ffffffe: return "USED";
2116 case 0x7fffffff: return "FILTER";
2118 default: return NULL
;
2123 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2125 static char buff
[64];
2129 case DT_NULL
: return "NULL";
2130 case DT_NEEDED
: return "NEEDED";
2131 case DT_PLTRELSZ
: return "PLTRELSZ";
2132 case DT_PLTGOT
: return "PLTGOT";
2133 case DT_HASH
: return "HASH";
2134 case DT_STRTAB
: return "STRTAB";
2135 case DT_SYMTAB
: return "SYMTAB";
2136 case DT_RELA
: return "RELA";
2137 case DT_RELASZ
: return "RELASZ";
2138 case DT_RELAENT
: return "RELAENT";
2139 case DT_STRSZ
: return "STRSZ";
2140 case DT_SYMENT
: return "SYMENT";
2141 case DT_INIT
: return "INIT";
2142 case DT_FINI
: return "FINI";
2143 case DT_SONAME
: return "SONAME";
2144 case DT_RPATH
: return "RPATH";
2145 case DT_SYMBOLIC
: return "SYMBOLIC";
2146 case DT_REL
: return "REL";
2147 case DT_RELSZ
: return "RELSZ";
2148 case DT_RELENT
: return "RELENT";
2149 case DT_PLTREL
: return "PLTREL";
2150 case DT_DEBUG
: return "DEBUG";
2151 case DT_TEXTREL
: return "TEXTREL";
2152 case DT_JMPREL
: return "JMPREL";
2153 case DT_BIND_NOW
: return "BIND_NOW";
2154 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2155 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2156 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2157 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2158 case DT_RUNPATH
: return "RUNPATH";
2159 case DT_FLAGS
: return "FLAGS";
2161 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2162 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2163 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2165 case DT_CHECKSUM
: return "CHECKSUM";
2166 case DT_PLTPADSZ
: return "PLTPADSZ";
2167 case DT_MOVEENT
: return "MOVEENT";
2168 case DT_MOVESZ
: return "MOVESZ";
2169 case DT_FEATURE
: return "FEATURE";
2170 case DT_POSFLAG_1
: return "POSFLAG_1";
2171 case DT_SYMINSZ
: return "SYMINSZ";
2172 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2174 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2175 case DT_CONFIG
: return "CONFIG";
2176 case DT_DEPAUDIT
: return "DEPAUDIT";
2177 case DT_AUDIT
: return "AUDIT";
2178 case DT_PLTPAD
: return "PLTPAD";
2179 case DT_MOVETAB
: return "MOVETAB";
2180 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2182 case DT_VERSYM
: return "VERSYM";
2184 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2185 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2186 case DT_RELACOUNT
: return "RELACOUNT";
2187 case DT_RELCOUNT
: return "RELCOUNT";
2188 case DT_FLAGS_1
: return "FLAGS_1";
2189 case DT_VERDEF
: return "VERDEF";
2190 case DT_VERDEFNUM
: return "VERDEFNUM";
2191 case DT_VERNEED
: return "VERNEED";
2192 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2194 case DT_AUXILIARY
: return "AUXILIARY";
2195 case DT_USED
: return "USED";
2196 case DT_FILTER
: return "FILTER";
2198 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2199 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2200 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2201 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2202 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2203 case DT_GNU_HASH
: return "GNU_HASH";
2206 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2208 const char * result
;
2210 switch (filedata
->file_header
.e_machine
)
2213 result
= get_aarch64_dynamic_type (type
);
2216 case EM_MIPS_RS3_LE
:
2217 result
= get_mips_dynamic_type (type
);
2220 result
= get_sparc64_dynamic_type (type
);
2223 result
= get_ppc_dynamic_type (type
);
2226 result
= get_ppc64_dynamic_type (type
);
2229 result
= get_ia64_dynamic_type (type
);
2232 result
= get_alpha_dynamic_type (type
);
2235 result
= get_score_dynamic_type (type
);
2238 result
= get_tic6x_dynamic_type (type
);
2240 case EM_ALTERA_NIOS2
:
2241 result
= get_nios2_dynamic_type (type
);
2244 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2245 result
= get_solaris_dynamic_type (type
);
2254 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2256 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2257 || (filedata
->file_header
.e_machine
== EM_PARISC
2258 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2260 const char * result
;
2262 switch (filedata
->file_header
.e_machine
)
2265 result
= get_parisc_dynamic_type (type
);
2268 result
= get_ia64_dynamic_type (type
);
2271 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2272 result
= get_solaris_dynamic_type (type
);
2281 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2285 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2292 get_file_type (unsigned e_type
)
2294 static char buff
[32];
2298 case ET_NONE
: return _("NONE (None)");
2299 case ET_REL
: return _("REL (Relocatable file)");
2300 case ET_EXEC
: return _("EXEC (Executable file)");
2301 case ET_DYN
: return _("DYN (Shared object file)");
2302 case ET_CORE
: return _("CORE (Core file)");
2305 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2306 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2307 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2308 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2310 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2316 get_machine_name (unsigned e_machine
)
2318 static char buff
[64]; /* XXX */
2322 /* Please keep this switch table sorted by increasing EM_ value. */
2324 case EM_NONE
: return _("None");
2325 case EM_M32
: return "WE32100";
2326 case EM_SPARC
: return "Sparc";
2327 case EM_386
: return "Intel 80386";
2328 case EM_68K
: return "MC68000";
2329 case EM_88K
: return "MC88000";
2330 case EM_IAMCU
: return "Intel MCU";
2331 case EM_860
: return "Intel 80860";
2332 case EM_MIPS
: return "MIPS R3000";
2333 case EM_S370
: return "IBM System/370";
2335 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2336 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2337 case EM_PARISC
: return "HPPA";
2338 case EM_VPP550
: return "Fujitsu VPP500";
2339 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2340 case EM_960
: return "Intel 80960";
2341 case EM_PPC
: return "PowerPC";
2343 case EM_PPC64
: return "PowerPC64";
2345 case EM_S390
: return "IBM S/390";
2346 case EM_SPU
: return "SPU";
2348 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2349 case EM_FR20
: return "Fujitsu FR20";
2350 case EM_RH32
: return "TRW RH32";
2351 case EM_MCORE
: return "MCORE";
2353 case EM_ARM
: return "ARM";
2354 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2355 case EM_SH
: return "Renesas / SuperH SH";
2356 case EM_SPARCV9
: return "Sparc v9";
2357 case EM_TRICORE
: return "Siemens Tricore";
2358 case EM_ARC
: return "ARC";
2359 case EM_H8_300
: return "Renesas H8/300";
2360 case EM_H8_300H
: return "Renesas H8/300H";
2361 case EM_H8S
: return "Renesas H8S";
2362 case EM_H8_500
: return "Renesas H8/500";
2364 case EM_IA_64
: return "Intel IA-64";
2365 case EM_MIPS_X
: return "Stanford MIPS-X";
2366 case EM_COLDFIRE
: return "Motorola Coldfire";
2367 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2368 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2369 case EM_PCP
: return "Siemens PCP";
2370 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2371 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2372 case EM_STARCORE
: return "Motorola Star*Core processor";
2373 case EM_ME16
: return "Toyota ME16 processor";
2375 case EM_ST100
: return "STMicroelectronics ST100 processor";
2376 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2377 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2378 case EM_PDSP
: return "Sony DSP processor";
2379 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2380 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2381 case EM_FX66
: return "Siemens FX66 microcontroller";
2382 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2383 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2384 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2386 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2387 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2388 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2389 case EM_SVX
: return "Silicon Graphics SVx";
2390 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2391 case EM_VAX
: return "Digital VAX";
2392 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2393 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2394 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2395 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2397 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2398 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2399 case EM_PRISM
: return "Vitesse Prism";
2401 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2402 case EM_CYGNUS_FR30
:
2403 case EM_FR30
: return "Fujitsu FR30";
2404 case EM_CYGNUS_D10V
:
2405 case EM_D10V
: return "d10v";
2406 case EM_CYGNUS_D30V
:
2407 case EM_D30V
: return "d30v";
2408 case EM_CYGNUS_V850
:
2409 case EM_V850
: return "Renesas V850";
2410 case EM_CYGNUS_M32R
:
2411 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2412 case EM_CYGNUS_MN10300
:
2413 case EM_MN10300
: return "mn10300";
2415 case EM_CYGNUS_MN10200
:
2416 case EM_MN10200
: return "mn10200";
2417 case EM_PJ
: return "picoJava";
2418 case EM_OR1K
: return "OpenRISC 1000";
2419 case EM_ARC_COMPACT
: return "ARCompact";
2421 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2422 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2423 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2424 case EM_NS32K
: return "National Semiconductor 32000 series";
2425 case EM_TPC
: return "Tenor Network TPC processor";
2426 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2428 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2430 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2431 case EM_MAX
: return "MAX Processor";
2432 case EM_CR
: return "National Semiconductor CompactRISC";
2433 case EM_F2MC16
: return "Fujitsu F2MC16";
2434 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2435 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2436 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2437 case EM_SEP
: return "Sharp embedded microprocessor";
2438 case EM_ARCA
: return "Arca RISC microprocessor";
2440 case EM_UNICORE
: return "Unicore";
2441 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2442 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2443 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2444 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2445 case EM_XGATE
: return "Motorola XGATE embedded processor";
2447 case EM_XC16X
: return "Infineon Technologies xc16x";
2448 case EM_M16C
: return "Renesas M16C series microprocessors";
2449 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2450 case EM_CE
: return "Freescale Communication Engine RISC core";
2452 case EM_M32C
: return "Renesas M32c";
2454 case EM_TSK3000
: return "Altium TSK3000 core";
2455 case EM_RS08
: return "Freescale RS08 embedded processor";
2456 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2457 case EM_SCORE
: return "SUNPLUS S+Core";
2458 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2459 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2460 case EM_LATTICEMICO32
: return "Lattice Mico32";
2461 case EM_SE_C17
: return "Seiko Epson C17 family";
2463 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2464 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2465 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2466 case EM_TI_PRU
: return "TI PRU I/O processor";
2468 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2469 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2470 case EM_R32C
: return "Renesas R32C series microprocessors";
2471 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2472 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2473 case EM_8051
: return "Intel 8051 and variants";
2474 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2475 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2476 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2477 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2479 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2480 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2481 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2482 case EM_RX
: return "Renesas RX";
2483 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2484 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2485 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2488 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2489 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2490 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2492 case EM_L1OM
: return "Intel L1OM";
2493 case EM_K1OM
: return "Intel K1OM";
2494 case EM_INTEL182
: return "Intel (reserved)";
2495 case EM_AARCH64
: return "AArch64";
2496 case EM_ARM184
: return "ARM (reserved)";
2497 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2498 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2499 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2500 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2502 case EM_CUDA
: return "NVIDIA CUDA architecture";
2503 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2504 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2505 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2506 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2507 case EM_ARC_COMPACT2
: return "ARCv2";
2508 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2509 case EM_RL78
: return "Renesas RL78";
2510 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2511 case EM_78K0R
: return "Renesas 78K0R";
2513 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2514 case EM_BA1
: return "Beyond BA1 CPU architecture";
2515 case EM_BA2
: return "Beyond BA2 CPU architecture";
2516 case EM_XCORE
: return "XMOS xCORE processor family";
2517 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2519 case EM_KM32
: return "KM211 KM32 32-bit processor";
2520 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2521 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2522 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2523 case EM_KVARC
: return "KM211 KVARC processor";
2524 case EM_CDP
: return "Paneve CDP architecture family";
2525 case EM_COGE
: return "Cognitive Smart Memory Processor";
2526 case EM_COOL
: return "Bluechip Systems CoolEngine";
2527 case EM_NORC
: return "Nanoradio Optimized RISC";
2528 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2530 case EM_Z80
: return "Zilog Z80";
2531 case EM_VISIUM
: return "CDS VISIUMcore processor";
2532 case EM_FT32
: return "FTDI Chip FT32";
2533 case EM_MOXIE
: return "Moxie";
2534 case EM_AMDGPU
: return "AMD GPU";
2535 case EM_RISCV
: return "RISC-V";
2536 case EM_LANAI
: return "Lanai 32-bit processor";
2537 case EM_BPF
: return "Linux BPF";
2538 case EM_NFP
: return "Netronome Flow Processor";
2540 /* Large numbers... */
2541 case EM_MT
: return "Morpho Techologies MT processor";
2542 case EM_ALPHA
: return "Alpha";
2543 case EM_WEBASSEMBLY
: return "Web Assembly";
2544 case EM_DLX
: return "OpenDLX";
2545 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2546 case EM_IQ2000
: return "Vitesse IQ2000";
2548 case EM_NIOS32
: return "Altera Nios";
2549 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2550 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2551 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2552 case EM_S12Z
: return "Freescale S12Z";
2553 case EM_CSKY
: return "C-SKY";
2556 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2562 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2564 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2565 other compilers don't a specific architecture type in the e_flags, and
2566 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2567 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2570 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2571 but also sets a specific architecture type in the e_flags field.
2573 However, when decoding the flags we don't worry if we see an
2574 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2575 ARCEM architecture type. */
2577 switch (e_flags
& EF_ARC_MACH_MSK
)
2579 /* We only expect these to occur for EM_ARC_COMPACT2. */
2580 case EF_ARC_CPU_ARCV2EM
:
2581 strcat (buf
, ", ARC EM");
2583 case EF_ARC_CPU_ARCV2HS
:
2584 strcat (buf
, ", ARC HS");
2587 /* We only expect these to occur for EM_ARC_COMPACT. */
2588 case E_ARC_MACH_ARC600
:
2589 strcat (buf
, ", ARC600");
2591 case E_ARC_MACH_ARC601
:
2592 strcat (buf
, ", ARC601");
2594 case E_ARC_MACH_ARC700
:
2595 strcat (buf
, ", ARC700");
2598 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2599 new ELF with new architecture being read by an old version of
2600 readelf, or (c) An ELF built with non-GNU compiler that does not
2601 set the architecture in the e_flags. */
2603 if (e_machine
== EM_ARC_COMPACT
)
2604 strcat (buf
, ", Unknown ARCompact");
2606 strcat (buf
, ", Unknown ARC");
2610 switch (e_flags
& EF_ARC_OSABI_MSK
)
2612 case E_ARC_OSABI_ORIG
:
2613 strcat (buf
, ", (ABI:legacy)");
2615 case E_ARC_OSABI_V2
:
2616 strcat (buf
, ", (ABI:v2)");
2618 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2619 case E_ARC_OSABI_V3
:
2620 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2622 case E_ARC_OSABI_V4
:
2623 strcat (buf
, ", v4 ABI");
2626 strcat (buf
, ", unrecognised ARC OSABI flag");
2632 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2635 bfd_boolean unknown
= FALSE
;
2637 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2638 e_flags
&= ~ EF_ARM_EABIMASK
;
2640 /* Handle "generic" ARM flags. */
2641 if (e_flags
& EF_ARM_RELEXEC
)
2643 strcat (buf
, ", relocatable executable");
2644 e_flags
&= ~ EF_ARM_RELEXEC
;
2647 if (e_flags
& EF_ARM_PIC
)
2649 strcat (buf
, ", position independent");
2650 e_flags
&= ~ EF_ARM_PIC
;
2653 /* Now handle EABI specific flags. */
2657 strcat (buf
, ", <unrecognized EABI>");
2662 case EF_ARM_EABI_VER1
:
2663 strcat (buf
, ", Version1 EABI");
2668 /* Process flags one bit at a time. */
2669 flag
= e_flags
& - e_flags
;
2674 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2675 strcat (buf
, ", sorted symbol tables");
2685 case EF_ARM_EABI_VER2
:
2686 strcat (buf
, ", Version2 EABI");
2691 /* Process flags one bit at a time. */
2692 flag
= e_flags
& - e_flags
;
2697 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2698 strcat (buf
, ", sorted symbol tables");
2701 case EF_ARM_DYNSYMSUSESEGIDX
:
2702 strcat (buf
, ", dynamic symbols use segment index");
2705 case EF_ARM_MAPSYMSFIRST
:
2706 strcat (buf
, ", mapping symbols precede others");
2716 case EF_ARM_EABI_VER3
:
2717 strcat (buf
, ", Version3 EABI");
2720 case EF_ARM_EABI_VER4
:
2721 strcat (buf
, ", Version4 EABI");
2726 /* Process flags one bit at a time. */
2727 flag
= e_flags
& - e_flags
;
2733 strcat (buf
, ", BE8");
2737 strcat (buf
, ", LE8");
2747 case EF_ARM_EABI_VER5
:
2748 strcat (buf
, ", Version5 EABI");
2753 /* Process flags one bit at a time. */
2754 flag
= e_flags
& - e_flags
;
2760 strcat (buf
, ", BE8");
2764 strcat (buf
, ", LE8");
2767 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2768 strcat (buf
, ", soft-float ABI");
2771 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2772 strcat (buf
, ", hard-float ABI");
2782 case EF_ARM_EABI_UNKNOWN
:
2783 strcat (buf
, ", GNU EABI");
2788 /* Process flags one bit at a time. */
2789 flag
= e_flags
& - e_flags
;
2794 case EF_ARM_INTERWORK
:
2795 strcat (buf
, ", interworking enabled");
2798 case EF_ARM_APCS_26
:
2799 strcat (buf
, ", uses APCS/26");
2802 case EF_ARM_APCS_FLOAT
:
2803 strcat (buf
, ", uses APCS/float");
2807 strcat (buf
, ", position independent");
2811 strcat (buf
, ", 8 bit structure alignment");
2814 case EF_ARM_NEW_ABI
:
2815 strcat (buf
, ", uses new ABI");
2818 case EF_ARM_OLD_ABI
:
2819 strcat (buf
, ", uses old ABI");
2822 case EF_ARM_SOFT_FLOAT
:
2823 strcat (buf
, ", software FP");
2826 case EF_ARM_VFP_FLOAT
:
2827 strcat (buf
, ", VFP");
2830 case EF_ARM_MAVERICK_FLOAT
:
2831 strcat (buf
, ", Maverick FP");
2842 strcat (buf
,_(", <unknown>"));
2846 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2848 --size
; /* Leave space for null terminator. */
2850 switch (e_flags
& EF_AVR_MACH
)
2852 case E_AVR_MACH_AVR1
:
2853 strncat (buf
, ", avr:1", size
);
2855 case E_AVR_MACH_AVR2
:
2856 strncat (buf
, ", avr:2", size
);
2858 case E_AVR_MACH_AVR25
:
2859 strncat (buf
, ", avr:25", size
);
2861 case E_AVR_MACH_AVR3
:
2862 strncat (buf
, ", avr:3", size
);
2864 case E_AVR_MACH_AVR31
:
2865 strncat (buf
, ", avr:31", size
);
2867 case E_AVR_MACH_AVR35
:
2868 strncat (buf
, ", avr:35", size
);
2870 case E_AVR_MACH_AVR4
:
2871 strncat (buf
, ", avr:4", size
);
2873 case E_AVR_MACH_AVR5
:
2874 strncat (buf
, ", avr:5", size
);
2876 case E_AVR_MACH_AVR51
:
2877 strncat (buf
, ", avr:51", size
);
2879 case E_AVR_MACH_AVR6
:
2880 strncat (buf
, ", avr:6", size
);
2882 case E_AVR_MACH_AVRTINY
:
2883 strncat (buf
, ", avr:100", size
);
2885 case E_AVR_MACH_XMEGA1
:
2886 strncat (buf
, ", avr:101", size
);
2888 case E_AVR_MACH_XMEGA2
:
2889 strncat (buf
, ", avr:102", size
);
2891 case E_AVR_MACH_XMEGA3
:
2892 strncat (buf
, ", avr:103", size
);
2894 case E_AVR_MACH_XMEGA4
:
2895 strncat (buf
, ", avr:104", size
);
2897 case E_AVR_MACH_XMEGA5
:
2898 strncat (buf
, ", avr:105", size
);
2900 case E_AVR_MACH_XMEGA6
:
2901 strncat (buf
, ", avr:106", size
);
2903 case E_AVR_MACH_XMEGA7
:
2904 strncat (buf
, ", avr:107", size
);
2907 strncat (buf
, ", avr:<unknown>", size
);
2911 size
-= strlen (buf
);
2912 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2913 strncat (buf
, ", link-relax", size
);
2917 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2923 bfd_boolean has_fpu
= FALSE
;
2926 static const char *ABI_STRINGS
[] =
2928 "ABI v0", /* use r5 as return register; only used in N1213HC */
2929 "ABI v1", /* use r0 as return register */
2930 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2931 "ABI v2fp", /* for FPU */
2935 static const char *VER_STRINGS
[] =
2937 "Andes ELF V1.3 or older",
2941 static const char *ARCH_STRINGS
[] =
2950 abi
= EF_NDS_ABI
& e_flags
;
2951 arch
= EF_NDS_ARCH
& e_flags
;
2952 config
= EF_NDS_INST
& e_flags
;
2953 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2955 memset (buf
, 0, size
);
2962 case E_NDS_ABI_V2FP
:
2963 case E_NDS_ABI_AABI
:
2964 case E_NDS_ABI_V2FP_PLUS
:
2965 /* In case there are holes in the array. */
2966 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2970 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2976 case E_NDS32_ELF_VER_1_2
:
2977 case E_NDS32_ELF_VER_1_3
:
2978 case E_NDS32_ELF_VER_1_4
:
2979 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2983 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2987 if (E_NDS_ABI_V0
== abi
)
2989 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2990 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2991 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2992 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2998 case E_NDS_ARCH_STAR_V1_0
:
2999 case E_NDS_ARCH_STAR_V2_0
:
3000 case E_NDS_ARCH_STAR_V3_0
:
3001 case E_NDS_ARCH_STAR_V3_M
:
3002 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3006 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3007 /* ARCH version determines how the e_flags are interpreted.
3008 If it is unknown, we cannot proceed. */
3012 /* Newer ABI; Now handle architecture specific flags. */
3013 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3015 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3016 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3018 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3019 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3021 if (config
& E_NDS32_HAS_DIV_INST
)
3022 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3024 if (config
& E_NDS32_HAS_16BIT_INST
)
3025 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3029 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3031 if (version
<= E_NDS32_ELF_VER_1_3
)
3032 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3034 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3037 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3038 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3040 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3041 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3043 if (config
& E_NDS32_HAS_16BIT_INST
)
3045 if (version
<= E_NDS32_ELF_VER_1_3
)
3046 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3048 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3052 if (config
& E_NDS32_HAS_EXT_INST
)
3053 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3055 if (config
& E_NDS32_HAS_EXT2_INST
)
3056 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3058 if (config
& E_NDS32_HAS_FPU_INST
)
3061 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3064 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3067 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3070 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3073 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3078 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3080 case E_NDS32_FPU_REG_8SP_4DP
:
3081 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3083 case E_NDS32_FPU_REG_16SP_8DP
:
3084 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3086 case E_NDS32_FPU_REG_32SP_16DP
:
3087 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3089 case E_NDS32_FPU_REG_32SP_32DP
:
3090 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3095 if (config
& E_NDS32_HAS_AUDIO_INST
)
3096 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3098 if (config
& E_NDS32_HAS_STRING_INST
)
3099 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3101 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3102 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3104 if (config
& E_NDS32_HAS_VIDEO_INST
)
3106 if (version
<= E_NDS32_ELF_VER_1_3
)
3107 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3109 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3112 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3113 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3115 if (config
& E_NDS32_HAS_L2C_INST
)
3116 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3120 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3122 static char buf
[1024];
3133 case EM_ARC_COMPACT2
:
3134 case EM_ARC_COMPACT
:
3135 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3139 decode_ARM_machine_flags (e_flags
, buf
);
3143 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3147 if (e_flags
& EF_BFIN_PIC
)
3148 strcat (buf
, ", PIC");
3150 if (e_flags
& EF_BFIN_FDPIC
)
3151 strcat (buf
, ", FDPIC");
3153 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3154 strcat (buf
, ", code in L1");
3156 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3157 strcat (buf
, ", data in L1");
3162 switch (e_flags
& EF_FRV_CPU_MASK
)
3164 case EF_FRV_CPU_GENERIC
:
3168 strcat (buf
, ", fr???");
3171 case EF_FRV_CPU_FR300
:
3172 strcat (buf
, ", fr300");
3175 case EF_FRV_CPU_FR400
:
3176 strcat (buf
, ", fr400");
3178 case EF_FRV_CPU_FR405
:
3179 strcat (buf
, ", fr405");
3182 case EF_FRV_CPU_FR450
:
3183 strcat (buf
, ", fr450");
3186 case EF_FRV_CPU_FR500
:
3187 strcat (buf
, ", fr500");
3189 case EF_FRV_CPU_FR550
:
3190 strcat (buf
, ", fr550");
3193 case EF_FRV_CPU_SIMPLE
:
3194 strcat (buf
, ", simple");
3196 case EF_FRV_CPU_TOMCAT
:
3197 strcat (buf
, ", tomcat");
3203 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3204 strcat (buf
, ", m68000");
3205 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3206 strcat (buf
, ", cpu32");
3207 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3208 strcat (buf
, ", fido_a");
3211 char const * isa
= _("unknown");
3212 char const * mac
= _("unknown mac");
3213 char const * additional
= NULL
;
3215 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3217 case EF_M68K_CF_ISA_A_NODIV
:
3219 additional
= ", nodiv";
3221 case EF_M68K_CF_ISA_A
:
3224 case EF_M68K_CF_ISA_A_PLUS
:
3227 case EF_M68K_CF_ISA_B_NOUSP
:
3229 additional
= ", nousp";
3231 case EF_M68K_CF_ISA_B
:
3234 case EF_M68K_CF_ISA_C
:
3237 case EF_M68K_CF_ISA_C_NODIV
:
3239 additional
= ", nodiv";
3242 strcat (buf
, ", cf, isa ");
3245 strcat (buf
, additional
);
3246 if (e_flags
& EF_M68K_CF_FLOAT
)
3247 strcat (buf
, ", float");
3248 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3253 case EF_M68K_CF_MAC
:
3256 case EF_M68K_CF_EMAC
:
3259 case EF_M68K_CF_EMAC_B
:
3272 switch (e_flags
& EF_MEP_CPU_MASK
)
3274 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3275 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3276 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3277 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3278 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3279 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3280 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3283 switch (e_flags
& EF_MEP_COP_MASK
)
3285 case EF_MEP_COP_NONE
: break;
3286 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3287 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3288 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3289 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3290 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3293 if (e_flags
& EF_MEP_LIBRARY
)
3294 strcat (buf
, ", Built for Library");
3296 if (e_flags
& EF_MEP_INDEX_MASK
)
3297 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3298 e_flags
& EF_MEP_INDEX_MASK
);
3300 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3301 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3302 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3306 if (e_flags
& EF_PPC_EMB
)
3307 strcat (buf
, ", emb");
3309 if (e_flags
& EF_PPC_RELOCATABLE
)
3310 strcat (buf
, _(", relocatable"));
3312 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3313 strcat (buf
, _(", relocatable-lib"));
3317 if (e_flags
& EF_PPC64_ABI
)
3319 char abi
[] = ", abiv0";
3321 abi
[6] += e_flags
& EF_PPC64_ABI
;
3327 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3328 strcat (buf
, ", RH850 ABI");
3330 if (e_flags
& EF_V800_850E3
)
3331 strcat (buf
, ", V3 architecture");
3333 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3334 strcat (buf
, ", FPU not used");
3336 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3337 strcat (buf
, ", regmode: COMMON");
3339 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3340 strcat (buf
, ", r4 not used");
3342 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3343 strcat (buf
, ", r30 not used");
3345 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3346 strcat (buf
, ", r5 not used");
3348 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3349 strcat (buf
, ", r2 not used");
3351 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3353 switch (e_flags
& - e_flags
)
3355 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3356 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3357 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3358 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3359 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3360 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3361 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3362 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3363 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3364 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3365 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3366 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3373 case EM_CYGNUS_V850
:
3374 switch (e_flags
& EF_V850_ARCH
)
3376 case E_V850E3V5_ARCH
:
3377 strcat (buf
, ", v850e3v5");
3379 case E_V850E2V3_ARCH
:
3380 strcat (buf
, ", v850e2v3");
3383 strcat (buf
, ", v850e2");
3386 strcat (buf
, ", v850e1");
3389 strcat (buf
, ", v850e");
3392 strcat (buf
, ", v850");
3395 strcat (buf
, _(", unknown v850 architecture variant"));
3401 case EM_CYGNUS_M32R
:
3402 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3403 strcat (buf
, ", m32r");
3407 case EM_MIPS_RS3_LE
:
3408 if (e_flags
& EF_MIPS_NOREORDER
)
3409 strcat (buf
, ", noreorder");
3411 if (e_flags
& EF_MIPS_PIC
)
3412 strcat (buf
, ", pic");
3414 if (e_flags
& EF_MIPS_CPIC
)
3415 strcat (buf
, ", cpic");
3417 if (e_flags
& EF_MIPS_UCODE
)
3418 strcat (buf
, ", ugen_reserved");
3420 if (e_flags
& EF_MIPS_ABI2
)
3421 strcat (buf
, ", abi2");
3423 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3424 strcat (buf
, ", odk first");
3426 if (e_flags
& EF_MIPS_32BITMODE
)
3427 strcat (buf
, ", 32bitmode");
3429 if (e_flags
& EF_MIPS_NAN2008
)
3430 strcat (buf
, ", nan2008");
3432 if (e_flags
& EF_MIPS_FP64
)
3433 strcat (buf
, ", fp64");
3435 switch ((e_flags
& EF_MIPS_MACH
))
3437 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3438 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3439 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3440 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3441 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3442 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3443 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3444 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3445 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3446 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3447 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3448 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3449 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3450 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3451 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3452 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3453 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3454 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3455 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3456 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3457 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3459 /* We simply ignore the field in this case to avoid confusion:
3460 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3463 default: strcat (buf
, _(", unknown CPU")); break;
3466 switch ((e_flags
& EF_MIPS_ABI
))
3468 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3469 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3470 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3471 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3473 /* We simply ignore the field in this case to avoid confusion:
3474 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3475 This means it is likely to be an o32 file, but not for
3478 default: strcat (buf
, _(", unknown ABI")); break;
3481 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3482 strcat (buf
, ", mdmx");
3484 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3485 strcat (buf
, ", mips16");
3487 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3488 strcat (buf
, ", micromips");
3490 switch ((e_flags
& EF_MIPS_ARCH
))
3492 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3493 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3494 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3495 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3496 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3497 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3498 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3499 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3500 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3501 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3502 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3503 default: strcat (buf
, _(", unknown ISA")); break;
3508 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3512 switch (EF_NFP_MACH (e_flags
))
3514 case E_NFP_MACH_3200
:
3515 strcat (buf
, ", NFP-32xx");
3517 case E_NFP_MACH_6000
:
3518 strcat (buf
, ", NFP-6xxx");
3524 if (e_flags
& EF_RISCV_RVC
)
3525 strcat (buf
, ", RVC");
3527 if (e_flags
& EF_RISCV_RVE
)
3528 strcat (buf
, ", RVE");
3530 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3532 case EF_RISCV_FLOAT_ABI_SOFT
:
3533 strcat (buf
, ", soft-float ABI");
3536 case EF_RISCV_FLOAT_ABI_SINGLE
:
3537 strcat (buf
, ", single-float ABI");
3540 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3541 strcat (buf
, ", double-float ABI");
3544 case EF_RISCV_FLOAT_ABI_QUAD
:
3545 strcat (buf
, ", quad-float ABI");
3551 switch ((e_flags
& EF_SH_MACH_MASK
))
3553 case EF_SH1
: strcat (buf
, ", sh1"); break;
3554 case EF_SH2
: strcat (buf
, ", sh2"); break;
3555 case EF_SH3
: strcat (buf
, ", sh3"); break;
3556 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3557 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3558 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3559 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3560 case EF_SH4
: strcat (buf
, ", sh4"); break;
3561 case EF_SH5
: strcat (buf
, ", sh5"); break;
3562 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3563 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3564 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3565 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3566 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3567 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3568 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3569 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3570 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3571 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3572 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3573 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3574 default: strcat (buf
, _(", unknown ISA")); break;
3577 if (e_flags
& EF_SH_PIC
)
3578 strcat (buf
, ", pic");
3580 if (e_flags
& EF_SH_FDPIC
)
3581 strcat (buf
, ", fdpic");
3585 if (e_flags
& EF_OR1K_NODELAY
)
3586 strcat (buf
, ", no delay");
3590 if (e_flags
& EF_SPARC_32PLUS
)
3591 strcat (buf
, ", v8+");
3593 if (e_flags
& EF_SPARC_SUN_US1
)
3594 strcat (buf
, ", ultrasparcI");
3596 if (e_flags
& EF_SPARC_SUN_US3
)
3597 strcat (buf
, ", ultrasparcIII");
3599 if (e_flags
& EF_SPARC_HAL_R1
)
3600 strcat (buf
, ", halr1");
3602 if (e_flags
& EF_SPARC_LEDATA
)
3603 strcat (buf
, ", ledata");
3605 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3606 strcat (buf
, ", tso");
3608 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3609 strcat (buf
, ", pso");
3611 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3612 strcat (buf
, ", rmo");
3616 switch (e_flags
& EF_PARISC_ARCH
)
3618 case EFA_PARISC_1_0
:
3619 strcpy (buf
, ", PA-RISC 1.0");
3621 case EFA_PARISC_1_1
:
3622 strcpy (buf
, ", PA-RISC 1.1");
3624 case EFA_PARISC_2_0
:
3625 strcpy (buf
, ", PA-RISC 2.0");
3630 if (e_flags
& EF_PARISC_TRAPNIL
)
3631 strcat (buf
, ", trapnil");
3632 if (e_flags
& EF_PARISC_EXT
)
3633 strcat (buf
, ", ext");
3634 if (e_flags
& EF_PARISC_LSB
)
3635 strcat (buf
, ", lsb");
3636 if (e_flags
& EF_PARISC_WIDE
)
3637 strcat (buf
, ", wide");
3638 if (e_flags
& EF_PARISC_NO_KABP
)
3639 strcat (buf
, ", no kabp");
3640 if (e_flags
& EF_PARISC_LAZYSWAP
)
3641 strcat (buf
, ", lazyswap");
3646 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3647 strcat (buf
, ", new calling convention");
3649 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3650 strcat (buf
, ", gnu calling convention");
3654 if ((e_flags
& EF_IA_64_ABI64
))
3655 strcat (buf
, ", 64-bit");
3657 strcat (buf
, ", 32-bit");
3658 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3659 strcat (buf
, ", reduced fp model");
3660 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3661 strcat (buf
, ", no function descriptors, constant gp");
3662 else if ((e_flags
& EF_IA_64_CONS_GP
))
3663 strcat (buf
, ", constant gp");
3664 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3665 strcat (buf
, ", absolute");
3666 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3668 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3669 strcat (buf
, ", vms_linkages");
3670 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3672 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3674 case EF_IA_64_VMS_COMCOD_WARNING
:
3675 strcat (buf
, ", warning");
3677 case EF_IA_64_VMS_COMCOD_ERROR
:
3678 strcat (buf
, ", error");
3680 case EF_IA_64_VMS_COMCOD_ABORT
:
3681 strcat (buf
, ", abort");
3684 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3685 e_flags
& EF_IA_64_VMS_COMCOD
);
3686 strcat (buf
, ", <unknown>");
3692 if ((e_flags
& EF_VAX_NONPIC
))
3693 strcat (buf
, ", non-PIC");
3694 if ((e_flags
& EF_VAX_DFLOAT
))
3695 strcat (buf
, ", D-Float");
3696 if ((e_flags
& EF_VAX_GFLOAT
))
3697 strcat (buf
, ", G-Float");
3701 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3702 strcat (buf
, ", mcm");
3703 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3704 strcat (buf
, ", mcm24");
3705 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3706 strcat (buf
, ", gr6");
3710 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3712 case E_FLAG_RL78_ANY_CPU
: break;
3713 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3714 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3715 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3717 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3718 strcat (buf
, ", 64-bit doubles");
3722 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3723 strcat (buf
, ", 64-bit doubles");
3724 if (e_flags
& E_FLAG_RX_DSP
)
3725 strcat (buf
, ", dsp");
3726 if (e_flags
& E_FLAG_RX_PID
)
3727 strcat (buf
, ", pid");
3728 if (e_flags
& E_FLAG_RX_ABI
)
3729 strcat (buf
, ", RX ABI");
3730 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3731 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3732 ? ", uses String instructions" : ", bans String instructions");
3733 if (e_flags
& E_FLAG_RX_V2
)
3734 strcat (buf
, ", V2");
3735 if (e_flags
& E_FLAG_RX_V3
)
3736 strcat (buf
, ", V3");
3740 if (e_flags
& EF_S390_HIGH_GPRS
)
3741 strcat (buf
, ", highgprs");
3745 if ((e_flags
& EF_C6000_REL
))
3746 strcat (buf
, ", relocatable module");
3750 strcat (buf
, _(": architecture variant: "));
3751 switch (e_flags
& EF_MSP430_MACH
)
3753 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3754 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3755 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3756 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3757 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3758 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3759 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3760 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3761 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3762 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3763 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3764 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3765 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3766 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3767 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3769 strcat (buf
, _(": unknown")); break;
3772 if (e_flags
& ~ EF_MSP430_MACH
)
3773 strcat (buf
, _(": unknown extra flag bits also present"));
3777 switch (e_flags
& EF_Z80_MACH_MSK
)
3779 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3780 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3781 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3782 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3783 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3784 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3785 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3787 strcat (buf
, _(", unknown")); break;
3797 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3799 static char buff
[32];
3803 case ELFOSABI_NONE
: return "UNIX - System V";
3804 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3805 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3806 case ELFOSABI_GNU
: return "UNIX - GNU";
3807 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3808 case ELFOSABI_AIX
: return "UNIX - AIX";
3809 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3810 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3811 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3812 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3813 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3814 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3815 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3816 case ELFOSABI_AROS
: return "AROS";
3817 case ELFOSABI_FENIXOS
: return "FenixOS";
3818 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3819 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3822 switch (filedata
->file_header
.e_machine
)
3827 case ELFOSABI_ARM
: return "ARM";
3828 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3839 case ELFOSABI_STANDALONE
: return _("Standalone App");
3848 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3849 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3858 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3864 get_aarch64_segment_type (unsigned long type
)
3868 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3869 default: return NULL
;
3874 get_arm_segment_type (unsigned long type
)
3878 case PT_ARM_EXIDX
: return "EXIDX";
3879 default: return NULL
;
3884 get_s390_segment_type (unsigned long type
)
3888 case PT_S390_PGSTE
: return "S390_PGSTE";
3889 default: return NULL
;
3894 get_mips_segment_type (unsigned long type
)
3898 case PT_MIPS_REGINFO
: return "REGINFO";
3899 case PT_MIPS_RTPROC
: return "RTPROC";
3900 case PT_MIPS_OPTIONS
: return "OPTIONS";
3901 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3902 default: return NULL
;
3907 get_parisc_segment_type (unsigned long type
)
3911 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3912 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3913 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3914 default: return NULL
;
3919 get_ia64_segment_type (unsigned long type
)
3923 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3924 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3925 default: return NULL
;
3930 get_tic6x_segment_type (unsigned long type
)
3934 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3935 default: return NULL
;
3940 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3942 if (e_machine
== EM_PARISC
)
3945 case PT_HP_TLS
: return "HP_TLS";
3946 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3947 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3948 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3949 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3950 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3951 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3952 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3953 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3954 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3955 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3956 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3957 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3958 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3959 case PT_HP_STACK
: return "HP_STACK";
3960 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3961 default: return NULL
;
3964 if (e_machine
== EM_IA_64
)
3967 case PT_HP_TLS
: return "HP_TLS";
3968 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3969 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3970 case PT_IA_64_HP_STACK
: return "HP_STACK";
3971 default: return NULL
;
3978 get_solaris_segment_type (unsigned long type
)
3982 case 0x6464e550: return "PT_SUNW_UNWIND";
3983 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3984 case 0x6ffffff7: return "PT_LOSUNW";
3985 case 0x6ffffffa: return "PT_SUNWBSS";
3986 case 0x6ffffffb: return "PT_SUNWSTACK";
3987 case 0x6ffffffc: return "PT_SUNWDTRACE";
3988 case 0x6ffffffd: return "PT_SUNWCAP";
3989 case 0x6fffffff: return "PT_HISUNW";
3990 default: return NULL
;
3995 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3997 static char buff
[32];
4001 case PT_NULL
: return "NULL";
4002 case PT_LOAD
: return "LOAD";
4003 case PT_DYNAMIC
: return "DYNAMIC";
4004 case PT_INTERP
: return "INTERP";
4005 case PT_NOTE
: return "NOTE";
4006 case PT_SHLIB
: return "SHLIB";
4007 case PT_PHDR
: return "PHDR";
4008 case PT_TLS
: return "TLS";
4009 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4010 case PT_GNU_STACK
: return "GNU_STACK";
4011 case PT_GNU_RELRO
: return "GNU_RELRO";
4012 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4015 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4017 const char * result
;
4019 switch (filedata
->file_header
.e_machine
)
4022 result
= get_aarch64_segment_type (p_type
);
4025 result
= get_arm_segment_type (p_type
);
4028 case EM_MIPS_RS3_LE
:
4029 result
= get_mips_segment_type (p_type
);
4032 result
= get_parisc_segment_type (p_type
);
4035 result
= get_ia64_segment_type (p_type
);
4038 result
= get_tic6x_segment_type (p_type
);
4042 result
= get_s390_segment_type (p_type
);
4052 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4054 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4056 const char * result
= NULL
;
4058 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4061 case ELFOSABI_FREEBSD
:
4062 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4064 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4069 result
= get_hpux_segment_type (p_type
,
4070 filedata
->file_header
.e_machine
);
4072 case ELFOSABI_SOLARIS
:
4073 result
= get_solaris_segment_type (p_type
);
4081 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4084 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4091 get_arc_section_type_name (unsigned int sh_type
)
4095 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4103 get_mips_section_type_name (unsigned int sh_type
)
4107 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4108 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4109 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4110 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4111 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4112 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4113 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4114 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4115 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4116 case SHT_MIPS_RELD
: return "MIPS_RELD";
4117 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4118 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4119 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4120 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4121 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4122 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4123 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4124 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4125 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4126 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4127 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4128 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4129 case SHT_MIPS_LINE
: return "MIPS_LINE";
4130 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4131 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4132 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4133 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4134 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4135 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4136 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4137 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4138 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4139 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4140 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4141 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4142 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4143 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4144 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4145 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4146 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4147 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4155 get_parisc_section_type_name (unsigned int sh_type
)
4159 case SHT_PARISC_EXT
: return "PARISC_EXT";
4160 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4161 case SHT_PARISC_DOC
: return "PARISC_DOC";
4162 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4163 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4164 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4165 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4166 default: return NULL
;
4171 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4173 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4174 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4175 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4179 case SHT_IA_64_EXT
: return "IA_64_EXT";
4180 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4181 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4182 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4183 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4184 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4185 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4186 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4187 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4188 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4196 get_x86_64_section_type_name (unsigned int sh_type
)
4200 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4201 default: return NULL
;
4206 get_aarch64_section_type_name (unsigned int sh_type
)
4210 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4211 default: return NULL
;
4216 get_arm_section_type_name (unsigned int sh_type
)
4220 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4221 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4222 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4223 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4224 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4225 default: return NULL
;
4230 get_tic6x_section_type_name (unsigned int sh_type
)
4234 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4235 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4236 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4237 case SHT_TI_ICODE
: return "TI_ICODE";
4238 case SHT_TI_XREF
: return "TI_XREF";
4239 case SHT_TI_HANDLER
: return "TI_HANDLER";
4240 case SHT_TI_INITINFO
: return "TI_INITINFO";
4241 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4242 default: return NULL
;
4247 get_msp430x_section_type_name (unsigned int sh_type
)
4251 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4252 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4253 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4254 default: return NULL
;
4259 get_nfp_section_type_name (unsigned int sh_type
)
4263 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4264 case SHT_NFP_INITREG
: return "NFP_INITREG";
4265 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4266 default: return NULL
;
4271 get_v850_section_type_name (unsigned int sh_type
)
4275 case SHT_V850_SCOMMON
: return "V850 Small Common";
4276 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4277 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4278 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4279 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4280 default: return NULL
;
4285 get_riscv_section_type_name (unsigned int sh_type
)
4289 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4290 default: return NULL
;
4295 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4297 static char buff
[32];
4298 const char * result
;
4302 case SHT_NULL
: return "NULL";
4303 case SHT_PROGBITS
: return "PROGBITS";
4304 case SHT_SYMTAB
: return "SYMTAB";
4305 case SHT_STRTAB
: return "STRTAB";
4306 case SHT_RELA
: return "RELA";
4307 case SHT_HASH
: return "HASH";
4308 case SHT_DYNAMIC
: return "DYNAMIC";
4309 case SHT_NOTE
: return "NOTE";
4310 case SHT_NOBITS
: return "NOBITS";
4311 case SHT_REL
: return "REL";
4312 case SHT_SHLIB
: return "SHLIB";
4313 case SHT_DYNSYM
: return "DYNSYM";
4314 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4315 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4316 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4317 case SHT_GNU_HASH
: return "GNU_HASH";
4318 case SHT_GROUP
: return "GROUP";
4319 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4320 case SHT_GNU_verdef
: return "VERDEF";
4321 case SHT_GNU_verneed
: return "VERNEED";
4322 case SHT_GNU_versym
: return "VERSYM";
4323 case 0x6ffffff0: return "VERSYM";
4324 case 0x6ffffffc: return "VERDEF";
4325 case 0x7ffffffd: return "AUXILIARY";
4326 case 0x7fffffff: return "FILTER";
4327 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4330 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4332 switch (filedata
->file_header
.e_machine
)
4335 case EM_ARC_COMPACT
:
4336 case EM_ARC_COMPACT2
:
4337 result
= get_arc_section_type_name (sh_type
);
4340 case EM_MIPS_RS3_LE
:
4341 result
= get_mips_section_type_name (sh_type
);
4344 result
= get_parisc_section_type_name (sh_type
);
4347 result
= get_ia64_section_type_name (filedata
, sh_type
);
4352 result
= get_x86_64_section_type_name (sh_type
);
4355 result
= get_aarch64_section_type_name (sh_type
);
4358 result
= get_arm_section_type_name (sh_type
);
4361 result
= get_tic6x_section_type_name (sh_type
);
4364 result
= get_msp430x_section_type_name (sh_type
);
4367 result
= get_nfp_section_type_name (sh_type
);
4371 case EM_CYGNUS_V850
:
4372 result
= get_v850_section_type_name (sh_type
);
4375 result
= get_riscv_section_type_name (sh_type
);
4385 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4387 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4389 switch (filedata
->file_header
.e_machine
)
4392 result
= get_ia64_section_type_name (filedata
, sh_type
);
4395 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4396 result
= get_solaris_section_type (sh_type
);
4401 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4402 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4403 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4404 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4416 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4418 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4420 switch (filedata
->file_header
.e_machine
)
4424 case EM_CYGNUS_V850
:
4425 result
= get_v850_section_type_name (sh_type
);
4435 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4438 /* This message is probably going to be displayed in a 15
4439 character wide field, so put the hex value first. */
4440 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4446 #define OPTION_DEBUG_DUMP 512
4447 #define OPTION_DYN_SYMS 513
4448 #define OPTION_DWARF_DEPTH 514
4449 #define OPTION_DWARF_START 515
4450 #define OPTION_DWARF_CHECK 516
4451 #define OPTION_CTF_DUMP 517
4452 #define OPTION_CTF_PARENT 518
4453 #define OPTION_CTF_SYMBOLS 519
4454 #define OPTION_CTF_STRINGS 520
4456 static struct option options
[] =
4458 {"all", no_argument
, 0, 'a'},
4459 {"file-header", no_argument
, 0, 'h'},
4460 {"program-headers", no_argument
, 0, 'l'},
4461 {"headers", no_argument
, 0, 'e'},
4462 {"histogram", no_argument
, 0, 'I'},
4463 {"segments", no_argument
, 0, 'l'},
4464 {"sections", no_argument
, 0, 'S'},
4465 {"section-headers", no_argument
, 0, 'S'},
4466 {"section-groups", no_argument
, 0, 'g'},
4467 {"section-details", no_argument
, 0, 't'},
4468 {"full-section-name",no_argument
, 0, 'N'},
4469 {"symbols", no_argument
, 0, 's'},
4470 {"syms", no_argument
, 0, 's'},
4471 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4472 {"relocs", no_argument
, 0, 'r'},
4473 {"notes", no_argument
, 0, 'n'},
4474 {"dynamic", no_argument
, 0, 'd'},
4475 {"arch-specific", no_argument
, 0, 'A'},
4476 {"version-info", no_argument
, 0, 'V'},
4477 {"use-dynamic", no_argument
, 0, 'D'},
4478 {"unwind", no_argument
, 0, 'u'},
4479 {"archive-index", no_argument
, 0, 'c'},
4480 {"hex-dump", required_argument
, 0, 'x'},
4481 {"relocated-dump", required_argument
, 0, 'R'},
4482 {"string-dump", required_argument
, 0, 'p'},
4483 {"decompress", no_argument
, 0, 'z'},
4484 #ifdef SUPPORT_DISASSEMBLY
4485 {"instruction-dump", required_argument
, 0, 'i'},
4487 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4489 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4490 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4491 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4493 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4495 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4496 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4497 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4499 {"version", no_argument
, 0, 'v'},
4500 {"wide", no_argument
, 0, 'W'},
4501 {"help", no_argument
, 0, 'H'},
4502 {0, no_argument
, 0, 0}
4506 usage (FILE * stream
)
4508 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4509 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4510 fprintf (stream
, _(" Options are:\n\
4511 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4512 -h --file-header Display the ELF file header\n\
4513 -l --program-headers Display the program headers\n\
4514 --segments An alias for --program-headers\n\
4515 -S --section-headers Display the sections' header\n\
4516 --sections An alias for --section-headers\n\
4517 -g --section-groups Display the section groups\n\
4518 -t --section-details Display the section details\n\
4519 -e --headers Equivalent to: -h -l -S\n\
4520 -s --syms Display the symbol table\n\
4521 --symbols An alias for --syms\n\
4522 --dyn-syms Display the dynamic symbol table\n\
4523 -n --notes Display the core notes (if present)\n\
4524 -r --relocs Display the relocations (if present)\n\
4525 -u --unwind Display the unwind info (if present)\n\
4526 -d --dynamic Display the dynamic section (if present)\n\
4527 -V --version-info Display the version sections (if present)\n\
4528 -A --arch-specific Display architecture specific information (if any)\n\
4529 -c --archive-index Display the symbol/file index in an archive\n\
4530 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4531 -x --hex-dump=<number|name>\n\
4532 Dump the contents of section <number|name> as bytes\n\
4533 -p --string-dump=<number|name>\n\
4534 Dump the contents of section <number|name> as strings\n\
4535 -R --relocated-dump=<number|name>\n\
4536 Dump the contents of section <number|name> as relocated bytes\n\
4537 -z --decompress Decompress section before dumping it\n\
4538 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4539 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4540 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4541 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4542 =addr,=cu_index,=links,=follow-links]\n\
4543 Display the contents of DWARF debug sections\n"));
4544 fprintf (stream
, _("\
4545 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4546 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4548 fprintf (stream
, _("\
4549 --ctf=<number|name> Display CTF info from section <number|name>\n\
4550 --ctf-parent=<number|name>\n\
4551 Use section <number|name> as the CTF parent\n\n\
4552 --ctf-symbols=<number|name>\n\
4553 Use section <number|name> as the CTF external symtab\n\n\
4554 --ctf-strings=<number|name>\n\
4555 Use section <number|name> as the CTF external strtab\n\n"));
4557 #ifdef SUPPORT_DISASSEMBLY
4558 fprintf (stream
, _("\
4559 -i --instruction-dump=<number|name>\n\
4560 Disassemble the contents of section <number|name>\n"));
4562 fprintf (stream
, _("\
4563 -I --histogram Display histogram of bucket list lengths\n\
4564 -W --wide Allow output width to exceed 80 characters\n\
4565 @<file> Read options from <file>\n\
4566 -H --help Display this information\n\
4567 -v --version Display the version number of readelf\n"));
4569 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4570 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4572 exit (stream
== stdout
? 0 : 1);
4575 /* Record the fact that the user wants the contents of section number
4576 SECTION to be displayed using the method(s) encoded as flags bits
4577 in TYPE. Note, TYPE can be zero if we are creating the array for
4581 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4583 if (section
>= filedata
->num_dump_sects
)
4585 dump_type
* new_dump_sects
;
4587 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4588 sizeof (* new_dump_sects
));
4590 if (new_dump_sects
== NULL
)
4591 error (_("Out of memory allocating dump request table.\n"));
4594 if (filedata
->dump_sects
)
4596 /* Copy current flag settings. */
4597 memcpy (new_dump_sects
, filedata
->dump_sects
,
4598 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4600 free (filedata
->dump_sects
);
4603 filedata
->dump_sects
= new_dump_sects
;
4604 filedata
->num_dump_sects
= section
+ 1;
4608 if (filedata
->dump_sects
)
4609 filedata
->dump_sects
[section
] |= type
;
4612 /* Request a dump by section name. */
4615 request_dump_byname (const char * section
, dump_type type
)
4617 struct dump_list_entry
* new_request
;
4619 new_request
= (struct dump_list_entry
*)
4620 malloc (sizeof (struct dump_list_entry
));
4622 error (_("Out of memory allocating dump request table.\n"));
4624 new_request
->name
= strdup (section
);
4625 if (!new_request
->name
)
4626 error (_("Out of memory allocating dump request table.\n"));
4628 new_request
->type
= type
;
4630 new_request
->next
= dump_sects_byname
;
4631 dump_sects_byname
= new_request
;
4635 request_dump (Filedata
* filedata
, dump_type type
)
4641 section
= strtoul (optarg
, & cp
, 0);
4643 if (! *cp
&& section
>= 0)
4644 request_dump_bynumber (filedata
, section
, type
);
4646 request_dump_byname (optarg
, type
);
4650 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4657 while ((c
= getopt_long
4658 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4676 do_section_groups
= TRUE
;
4679 do_histogram
= TRUE
;
4684 do_section_groups
= TRUE
;
4689 do_section_details
= TRUE
;
4700 do_using_dynamic
= TRUE
;
4724 do_histogram
= TRUE
;
4730 do_archive_index
= TRUE
;
4733 request_dump (filedata
, HEX_DUMP
);
4736 request_dump (filedata
, STRING_DUMP
);
4739 request_dump (filedata
, RELOC_DUMP
);
4742 decompress_dumps
= TRUE
;
4748 do_debugging
= TRUE
;
4749 dwarf_select_sections_all ();
4753 do_debugging
= FALSE
;
4754 dwarf_select_sections_by_letters (optarg
);
4757 case OPTION_DEBUG_DUMP
:
4760 do_debugging
= TRUE
;
4763 do_debugging
= FALSE
;
4764 dwarf_select_sections_by_names (optarg
);
4767 case OPTION_DWARF_DEPTH
:
4771 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4774 case OPTION_DWARF_START
:
4778 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4781 case OPTION_DWARF_CHECK
:
4784 case OPTION_CTF_DUMP
:
4786 request_dump (filedata
, CTF_DUMP
);
4788 case OPTION_CTF_SYMBOLS
:
4789 dump_ctf_symtab_name
= strdup (optarg
);
4791 case OPTION_CTF_STRINGS
:
4792 dump_ctf_strtab_name
= strdup (optarg
);
4794 case OPTION_CTF_PARENT
:
4795 dump_ctf_parent_name
= strdup (optarg
);
4797 case OPTION_DYN_SYMS
:
4800 #ifdef SUPPORT_DISASSEMBLY
4802 request_dump (filedata
, DISASS_DUMP
);
4806 print_version (program_name
);
4815 /* xgettext:c-format */
4816 error (_("Invalid option '-%c'\n"), c
);
4823 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4824 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4825 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4826 && !do_section_groups
&& !do_archive_index
4832 get_elf_class (unsigned int elf_class
)
4834 static char buff
[32];
4838 case ELFCLASSNONE
: return _("none");
4839 case ELFCLASS32
: return "ELF32";
4840 case ELFCLASS64
: return "ELF64";
4842 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4848 get_data_encoding (unsigned int encoding
)
4850 static char buff
[32];
4854 case ELFDATANONE
: return _("none");
4855 case ELFDATA2LSB
: return _("2's complement, little endian");
4856 case ELFDATA2MSB
: return _("2's complement, big endian");
4858 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4863 /* Decode the data held in 'filedata->file_header'. */
4866 process_file_header (Filedata
* filedata
)
4868 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4870 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4871 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4872 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4873 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4876 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4880 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4886 printf (_("ELF Header:\n"));
4887 printf (_(" Magic: "));
4888 for (i
= 0; i
< EI_NIDENT
; i
++)
4889 printf ("%2.2x ", header
->e_ident
[i
]);
4891 printf (_(" Class: %s\n"),
4892 get_elf_class (header
->e_ident
[EI_CLASS
]));
4893 printf (_(" Data: %s\n"),
4894 get_data_encoding (header
->e_ident
[EI_DATA
]));
4895 printf (_(" Version: %d%s\n"),
4896 header
->e_ident
[EI_VERSION
],
4897 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4899 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4902 printf (_(" OS/ABI: %s\n"),
4903 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4904 printf (_(" ABI Version: %d\n"),
4905 header
->e_ident
[EI_ABIVERSION
]);
4906 printf (_(" Type: %s\n"),
4907 get_file_type (header
->e_type
));
4908 printf (_(" Machine: %s\n"),
4909 get_machine_name (header
->e_machine
));
4910 printf (_(" Version: 0x%lx\n"),
4913 printf (_(" Entry point address: "));
4914 print_vma (header
->e_entry
, PREFIX_HEX
);
4915 printf (_("\n Start of program headers: "));
4916 print_vma (header
->e_phoff
, DEC
);
4917 printf (_(" (bytes into file)\n Start of section headers: "));
4918 print_vma (header
->e_shoff
, DEC
);
4919 printf (_(" (bytes into file)\n"));
4921 printf (_(" Flags: 0x%lx%s\n"),
4923 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4924 printf (_(" Size of this header: %u (bytes)\n"),
4926 printf (_(" Size of program headers: %u (bytes)\n"),
4927 header
->e_phentsize
);
4928 printf (_(" Number of program headers: %u"),
4930 if (filedata
->section_headers
!= NULL
4931 && header
->e_phnum
== PN_XNUM
4932 && filedata
->section_headers
[0].sh_info
!= 0)
4934 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4935 printf (" (%u)", header
->e_phnum
);
4937 putc ('\n', stdout
);
4938 printf (_(" Size of section headers: %u (bytes)\n"),
4939 header
->e_shentsize
);
4940 printf (_(" Number of section headers: %u"),
4942 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4944 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4945 printf (" (%u)", header
->e_shnum
);
4947 putc ('\n', stdout
);
4948 printf (_(" Section header string table index: %u"),
4949 header
->e_shstrndx
);
4950 if (filedata
->section_headers
!= NULL
4951 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4953 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4954 printf (" (%u)", header
->e_shstrndx
);
4956 if (header
->e_shstrndx
!= SHN_UNDEF
4957 && header
->e_shstrndx
>= header
->e_shnum
)
4959 header
->e_shstrndx
= SHN_UNDEF
;
4960 printf (_(" <corrupt: out of range>"));
4962 putc ('\n', stdout
);
4965 if (filedata
->section_headers
!= NULL
)
4967 if (header
->e_phnum
== PN_XNUM
4968 && filedata
->section_headers
[0].sh_info
!= 0)
4969 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4970 if (header
->e_shnum
== SHN_UNDEF
)
4971 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4972 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4973 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4974 if (header
->e_shstrndx
>= header
->e_shnum
)
4975 header
->e_shstrndx
= SHN_UNDEF
;
4976 free (filedata
->section_headers
);
4977 filedata
->section_headers
= NULL
;
4983 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4984 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4987 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4989 Elf32_External_Phdr
* phdrs
;
4990 Elf32_External_Phdr
* external
;
4991 Elf_Internal_Phdr
* internal
;
4993 unsigned int size
= filedata
->file_header
.e_phentsize
;
4994 unsigned int num
= filedata
->file_header
.e_phnum
;
4996 /* PR binutils/17531: Cope with unexpected section header sizes. */
4997 if (size
== 0 || num
== 0)
4999 if (size
< sizeof * phdrs
)
5001 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5004 if (size
> sizeof * phdrs
)
5005 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5007 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5008 size
, num
, _("program headers"));
5012 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5013 i
< filedata
->file_header
.e_phnum
;
5014 i
++, internal
++, external
++)
5016 internal
->p_type
= BYTE_GET (external
->p_type
);
5017 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5018 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5019 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5020 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5021 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5022 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5023 internal
->p_align
= BYTE_GET (external
->p_align
);
5030 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5031 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5034 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5036 Elf64_External_Phdr
* phdrs
;
5037 Elf64_External_Phdr
* external
;
5038 Elf_Internal_Phdr
* internal
;
5040 unsigned int size
= filedata
->file_header
.e_phentsize
;
5041 unsigned int num
= filedata
->file_header
.e_phnum
;
5043 /* PR binutils/17531: Cope with unexpected section header sizes. */
5044 if (size
== 0 || num
== 0)
5046 if (size
< sizeof * phdrs
)
5048 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5051 if (size
> sizeof * phdrs
)
5052 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5054 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5055 size
, num
, _("program headers"));
5059 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5060 i
< filedata
->file_header
.e_phnum
;
5061 i
++, internal
++, external
++)
5063 internal
->p_type
= BYTE_GET (external
->p_type
);
5064 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5065 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5066 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5067 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5068 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5069 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5070 internal
->p_align
= BYTE_GET (external
->p_align
);
5077 /* Returns TRUE if the program headers were read into `program_headers'. */
5080 get_program_headers (Filedata
* filedata
)
5082 Elf_Internal_Phdr
* phdrs
;
5084 /* Check cache of prior read. */
5085 if (filedata
->program_headers
!= NULL
)
5088 /* Be kind to memory checkers by looking for
5089 e_phnum values which we know must be invalid. */
5090 if (filedata
->file_header
.e_phnum
5091 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5092 >= filedata
->file_size
)
5094 error (_("Too many program headers - %#x - the file is not that big\n"),
5095 filedata
->file_header
.e_phnum
);
5099 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5100 sizeof (Elf_Internal_Phdr
));
5103 error (_("Out of memory reading %u program headers\n"),
5104 filedata
->file_header
.e_phnum
);
5109 ? get_32bit_program_headers (filedata
, phdrs
)
5110 : get_64bit_program_headers (filedata
, phdrs
))
5112 filedata
->program_headers
= phdrs
;
5120 /* Returns TRUE if the program headers were loaded. */
5123 process_program_headers (Filedata
* filedata
)
5125 Elf_Internal_Phdr
* segment
;
5127 Elf_Internal_Phdr
* previous_load
= NULL
;
5132 if (filedata
->file_header
.e_phnum
== 0)
5134 /* PR binutils/12467. */
5135 if (filedata
->file_header
.e_phoff
!= 0)
5137 warn (_("possibly corrupt ELF header - it has a non-zero program"
5138 " header offset, but no program headers\n"));
5141 else if (do_segments
)
5142 printf (_("\nThere are no program headers in this file.\n"));
5146 if (do_segments
&& !do_header
)
5148 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5149 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5150 printf (ngettext ("There is %d program header, starting at offset %s\n",
5151 "There are %d program headers, starting at offset %s\n",
5152 filedata
->file_header
.e_phnum
),
5153 filedata
->file_header
.e_phnum
,
5154 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5157 if (! get_program_headers (filedata
))
5162 if (filedata
->file_header
.e_phnum
> 1)
5163 printf (_("\nProgram Headers:\n"));
5165 printf (_("\nProgram Headers:\n"));
5169 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5172 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5176 (_(" Type Offset VirtAddr PhysAddr\n"));
5178 (_(" FileSiz MemSiz Flags Align\n"));
5182 for (i
= 0, segment
= filedata
->program_headers
;
5183 i
< filedata
->file_header
.e_phnum
;
5188 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5192 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5193 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5194 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5195 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5196 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5198 (segment
->p_flags
& PF_R
? 'R' : ' '),
5199 (segment
->p_flags
& PF_W
? 'W' : ' '),
5200 (segment
->p_flags
& PF_X
? 'E' : ' '));
5201 printf ("%#lx", (unsigned long) segment
->p_align
);
5205 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5206 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5209 print_vma (segment
->p_offset
, FULL_HEX
);
5213 print_vma (segment
->p_vaddr
, FULL_HEX
);
5215 print_vma (segment
->p_paddr
, FULL_HEX
);
5218 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5219 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5222 print_vma (segment
->p_filesz
, FULL_HEX
);
5226 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5227 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5230 print_vma (segment
->p_memsz
, FULL_HEX
);
5234 (segment
->p_flags
& PF_R
? 'R' : ' '),
5235 (segment
->p_flags
& PF_W
? 'W' : ' '),
5236 (segment
->p_flags
& PF_X
? 'E' : ' '));
5238 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5239 printf ("%#lx", (unsigned long) segment
->p_align
);
5242 print_vma (segment
->p_align
, PREFIX_HEX
);
5247 print_vma (segment
->p_offset
, FULL_HEX
);
5249 print_vma (segment
->p_vaddr
, FULL_HEX
);
5251 print_vma (segment
->p_paddr
, FULL_HEX
);
5253 print_vma (segment
->p_filesz
, FULL_HEX
);
5255 print_vma (segment
->p_memsz
, FULL_HEX
);
5257 (segment
->p_flags
& PF_R
? 'R' : ' '),
5258 (segment
->p_flags
& PF_W
? 'W' : ' '),
5259 (segment
->p_flags
& PF_X
? 'E' : ' '));
5260 print_vma (segment
->p_align
, PREFIX_HEX
);
5263 putc ('\n', stdout
);
5266 switch (segment
->p_type
)
5269 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5270 required by the ELF standard, several programs, including the Linux
5271 kernel, make use of non-ordered segments. */
5273 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5274 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5276 if (segment
->p_memsz
< segment
->p_filesz
)
5277 error (_("the segment's file size is larger than its memory size\n"));
5278 previous_load
= segment
;
5282 /* PR 20815 - Verify that the program header is loaded into memory. */
5283 if (i
> 0 && previous_load
!= NULL
)
5284 error (_("the PHDR segment must occur before any LOAD segment\n"));
5285 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5289 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5291 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5292 if (load
->p_type
== PT_LOAD
5293 && load
->p_offset
<= segment
->p_offset
5294 && (load
->p_offset
+ load
->p_filesz
5295 >= segment
->p_offset
+ segment
->p_filesz
)
5296 && load
->p_vaddr
<= segment
->p_vaddr
5297 && (load
->p_vaddr
+ load
->p_filesz
5298 >= segment
->p_vaddr
+ segment
->p_filesz
))
5301 if (j
== filedata
->file_header
.e_phnum
)
5302 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5308 error (_("more than one dynamic segment\n"));
5310 /* By default, assume that the .dynamic section is the first
5311 section in the DYNAMIC segment. */
5312 dynamic_addr
= segment
->p_offset
;
5313 dynamic_size
= segment
->p_filesz
;
5315 /* Try to locate the .dynamic section. If there is
5316 a section header table, we can easily locate it. */
5317 if (filedata
->section_headers
!= NULL
)
5319 Elf_Internal_Shdr
* sec
;
5321 sec
= find_section (filedata
, ".dynamic");
5322 if (sec
== NULL
|| sec
->sh_size
== 0)
5324 /* A corresponding .dynamic section is expected, but on
5325 IA-64/OpenVMS it is OK for it to be missing. */
5326 if (!is_ia64_vms (filedata
))
5327 error (_("no .dynamic section in the dynamic segment\n"));
5331 if (sec
->sh_type
== SHT_NOBITS
)
5337 dynamic_addr
= sec
->sh_offset
;
5338 dynamic_size
= sec
->sh_size
;
5340 if (dynamic_addr
< segment
->p_offset
5341 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5342 warn (_("the .dynamic section is not contained"
5343 " within the dynamic segment\n"));
5344 else if (dynamic_addr
> segment
->p_offset
)
5345 warn (_("the .dynamic section is not the first section"
5346 " in the dynamic segment.\n"));
5349 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5350 segment. Check this after matching against the section headers
5351 so we don't warn on debuginfo file (which have NOBITS .dynamic
5353 if (dynamic_addr
> filedata
->file_size
5354 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5356 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5357 dynamic_addr
= dynamic_size
= 0;
5362 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5364 error (_("Unable to find program interpreter name\n"));
5368 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5370 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5371 error (_("Internal error: failed to create format string to display program interpreter\n"));
5373 program_interpreter
[0] = 0;
5374 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5375 error (_("Unable to read program interpreter name\n"));
5378 printf (_(" [Requesting program interpreter: %s]\n"),
5379 program_interpreter
);
5386 && filedata
->section_headers
!= NULL
5387 && filedata
->string_table
!= NULL
)
5389 printf (_("\n Section to Segment mapping:\n"));
5390 printf (_(" Segment Sections...\n"));
5392 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5395 Elf_Internal_Shdr
* section
;
5397 segment
= filedata
->program_headers
+ i
;
5398 section
= filedata
->section_headers
+ 1;
5400 printf (" %2.2d ", i
);
5402 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5404 if (!ELF_TBSS_SPECIAL (section
, segment
)
5405 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5406 printf ("%s ", printable_section_name (filedata
, section
));
5417 /* Find the file offset corresponding to VMA by using the program headers. */
5420 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5422 Elf_Internal_Phdr
* seg
;
5424 if (! get_program_headers (filedata
))
5426 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5430 for (seg
= filedata
->program_headers
;
5431 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5434 if (seg
->p_type
!= PT_LOAD
)
5437 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5438 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5439 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5442 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5443 (unsigned long) vma
);
5448 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5449 If PROBE is true, this is just a probe and we do not generate any error
5450 messages if the load fails. */
5453 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5455 Elf32_External_Shdr
* shdrs
;
5456 Elf_Internal_Shdr
* internal
;
5458 unsigned int size
= filedata
->file_header
.e_shentsize
;
5459 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5461 /* PR binutils/17531: Cope with unexpected section header sizes. */
5462 if (size
== 0 || num
== 0)
5464 if (size
< sizeof * shdrs
)
5467 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5470 if (!probe
&& size
> sizeof * shdrs
)
5471 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5473 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5475 probe
? NULL
: _("section headers"));
5479 free (filedata
->section_headers
);
5480 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5481 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5482 if (filedata
->section_headers
== NULL
)
5485 error (_("Out of memory reading %u section headers\n"), num
);
5490 for (i
= 0, internal
= filedata
->section_headers
;
5494 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5495 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5496 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5497 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5498 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5499 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5500 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5501 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5502 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5503 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5504 if (!probe
&& internal
->sh_link
> num
)
5505 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5506 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5507 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5514 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5517 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5519 Elf64_External_Shdr
* shdrs
;
5520 Elf_Internal_Shdr
* internal
;
5522 unsigned int size
= filedata
->file_header
.e_shentsize
;
5523 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5525 /* PR binutils/17531: Cope with unexpected section header sizes. */
5526 if (size
== 0 || num
== 0)
5529 if (size
< sizeof * shdrs
)
5532 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5536 if (! probe
&& size
> sizeof * shdrs
)
5537 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5539 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5540 filedata
->file_header
.e_shoff
,
5542 probe
? NULL
: _("section headers"));
5546 free (filedata
->section_headers
);
5547 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5548 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5549 if (filedata
->section_headers
== NULL
)
5552 error (_("Out of memory reading %u section headers\n"), num
);
5557 for (i
= 0, internal
= filedata
->section_headers
;
5561 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5562 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5563 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5564 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5565 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5566 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5567 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5568 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5569 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5570 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5571 if (!probe
&& internal
->sh_link
> num
)
5572 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5573 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5574 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5581 static Elf_Internal_Sym
*
5582 get_32bit_elf_symbols (Filedata
* filedata
,
5583 Elf_Internal_Shdr
* section
,
5584 unsigned long * num_syms_return
)
5586 unsigned long number
= 0;
5587 Elf32_External_Sym
* esyms
= NULL
;
5588 Elf_External_Sym_Shndx
* shndx
= NULL
;
5589 Elf_Internal_Sym
* isyms
= NULL
;
5590 Elf_Internal_Sym
* psym
;
5592 elf_section_list
* entry
;
5594 if (section
->sh_size
== 0)
5596 if (num_syms_return
!= NULL
)
5597 * num_syms_return
= 0;
5601 /* Run some sanity checks first. */
5602 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5604 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5605 printable_section_name (filedata
, section
),
5606 (unsigned long) section
->sh_entsize
);
5610 if (section
->sh_size
> filedata
->file_size
)
5612 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5613 printable_section_name (filedata
, section
),
5614 (unsigned long) section
->sh_size
);
5618 number
= section
->sh_size
/ section
->sh_entsize
;
5620 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5622 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5623 (unsigned long) section
->sh_size
,
5624 printable_section_name (filedata
, section
),
5625 (unsigned long) section
->sh_entsize
);
5629 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5630 section
->sh_size
, _("symbols"));
5635 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5637 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5642 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5646 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5647 entry
->hdr
->sh_offset
,
5648 1, entry
->hdr
->sh_size
,
5649 _("symbol table section indices"));
5653 /* PR17531: file: heap-buffer-overflow */
5654 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5656 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5657 printable_section_name (filedata
, entry
->hdr
),
5658 (unsigned long) entry
->hdr
->sh_size
,
5659 (unsigned long) section
->sh_size
);
5664 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5668 error (_("Out of memory reading %lu symbols\n"),
5669 (unsigned long) number
);
5673 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5675 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5676 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5677 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5678 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5679 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5681 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5682 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5683 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5684 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5685 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5692 if (num_syms_return
!= NULL
)
5693 * num_syms_return
= isyms
== NULL
? 0 : number
;
5698 static Elf_Internal_Sym
*
5699 get_64bit_elf_symbols (Filedata
* filedata
,
5700 Elf_Internal_Shdr
* section
,
5701 unsigned long * num_syms_return
)
5703 unsigned long number
= 0;
5704 Elf64_External_Sym
* esyms
= NULL
;
5705 Elf_External_Sym_Shndx
* shndx
= NULL
;
5706 Elf_Internal_Sym
* isyms
= NULL
;
5707 Elf_Internal_Sym
* psym
;
5709 elf_section_list
* entry
;
5711 if (section
->sh_size
== 0)
5713 if (num_syms_return
!= NULL
)
5714 * num_syms_return
= 0;
5718 /* Run some sanity checks first. */
5719 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5721 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5722 printable_section_name (filedata
, section
),
5723 (unsigned long) section
->sh_entsize
);
5727 if (section
->sh_size
> filedata
->file_size
)
5729 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5730 printable_section_name (filedata
, section
),
5731 (unsigned long) section
->sh_size
);
5735 number
= section
->sh_size
/ section
->sh_entsize
;
5737 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5739 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5740 (unsigned long) section
->sh_size
,
5741 printable_section_name (filedata
, section
),
5742 (unsigned long) section
->sh_entsize
);
5746 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5747 section
->sh_size
, _("symbols"));
5752 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5754 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5759 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5763 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5764 entry
->hdr
->sh_offset
,
5765 1, entry
->hdr
->sh_size
,
5766 _("symbol table section indices"));
5770 /* PR17531: file: heap-buffer-overflow */
5771 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5773 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5774 printable_section_name (filedata
, entry
->hdr
),
5775 (unsigned long) entry
->hdr
->sh_size
,
5776 (unsigned long) section
->sh_size
);
5781 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5785 error (_("Out of memory reading %lu symbols\n"),
5786 (unsigned long) number
);
5790 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5792 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5793 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5794 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5795 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5797 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5799 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5800 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5801 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5803 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5804 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5811 if (num_syms_return
!= NULL
)
5812 * num_syms_return
= isyms
== NULL
? 0 : number
;
5818 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5820 static char buff
[1024];
5822 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5824 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5825 bfd_vma os_flags
= 0;
5826 bfd_vma proc_flags
= 0;
5827 bfd_vma unknown_flags
= 0;
5835 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5836 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5837 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5838 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5839 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5840 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5841 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5842 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5843 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5844 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5845 /* IA-64 specific. */
5846 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5847 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5848 /* IA-64 OpenVMS specific. */
5849 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5850 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5851 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5852 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5853 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5854 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5856 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5857 /* SPARC specific. */
5858 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5859 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5861 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5862 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5863 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5865 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5867 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5870 if (do_section_details
)
5872 sprintf (buff
, "[%*.*lx]: ",
5873 field_size
, field_size
, (unsigned long) sh_flags
);
5874 p
+= field_size
+ 4;
5881 flag
= sh_flags
& - sh_flags
;
5884 if (do_section_details
)
5888 case SHF_WRITE
: sindex
= 0; break;
5889 case SHF_ALLOC
: sindex
= 1; break;
5890 case SHF_EXECINSTR
: sindex
= 2; break;
5891 case SHF_MERGE
: sindex
= 3; break;
5892 case SHF_STRINGS
: sindex
= 4; break;
5893 case SHF_INFO_LINK
: sindex
= 5; break;
5894 case SHF_LINK_ORDER
: sindex
= 6; break;
5895 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5896 case SHF_GROUP
: sindex
= 8; break;
5897 case SHF_TLS
: sindex
= 9; break;
5898 case SHF_EXCLUDE
: sindex
= 18; break;
5899 case SHF_COMPRESSED
: sindex
= 20; break;
5900 case SHF_GNU_MBIND
: sindex
= 24; break;
5904 switch (filedata
->file_header
.e_machine
)
5907 if (flag
== SHF_IA_64_SHORT
)
5909 else if (flag
== SHF_IA_64_NORECOV
)
5912 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5915 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5916 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5917 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5918 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5919 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5920 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5931 case EM_OLD_SPARCV9
:
5932 case EM_SPARC32PLUS
:
5935 if (flag
== SHF_ORDERED
)
5942 case SHF_ENTRYSECT
: sindex
= 21; break;
5943 case SHF_ARM_PURECODE
: sindex
= 22; break;
5944 case SHF_COMDEF
: sindex
= 23; break;
5949 if (flag
== SHF_PPC_VLE
)
5960 if (p
!= buff
+ field_size
+ 4)
5962 if (size
< (10 + 2))
5964 warn (_("Internal error: not enough buffer room for section flag info"));
5965 return _("<unknown>");
5972 size
-= flags
[sindex
].len
;
5973 p
= stpcpy (p
, flags
[sindex
].str
);
5975 else if (flag
& SHF_MASKOS
)
5977 else if (flag
& SHF_MASKPROC
)
5980 unknown_flags
|= flag
;
5986 case SHF_WRITE
: *p
= 'W'; break;
5987 case SHF_ALLOC
: *p
= 'A'; break;
5988 case SHF_EXECINSTR
: *p
= 'X'; break;
5989 case SHF_MERGE
: *p
= 'M'; break;
5990 case SHF_STRINGS
: *p
= 'S'; break;
5991 case SHF_INFO_LINK
: *p
= 'I'; break;
5992 case SHF_LINK_ORDER
: *p
= 'L'; break;
5993 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5994 case SHF_GROUP
: *p
= 'G'; break;
5995 case SHF_TLS
: *p
= 'T'; break;
5996 case SHF_EXCLUDE
: *p
= 'E'; break;
5997 case SHF_COMPRESSED
: *p
= 'C'; break;
5998 case SHF_GNU_MBIND
: *p
= 'D'; break;
6001 if ((filedata
->file_header
.e_machine
== EM_X86_64
6002 || filedata
->file_header
.e_machine
== EM_L1OM
6003 || filedata
->file_header
.e_machine
== EM_K1OM
)
6004 && flag
== SHF_X86_64_LARGE
)
6006 else if (filedata
->file_header
.e_machine
== EM_ARM
6007 && flag
== SHF_ARM_PURECODE
)
6009 else if (filedata
->file_header
.e_machine
== EM_PPC
6010 && flag
== SHF_PPC_VLE
)
6012 else if (flag
& SHF_MASKOS
)
6015 sh_flags
&= ~ SHF_MASKOS
;
6017 else if (flag
& SHF_MASKPROC
)
6020 sh_flags
&= ~ SHF_MASKPROC
;
6030 if (do_section_details
)
6034 size
-= 5 + field_size
;
6035 if (p
!= buff
+ field_size
+ 4)
6039 warn (_("Internal error: not enough buffer room for section flag info"));
6040 return _("<unknown>");
6046 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6047 (unsigned long) os_flags
);
6048 p
+= 5 + field_size
;
6052 size
-= 7 + field_size
;
6053 if (p
!= buff
+ field_size
+ 4)
6057 warn (_("Internal error: not enough buffer room for section flag info"));
6058 return _("<unknown>");
6064 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6065 (unsigned long) proc_flags
);
6066 p
+= 7 + field_size
;
6070 size
-= 10 + field_size
;
6071 if (p
!= buff
+ field_size
+ 4)
6075 warn (_("Internal error: not enough buffer room for section flag info"));
6076 return _("<unknown>");
6082 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6083 (unsigned long) unknown_flags
);
6084 p
+= 10 + field_size
;
6092 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6093 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6097 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6099 if (size
< sizeof (* echdr
))
6101 error (_("Compressed section is too small even for a compression header\n"));
6105 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6106 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6107 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6108 return sizeof (*echdr
);
6112 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6114 if (size
< sizeof (* echdr
))
6116 error (_("Compressed section is too small even for a compression header\n"));
6120 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6121 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6122 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6123 return sizeof (*echdr
);
6128 process_section_headers (Filedata
* filedata
)
6130 Elf_Internal_Shdr
* section
;
6133 free (filedata
->section_headers
);
6134 filedata
->section_headers
= NULL
;
6136 if (filedata
->file_header
.e_shnum
== 0)
6138 /* PR binutils/12467. */
6139 if (filedata
->file_header
.e_shoff
!= 0)
6141 warn (_("possibly corrupt ELF file header - it has a non-zero"
6142 " section header offset, but no section headers\n"));
6145 else if (do_sections
)
6146 printf (_("\nThere are no sections in this file.\n"));
6151 if (do_sections
&& !do_header
)
6152 printf (ngettext ("There is %d section header, "
6153 "starting at offset 0x%lx:\n",
6154 "There are %d section headers, "
6155 "starting at offset 0x%lx:\n",
6156 filedata
->file_header
.e_shnum
),
6157 filedata
->file_header
.e_shnum
,
6158 (unsigned long) filedata
->file_header
.e_shoff
);
6162 if (! get_32bit_section_headers (filedata
, FALSE
))
6167 if (! get_64bit_section_headers (filedata
, FALSE
))
6171 /* Read in the string table, so that we have names to display. */
6172 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6173 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6175 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6177 if (section
->sh_size
!= 0)
6179 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6180 1, section
->sh_size
,
6183 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6187 /* Scan the sections for the dynamic symbol table
6188 and dynamic string table and debug sections. */
6189 free (dynamic_symbols
);
6190 dynamic_symbols
= NULL
;
6191 num_dynamic_syms
= 0;
6192 free (dynamic_strings
);
6193 dynamic_strings
= NULL
;
6194 dynamic_strings_length
= 0;
6195 free (dynamic_syminfo
);
6196 dynamic_syminfo
= NULL
;
6197 while (symtab_shndx_list
!= NULL
)
6199 elf_section_list
*next
= symtab_shndx_list
->next
;
6200 free (symtab_shndx_list
);
6201 symtab_shndx_list
= next
;
6204 eh_addr_size
= is_32bit_elf
? 4 : 8;
6205 switch (filedata
->file_header
.e_machine
)
6208 case EM_MIPS_RS3_LE
:
6209 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6210 FDE addresses. However, the ABI also has a semi-official ILP32
6211 variant for which the normal FDE address size rules apply.
6213 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6214 section, where XX is the size of longs in bits. Unfortunately,
6215 earlier compilers provided no way of distinguishing ILP32 objects
6216 from LP64 objects, so if there's any doubt, we should assume that
6217 the official LP64 form is being used. */
6218 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6219 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6225 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6227 case E_H8_MACH_H8300
:
6228 case E_H8_MACH_H8300HN
:
6229 case E_H8_MACH_H8300SN
:
6230 case E_H8_MACH_H8300SXN
:
6233 case E_H8_MACH_H8300H
:
6234 case E_H8_MACH_H8300S
:
6235 case E_H8_MACH_H8300SX
:
6243 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6245 case EF_M32C_CPU_M16C
:
6252 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6255 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6256 if (section->sh_entsize != expected_entsize) \
6259 sprintf_vma (buf, section->sh_entsize); \
6260 /* Note: coded this way so that there is a single string for \
6262 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6263 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6264 (unsigned) expected_entsize); \
6265 section->sh_entsize = expected_entsize; \
6270 #define CHECK_ENTSIZE(section, i, type) \
6271 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6272 sizeof (Elf64_External_##type))
6274 for (i
= 0, section
= filedata
->section_headers
;
6275 i
< filedata
->file_header
.e_shnum
;
6278 char * name
= SECTION_NAME (section
);
6280 if (section
->sh_type
== SHT_DYNSYM
)
6282 if (dynamic_symbols
!= NULL
)
6284 error (_("File contains multiple dynamic symbol tables\n"));
6288 CHECK_ENTSIZE (section
, i
, Sym
);
6289 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6291 else if (section
->sh_type
== SHT_STRTAB
6292 && streq (name
, ".dynstr"))
6294 if (dynamic_strings
!= NULL
)
6296 error (_("File contains multiple dynamic string tables\n"));
6300 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6301 1, section
->sh_size
,
6302 _("dynamic strings"));
6303 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6305 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6307 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6309 entry
->hdr
= section
;
6310 entry
->next
= symtab_shndx_list
;
6311 symtab_shndx_list
= entry
;
6313 else if (section
->sh_type
== SHT_SYMTAB
)
6314 CHECK_ENTSIZE (section
, i
, Sym
);
6315 else if (section
->sh_type
== SHT_GROUP
)
6316 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6317 else if (section
->sh_type
== SHT_REL
)
6318 CHECK_ENTSIZE (section
, i
, Rel
);
6319 else if (section
->sh_type
== SHT_RELA
)
6320 CHECK_ENTSIZE (section
, i
, Rela
);
6321 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6322 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6323 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6324 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6325 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6326 && (const_strneq (name
, ".debug_")
6327 || const_strneq (name
, ".zdebug_")))
6330 name
+= sizeof (".zdebug_") - 1;
6332 name
+= sizeof (".debug_") - 1;
6335 || (do_debug_info
&& const_strneq (name
, "info"))
6336 || (do_debug_info
&& const_strneq (name
, "types"))
6337 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6338 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6339 || (do_debug_lines
&& const_strneq (name
, "line."))
6340 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6341 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6342 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6343 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6344 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6345 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6346 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6347 || (do_debug_frames
&& const_strneq (name
, "frame"))
6348 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6349 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6350 || (do_debug_str
&& const_strneq (name
, "str"))
6351 || (do_debug_loc
&& const_strneq (name
, "loc"))
6352 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6353 || (do_debug_addr
&& const_strneq (name
, "addr"))
6354 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6355 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6357 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6359 /* Linkonce section to be combined with .debug_info at link time. */
6360 else if ((do_debugging
|| do_debug_info
)
6361 && const_strneq (name
, ".gnu.linkonce.wi."))
6362 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6363 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6364 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6365 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6366 || streq (name
, ".debug_names")))
6367 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6368 /* Trace sections for Itanium VMS. */
6369 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6370 || do_trace_aranges
)
6371 && const_strneq (name
, ".trace_"))
6373 name
+= sizeof (".trace_") - 1;
6376 || (do_trace_info
&& streq (name
, "info"))
6377 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6378 || (do_trace_aranges
&& streq (name
, "aranges"))
6380 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6382 else if ((do_debugging
|| do_debug_links
)
6383 && (const_strneq (name
, ".gnu_debuglink")
6384 || const_strneq (name
, ".gnu_debugaltlink")))
6385 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6391 if (filedata
->file_header
.e_shnum
> 1)
6392 printf (_("\nSection Headers:\n"));
6394 printf (_("\nSection Header:\n"));
6398 if (do_section_details
)
6400 printf (_(" [Nr] Name\n"));
6401 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6405 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6409 if (do_section_details
)
6411 printf (_(" [Nr] Name\n"));
6412 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6416 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6420 if (do_section_details
)
6422 printf (_(" [Nr] Name\n"));
6423 printf (_(" Type Address Offset Link\n"));
6424 printf (_(" Size EntSize Info Align\n"));
6428 printf (_(" [Nr] Name Type Address Offset\n"));
6429 printf (_(" Size EntSize Flags Link Info Align\n"));
6433 if (do_section_details
)
6434 printf (_(" Flags\n"));
6436 for (i
= 0, section
= filedata
->section_headers
;
6437 i
< filedata
->file_header
.e_shnum
;
6440 /* Run some sanity checks on the section header. */
6442 /* Check the sh_link field. */
6443 switch (section
->sh_type
)
6447 if (section
->sh_link
== 0
6448 && (filedata
->file_header
.e_type
== ET_EXEC
6449 || filedata
->file_header
.e_type
== ET_DYN
))
6450 /* A dynamic relocation section where all entries use a
6451 zero symbol index need not specify a symtab section. */
6454 case SHT_SYMTAB_SHNDX
:
6458 case SHT_GNU_versym
:
6459 if (section
->sh_link
== 0
6460 || section
->sh_link
>= filedata
->file_header
.e_shnum
6461 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6462 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6463 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6464 i
, section
->sh_link
);
6470 case SHT_GNU_verneed
:
6471 case SHT_GNU_verdef
:
6472 case SHT_GNU_LIBLIST
:
6473 if (section
->sh_link
== 0
6474 || section
->sh_link
>= filedata
->file_header
.e_shnum
6475 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6476 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6477 i
, section
->sh_link
);
6480 case SHT_INIT_ARRAY
:
6481 case SHT_FINI_ARRAY
:
6482 case SHT_PREINIT_ARRAY
:
6483 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6484 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6485 i
, section
->sh_link
);
6489 /* FIXME: Add support for target specific section types. */
6490 #if 0 /* Currently we do not check other section types as there are too
6491 many special cases. Stab sections for example have a type
6492 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6494 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6495 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6496 i
, section
->sh_link
);
6501 /* Check the sh_info field. */
6502 switch (section
->sh_type
)
6506 if (section
->sh_info
== 0
6507 && (filedata
->file_header
.e_type
== ET_EXEC
6508 || filedata
->file_header
.e_type
== ET_DYN
))
6509 /* Dynamic relocations apply to segments, so they do not
6510 need to specify the section they relocate. */
6512 if (section
->sh_info
== 0
6513 || section
->sh_info
>= filedata
->file_header
.e_shnum
6514 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6515 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6516 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6517 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6518 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6519 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6520 /* FIXME: Are other section types valid ? */
6521 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6522 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6523 i
, section
->sh_info
);
6528 case SHT_SYMTAB_SHNDX
:
6529 case SHT_INIT_ARRAY
:
6530 case SHT_FINI_ARRAY
:
6531 case SHT_PREINIT_ARRAY
:
6532 if (section
->sh_info
!= 0)
6533 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6534 i
, section
->sh_info
);
6540 /* A symbol index - we assume that it is valid. */
6544 /* FIXME: Add support for target specific section types. */
6545 if (section
->sh_type
== SHT_NOBITS
)
6546 /* NOBITS section headers with non-zero sh_info fields can be
6547 created when a binary is stripped of everything but its debug
6548 information. The stripped sections have their headers
6549 preserved but their types set to SHT_NOBITS. So do not check
6550 this type of section. */
6552 else if (section
->sh_flags
& SHF_INFO_LINK
)
6554 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6555 warn (_("[%2u]: Expected link to another section in info field"), i
);
6557 else if (section
->sh_type
< SHT_LOOS
6558 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6559 && section
->sh_info
!= 0)
6560 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6561 i
, section
->sh_info
);
6565 /* Check the sh_size field. */
6566 if (section
->sh_size
> filedata
->file_size
6567 && section
->sh_type
!= SHT_NOBITS
6568 && section
->sh_type
!= SHT_NULL
6569 && section
->sh_type
< SHT_LOOS
)
6570 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6572 printf (" [%2u] ", i
);
6573 if (do_section_details
)
6574 printf ("%s\n ", printable_section_name (filedata
, section
));
6576 print_symbol (-17, SECTION_NAME (section
));
6578 printf (do_wide
? " %-15s " : " %-15.15s ",
6579 get_section_type_name (filedata
, section
->sh_type
));
6583 const char * link_too_big
= NULL
;
6585 print_vma (section
->sh_addr
, LONG_HEX
);
6587 printf ( " %6.6lx %6.6lx %2.2lx",
6588 (unsigned long) section
->sh_offset
,
6589 (unsigned long) section
->sh_size
,
6590 (unsigned long) section
->sh_entsize
);
6592 if (do_section_details
)
6593 fputs (" ", stdout
);
6595 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6597 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6600 /* The sh_link value is out of range. Normally this indicates
6601 an error but it can have special values in Solaris binaries. */
6602 switch (filedata
->file_header
.e_machine
)
6609 case EM_OLD_SPARCV9
:
6610 case EM_SPARC32PLUS
:
6613 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6614 link_too_big
= "BEFORE";
6615 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6616 link_too_big
= "AFTER";
6623 if (do_section_details
)
6625 if (link_too_big
!= NULL
&& * link_too_big
)
6626 printf ("<%s> ", link_too_big
);
6628 printf ("%2u ", section
->sh_link
);
6629 printf ("%3u %2lu\n", section
->sh_info
,
6630 (unsigned long) section
->sh_addralign
);
6633 printf ("%2u %3u %2lu\n",
6636 (unsigned long) section
->sh_addralign
);
6638 if (link_too_big
&& ! * link_too_big
)
6639 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6640 i
, section
->sh_link
);
6644 print_vma (section
->sh_addr
, LONG_HEX
);
6646 if ((long) section
->sh_offset
== section
->sh_offset
)
6647 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6651 print_vma (section
->sh_offset
, LONG_HEX
);
6654 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6655 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6659 print_vma (section
->sh_size
, LONG_HEX
);
6662 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6663 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6667 print_vma (section
->sh_entsize
, LONG_HEX
);
6670 if (do_section_details
)
6671 fputs (" ", stdout
);
6673 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6675 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6677 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6678 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6681 print_vma (section
->sh_addralign
, DEC
);
6685 else if (do_section_details
)
6688 print_vma (section
->sh_addr
, LONG_HEX
);
6689 if ((long) section
->sh_offset
== section
->sh_offset
)
6690 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6694 print_vma (section
->sh_offset
, LONG_HEX
);
6696 printf (" %u\n ", section
->sh_link
);
6697 print_vma (section
->sh_size
, LONG_HEX
);
6699 print_vma (section
->sh_entsize
, LONG_HEX
);
6701 printf (" %-16u %lu\n",
6703 (unsigned long) section
->sh_addralign
);
6708 print_vma (section
->sh_addr
, LONG_HEX
);
6709 if ((long) section
->sh_offset
== section
->sh_offset
)
6710 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6714 print_vma (section
->sh_offset
, LONG_HEX
);
6717 print_vma (section
->sh_size
, LONG_HEX
);
6719 print_vma (section
->sh_entsize
, LONG_HEX
);
6721 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6723 printf (" %2u %3u %lu\n",
6726 (unsigned long) section
->sh_addralign
);
6729 if (do_section_details
)
6731 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6732 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6734 /* Minimum section size is 12 bytes for 32-bit compression
6735 header + 12 bytes for compressed data header. */
6736 unsigned char buf
[24];
6738 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6739 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6740 sizeof (buf
), _("compression header")))
6742 Elf_Internal_Chdr chdr
;
6744 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6745 printf (_(" [<corrupt>]\n"));
6748 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6751 printf (_(" [<unknown>: 0x%x], "),
6753 print_vma (chdr
.ch_size
, LONG_HEX
);
6754 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6761 if (!do_section_details
)
6763 /* The ordering of the letters shown here matches the ordering of the
6764 corresponding SHF_xxx values, and hence the order in which these
6765 letters will be displayed to the user. */
6766 printf (_("Key to Flags:\n\
6767 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6768 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6769 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6770 if (filedata
->file_header
.e_machine
== EM_X86_64
6771 || filedata
->file_header
.e_machine
== EM_L1OM
6772 || filedata
->file_header
.e_machine
== EM_K1OM
)
6773 printf (_("l (large), "));
6774 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6775 printf (_("y (purecode), "));
6776 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6777 printf (_("v (VLE), "));
6778 printf ("p (processor specific)\n");
6785 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6786 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6787 char **strtab
, unsigned long *strtablen
)
6791 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6793 if (*symtab
== NULL
)
6796 if (symsec
->sh_link
!= 0)
6798 Elf_Internal_Shdr
*strsec
;
6800 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6802 error (_("Bad sh_link in symbol table section\n"));
6809 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6811 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6812 1, strsec
->sh_size
, _("string table"));
6813 if (*strtab
== NULL
)
6820 *strtablen
= strsec
->sh_size
;
6826 get_group_flags (unsigned int flags
)
6828 static char buff
[128];
6832 else if (flags
== GRP_COMDAT
)
6835 snprintf (buff
, 14, _("[0x%x: "), flags
);
6837 flags
&= ~ GRP_COMDAT
;
6838 if (flags
& GRP_MASKOS
)
6840 strcat (buff
, "<OS specific>");
6841 flags
&= ~ GRP_MASKOS
;
6844 if (flags
& GRP_MASKPROC
)
6846 strcat (buff
, "<PROC specific>");
6847 flags
&= ~ GRP_MASKPROC
;
6851 strcat (buff
, "<unknown>");
6858 process_section_groups (Filedata
* filedata
)
6860 Elf_Internal_Shdr
* section
;
6862 struct group
* group
;
6863 Elf_Internal_Shdr
* symtab_sec
;
6864 Elf_Internal_Shdr
* strtab_sec
;
6865 Elf_Internal_Sym
* symtab
;
6866 unsigned long num_syms
;
6870 /* Don't process section groups unless needed. */
6871 if (!do_unwind
&& !do_section_groups
)
6874 if (filedata
->file_header
.e_shnum
== 0)
6876 if (do_section_groups
)
6877 printf (_("\nThere are no sections to group in this file.\n"));
6882 if (filedata
->section_headers
== NULL
)
6884 error (_("Section headers are not available!\n"));
6885 /* PR 13622: This can happen with a corrupt ELF header. */
6889 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6890 sizeof (struct group
*));
6892 if (section_headers_groups
== NULL
)
6894 error (_("Out of memory reading %u section group headers\n"),
6895 filedata
->file_header
.e_shnum
);
6899 /* Scan the sections for the group section. */
6901 for (i
= 0, section
= filedata
->section_headers
;
6902 i
< filedata
->file_header
.e_shnum
;
6904 if (section
->sh_type
== SHT_GROUP
)
6907 if (group_count
== 0)
6909 if (do_section_groups
)
6910 printf (_("\nThere are no section groups in this file.\n"));
6915 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6917 if (section_groups
== NULL
)
6919 error (_("Out of memory reading %lu groups\n"),
6920 (unsigned long) group_count
);
6930 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6931 i
< filedata
->file_header
.e_shnum
;
6934 if (section
->sh_type
== SHT_GROUP
)
6936 const char * name
= printable_section_name (filedata
, section
);
6937 const char * group_name
;
6938 unsigned char * start
;
6939 unsigned char * indices
;
6940 unsigned int entry
, j
, size
;
6941 Elf_Internal_Shdr
* sec
;
6942 Elf_Internal_Sym
* sym
;
6944 /* Get the symbol table. */
6945 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6946 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6949 error (_("Bad sh_link in group section `%s'\n"), name
);
6953 if (symtab_sec
!= sec
)
6958 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6963 error (_("Corrupt header in group section `%s'\n"), name
);
6967 if (section
->sh_info
>= num_syms
)
6969 error (_("Bad sh_info in group section `%s'\n"), name
);
6973 sym
= symtab
+ section
->sh_info
;
6975 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6977 if (sym
->st_shndx
== 0
6978 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6980 error (_("Bad sh_info in group section `%s'\n"), name
);
6984 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6993 /* Get the string table. */
6994 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7003 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7009 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7010 1, strtab_sec
->sh_size
,
7012 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7014 group_name
= sym
->st_name
< strtab_size
7015 ? strtab
+ sym
->st_name
: _("<corrupt>");
7018 /* PR 17531: file: loop. */
7019 if (section
->sh_entsize
> section
->sh_size
)
7021 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7022 printable_section_name (filedata
, section
),
7023 (unsigned long) section
->sh_entsize
,
7024 (unsigned long) section
->sh_size
);
7028 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7029 1, section
->sh_size
,
7035 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7036 entry
= byte_get (indices
, 4);
7039 if (do_section_groups
)
7041 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7042 get_group_flags (entry
), i
, name
, group_name
, size
);
7044 printf (_(" [Index] Name\n"));
7047 group
->group_index
= i
;
7049 for (j
= 0; j
< size
; j
++)
7051 struct group_list
* g
;
7053 entry
= byte_get (indices
, 4);
7056 if (entry
>= filedata
->file_header
.e_shnum
)
7058 static unsigned num_group_errors
= 0;
7060 if (num_group_errors
++ < 10)
7062 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7063 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7064 if (num_group_errors
== 10)
7065 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7070 if (section_headers_groups
[entry
] != NULL
)
7074 static unsigned num_errs
= 0;
7076 if (num_errs
++ < 10)
7078 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7080 section_headers_groups
[entry
]->group_index
);
7082 warn (_("Further error messages about already contained group sections suppressed\n"));
7088 /* Intel C/C++ compiler may put section 0 in a
7089 section group. We just warn it the first time
7090 and ignore it afterwards. */
7091 static bfd_boolean warned
= FALSE
;
7094 error (_("section 0 in group section [%5u]\n"),
7095 section_headers_groups
[entry
]->group_index
);
7101 section_headers_groups
[entry
] = group
;
7103 if (do_section_groups
)
7105 sec
= filedata
->section_headers
+ entry
;
7106 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7109 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7110 g
->section_index
= entry
;
7111 g
->next
= group
->root
;
7129 /* Data used to display dynamic fixups. */
7131 struct ia64_vms_dynfixup
7133 bfd_vma needed_ident
; /* Library ident number. */
7134 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7135 bfd_vma fixup_needed
; /* Index of the library. */
7136 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7137 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7140 /* Data used to display dynamic relocations. */
7142 struct ia64_vms_dynimgrela
7144 bfd_vma img_rela_cnt
; /* Number of relocations. */
7145 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7148 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7152 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7153 struct ia64_vms_dynfixup
* fixup
,
7154 const char * strtab
,
7155 unsigned int strtab_sz
)
7157 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7159 const char * lib_name
;
7161 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7162 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7163 _("dynamic section image fixups"));
7167 if (fixup
->needed
< strtab_sz
)
7168 lib_name
= strtab
+ fixup
->needed
;
7171 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7172 (unsigned long) fixup
->needed
);
7176 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7177 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7179 (_("Seg Offset Type SymVec DataType\n"));
7181 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7186 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7187 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7188 type
= BYTE_GET (imfs
[i
].type
);
7189 rtype
= elf_ia64_reloc_type (type
);
7191 printf (" 0x%08x ", type
);
7193 printf (" %-32s ", rtype
);
7194 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7195 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7202 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7205 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7207 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7210 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7211 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7212 _("dynamic section image relocations"));
7216 printf (_("\nImage relocs\n"));
7218 (_("Seg Offset Type Addend Seg Sym Off\n"));
7220 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7225 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7226 printf ("%08" BFD_VMA_FMT
"x ",
7227 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7228 type
= BYTE_GET (imrs
[i
].type
);
7229 rtype
= elf_ia64_reloc_type (type
);
7231 printf ("0x%08x ", type
);
7233 printf ("%-31s ", rtype
);
7234 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7235 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7236 printf ("%08" BFD_VMA_FMT
"x\n",
7237 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7244 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7247 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7249 struct ia64_vms_dynfixup fixup
;
7250 struct ia64_vms_dynimgrela imgrela
;
7251 Elf_Internal_Dyn
*entry
;
7252 bfd_vma strtab_off
= 0;
7253 bfd_vma strtab_sz
= 0;
7254 char *strtab
= NULL
;
7255 bfd_boolean res
= TRUE
;
7257 memset (&fixup
, 0, sizeof (fixup
));
7258 memset (&imgrela
, 0, sizeof (imgrela
));
7260 /* Note: the order of the entries is specified by the OpenVMS specs. */
7261 for (entry
= dynamic_section
;
7262 entry
< dynamic_section
+ dynamic_nent
;
7265 switch (entry
->d_tag
)
7267 case DT_IA_64_VMS_STRTAB_OFFSET
:
7268 strtab_off
= entry
->d_un
.d_val
;
7271 strtab_sz
= entry
->d_un
.d_val
;
7273 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7274 1, strtab_sz
, _("dynamic string section"));
7279 case DT_IA_64_VMS_NEEDED_IDENT
:
7280 fixup
.needed_ident
= entry
->d_un
.d_val
;
7283 fixup
.needed
= entry
->d_un
.d_val
;
7285 case DT_IA_64_VMS_FIXUP_NEEDED
:
7286 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7288 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7289 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7291 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7292 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7293 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7296 case DT_IA_64_VMS_IMG_RELA_CNT
:
7297 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7299 case DT_IA_64_VMS_IMG_RELA_OFF
:
7300 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7301 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7323 dynamic_relocations
[] =
7325 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7326 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7327 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7330 /* Process the reloc section. */
7333 process_relocs (Filedata
* filedata
)
7335 unsigned long rel_size
;
7336 unsigned long rel_offset
;
7341 if (do_using_dynamic
)
7345 bfd_boolean has_dynamic_reloc
;
7348 has_dynamic_reloc
= FALSE
;
7350 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7352 is_rela
= dynamic_relocations
[i
].rela
;
7353 name
= dynamic_relocations
[i
].name
;
7354 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7355 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7358 has_dynamic_reloc
= TRUE
;
7360 if (is_rela
== UNKNOWN
)
7362 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7363 switch (dynamic_info
[DT_PLTREL
])
7377 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7378 name
, rel_offset
, rel_size
);
7380 dump_relocations (filedata
,
7381 offset_from_vma (filedata
, rel_offset
, rel_size
),
7383 dynamic_symbols
, num_dynamic_syms
,
7384 dynamic_strings
, dynamic_strings_length
,
7385 is_rela
, TRUE
/* is_dynamic */);
7389 if (is_ia64_vms (filedata
))
7390 if (process_ia64_vms_dynamic_relocs (filedata
))
7391 has_dynamic_reloc
= TRUE
;
7393 if (! has_dynamic_reloc
)
7394 printf (_("\nThere are no dynamic relocations in this file.\n"));
7398 Elf_Internal_Shdr
* section
;
7400 bfd_boolean found
= FALSE
;
7402 for (i
= 0, section
= filedata
->section_headers
;
7403 i
< filedata
->file_header
.e_shnum
;
7406 if ( section
->sh_type
!= SHT_RELA
7407 && section
->sh_type
!= SHT_REL
)
7410 rel_offset
= section
->sh_offset
;
7411 rel_size
= section
->sh_size
;
7416 unsigned long num_rela
;
7418 printf (_("\nRelocation section "));
7420 if (filedata
->string_table
== NULL
)
7421 printf ("%d", section
->sh_name
);
7423 printf ("'%s'", printable_section_name (filedata
, section
));
7425 num_rela
= rel_size
/ section
->sh_entsize
;
7426 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7427 " at offset 0x%lx contains %lu entries:\n",
7429 rel_offset
, num_rela
);
7431 is_rela
= section
->sh_type
== SHT_RELA
;
7433 if (section
->sh_link
!= 0
7434 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7436 Elf_Internal_Shdr
* symsec
;
7437 Elf_Internal_Sym
* symtab
;
7438 unsigned long nsyms
;
7439 unsigned long strtablen
= 0;
7440 char * strtab
= NULL
;
7442 symsec
= filedata
->section_headers
+ section
->sh_link
;
7443 if (symsec
->sh_type
!= SHT_SYMTAB
7444 && symsec
->sh_type
!= SHT_DYNSYM
)
7447 if (!get_symtab (filedata
, symsec
,
7448 &symtab
, &nsyms
, &strtab
, &strtablen
))
7451 dump_relocations (filedata
, rel_offset
, rel_size
,
7452 symtab
, nsyms
, strtab
, strtablen
,
7454 symsec
->sh_type
== SHT_DYNSYM
);
7460 dump_relocations (filedata
, rel_offset
, rel_size
,
7461 NULL
, 0, NULL
, 0, is_rela
,
7462 FALSE
/* is_dynamic */);
7470 /* Users sometimes forget the -D option, so try to be helpful. */
7471 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7473 if (dynamic_info
[dynamic_relocations
[i
].size
])
7475 printf (_("\nThere are no static relocations in this file."));
7476 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7481 if (i
== ARRAY_SIZE (dynamic_relocations
))
7482 printf (_("\nThere are no relocations in this file.\n"));
7489 /* An absolute address consists of a section and an offset. If the
7490 section is NULL, the offset itself is the address, otherwise, the
7491 address equals to LOAD_ADDRESS(section) + offset. */
7495 unsigned short section
;
7499 /* Find the nearest symbol at or below ADDR. Returns the symbol
7500 name, if found, and the offset from the symbol to ADDR. */
7503 find_symbol_for_address (Filedata
* filedata
,
7504 Elf_Internal_Sym
* symtab
,
7505 unsigned long nsyms
,
7506 const char * strtab
,
7507 unsigned long strtab_size
,
7508 struct absaddr addr
,
7509 const char ** symname
,
7512 bfd_vma dist
= 0x100000;
7513 Elf_Internal_Sym
* sym
;
7514 Elf_Internal_Sym
* beg
;
7515 Elf_Internal_Sym
* end
;
7516 Elf_Internal_Sym
* best
= NULL
;
7518 REMOVE_ARCH_BITS (addr
.offset
);
7520 end
= symtab
+ nsyms
;
7526 sym
= beg
+ (end
- beg
) / 2;
7528 value
= sym
->st_value
;
7529 REMOVE_ARCH_BITS (value
);
7531 if (sym
->st_name
!= 0
7532 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7533 && addr
.offset
>= value
7534 && addr
.offset
- value
< dist
)
7537 dist
= addr
.offset
- value
;
7542 if (addr
.offset
< value
)
7550 *symname
= (best
->st_name
>= strtab_size
7551 ? _("<corrupt>") : strtab
+ best
->st_name
);
7557 *offset
= addr
.offset
;
7560 static /* signed */ int
7561 symcmp (const void *p
, const void *q
)
7563 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7564 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7566 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7569 /* Process the unwind section. */
7571 #include "unwind-ia64.h"
7573 struct ia64_unw_table_entry
7575 struct absaddr start
;
7577 struct absaddr info
;
7580 struct ia64_unw_aux_info
7582 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7583 unsigned long table_len
; /* Length of unwind table. */
7584 unsigned char * info
; /* Unwind info. */
7585 unsigned long info_size
; /* Size of unwind info. */
7586 bfd_vma info_addr
; /* Starting address of unwind info. */
7587 bfd_vma seg_base
; /* Starting address of segment. */
7588 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7589 unsigned long nsyms
; /* Number of symbols. */
7590 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7591 unsigned long nfuns
; /* Number of entries in funtab. */
7592 char * strtab
; /* The string table. */
7593 unsigned long strtab_size
; /* Size of string table. */
7597 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7599 struct ia64_unw_table_entry
* tp
;
7600 unsigned long j
, nfuns
;
7602 bfd_boolean res
= TRUE
;
7604 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7605 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7606 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7607 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7609 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7611 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7615 const unsigned char * dp
;
7616 const unsigned char * head
;
7617 const unsigned char * end
;
7618 const char * procname
;
7620 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7621 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7623 fputs ("\n<", stdout
);
7627 fputs (procname
, stdout
);
7630 printf ("+%lx", (unsigned long) offset
);
7633 fputs (">: [", stdout
);
7634 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7635 fputc ('-', stdout
);
7636 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7637 printf ("], info at +0x%lx\n",
7638 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7640 /* PR 17531: file: 86232b32. */
7641 if (aux
->info
== NULL
)
7644 offset
= tp
->info
.offset
;
7645 if (tp
->info
.section
)
7647 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7649 warn (_("Invalid section %u in table entry %ld\n"),
7650 tp
->info
.section
, (long) (tp
- aux
->table
));
7654 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7656 offset
-= aux
->info_addr
;
7657 /* PR 17531: file: 0997b4d1. */
7658 if (offset
>= aux
->info_size
7659 || aux
->info_size
- offset
< 8)
7661 warn (_("Invalid offset %lx in table entry %ld\n"),
7662 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7667 head
= aux
->info
+ offset
;
7668 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7670 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7671 (unsigned) UNW_VER (stamp
),
7672 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7673 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7674 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7675 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7677 if (UNW_VER (stamp
) != 1)
7679 printf (_("\tUnknown version.\n"));
7684 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7685 /* PR 17531: file: 16ceda89. */
7686 if (end
> aux
->info
+ aux
->info_size
)
7687 end
= aux
->info
+ aux
->info_size
;
7688 for (dp
= head
+ 8; dp
< end
;)
7689 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7698 slurp_ia64_unwind_table (Filedata
* filedata
,
7699 struct ia64_unw_aux_info
* aux
,
7700 Elf_Internal_Shdr
* sec
)
7702 unsigned long size
, nrelas
, i
;
7703 Elf_Internal_Phdr
* seg
;
7704 struct ia64_unw_table_entry
* tep
;
7705 Elf_Internal_Shdr
* relsec
;
7706 Elf_Internal_Rela
* rela
;
7707 Elf_Internal_Rela
* rp
;
7708 unsigned char * table
;
7710 Elf_Internal_Sym
* sym
;
7711 const char * relname
;
7715 /* First, find the starting address of the segment that includes
7718 if (filedata
->file_header
.e_phnum
)
7720 if (! get_program_headers (filedata
))
7723 for (seg
= filedata
->program_headers
;
7724 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7727 if (seg
->p_type
!= PT_LOAD
)
7730 if (sec
->sh_addr
>= seg
->p_vaddr
7731 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7733 aux
->seg_base
= seg
->p_vaddr
;
7739 /* Second, build the unwind table from the contents of the unwind section: */
7740 size
= sec
->sh_size
;
7741 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7746 aux
->table_len
= size
/ (3 * eh_addr_size
);
7747 aux
->table
= (struct ia64_unw_table_entry
*)
7748 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7751 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7753 tep
->start
.section
= SHN_UNDEF
;
7754 tep
->end
.section
= SHN_UNDEF
;
7755 tep
->info
.section
= SHN_UNDEF
;
7756 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7757 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7758 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7759 tep
->start
.offset
+= aux
->seg_base
;
7760 tep
->end
.offset
+= aux
->seg_base
;
7761 tep
->info
.offset
+= aux
->seg_base
;
7765 /* Third, apply any relocations to the unwind table: */
7766 for (relsec
= filedata
->section_headers
;
7767 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7770 if (relsec
->sh_type
!= SHT_RELA
7771 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7772 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7775 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7784 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7786 unsigned int sym_ndx
;
7787 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7788 relname
= elf_ia64_reloc_type (r_type
);
7790 /* PR 17531: file: 9fa67536. */
7791 if (relname
== NULL
)
7793 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7797 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7799 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7803 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7805 /* PR 17531: file: 5bc8d9bf. */
7806 if (i
>= aux
->table_len
)
7808 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7812 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7813 if (sym_ndx
>= aux
->nsyms
)
7815 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7819 sym
= aux
->symtab
+ sym_ndx
;
7821 switch (rp
->r_offset
/ eh_addr_size
% 3)
7824 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7825 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7828 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7829 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7832 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7833 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7847 ia64_process_unwind (Filedata
* filedata
)
7849 Elf_Internal_Shdr
* sec
;
7850 Elf_Internal_Shdr
* unwsec
= NULL
;
7851 unsigned long i
, unwcount
= 0, unwstart
= 0;
7852 struct ia64_unw_aux_info aux
;
7853 bfd_boolean res
= TRUE
;
7855 memset (& aux
, 0, sizeof (aux
));
7857 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7859 if (sec
->sh_type
== SHT_SYMTAB
)
7863 error (_("Multiple symbol tables encountered\n"));
7869 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7870 &aux
.strtab
, &aux
.strtab_size
))
7873 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7878 printf (_("\nThere are no unwind sections in this file.\n"));
7880 while (unwcount
-- > 0)
7885 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7886 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7887 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7892 /* We have already counted the number of SHT_IA64_UNWIND
7893 sections so the loop above should never fail. */
7894 assert (unwsec
!= NULL
);
7897 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7899 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7901 /* We need to find which section group it is in. */
7902 struct group_list
* g
;
7904 if (section_headers_groups
== NULL
7905 || section_headers_groups
[i
] == NULL
)
7906 i
= filedata
->file_header
.e_shnum
;
7909 g
= section_headers_groups
[i
]->root
;
7911 for (; g
!= NULL
; g
= g
->next
)
7913 sec
= filedata
->section_headers
+ g
->section_index
;
7915 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7920 i
= filedata
->file_header
.e_shnum
;
7923 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7925 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7926 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7927 suffix
= SECTION_NAME (unwsec
) + len
;
7928 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7930 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7931 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7936 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7937 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7938 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7939 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7941 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7942 suffix
= SECTION_NAME (unwsec
) + len
;
7943 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7945 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7946 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7950 if (i
== filedata
->file_header
.e_shnum
)
7952 printf (_("\nCould not find unwind info section for "));
7954 if (filedata
->string_table
== NULL
)
7955 printf ("%d", unwsec
->sh_name
);
7957 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7961 aux
.info_addr
= sec
->sh_addr
;
7962 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7965 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7967 printf (_("\nUnwind section "));
7969 if (filedata
->string_table
== NULL
)
7970 printf ("%d", unwsec
->sh_name
);
7972 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7974 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7975 (unsigned long) unwsec
->sh_offset
,
7976 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7978 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7979 && aux
.table_len
> 0)
7980 dump_ia64_unwind (filedata
, & aux
);
7983 free ((char *) aux
.table
);
7985 free ((char *) aux
.info
);
7994 free ((char *) aux
.strtab
);
7999 struct hppa_unw_table_entry
8001 struct absaddr start
;
8003 unsigned int Cannot_unwind
:1; /* 0 */
8004 unsigned int Millicode
:1; /* 1 */
8005 unsigned int Millicode_save_sr0
:1; /* 2 */
8006 unsigned int Region_description
:2; /* 3..4 */
8007 unsigned int reserved1
:1; /* 5 */
8008 unsigned int Entry_SR
:1; /* 6 */
8009 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8010 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8011 unsigned int Args_stored
:1; /* 16 */
8012 unsigned int Variable_Frame
:1; /* 17 */
8013 unsigned int Separate_Package_Body
:1; /* 18 */
8014 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8015 unsigned int Stack_Overflow_Check
:1; /* 20 */
8016 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8017 unsigned int Ada_Region
:1; /* 22 */
8018 unsigned int cxx_info
:1; /* 23 */
8019 unsigned int cxx_try_catch
:1; /* 24 */
8020 unsigned int sched_entry_seq
:1; /* 25 */
8021 unsigned int reserved2
:1; /* 26 */
8022 unsigned int Save_SP
:1; /* 27 */
8023 unsigned int Save_RP
:1; /* 28 */
8024 unsigned int Save_MRP_in_frame
:1; /* 29 */
8025 unsigned int extn_ptr_defined
:1; /* 30 */
8026 unsigned int Cleanup_defined
:1; /* 31 */
8028 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8029 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8030 unsigned int Large_frame
:1; /* 2 */
8031 unsigned int Pseudo_SP_Set
:1; /* 3 */
8032 unsigned int reserved4
:1; /* 4 */
8033 unsigned int Total_frame_size
:27; /* 5..31 */
8036 struct hppa_unw_aux_info
8038 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8039 unsigned long table_len
; /* Length of unwind table. */
8040 bfd_vma seg_base
; /* Starting address of segment. */
8041 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8042 unsigned long nsyms
; /* Number of symbols. */
8043 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8044 unsigned long nfuns
; /* Number of entries in funtab. */
8045 char * strtab
; /* The string table. */
8046 unsigned long strtab_size
; /* Size of string table. */
8050 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8052 struct hppa_unw_table_entry
* tp
;
8053 unsigned long j
, nfuns
;
8054 bfd_boolean res
= TRUE
;
8056 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8057 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8058 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8059 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8061 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8063 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8066 const char * procname
;
8068 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8069 aux
->strtab_size
, tp
->start
, &procname
,
8072 fputs ("\n<", stdout
);
8076 fputs (procname
, stdout
);
8079 printf ("+%lx", (unsigned long) offset
);
8082 fputs (">: [", stdout
);
8083 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8084 fputc ('-', stdout
);
8085 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8088 #define PF(_m) if (tp->_m) printf (#_m " ");
8089 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8092 PF(Millicode_save_sr0
);
8093 /* PV(Region_description); */
8099 PF(Separate_Package_Body
);
8100 PF(Frame_Extension_Millicode
);
8101 PF(Stack_Overflow_Check
);
8102 PF(Two_Instruction_SP_Increment
);
8106 PF(sched_entry_seq
);
8109 PF(Save_MRP_in_frame
);
8110 PF(extn_ptr_defined
);
8111 PF(Cleanup_defined
);
8112 PF(MPE_XL_interrupt_marker
);
8113 PF(HP_UX_interrupt_marker
);
8116 PV(Total_frame_size
);
8129 slurp_hppa_unwind_table (Filedata
* filedata
,
8130 struct hppa_unw_aux_info
* aux
,
8131 Elf_Internal_Shdr
* sec
)
8133 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8134 Elf_Internal_Phdr
* seg
;
8135 struct hppa_unw_table_entry
* tep
;
8136 Elf_Internal_Shdr
* relsec
;
8137 Elf_Internal_Rela
* rela
;
8138 Elf_Internal_Rela
* rp
;
8139 unsigned char * table
;
8141 Elf_Internal_Sym
* sym
;
8142 const char * relname
;
8144 /* First, find the starting address of the segment that includes
8146 if (filedata
->file_header
.e_phnum
)
8148 if (! get_program_headers (filedata
))
8151 for (seg
= filedata
->program_headers
;
8152 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8155 if (seg
->p_type
!= PT_LOAD
)
8158 if (sec
->sh_addr
>= seg
->p_vaddr
8159 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8161 aux
->seg_base
= seg
->p_vaddr
;
8167 /* Second, build the unwind table from the contents of the unwind
8169 size
= sec
->sh_size
;
8170 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8176 nentries
= size
/ unw_ent_size
;
8177 size
= unw_ent_size
* nentries
;
8179 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8180 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8182 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8184 unsigned int tmp1
, tmp2
;
8186 tep
->start
.section
= SHN_UNDEF
;
8187 tep
->end
.section
= SHN_UNDEF
;
8189 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8190 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8191 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8192 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8194 tep
->start
.offset
+= aux
->seg_base
;
8195 tep
->end
.offset
+= aux
->seg_base
;
8197 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8198 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8199 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8200 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8201 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8202 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8203 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8204 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8205 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8206 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8207 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8208 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8209 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8210 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8211 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8212 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8213 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8214 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8215 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8216 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8217 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8218 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8219 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8220 tep
->Cleanup_defined
= tmp1
& 0x1;
8222 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8223 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8224 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8225 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8226 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8227 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8231 /* Third, apply any relocations to the unwind table. */
8232 for (relsec
= filedata
->section_headers
;
8233 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8236 if (relsec
->sh_type
!= SHT_RELA
8237 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8238 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8241 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8245 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8247 unsigned int sym_ndx
;
8248 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8249 relname
= elf_hppa_reloc_type (r_type
);
8251 if (relname
== NULL
)
8253 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8257 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8258 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8260 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8264 i
= rp
->r_offset
/ unw_ent_size
;
8265 if (i
>= aux
->table_len
)
8267 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8271 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8272 if (sym_ndx
>= aux
->nsyms
)
8274 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8278 sym
= aux
->symtab
+ sym_ndx
;
8280 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8283 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8284 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8287 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8288 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8298 aux
->table_len
= nentries
;
8304 hppa_process_unwind (Filedata
* filedata
)
8306 struct hppa_unw_aux_info aux
;
8307 Elf_Internal_Shdr
* unwsec
= NULL
;
8308 Elf_Internal_Shdr
* sec
;
8310 bfd_boolean res
= TRUE
;
8312 if (filedata
->string_table
== NULL
)
8315 memset (& aux
, 0, sizeof (aux
));
8317 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8319 if (sec
->sh_type
== SHT_SYMTAB
)
8323 error (_("Multiple symbol tables encountered\n"));
8329 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8330 &aux
.strtab
, &aux
.strtab_size
))
8333 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8338 printf (_("\nThere are no unwind sections in this file.\n"));
8340 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8342 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8344 unsigned long num_unwind
= sec
->sh_size
/ 16;
8346 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8347 "contains %lu entry:\n",
8348 "\nUnwind section '%s' at offset 0x%lx "
8349 "contains %lu entries:\n",
8351 printable_section_name (filedata
, sec
),
8352 (unsigned long) sec
->sh_offset
,
8355 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8358 if (res
&& aux
.table_len
> 0)
8360 if (! dump_hppa_unwind (filedata
, &aux
))
8365 free ((char *) aux
.table
);
8373 free ((char *) aux
.strtab
);
8380 unsigned char * data
; /* The unwind data. */
8381 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8382 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8383 unsigned long nrelas
; /* The number of relocations. */
8384 unsigned int rel_type
; /* REL or RELA ? */
8385 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8388 struct arm_unw_aux_info
8390 Filedata
* filedata
; /* The file containing the unwind sections. */
8391 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8392 unsigned long nsyms
; /* Number of symbols. */
8393 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8394 unsigned long nfuns
; /* Number of these symbols. */
8395 char * strtab
; /* The file's string table. */
8396 unsigned long strtab_size
; /* Size of string table. */
8400 arm_print_vma_and_name (Filedata
* filedata
,
8401 struct arm_unw_aux_info
* aux
,
8403 struct absaddr addr
)
8405 const char *procname
;
8408 if (addr
.section
== SHN_UNDEF
)
8411 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8412 aux
->strtab_size
, addr
, &procname
,
8415 print_vma (fn
, PREFIX_HEX
);
8419 fputs (" <", stdout
);
8420 fputs (procname
, stdout
);
8423 printf ("+0x%lx", (unsigned long) sym_offset
);
8424 fputc ('>', stdout
);
8431 arm_free_section (struct arm_section
*arm_sec
)
8433 if (arm_sec
->data
!= NULL
)
8434 free (arm_sec
->data
);
8436 if (arm_sec
->rela
!= NULL
)
8437 free (arm_sec
->rela
);
8440 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8441 cached section and install SEC instead.
8442 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8443 and return its valued in * WORDP, relocating if necessary.
8444 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8445 relocation's offset in ADDR.
8446 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8447 into the string table of the symbol associated with the reloc. If no
8448 reloc was applied store -1 there.
8449 5) Return TRUE upon success, FALSE otherwise. */
8452 get_unwind_section_word (Filedata
* filedata
,
8453 struct arm_unw_aux_info
* aux
,
8454 struct arm_section
* arm_sec
,
8455 Elf_Internal_Shdr
* sec
,
8456 bfd_vma word_offset
,
8457 unsigned int * wordp
,
8458 struct absaddr
* addr
,
8461 Elf_Internal_Rela
*rp
;
8462 Elf_Internal_Sym
*sym
;
8463 const char * relname
;
8465 bfd_boolean wrapped
;
8467 if (sec
== NULL
|| arm_sec
== NULL
)
8470 addr
->section
= SHN_UNDEF
;
8473 if (sym_name
!= NULL
)
8474 *sym_name
= (bfd_vma
) -1;
8476 /* If necessary, update the section cache. */
8477 if (sec
!= arm_sec
->sec
)
8479 Elf_Internal_Shdr
*relsec
;
8481 arm_free_section (arm_sec
);
8484 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8485 sec
->sh_size
, _("unwind data"));
8486 arm_sec
->rela
= NULL
;
8487 arm_sec
->nrelas
= 0;
8489 for (relsec
= filedata
->section_headers
;
8490 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8493 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8494 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8495 /* PR 15745: Check the section type as well. */
8496 || (relsec
->sh_type
!= SHT_REL
8497 && relsec
->sh_type
!= SHT_RELA
))
8500 arm_sec
->rel_type
= relsec
->sh_type
;
8501 if (relsec
->sh_type
== SHT_REL
)
8503 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8505 & arm_sec
->rela
, & arm_sec
->nrelas
))
8508 else /* relsec->sh_type == SHT_RELA */
8510 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8512 & arm_sec
->rela
, & arm_sec
->nrelas
))
8518 arm_sec
->next_rela
= arm_sec
->rela
;
8521 /* If there is no unwind data we can do nothing. */
8522 if (arm_sec
->data
== NULL
)
8525 /* If the offset is invalid then fail. */
8526 if (/* PR 21343 *//* PR 18879 */
8528 || word_offset
> (sec
->sh_size
- 4)
8529 || ((bfd_signed_vma
) word_offset
) < 0)
8532 /* Get the word at the required offset. */
8533 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8535 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8536 if (arm_sec
->rela
== NULL
)
8542 /* Look through the relocs to find the one that applies to the provided offset. */
8544 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8546 bfd_vma prelval
, offset
;
8548 if (rp
->r_offset
> word_offset
&& !wrapped
)
8553 if (rp
->r_offset
> word_offset
)
8556 if (rp
->r_offset
& 3)
8558 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8559 (unsigned long) rp
->r_offset
);
8563 if (rp
->r_offset
< word_offset
)
8566 /* PR 17531: file: 027-161405-0.004 */
8567 if (aux
->symtab
== NULL
)
8570 if (arm_sec
->rel_type
== SHT_REL
)
8572 offset
= word
& 0x7fffffff;
8573 if (offset
& 0x40000000)
8574 offset
|= ~ (bfd_vma
) 0x7fffffff;
8576 else if (arm_sec
->rel_type
== SHT_RELA
)
8577 offset
= rp
->r_addend
;
8580 error (_("Unknown section relocation type %d encountered\n"),
8585 /* PR 17531 file: 027-1241568-0.004. */
8586 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8588 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8589 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8593 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8594 offset
+= sym
->st_value
;
8595 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8597 /* Check that we are processing the expected reloc type. */
8598 if (filedata
->file_header
.e_machine
== EM_ARM
)
8600 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8601 if (relname
== NULL
)
8603 warn (_("Skipping unknown ARM relocation type: %d\n"),
8604 (int) ELF32_R_TYPE (rp
->r_info
));
8608 if (streq (relname
, "R_ARM_NONE"))
8611 if (! streq (relname
, "R_ARM_PREL31"))
8613 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8617 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8619 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8620 if (relname
== NULL
)
8622 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8623 (int) ELF32_R_TYPE (rp
->r_info
));
8627 if (streq (relname
, "R_C6000_NONE"))
8630 if (! streq (relname
, "R_C6000_PREL31"))
8632 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8640 /* This function currently only supports ARM and TI unwinders. */
8641 warn (_("Only TI and ARM unwinders are currently supported\n"));
8645 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8646 addr
->section
= sym
->st_shndx
;
8647 addr
->offset
= offset
;
8650 * sym_name
= sym
->st_name
;
8655 arm_sec
->next_rela
= rp
;
8660 static const char *tic6x_unwind_regnames
[16] =
8662 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8663 "A14", "A13", "A12", "A11", "A10",
8664 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8668 decode_tic6x_unwind_regmask (unsigned int mask
)
8672 for (i
= 12; mask
; mask
>>= 1, i
--)
8676 fputs (tic6x_unwind_regnames
[i
], stdout
);
8678 fputs (", ", stdout
);
8684 if (remaining == 0 && more_words) \
8687 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8688 data_offset, & word, & addr, NULL)) \
8694 #define GET_OP(OP) \
8699 (OP) = word >> 24; \
8704 printf (_("[Truncated opcode]\n")); \
8707 printf ("0x%02x ", OP)
8710 decode_arm_unwind_bytecode (Filedata
* filedata
,
8711 struct arm_unw_aux_info
* aux
,
8713 unsigned int remaining
,
8714 unsigned int more_words
,
8715 bfd_vma data_offset
,
8716 Elf_Internal_Shdr
* data_sec
,
8717 struct arm_section
* data_arm_sec
)
8719 struct absaddr addr
;
8720 bfd_boolean res
= TRUE
;
8722 /* Decode the unwinding instructions. */
8725 unsigned int op
, op2
;
8734 printf (" 0x%02x ", op
);
8736 if ((op
& 0xc0) == 0x00)
8738 int offset
= ((op
& 0x3f) << 2) + 4;
8740 printf (" vsp = vsp + %d", offset
);
8742 else if ((op
& 0xc0) == 0x40)
8744 int offset
= ((op
& 0x3f) << 2) + 4;
8746 printf (" vsp = vsp - %d", offset
);
8748 else if ((op
& 0xf0) == 0x80)
8751 if (op
== 0x80 && op2
== 0)
8752 printf (_("Refuse to unwind"));
8755 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8756 bfd_boolean first
= TRUE
;
8760 for (i
= 0; i
< 12; i
++)
8761 if (mask
& (1 << i
))
8767 printf ("r%d", 4 + i
);
8772 else if ((op
& 0xf0) == 0x90)
8774 if (op
== 0x9d || op
== 0x9f)
8775 printf (_(" [Reserved]"));
8777 printf (" vsp = r%d", op
& 0x0f);
8779 else if ((op
& 0xf0) == 0xa0)
8781 int end
= 4 + (op
& 0x07);
8782 bfd_boolean first
= TRUE
;
8786 for (i
= 4; i
<= end
; i
++)
8802 else if (op
== 0xb0)
8803 printf (_(" finish"));
8804 else if (op
== 0xb1)
8807 if (op2
== 0 || (op2
& 0xf0) != 0)
8808 printf (_("[Spare]"));
8811 unsigned int mask
= op2
& 0x0f;
8812 bfd_boolean first
= TRUE
;
8816 for (i
= 0; i
< 12; i
++)
8817 if (mask
& (1 << i
))
8828 else if (op
== 0xb2)
8830 unsigned char buf
[9];
8831 unsigned int i
, len
;
8832 unsigned long offset
;
8834 for (i
= 0; i
< sizeof (buf
); i
++)
8837 if ((buf
[i
] & 0x80) == 0)
8840 if (i
== sizeof (buf
))
8842 error (_("corrupt change to vsp\n"));
8847 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8848 assert (len
== i
+ 1);
8849 offset
= offset
* 4 + 0x204;
8850 printf ("vsp = vsp + %ld", offset
);
8853 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8855 unsigned int first
, last
;
8862 printf ("pop {D%d", first
);
8864 printf ("-D%d", first
+ last
);
8867 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8869 unsigned int count
= op
& 0x07;
8873 printf ("-D%d", 8 + count
);
8876 else if (op
>= 0xc0 && op
<= 0xc5)
8878 unsigned int count
= op
& 0x07;
8880 printf (" pop {wR10");
8882 printf ("-wR%d", 10 + count
);
8885 else if (op
== 0xc6)
8887 unsigned int first
, last
;
8892 printf ("pop {wR%d", first
);
8894 printf ("-wR%d", first
+ last
);
8897 else if (op
== 0xc7)
8900 if (op2
== 0 || (op2
& 0xf0) != 0)
8901 printf (_("[Spare]"));
8904 unsigned int mask
= op2
& 0x0f;
8905 bfd_boolean first
= TRUE
;
8909 for (i
= 0; i
< 4; i
++)
8910 if (mask
& (1 << i
))
8916 printf ("wCGR%d", i
);
8923 printf (_(" [unsupported opcode]"));
8934 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8935 struct arm_unw_aux_info
* aux
,
8937 unsigned int remaining
,
8938 unsigned int more_words
,
8939 bfd_vma data_offset
,
8940 Elf_Internal_Shdr
* data_sec
,
8941 struct arm_section
* data_arm_sec
)
8943 struct absaddr addr
;
8945 /* Decode the unwinding instructions. */
8948 unsigned int op
, op2
;
8957 printf (" 0x%02x ", op
);
8959 if ((op
& 0xc0) == 0x00)
8961 int offset
= ((op
& 0x3f) << 3) + 8;
8962 printf (" sp = sp + %d", offset
);
8964 else if ((op
& 0xc0) == 0x80)
8967 if (op
== 0x80 && op2
== 0)
8968 printf (_("Refuse to unwind"));
8971 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8973 printf ("pop compact {");
8977 decode_tic6x_unwind_regmask (mask
);
8981 else if ((op
& 0xf0) == 0xc0)
8989 unsigned int offset
;
8993 /* Scan entire instruction first so that GET_OP output is not
8994 interleaved with disassembly. */
8996 for (i
= 0; nregs
< (op
& 0xf); i
++)
9002 regpos
[nregs
].offset
= i
* 2;
9003 regpos
[nregs
].reg
= reg
;
9010 regpos
[nregs
].offset
= i
* 2 + 1;
9011 regpos
[nregs
].reg
= reg
;
9016 printf (_("pop frame {"));
9019 printf (_("*corrupt* - no registers specified"));
9024 for (i
= i
* 2; i
> 0; i
--)
9026 if (regpos
[reg
].offset
== i
- 1)
9028 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9035 fputs (name
, stdout
);
9043 else if (op
== 0xd0)
9044 printf (" MOV FP, SP");
9045 else if (op
== 0xd1)
9046 printf (" __c6xabi_pop_rts");
9047 else if (op
== 0xd2)
9049 unsigned char buf
[9];
9050 unsigned int i
, len
;
9051 unsigned long offset
;
9053 for (i
= 0; i
< sizeof (buf
); i
++)
9056 if ((buf
[i
] & 0x80) == 0)
9059 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9060 if (i
== sizeof (buf
))
9062 warn (_("Corrupt stack pointer adjustment detected\n"));
9066 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9067 assert (len
== i
+ 1);
9068 offset
= offset
* 8 + 0x408;
9069 printf (_("sp = sp + %ld"), offset
);
9071 else if ((op
& 0xf0) == 0xe0)
9073 if ((op
& 0x0f) == 7)
9076 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9080 printf (_(" [unsupported opcode]"));
9089 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9093 offset
= word
& 0x7fffffff;
9094 if (offset
& 0x40000000)
9095 offset
|= ~ (bfd_vma
) 0x7fffffff;
9097 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9100 return offset
+ where
;
9104 decode_arm_unwind (Filedata
* filedata
,
9105 struct arm_unw_aux_info
* aux
,
9107 unsigned int remaining
,
9108 bfd_vma data_offset
,
9109 Elf_Internal_Shdr
* data_sec
,
9110 struct arm_section
* data_arm_sec
)
9113 unsigned int more_words
= 0;
9114 struct absaddr addr
;
9115 bfd_vma sym_name
= (bfd_vma
) -1;
9116 bfd_boolean res
= TRUE
;
9120 /* Fetch the first word.
9121 Note - when decoding an object file the address extracted
9122 here will always be 0. So we also pass in the sym_name
9123 parameter so that we can find the symbol associated with
9124 the personality routine. */
9125 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9126 & word
, & addr
, & sym_name
))
9133 addr
.section
= SHN_UNDEF
;
9137 if ((word
& 0x80000000) == 0)
9139 /* Expand prel31 for personality routine. */
9141 const char *procname
;
9143 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9144 printf (_(" Personality routine: "));
9146 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9147 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9149 procname
= aux
->strtab
+ sym_name
;
9150 print_vma (fn
, PREFIX_HEX
);
9153 fputs (" <", stdout
);
9154 fputs (procname
, stdout
);
9155 fputc ('>', stdout
);
9159 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9160 fputc ('\n', stdout
);
9162 /* The GCC personality routines use the standard compact
9163 encoding, starting with one byte giving the number of
9165 if (procname
!= NULL
9166 && (const_strneq (procname
, "__gcc_personality_v0")
9167 || const_strneq (procname
, "__gxx_personality_v0")
9168 || const_strneq (procname
, "__gcj_personality_v0")
9169 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9176 printf (_(" [Truncated data]\n"));
9179 more_words
= word
>> 24;
9189 /* ARM EHABI Section 6.3:
9191 An exception-handling table entry for the compact model looks like:
9195 1 0 index Data for personalityRoutine[index] */
9197 if (filedata
->file_header
.e_machine
== EM_ARM
9198 && (word
& 0x70000000))
9200 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9204 per_index
= (word
>> 24) & 0x7f;
9205 printf (_(" Compact model index: %d\n"), per_index
);
9212 else if (per_index
< 3)
9214 more_words
= (word
>> 16) & 0xff;
9220 switch (filedata
->file_header
.e_machine
)
9225 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9226 data_offset
, data_sec
, data_arm_sec
))
9231 warn (_("Unknown ARM compact model index encountered\n"));
9232 printf (_(" [reserved]\n"));
9240 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9241 data_offset
, data_sec
, data_arm_sec
))
9244 else if (per_index
< 5)
9246 if (((word
>> 17) & 0x7f) == 0x7f)
9247 printf (_(" Restore stack from frame pointer\n"));
9249 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9250 printf (_(" Registers restored: "));
9252 printf (" (compact) ");
9253 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9255 printf (_(" Return register: %s\n"),
9256 tic6x_unwind_regnames
[word
& 0xf]);
9259 printf (_(" [reserved (%d)]\n"), per_index
);
9263 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9264 filedata
->file_header
.e_machine
);
9268 /* Decode the descriptors. Not implemented. */
9274 dump_arm_unwind (Filedata
* filedata
,
9275 struct arm_unw_aux_info
* aux
,
9276 Elf_Internal_Shdr
* exidx_sec
)
9278 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9279 unsigned int i
, exidx_len
;
9280 unsigned long j
, nfuns
;
9281 bfd_boolean res
= TRUE
;
9283 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9284 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9285 exidx_len
= exidx_sec
->sh_size
/ 8;
9287 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9288 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9289 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9290 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9292 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9294 for (i
= 0; i
< exidx_len
; i
++)
9296 unsigned int exidx_fn
, exidx_entry
;
9297 struct absaddr fn_addr
, entry_addr
;
9300 fputc ('\n', stdout
);
9302 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9303 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9304 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9305 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9308 arm_free_section (& exidx_arm_sec
);
9309 arm_free_section (& extab_arm_sec
);
9313 /* ARM EHABI, Section 5:
9314 An index table entry consists of 2 words.
9315 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9316 if (exidx_fn
& 0x80000000)
9318 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9322 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9324 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9325 fputs (": ", stdout
);
9327 if (exidx_entry
== 1)
9329 print_vma (exidx_entry
, PREFIX_HEX
);
9330 fputs (" [cantunwind]\n", stdout
);
9332 else if (exidx_entry
& 0x80000000)
9334 print_vma (exidx_entry
, PREFIX_HEX
);
9335 fputc ('\n', stdout
);
9336 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9340 bfd_vma table
, table_offset
= 0;
9341 Elf_Internal_Shdr
*table_sec
;
9343 fputs ("@", stdout
);
9344 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9345 print_vma (table
, PREFIX_HEX
);
9348 /* Locate the matching .ARM.extab. */
9349 if (entry_addr
.section
!= SHN_UNDEF
9350 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9352 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9353 table_offset
= entry_addr
.offset
;
9355 if (table_offset
> table_sec
->sh_size
9356 || ((bfd_signed_vma
) table_offset
) < 0)
9358 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9359 (unsigned long) table_offset
,
9360 printable_section_name (filedata
, table_sec
));
9367 table_sec
= find_section_by_address (filedata
, table
);
9368 if (table_sec
!= NULL
)
9369 table_offset
= table
- table_sec
->sh_addr
;
9372 if (table_sec
== NULL
)
9374 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9375 (unsigned long) table
);
9380 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9389 arm_free_section (&exidx_arm_sec
);
9390 arm_free_section (&extab_arm_sec
);
9395 /* Used for both ARM and C6X unwinding tables. */
9398 arm_process_unwind (Filedata
* filedata
)
9400 struct arm_unw_aux_info aux
;
9401 Elf_Internal_Shdr
*unwsec
= NULL
;
9402 Elf_Internal_Shdr
*sec
;
9404 unsigned int sec_type
;
9405 bfd_boolean res
= TRUE
;
9407 switch (filedata
->file_header
.e_machine
)
9410 sec_type
= SHT_ARM_EXIDX
;
9414 sec_type
= SHT_C6000_UNWIND
;
9418 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9419 filedata
->file_header
.e_machine
);
9423 if (filedata
->string_table
== NULL
)
9426 memset (& aux
, 0, sizeof (aux
));
9427 aux
.filedata
= filedata
;
9429 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9431 if (sec
->sh_type
== SHT_SYMTAB
)
9435 error (_("Multiple symbol tables encountered\n"));
9441 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9442 &aux
.strtab
, &aux
.strtab_size
))
9445 else if (sec
->sh_type
== sec_type
)
9450 printf (_("\nThere are no unwind sections in this file.\n"));
9452 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9454 if (sec
->sh_type
== sec_type
)
9456 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9457 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9458 "contains %lu entry:\n",
9459 "\nUnwind section '%s' at offset 0x%lx "
9460 "contains %lu entries:\n",
9462 printable_section_name (filedata
, sec
),
9463 (unsigned long) sec
->sh_offset
,
9466 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9474 free ((char *) aux
.strtab
);
9480 process_unwind (Filedata
* filedata
)
9482 struct unwind_handler
9484 unsigned int machtype
;
9485 bfd_boolean (* handler
)(Filedata
*);
9488 { EM_ARM
, arm_process_unwind
},
9489 { EM_IA_64
, ia64_process_unwind
},
9490 { EM_PARISC
, hppa_process_unwind
},
9491 { EM_TI_C6000
, arm_process_unwind
},
9499 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9500 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9501 return handlers
[i
].handler (filedata
);
9503 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9504 get_machine_name (filedata
->file_header
.e_machine
));
9509 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9511 switch (entry
->d_tag
)
9513 case DT_AARCH64_BTI_PLT
:
9514 case DT_AARCH64_PAC_PLT
:
9517 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9524 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9526 switch (entry
->d_tag
)
9529 if (entry
->d_un
.d_val
== 0)
9533 static const char * opts
[] =
9535 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9536 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9537 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9538 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9542 bfd_boolean first
= TRUE
;
9544 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9545 if (entry
->d_un
.d_val
& (1 << cnt
))
9547 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9553 case DT_MIPS_IVERSION
:
9554 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9555 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9559 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9560 /* Note: coded this way so that there is a single string for translation. */
9561 printf (_("<corrupt: %s>"), buf
);
9565 case DT_MIPS_TIME_STAMP
:
9569 time_t atime
= entry
->d_un
.d_val
;
9571 tmp
= gmtime (&atime
);
9572 /* PR 17531: file: 6accc532. */
9574 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9576 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9577 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9578 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9579 printf (_("Time Stamp: %s"), timebuf
);
9583 case DT_MIPS_RLD_VERSION
:
9584 case DT_MIPS_LOCAL_GOTNO
:
9585 case DT_MIPS_CONFLICTNO
:
9586 case DT_MIPS_LIBLISTNO
:
9587 case DT_MIPS_SYMTABNO
:
9588 case DT_MIPS_UNREFEXTNO
:
9589 case DT_MIPS_HIPAGENO
:
9590 case DT_MIPS_DELTA_CLASS_NO
:
9591 case DT_MIPS_DELTA_INSTANCE_NO
:
9592 case DT_MIPS_DELTA_RELOC_NO
:
9593 case DT_MIPS_DELTA_SYM_NO
:
9594 case DT_MIPS_DELTA_CLASSSYM_NO
:
9595 case DT_MIPS_COMPACT_SIZE
:
9596 print_vma (entry
->d_un
.d_val
, DEC
);
9600 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9601 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9602 /* Falls through. */
9605 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9611 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9613 switch (entry
->d_tag
)
9615 case DT_HP_DLD_FLAGS
:
9624 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9625 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9626 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9627 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9628 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9629 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9630 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9631 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9632 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9633 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9634 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9635 { DT_HP_GST
, "HP_GST" },
9636 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9637 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9638 { DT_HP_NODELETE
, "HP_NODELETE" },
9639 { DT_HP_GROUP
, "HP_GROUP" },
9640 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9642 bfd_boolean first
= TRUE
;
9644 bfd_vma val
= entry
->d_un
.d_val
;
9646 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9647 if (val
& flags
[cnt
].bit
)
9651 fputs (flags
[cnt
].str
, stdout
);
9653 val
^= flags
[cnt
].bit
;
9656 if (val
!= 0 || first
)
9660 print_vma (val
, HEX
);
9666 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9674 /* VMS vs Unix time offset and factor. */
9676 #define VMS_EPOCH_OFFSET 35067168000000000LL
9677 #define VMS_GRANULARITY_FACTOR 10000000
9679 /* Display a VMS time in a human readable format. */
9682 print_vms_time (bfd_int64_t vmstime
)
9687 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9688 tm
= gmtime (&unxtime
);
9689 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9690 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9691 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9696 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9698 switch (entry
->d_tag
)
9700 case DT_IA_64_PLT_RESERVE
:
9701 /* First 3 slots reserved. */
9702 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9704 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9707 case DT_IA_64_VMS_LINKTIME
:
9709 print_vms_time (entry
->d_un
.d_val
);
9713 case DT_IA_64_VMS_LNKFLAGS
:
9714 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9715 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9716 printf (" CALL_DEBUG");
9717 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9718 printf (" NOP0BUFS");
9719 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9720 printf (" P0IMAGE");
9721 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9722 printf (" MKTHREADS");
9723 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9724 printf (" UPCALLS");
9725 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9727 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9728 printf (" INITIALIZE");
9729 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9731 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9732 printf (" EXE_INIT");
9733 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9734 printf (" TBK_IN_IMG");
9735 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9736 printf (" DBG_IN_IMG");
9737 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9738 printf (" TBK_IN_DSF");
9739 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9740 printf (" DBG_IN_DSF");
9741 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9742 printf (" SIGNATURES");
9743 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9744 printf (" REL_SEG_OFF");
9748 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9755 get_32bit_dynamic_section (Filedata
* filedata
)
9757 Elf32_External_Dyn
* edyn
;
9758 Elf32_External_Dyn
* ext
;
9759 Elf_Internal_Dyn
* entry
;
9761 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9762 dynamic_size
, _("dynamic section"));
9766 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9767 might not have the luxury of section headers. Look for the DT_NULL
9768 terminator to determine the number of entries. */
9769 for (ext
= edyn
, dynamic_nent
= 0;
9770 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9774 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9778 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9780 if (dynamic_section
== NULL
)
9782 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9783 (unsigned long) dynamic_nent
);
9788 for (ext
= edyn
, entry
= dynamic_section
;
9789 entry
< dynamic_section
+ dynamic_nent
;
9792 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9793 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9802 get_64bit_dynamic_section (Filedata
* filedata
)
9804 Elf64_External_Dyn
* edyn
;
9805 Elf64_External_Dyn
* ext
;
9806 Elf_Internal_Dyn
* entry
;
9808 /* Read in the data. */
9809 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9810 dynamic_size
, _("dynamic section"));
9814 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9815 might not have the luxury of section headers. Look for the DT_NULL
9816 terminator to determine the number of entries. */
9817 for (ext
= edyn
, dynamic_nent
= 0;
9818 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9819 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9823 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9827 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9829 if (dynamic_section
== NULL
)
9831 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9832 (unsigned long) dynamic_nent
);
9837 /* Convert from external to internal formats. */
9838 for (ext
= edyn
, entry
= dynamic_section
;
9839 entry
< dynamic_section
+ dynamic_nent
;
9842 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9843 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9852 print_dynamic_flags (bfd_vma flags
)
9854 bfd_boolean first
= TRUE
;
9860 flag
= flags
& - flags
;
9870 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9871 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9872 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9873 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9874 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9875 default: fputs (_("unknown"), stdout
); break;
9882 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9884 unsigned char * e_data
;
9887 /* If the size_t type is smaller than the bfd_size_type, eg because
9888 you are building a 32-bit tool on a 64-bit host, then make sure
9889 that when (number) is cast to (size_t) no information is lost. */
9890 if (sizeof (size_t) < sizeof (bfd_size_type
)
9891 && (bfd_size_type
) ((size_t) number
) != number
)
9893 error (_("Size truncation prevents reading %s elements of size %u\n"),
9894 bfd_vmatoa ("u", number
), ent_size
);
9898 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9899 attempting to allocate memory when the read is bound to fail. */
9900 if (ent_size
* number
> filedata
->file_size
)
9902 error (_("Invalid number of dynamic entries: %s\n"),
9903 bfd_vmatoa ("u", number
));
9907 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9910 error (_("Out of memory reading %s dynamic entries\n"),
9911 bfd_vmatoa ("u", number
));
9915 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9917 error (_("Unable to read in %s bytes of dynamic data\n"),
9918 bfd_vmatoa ("u", number
* ent_size
));
9923 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
9926 error (_("Out of memory allocating space for %s dynamic entries\n"),
9927 bfd_vmatoa ("u", number
));
9933 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9940 static unsigned long
9941 get_num_dynamic_syms (Filedata
* filedata
)
9943 unsigned long num_of_syms
= 0;
9945 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
9948 if (dynamic_info
[DT_HASH
])
9950 unsigned char nb
[8];
9951 unsigned char nc
[8];
9952 unsigned int hash_ent_size
= 4;
9954 if ((filedata
->file_header
.e_machine
== EM_ALPHA
9955 || filedata
->file_header
.e_machine
== EM_S390
9956 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
9957 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9960 if (fseek (filedata
->handle
,
9961 (archive_file_offset
9962 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
9963 sizeof nb
+ sizeof nc
)),
9966 error (_("Unable to seek to start of dynamic information\n"));
9970 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
9972 error (_("Failed to read in number of buckets\n"));
9976 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
9978 error (_("Failed to read in number of chains\n"));
9982 nbuckets
= byte_get (nb
, hash_ent_size
);
9983 nchains
= byte_get (nc
, hash_ent_size
);
9984 num_of_syms
= nchains
;
9986 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
9987 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
9990 if (num_of_syms
== 0)
10006 if (dynamic_info_DT_GNU_HASH
)
10008 unsigned char nb
[16];
10009 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10010 bfd_vma buckets_vma
;
10012 bfd_boolean gnu_hash_error
= FALSE
;
10014 if (fseek (filedata
->handle
,
10015 (archive_file_offset
10016 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
10020 error (_("Unable to seek to start of dynamic information\n"));
10021 gnu_hash_error
= TRUE
;
10025 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10027 error (_("Failed to read in number of buckets\n"));
10028 gnu_hash_error
= TRUE
;
10032 ngnubuckets
= byte_get (nb
, 4);
10033 gnusymidx
= byte_get (nb
+ 4, 4);
10034 bitmaskwords
= byte_get (nb
+ 8, 4);
10035 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10037 buckets_vma
+= bitmaskwords
* 4;
10039 buckets_vma
+= bitmaskwords
* 8;
10041 if (fseek (filedata
->handle
,
10042 (archive_file_offset
10043 + offset_from_vma (filedata
, buckets_vma
, 4)),
10046 error (_("Unable to seek to start of dynamic information\n"));
10047 gnu_hash_error
= TRUE
;
10051 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
10053 if (gnubuckets
== NULL
)
10055 gnu_hash_error
= TRUE
;
10059 for (i
= 0; i
< ngnubuckets
; i
++)
10060 if (gnubuckets
[i
] != 0)
10062 if (gnubuckets
[i
] < gnusymidx
)
10064 gnu_hash_error
= TRUE
;
10068 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10069 maxchain
= gnubuckets
[i
];
10072 if (maxchain
== 0xffffffff)
10074 gnu_hash_error
= TRUE
;
10078 maxchain
-= gnusymidx
;
10080 if (fseek (filedata
->handle
,
10081 (archive_file_offset
10082 + offset_from_vma (filedata
, buckets_vma
10083 + 4 * (ngnubuckets
+ maxchain
), 4)),
10086 error (_("Unable to seek to start of dynamic information\n"));
10087 gnu_hash_error
= TRUE
;
10093 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10095 error (_("Failed to determine last chain length\n"));
10096 gnu_hash_error
= TRUE
;
10100 if (maxchain
+ 1 == 0)
10102 gnu_hash_error
= TRUE
;
10108 while ((byte_get (nb
, 4) & 1) == 0);
10110 if (fseek (filedata
->handle
,
10111 (archive_file_offset
10112 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10115 error (_("Unable to seek to start of dynamic information\n"));
10116 gnu_hash_error
= TRUE
;
10120 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10121 ngnuchains
= maxchain
;
10123 if (gnuchains
== NULL
)
10125 gnu_hash_error
= TRUE
;
10129 if (dynamic_info_DT_MIPS_XHASH
)
10131 if (fseek (filedata
->handle
,
10132 (archive_file_offset
10133 + offset_from_vma (filedata
, (buckets_vma
10138 error (_("Unable to seek to start of dynamic information\n"));
10139 gnu_hash_error
= TRUE
;
10143 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10146 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10147 if (gnubuckets
[hn
] != 0)
10149 bfd_vma si
= gnubuckets
[hn
];
10150 bfd_vma off
= si
- gnusymidx
;
10154 if (dynamic_info_DT_MIPS_XHASH
)
10156 if (mipsxlat
[off
] >= num_of_syms
)
10157 num_of_syms
= mipsxlat
[off
] + 1;
10161 if (si
>= num_of_syms
)
10162 num_of_syms
= si
+ 1;
10166 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10170 if (gnu_hash_error
)
10192 return num_of_syms
;
10195 /* Parse and display the contents of the dynamic section. */
10198 process_dynamic_section (Filedata
* filedata
)
10200 Elf_Internal_Dyn
* entry
;
10202 if (dynamic_size
== 0)
10205 printf (_("\nThere is no dynamic section in this file.\n"));
10212 if (! get_32bit_dynamic_section (filedata
))
10217 if (! get_64bit_dynamic_section (filedata
))
10221 /* Find the appropriate symbol table. */
10222 if (dynamic_symbols
== NULL
|| do_histogram
)
10224 for (entry
= dynamic_section
;
10225 entry
< dynamic_section
+ dynamic_nent
;
10227 if (entry
->d_tag
== DT_SYMTAB
)
10228 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10229 else if (entry
->d_tag
== DT_SYMENT
)
10230 dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10231 else if (entry
->d_tag
== DT_HASH
)
10232 dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10233 else if (entry
->d_tag
== DT_GNU_HASH
)
10234 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10235 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10236 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10237 && entry
->d_tag
== DT_MIPS_XHASH
)
10239 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10240 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10243 if (dynamic_info
[DT_SYMTAB
] && dynamic_info
[DT_SYMENT
])
10245 Elf_Internal_Phdr
*seg
;
10246 bfd_vma vma
= dynamic_info
[DT_SYMTAB
];
10248 if (! get_program_headers (filedata
))
10250 error (_("Cannot interpret virtual addresses without program headers.\n"));
10254 for (seg
= filedata
->program_headers
;
10255 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10258 unsigned long num_of_syms
;
10260 if (seg
->p_type
!= PT_LOAD
)
10263 if ((seg
->p_offset
+ seg
->p_filesz
)
10264 > filedata
->file_size
)
10266 /* See PR 21379 for a reproducer. */
10267 error (_("Invalid PT_LOAD entry\n"));
10271 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10272 && vma
<= seg
->p_vaddr
+ seg
->p_filesz
10273 && (num_of_syms
= get_num_dynamic_syms (filedata
)))
10275 /* Since we do not know how big the symbol table is,
10276 we default to reading in up to the end of PT_LOAD
10277 segment and processing that. This is overkill, I
10278 know, but it should work. */
10279 Elf_Internal_Shdr section
;
10280 section
.sh_offset
= (vma
- seg
->p_vaddr
10282 section
.sh_size
= (num_of_syms
10283 * dynamic_info
[DT_SYMENT
]);
10284 section
.sh_entsize
= dynamic_info
[DT_SYMENT
];
10285 section
.sh_name
= filedata
->string_table_length
;
10286 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
,
10288 & num_dynamic_syms
);
10289 if (dynamic_symbols
== NULL
10290 || num_dynamic_syms
!= num_of_syms
)
10292 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10300 /* Similarly find a string table. */
10301 if (dynamic_strings
== NULL
)
10302 for (entry
= dynamic_section
;
10303 entry
< dynamic_section
+ dynamic_nent
;
10306 if (entry
->d_tag
== DT_STRTAB
)
10307 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10309 if (entry
->d_tag
== DT_STRSZ
)
10310 dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10312 if (dynamic_info
[DT_STRTAB
] && dynamic_info
[DT_STRSZ
])
10314 unsigned long offset
;
10315 bfd_size_type str_tab_len
= dynamic_info
[DT_STRSZ
];
10317 offset
= offset_from_vma (filedata
,
10318 dynamic_info
[DT_STRTAB
],
10320 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
10322 _("dynamic string table"));
10323 if (dynamic_strings
== NULL
)
10325 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10329 dynamic_strings_length
= str_tab_len
;
10334 /* And find the syminfo section if available. */
10335 if (dynamic_syminfo
== NULL
)
10337 unsigned long syminsz
= 0;
10339 for (entry
= dynamic_section
;
10340 entry
< dynamic_section
+ dynamic_nent
;
10343 if (entry
->d_tag
== DT_SYMINENT
)
10345 /* Note: these braces are necessary to avoid a syntax
10346 error from the SunOS4 C compiler. */
10347 /* PR binutils/17531: A corrupt file can trigger this test.
10348 So do not use an assert, instead generate an error message. */
10349 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10350 error (_("Bad value (%d) for SYMINENT entry\n"),
10351 (int) entry
->d_un
.d_val
);
10353 else if (entry
->d_tag
== DT_SYMINSZ
)
10354 syminsz
= entry
->d_un
.d_val
;
10355 else if (entry
->d_tag
== DT_SYMINFO
)
10356 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
10360 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10362 Elf_External_Syminfo
* extsyminfo
;
10363 Elf_External_Syminfo
* extsym
;
10364 Elf_Internal_Syminfo
* syminfo
;
10366 /* There is a syminfo section. Read the data. */
10367 extsyminfo
= (Elf_External_Syminfo
*)
10368 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
10369 _("symbol information"));
10373 if (dynamic_syminfo
!= NULL
)
10375 error (_("Multiple dynamic symbol information sections found\n"));
10376 free (dynamic_syminfo
);
10378 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10379 if (dynamic_syminfo
== NULL
)
10381 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10382 (unsigned long) syminsz
);
10386 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10387 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10388 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10389 ++syminfo
, ++extsym
)
10391 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10392 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10399 if (do_dynamic
&& dynamic_addr
)
10400 printf (ngettext ("\nDynamic section at offset 0x%lx "
10401 "contains %lu entry:\n",
10402 "\nDynamic section at offset 0x%lx "
10403 "contains %lu entries:\n",
10405 dynamic_addr
, (unsigned long) dynamic_nent
);
10407 printf (_(" Tag Type Name/Value\n"));
10409 for (entry
= dynamic_section
;
10410 entry
< dynamic_section
+ dynamic_nent
;
10415 const char * dtype
;
10418 print_vma (entry
->d_tag
, FULL_HEX
);
10419 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10420 printf (" (%s)%*s", dtype
,
10421 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10424 switch (entry
->d_tag
)
10428 print_dynamic_flags (entry
->d_un
.d_val
);
10438 switch (entry
->d_tag
)
10441 printf (_("Auxiliary library"));
10445 printf (_("Filter library"));
10449 printf (_("Configuration file"));
10453 printf (_("Dependency audit library"));
10457 printf (_("Audit library"));
10461 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10462 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10466 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10475 printf (_("Flags:"));
10477 if (entry
->d_un
.d_val
== 0)
10478 printf (_(" None\n"));
10481 unsigned long int val
= entry
->d_un
.d_val
;
10483 if (val
& DTF_1_PARINIT
)
10485 printf (" PARINIT");
10486 val
^= DTF_1_PARINIT
;
10488 if (val
& DTF_1_CONFEXP
)
10490 printf (" CONFEXP");
10491 val
^= DTF_1_CONFEXP
;
10494 printf (" %lx", val
);
10503 printf (_("Flags:"));
10505 if (entry
->d_un
.d_val
== 0)
10506 printf (_(" None\n"));
10509 unsigned long int val
= entry
->d_un
.d_val
;
10511 if (val
& DF_P1_LAZYLOAD
)
10513 printf (" LAZYLOAD");
10514 val
^= DF_P1_LAZYLOAD
;
10516 if (val
& DF_P1_GROUPPERM
)
10518 printf (" GROUPPERM");
10519 val
^= DF_P1_GROUPPERM
;
10522 printf (" %lx", val
);
10531 printf (_("Flags:"));
10532 if (entry
->d_un
.d_val
== 0)
10533 printf (_(" None\n"));
10536 unsigned long int val
= entry
->d_un
.d_val
;
10538 if (val
& DF_1_NOW
)
10543 if (val
& DF_1_GLOBAL
)
10545 printf (" GLOBAL");
10546 val
^= DF_1_GLOBAL
;
10548 if (val
& DF_1_GROUP
)
10553 if (val
& DF_1_NODELETE
)
10555 printf (" NODELETE");
10556 val
^= DF_1_NODELETE
;
10558 if (val
& DF_1_LOADFLTR
)
10560 printf (" LOADFLTR");
10561 val
^= DF_1_LOADFLTR
;
10563 if (val
& DF_1_INITFIRST
)
10565 printf (" INITFIRST");
10566 val
^= DF_1_INITFIRST
;
10568 if (val
& DF_1_NOOPEN
)
10570 printf (" NOOPEN");
10571 val
^= DF_1_NOOPEN
;
10573 if (val
& DF_1_ORIGIN
)
10575 printf (" ORIGIN");
10576 val
^= DF_1_ORIGIN
;
10578 if (val
& DF_1_DIRECT
)
10580 printf (" DIRECT");
10581 val
^= DF_1_DIRECT
;
10583 if (val
& DF_1_TRANS
)
10588 if (val
& DF_1_INTERPOSE
)
10590 printf (" INTERPOSE");
10591 val
^= DF_1_INTERPOSE
;
10593 if (val
& DF_1_NODEFLIB
)
10595 printf (" NODEFLIB");
10596 val
^= DF_1_NODEFLIB
;
10598 if (val
& DF_1_NODUMP
)
10600 printf (" NODUMP");
10601 val
^= DF_1_NODUMP
;
10603 if (val
& DF_1_CONFALT
)
10605 printf (" CONFALT");
10606 val
^= DF_1_CONFALT
;
10608 if (val
& DF_1_ENDFILTEE
)
10610 printf (" ENDFILTEE");
10611 val
^= DF_1_ENDFILTEE
;
10613 if (val
& DF_1_DISPRELDNE
)
10615 printf (" DISPRELDNE");
10616 val
^= DF_1_DISPRELDNE
;
10618 if (val
& DF_1_DISPRELPND
)
10620 printf (" DISPRELPND");
10621 val
^= DF_1_DISPRELPND
;
10623 if (val
& DF_1_NODIRECT
)
10625 printf (" NODIRECT");
10626 val
^= DF_1_NODIRECT
;
10628 if (val
& DF_1_IGNMULDEF
)
10630 printf (" IGNMULDEF");
10631 val
^= DF_1_IGNMULDEF
;
10633 if (val
& DF_1_NOKSYMS
)
10635 printf (" NOKSYMS");
10636 val
^= DF_1_NOKSYMS
;
10638 if (val
& DF_1_NOHDR
)
10643 if (val
& DF_1_EDITED
)
10645 printf (" EDITED");
10646 val
^= DF_1_EDITED
;
10648 if (val
& DF_1_NORELOC
)
10650 printf (" NORELOC");
10651 val
^= DF_1_NORELOC
;
10653 if (val
& DF_1_SYMINTPOSE
)
10655 printf (" SYMINTPOSE");
10656 val
^= DF_1_SYMINTPOSE
;
10658 if (val
& DF_1_GLOBAUDIT
)
10660 printf (" GLOBAUDIT");
10661 val
^= DF_1_GLOBAUDIT
;
10663 if (val
& DF_1_SINGLETON
)
10665 printf (" SINGLETON");
10666 val
^= DF_1_SINGLETON
;
10668 if (val
& DF_1_STUB
)
10673 if (val
& DF_1_PIE
)
10678 if (val
& DF_1_KMOD
)
10683 if (val
& DF_1_WEAKFILTER
)
10685 printf (" WEAKFILTER");
10686 val
^= DF_1_WEAKFILTER
;
10688 if (val
& DF_1_NOCOMMON
)
10690 printf (" NOCOMMON");
10691 val
^= DF_1_NOCOMMON
;
10694 printf (" %lx", val
);
10701 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10703 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10723 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10729 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10730 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10736 switch (entry
->d_tag
)
10739 printf (_("Shared library: [%s]"), name
);
10741 if (streq (name
, program_interpreter
))
10742 printf (_(" program interpreter"));
10746 printf (_("Library soname: [%s]"), name
);
10750 printf (_("Library rpath: [%s]"), name
);
10754 printf (_("Library runpath: [%s]"), name
);
10758 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10763 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10776 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10777 /* Fall through. */
10781 case DT_INIT_ARRAYSZ
:
10782 case DT_FINI_ARRAYSZ
:
10783 case DT_GNU_CONFLICTSZ
:
10784 case DT_GNU_LIBLISTSZ
:
10787 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10788 printf (_(" (bytes)\n"));
10793 case DT_VERNEEDNUM
:
10798 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10807 case DT_INIT_ARRAY
:
10808 case DT_FINI_ARRAY
:
10811 if (entry
->d_tag
== DT_USED
10812 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10814 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10818 printf (_("Not needed object: [%s]\n"), name
);
10823 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10829 /* The value of this entry is ignored. */
10834 case DT_GNU_PRELINKED
:
10838 time_t atime
= entry
->d_un
.d_val
;
10840 tmp
= gmtime (&atime
);
10841 /* PR 17533 file: 041-1244816-0.004. */
10843 printf (_("<corrupt time val: %lx"),
10844 (unsigned long) atime
);
10846 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10847 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10848 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10854 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10857 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10863 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10864 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10869 switch (filedata
->file_header
.e_machine
)
10872 dynamic_section_aarch64_val (entry
);
10875 case EM_MIPS_RS3_LE
:
10876 dynamic_section_mips_val (entry
);
10879 dynamic_section_parisc_val (entry
);
10882 dynamic_section_ia64_val (entry
);
10885 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10897 get_ver_flags (unsigned int flags
)
10899 static char buff
[128];
10906 if (flags
& VER_FLG_BASE
)
10907 strcat (buff
, "BASE");
10909 if (flags
& VER_FLG_WEAK
)
10911 if (flags
& VER_FLG_BASE
)
10912 strcat (buff
, " | ");
10914 strcat (buff
, "WEAK");
10917 if (flags
& VER_FLG_INFO
)
10919 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10920 strcat (buff
, " | ");
10922 strcat (buff
, "INFO");
10925 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10927 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10928 strcat (buff
, " | ");
10930 strcat (buff
, _("<unknown>"));
10936 /* Display the contents of the version sections. */
10939 process_version_sections (Filedata
* filedata
)
10941 Elf_Internal_Shdr
* section
;
10943 bfd_boolean found
= FALSE
;
10948 for (i
= 0, section
= filedata
->section_headers
;
10949 i
< filedata
->file_header
.e_shnum
;
10952 switch (section
->sh_type
)
10954 case SHT_GNU_verdef
:
10956 Elf_External_Verdef
* edefs
;
10963 printf (ngettext ("\nVersion definition section '%s' "
10964 "contains %u entry:\n",
10965 "\nVersion definition section '%s' "
10966 "contains %u entries:\n",
10968 printable_section_name (filedata
, section
),
10971 printf (_(" Addr: 0x"));
10972 printf_vma (section
->sh_addr
);
10973 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10974 (unsigned long) section
->sh_offset
, section
->sh_link
,
10975 printable_section_name_from_index (filedata
, section
->sh_link
));
10977 edefs
= (Elf_External_Verdef
*)
10978 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10979 _("version definition section"));
10982 endbuf
= (char *) edefs
+ section
->sh_size
;
10984 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10987 Elf_External_Verdef
* edef
;
10988 Elf_Internal_Verdef ent
;
10989 Elf_External_Verdaux
* eaux
;
10990 Elf_Internal_Verdaux aux
;
10991 unsigned long isum
;
10994 vstart
= ((char *) edefs
) + idx
;
10995 if (vstart
+ sizeof (*edef
) > endbuf
)
10998 edef
= (Elf_External_Verdef
*) vstart
;
11000 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11001 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11002 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11003 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11004 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11005 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11006 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11008 printf (_(" %#06lx: Rev: %d Flags: %s"),
11009 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11011 printf (_(" Index: %d Cnt: %d "),
11012 ent
.vd_ndx
, ent
.vd_cnt
);
11014 /* Check for overflow. */
11015 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11018 vstart
+= ent
.vd_aux
;
11020 if (vstart
+ sizeof (*eaux
) > endbuf
)
11022 eaux
= (Elf_External_Verdaux
*) vstart
;
11024 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11025 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11027 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
11028 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
11030 printf (_("Name index: %ld\n"), aux
.vda_name
);
11032 isum
= idx
+ ent
.vd_aux
;
11034 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11036 if (aux
.vda_next
< sizeof (*eaux
)
11037 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11039 warn (_("Invalid vda_next field of %lx\n"),
11044 /* Check for overflow. */
11045 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11048 isum
+= aux
.vda_next
;
11049 vstart
+= aux
.vda_next
;
11051 if (vstart
+ sizeof (*eaux
) > endbuf
)
11053 eaux
= (Elf_External_Verdaux
*) vstart
;
11055 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11056 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11058 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
11059 printf (_(" %#06lx: Parent %d: %s\n"),
11060 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
11062 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11063 isum
, j
, aux
.vda_name
);
11066 if (j
< ent
.vd_cnt
)
11067 printf (_(" Version def aux past end of section\n"));
11070 file: id:000001,src:000172+005151,op:splice,rep:2. */
11071 if (ent
.vd_next
< sizeof (*edef
)
11072 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11074 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11075 cnt
= section
->sh_info
;
11078 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11081 idx
+= ent
.vd_next
;
11084 if (cnt
< section
->sh_info
)
11085 printf (_(" Version definition past end of section\n"));
11091 case SHT_GNU_verneed
:
11093 Elf_External_Verneed
* eneed
;
11100 printf (ngettext ("\nVersion needs section '%s' "
11101 "contains %u entry:\n",
11102 "\nVersion needs section '%s' "
11103 "contains %u entries:\n",
11105 printable_section_name (filedata
, section
), section
->sh_info
);
11107 printf (_(" Addr: 0x"));
11108 printf_vma (section
->sh_addr
);
11109 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11110 (unsigned long) section
->sh_offset
, section
->sh_link
,
11111 printable_section_name_from_index (filedata
, section
->sh_link
));
11113 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11114 section
->sh_offset
, 1,
11116 _("Version Needs section"));
11119 endbuf
= (char *) eneed
+ section
->sh_size
;
11121 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11123 Elf_External_Verneed
* entry
;
11124 Elf_Internal_Verneed ent
;
11125 unsigned long isum
;
11129 vstart
= ((char *) eneed
) + idx
;
11130 if (vstart
+ sizeof (*entry
) > endbuf
)
11133 entry
= (Elf_External_Verneed
*) vstart
;
11135 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11136 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11137 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11138 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11139 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11141 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11143 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
11144 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
11146 printf (_(" File: %lx"), ent
.vn_file
);
11148 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11150 /* Check for overflow. */
11151 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11153 vstart
+= ent
.vn_aux
;
11155 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11157 Elf_External_Vernaux
* eaux
;
11158 Elf_Internal_Vernaux aux
;
11160 if (vstart
+ sizeof (*eaux
) > endbuf
)
11162 eaux
= (Elf_External_Vernaux
*) vstart
;
11164 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11165 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11166 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11167 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11168 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11170 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
11171 printf (_(" %#06lx: Name: %s"),
11172 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
11174 printf (_(" %#06lx: Name index: %lx"),
11175 isum
, aux
.vna_name
);
11177 printf (_(" Flags: %s Version: %d\n"),
11178 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11180 if (aux
.vna_next
< sizeof (*eaux
)
11181 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11183 warn (_("Invalid vna_next field of %lx\n"),
11188 /* Check for overflow. */
11189 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11191 isum
+= aux
.vna_next
;
11192 vstart
+= aux
.vna_next
;
11195 if (j
< ent
.vn_cnt
)
11196 warn (_("Missing Version Needs auxillary information\n"));
11198 if (ent
.vn_next
< sizeof (*entry
)
11199 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11201 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11202 cnt
= section
->sh_info
;
11205 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11207 idx
+= ent
.vn_next
;
11210 if (cnt
< section
->sh_info
)
11211 warn (_("Missing Version Needs information\n"));
11217 case SHT_GNU_versym
:
11219 Elf_Internal_Shdr
* link_section
;
11222 unsigned char * edata
;
11223 unsigned short * data
;
11225 Elf_Internal_Sym
* symbols
;
11226 Elf_Internal_Shdr
* string_sec
;
11227 unsigned long num_syms
;
11230 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11233 link_section
= filedata
->section_headers
+ section
->sh_link
;
11234 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11236 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11241 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11242 if (symbols
== NULL
)
11245 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11247 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11248 string_sec
->sh_size
,
11249 _("version string table"));
11256 printf (ngettext ("\nVersion symbols section '%s' "
11257 "contains %lu entry:\n",
11258 "\nVersion symbols section '%s' "
11259 "contains %lu entries:\n",
11261 printable_section_name (filedata
, section
), (unsigned long) total
);
11263 printf (_(" Addr: 0x"));
11264 printf_vma (section
->sh_addr
);
11265 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11266 (unsigned long) section
->sh_offset
, section
->sh_link
,
11267 printable_section_name (filedata
, link_section
));
11269 off
= offset_from_vma (filedata
,
11270 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11271 total
* sizeof (short));
11272 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11273 sizeof (short), total
,
11274 _("version symbol data"));
11282 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11284 for (cnt
= total
; cnt
--;)
11285 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11290 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11294 char *invalid
= _("*invalid*");
11296 printf (" %03x:", cnt
);
11298 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11299 switch (data
[cnt
+ j
])
11302 fputs (_(" 0 (*local*) "), stdout
);
11306 fputs (_(" 1 (*global*) "), stdout
);
11310 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11311 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11313 /* If this index value is greater than the size of the symbols
11314 array, break to avoid an out-of-bounds read. */
11315 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11317 warn (_("invalid index into symbol array\n"));
11322 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11324 Elf_Internal_Verneed ivn
;
11325 unsigned long offset
;
11327 offset
= offset_from_vma
11328 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11329 sizeof (Elf_External_Verneed
));
11333 Elf_Internal_Vernaux ivna
;
11334 Elf_External_Verneed evn
;
11335 Elf_External_Vernaux evna
;
11336 unsigned long a_off
;
11338 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11339 _("version need")) == NULL
)
11342 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11343 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11345 a_off
= offset
+ ivn
.vn_aux
;
11349 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11350 1, _("version need aux (2)")) == NULL
)
11353 ivna
.vna_other
= 0;
11357 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11358 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11361 a_off
+= ivna
.vna_next
;
11363 while (ivna
.vna_other
!= data
[cnt
+ j
]
11364 && ivna
.vna_next
!= 0);
11366 if (ivna
.vna_other
== data
[cnt
+ j
])
11368 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11370 if (ivna
.vna_name
>= string_sec
->sh_size
)
11373 name
= strtab
+ ivna
.vna_name
;
11377 offset
+= ivn
.vn_next
;
11379 while (ivn
.vn_next
);
11382 if (data
[cnt
+ j
] != 0x8001
11383 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11385 Elf_Internal_Verdef ivd
;
11386 Elf_External_Verdef evd
;
11387 unsigned long offset
;
11389 offset
= offset_from_vma
11390 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11395 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11396 _("version def")) == NULL
)
11399 /* PR 17531: file: 046-1082287-0.004. */
11400 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11405 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11406 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11409 offset
+= ivd
.vd_next
;
11411 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11412 && ivd
.vd_next
!= 0);
11414 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11416 Elf_External_Verdaux evda
;
11417 Elf_Internal_Verdaux ivda
;
11419 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11421 if (get_data (&evda
, filedata
,
11422 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11424 _("version def aux")) == NULL
)
11427 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11429 if (ivda
.vda_name
>= string_sec
->sh_size
)
11431 else if (name
!= NULL
&& name
!= invalid
)
11432 name
= _("*both*");
11434 name
= strtab
+ ivda
.vda_name
;
11438 nn
+= printf ("(%s%-*s",
11440 12 - (int) strlen (name
),
11444 printf ("%*c", 18 - nn
, ' ');
11462 printf (_("\nNo version information found in this file.\n"));
11467 static const char *
11468 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11470 static char buff
[32];
11474 case STB_LOCAL
: return "LOCAL";
11475 case STB_GLOBAL
: return "GLOBAL";
11476 case STB_WEAK
: return "WEAK";
11478 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11479 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11481 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11483 if (binding
== STB_GNU_UNIQUE
11484 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11486 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11489 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11494 static const char *
11495 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11497 static char buff
[32];
11501 case STT_NOTYPE
: return "NOTYPE";
11502 case STT_OBJECT
: return "OBJECT";
11503 case STT_FUNC
: return "FUNC";
11504 case STT_SECTION
: return "SECTION";
11505 case STT_FILE
: return "FILE";
11506 case STT_COMMON
: return "COMMON";
11507 case STT_TLS
: return "TLS";
11508 case STT_RELC
: return "RELC";
11509 case STT_SRELC
: return "SRELC";
11511 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11513 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11514 return "THUMB_FUNC";
11516 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11519 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11520 return "PARISC_MILLI";
11522 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11524 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11526 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11528 if (type
== STT_HP_OPAQUE
)
11529 return "HP_OPAQUE";
11530 if (type
== STT_HP_STUB
)
11534 if (type
== STT_GNU_IFUNC
11535 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11536 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11539 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11542 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11547 static const char *
11548 get_symbol_visibility (unsigned int visibility
)
11550 switch (visibility
)
11552 case STV_DEFAULT
: return "DEFAULT";
11553 case STV_INTERNAL
: return "INTERNAL";
11554 case STV_HIDDEN
: return "HIDDEN";
11555 case STV_PROTECTED
: return "PROTECTED";
11557 error (_("Unrecognized visibility value: %u\n"), visibility
);
11558 return _("<unknown>");
11562 static const char *
11563 get_alpha_symbol_other (unsigned int other
)
11567 case STO_ALPHA_NOPV
: return "NOPV";
11568 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11570 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11571 return _("<unknown>");
11575 static const char *
11576 get_solaris_symbol_visibility (unsigned int visibility
)
11578 switch (visibility
)
11580 case 4: return "EXPORTED";
11581 case 5: return "SINGLETON";
11582 case 6: return "ELIMINATE";
11583 default: return get_symbol_visibility (visibility
);
11587 static const char *
11588 get_aarch64_symbol_other (unsigned int other
)
11590 static char buf
[32];
11592 if (other
& STO_AARCH64_VARIANT_PCS
)
11594 other
&= ~STO_AARCH64_VARIANT_PCS
;
11596 return "VARIANT_PCS";
11597 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11603 static const char *
11604 get_mips_symbol_other (unsigned int other
)
11608 case STO_OPTIONAL
: return "OPTIONAL";
11609 case STO_MIPS_PLT
: return "MIPS PLT";
11610 case STO_MIPS_PIC
: return "MIPS PIC";
11611 case STO_MICROMIPS
: return "MICROMIPS";
11612 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11613 case STO_MIPS16
: return "MIPS16";
11614 default: return NULL
;
11618 static const char *
11619 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11621 if (is_ia64_vms (filedata
))
11623 static char res
[32];
11627 /* Function types is for images and .STB files only. */
11628 switch (filedata
->file_header
.e_type
)
11632 switch (VMS_ST_FUNC_TYPE (other
))
11634 case VMS_SFT_CODE_ADDR
:
11635 strcat (res
, " CA");
11637 case VMS_SFT_SYMV_IDX
:
11638 strcat (res
, " VEC");
11641 strcat (res
, " FD");
11643 case VMS_SFT_RESERVE
:
11644 strcat (res
, " RSV");
11647 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11648 VMS_ST_FUNC_TYPE (other
));
11649 strcat (res
, " <unknown>");
11656 switch (VMS_ST_LINKAGE (other
))
11658 case VMS_STL_IGNORE
:
11659 strcat (res
, " IGN");
11661 case VMS_STL_RESERVE
:
11662 strcat (res
, " RSV");
11665 strcat (res
, " STD");
11668 strcat (res
, " LNK");
11671 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11672 VMS_ST_LINKAGE (other
));
11673 strcat (res
, " <unknown>");
11685 static const char *
11686 get_ppc64_symbol_other (unsigned int other
)
11688 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11691 other
>>= STO_PPC64_LOCAL_BIT
;
11694 static char buf
[32];
11696 other
= ppc64_decode_local_entry (other
);
11697 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11703 static const char *
11704 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11706 const char * result
= NULL
;
11707 static char buff
[32];
11712 switch (filedata
->file_header
.e_machine
)
11715 result
= get_alpha_symbol_other (other
);
11718 result
= get_aarch64_symbol_other (other
);
11721 result
= get_mips_symbol_other (other
);
11724 result
= get_ia64_symbol_other (filedata
, other
);
11727 result
= get_ppc64_symbol_other (other
);
11737 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11741 static const char *
11742 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11744 static char buff
[32];
11748 case SHN_UNDEF
: return "UND";
11749 case SHN_ABS
: return "ABS";
11750 case SHN_COMMON
: return "COM";
11752 if (type
== SHN_IA_64_ANSI_COMMON
11753 && filedata
->file_header
.e_machine
== EM_IA_64
11754 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11756 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11757 || filedata
->file_header
.e_machine
== EM_L1OM
11758 || filedata
->file_header
.e_machine
== EM_K1OM
)
11759 && type
== SHN_X86_64_LCOMMON
)
11760 return "LARGE_COM";
11761 else if ((type
== SHN_MIPS_SCOMMON
11762 && filedata
->file_header
.e_machine
== EM_MIPS
)
11763 || (type
== SHN_TIC6X_SCOMMON
11764 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11766 else if (type
== SHN_MIPS_SUNDEFINED
11767 && filedata
->file_header
.e_machine
== EM_MIPS
)
11769 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11770 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11771 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11772 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11773 else if (type
>= SHN_LORESERVE
)
11774 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11775 else if (filedata
->file_header
.e_shnum
!= 0
11776 && type
>= filedata
->file_header
.e_shnum
)
11777 sprintf (buff
, _("bad section index[%3d]"), type
);
11779 sprintf (buff
, "%3d", type
);
11786 static const char *
11787 get_symbol_version_string (Filedata
* filedata
,
11788 bfd_boolean is_dynsym
,
11789 const char * strtab
,
11790 unsigned long int strtab_size
,
11792 Elf_Internal_Sym
* psym
,
11793 enum versioned_symbol_info
* sym_info
,
11794 unsigned short * vna_other
)
11796 unsigned char data
[2];
11797 unsigned short vers_data
;
11798 unsigned long offset
;
11799 unsigned short max_vd_ndx
;
11802 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11805 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11806 sizeof data
+ si
* sizeof (vers_data
));
11808 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11809 sizeof (data
), 1, _("version data")) == NULL
)
11812 vers_data
= byte_get (data
, 2);
11814 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11817 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11820 /* Usually we'd only see verdef for defined symbols, and verneed for
11821 undefined symbols. However, symbols defined by the linker in
11822 .dynbss for variables copied from a shared library in order to
11823 avoid text relocations are defined yet have verneed. We could
11824 use a heuristic to detect the special case, for example, check
11825 for verneed first on symbols defined in SHT_NOBITS sections, but
11826 it is simpler and more reliable to just look for both verdef and
11827 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11829 if (psym
->st_shndx
!= SHN_UNDEF
11830 && vers_data
!= 0x8001
11831 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11833 Elf_Internal_Verdef ivd
;
11834 Elf_Internal_Verdaux ivda
;
11835 Elf_External_Verdaux evda
;
11838 off
= offset_from_vma (filedata
,
11839 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11840 sizeof (Elf_External_Verdef
));
11844 Elf_External_Verdef evd
;
11846 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11847 _("version def")) == NULL
)
11856 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11857 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11858 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11859 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11862 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11863 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11865 off
+= ivd
.vd_next
;
11867 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11869 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11871 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11874 off
-= ivd
.vd_next
;
11877 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11878 _("version def aux")) != NULL
)
11880 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11882 if (psym
->st_name
!= ivda
.vda_name
)
11883 return (ivda
.vda_name
< strtab_size
11884 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11889 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11891 Elf_External_Verneed evn
;
11892 Elf_Internal_Verneed ivn
;
11893 Elf_Internal_Vernaux ivna
;
11895 offset
= offset_from_vma (filedata
,
11896 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11900 unsigned long vna_off
;
11902 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11903 _("version need")) == NULL
)
11906 ivna
.vna_other
= 0;
11911 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11912 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11914 vna_off
= offset
+ ivn
.vn_aux
;
11918 Elf_External_Vernaux evna
;
11920 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11921 _("version need aux (3)")) == NULL
)
11924 ivna
.vna_other
= 0;
11929 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11930 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11931 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11934 vna_off
+= ivna
.vna_next
;
11936 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11938 if (ivna
.vna_other
== vers_data
)
11941 offset
+= ivn
.vn_next
;
11943 while (ivn
.vn_next
!= 0);
11945 if (ivna
.vna_other
== vers_data
)
11947 *sym_info
= symbol_undefined
;
11948 *vna_other
= ivna
.vna_other
;
11949 return (ivna
.vna_name
< strtab_size
11950 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11952 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11953 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11954 return _("<corrupt>");
11960 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
11961 Elf_Internal_Sym
*symtab
,
11962 Elf_Internal_Shdr
*section
,
11963 char *strtab
, size_t strtab_size
)
11965 const char *version_string
;
11966 enum versioned_symbol_info sym_info
;
11967 unsigned short vna_other
;
11968 Elf_Internal_Sym
*psym
= symtab
+ si
;
11970 printf ("%6ld: ", si
);
11971 print_vma (psym
->st_value
, LONG_HEX
);
11973 print_vma (psym
->st_size
, DEC_5
);
11974 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11975 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11976 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11977 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11980 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11982 printf (" %-7s", get_symbol_visibility (vis
));
11983 /* Check to see if any other bits in the st_other field are set.
11984 Note - displaying this information disrupts the layout of the
11985 table being generated, but for the moment this case is very rare. */
11986 if (psym
->st_other
^ vis
)
11987 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11989 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11990 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
11992 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11995 = get_symbol_version_string (filedata
,
11997 || section
->sh_type
== SHT_DYNSYM
),
11998 strtab
, strtab_size
, si
,
11999 psym
, &sym_info
, &vna_other
);
12000 if (version_string
)
12002 if (sym_info
== symbol_undefined
)
12003 printf ("@%s (%d)", version_string
, vna_other
);
12005 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12011 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12013 && si
>= section
->sh_info
12014 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12015 && filedata
->file_header
.e_machine
!= EM_MIPS
12016 /* Solaris binaries have been found to violate this requirement as
12017 well. Not sure if this is a bug or an ABI requirement. */
12018 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12019 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12020 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12023 /* Dump the symbol table. */
12025 process_symbol_table (Filedata
* filedata
)
12027 Elf_Internal_Shdr
* section
;
12029 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12032 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
12034 && do_using_dynamic
12035 && dynamic_strings
!= NULL
12036 && dynamic_symbols
!= NULL
)
12040 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12041 "\nSymbol table for image contains %lu entries:\n",
12042 num_dynamic_syms
), num_dynamic_syms
);
12044 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12046 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12048 for (si
= 0; si
< num_dynamic_syms
; si
++)
12049 print_dynamic_symbol (filedata
, si
, dynamic_symbols
, NULL
,
12050 dynamic_strings
, dynamic_strings_length
);
12052 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12053 && filedata
->section_headers
!= NULL
)
12057 for (i
= 0, section
= filedata
->section_headers
;
12058 i
< filedata
->file_header
.e_shnum
;
12061 char * strtab
= NULL
;
12062 unsigned long int strtab_size
= 0;
12063 Elf_Internal_Sym
* symtab
;
12064 unsigned long si
, num_syms
;
12066 if ((section
->sh_type
!= SHT_SYMTAB
12067 && section
->sh_type
!= SHT_DYNSYM
)
12069 && section
->sh_type
== SHT_SYMTAB
))
12072 if (section
->sh_entsize
== 0)
12074 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12075 printable_section_name (filedata
, section
));
12079 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12080 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12081 "\nSymbol table '%s' contains %lu entries:\n",
12083 printable_section_name (filedata
, section
),
12087 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12089 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12091 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12092 if (symtab
== NULL
)
12095 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12097 strtab
= filedata
->string_table
;
12098 strtab_size
= filedata
->string_table_length
;
12100 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12102 Elf_Internal_Shdr
* string_sec
;
12104 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12106 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12107 1, string_sec
->sh_size
,
12108 _("string table"));
12109 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12112 for (si
= 0; si
< num_syms
; si
++)
12113 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12114 strtab
, strtab_size
);
12117 if (strtab
!= filedata
->string_table
)
12123 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12125 if (do_histogram
&& buckets
!= NULL
)
12127 unsigned long * lengths
;
12128 unsigned long * counts
;
12131 unsigned long maxlength
= 0;
12132 unsigned long nzero_counts
= 0;
12133 unsigned long nsyms
= 0;
12136 printf (ngettext ("\nHistogram for bucket list length "
12137 "(total of %lu bucket):\n",
12138 "\nHistogram for bucket list length "
12139 "(total of %lu buckets):\n",
12140 (unsigned long) nbuckets
),
12141 (unsigned long) nbuckets
);
12143 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12144 if (lengths
== NULL
)
12146 error (_("Out of memory allocating space for histogram buckets\n"));
12149 visited
= xcmalloc (nchains
, 1);
12150 memset (visited
, 0, nchains
);
12152 printf (_(" Length Number %% of total Coverage\n"));
12153 for (hn
= 0; hn
< nbuckets
; ++hn
)
12155 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12158 if (maxlength
< ++lengths
[hn
])
12160 if (si
>= nchains
|| visited
[si
])
12162 error (_("histogram chain is corrupt\n"));
12170 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12171 if (counts
== NULL
)
12174 error (_("Out of memory allocating space for histogram counts\n"));
12178 for (hn
= 0; hn
< nbuckets
; ++hn
)
12179 ++counts
[lengths
[hn
]];
12184 printf (" 0 %-10lu (%5.1f%%)\n",
12185 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12186 for (i
= 1; i
<= maxlength
; ++i
)
12188 nzero_counts
+= counts
[i
] * i
;
12189 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12190 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12191 (nzero_counts
* 100.0) / nsyms
);
12204 if (do_histogram
&& gnubuckets
!= NULL
)
12206 unsigned long * lengths
;
12207 unsigned long * counts
;
12209 unsigned long maxlength
= 0;
12210 unsigned long nzero_counts
= 0;
12211 unsigned long nsyms
= 0;
12213 printf (ngettext ("\nHistogram for `%s' bucket list length "
12214 "(total of %lu bucket):\n",
12215 "\nHistogram for `%s' bucket list length "
12216 "(total of %lu buckets):\n",
12217 (unsigned long) ngnubuckets
),
12218 GNU_HASH_SECTION_NAME
,
12219 (unsigned long) ngnubuckets
);
12221 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12222 if (lengths
== NULL
)
12224 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12228 printf (_(" Length Number %% of total Coverage\n"));
12230 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12231 if (gnubuckets
[hn
] != 0)
12233 bfd_vma off
, length
= 1;
12235 for (off
= gnubuckets
[hn
] - gnusymidx
;
12236 /* PR 17531 file: 010-77222-0.004. */
12237 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12240 lengths
[hn
] = length
;
12241 if (length
> maxlength
)
12242 maxlength
= length
;
12246 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12247 if (counts
== NULL
)
12250 error (_("Out of memory allocating space for gnu histogram counts\n"));
12254 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12255 ++counts
[lengths
[hn
]];
12257 if (ngnubuckets
> 0)
12260 printf (" 0 %-10lu (%5.1f%%)\n",
12261 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12262 for (j
= 1; j
<= maxlength
; ++j
)
12264 nzero_counts
+= counts
[j
] * j
;
12265 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12266 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12267 (nzero_counts
* 100.0) / nsyms
);
12289 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12293 if (dynamic_syminfo
== NULL
12295 /* No syminfo, this is ok. */
12298 /* There better should be a dynamic symbol section. */
12299 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12303 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12304 "contains %d entry:\n",
12305 "\nDynamic info segment at offset 0x%lx "
12306 "contains %d entries:\n",
12307 dynamic_syminfo_nent
),
12308 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12310 printf (_(" Num: Name BoundTo Flags\n"));
12311 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12313 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12315 printf ("%4d: ", i
);
12316 if (i
>= num_dynamic_syms
)
12317 printf (_("<corrupt index>"));
12318 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12319 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12321 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12324 switch (dynamic_syminfo
[i
].si_boundto
)
12326 case SYMINFO_BT_SELF
:
12327 fputs ("SELF ", stdout
);
12329 case SYMINFO_BT_PARENT
:
12330 fputs ("PARENT ", stdout
);
12333 if (dynamic_syminfo
[i
].si_boundto
> 0
12334 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12335 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12337 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12341 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12345 if (flags
& SYMINFO_FLG_DIRECT
)
12346 printf (" DIRECT");
12347 if (flags
& SYMINFO_FLG_PASSTHRU
)
12348 printf (" PASSTHRU");
12349 if (flags
& SYMINFO_FLG_COPY
)
12351 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12352 printf (" LAZYLOAD");
12360 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12361 is contained by the region START .. END. The types of ADDR, START
12362 and END should all be the same. Note both ADDR + NELEM and END
12363 point to just beyond the end of the regions that are being tested. */
12364 #define IN_RANGE(START,END,ADDR,NELEM) \
12365 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12367 /* Check to see if the given reloc needs to be handled in a target specific
12368 manner. If so then process the reloc and return TRUE otherwise return
12371 If called with reloc == NULL, then this is a signal that reloc processing
12372 for the current section has finished, and any saved state should be
12376 target_specific_reloc_handling (Filedata
* filedata
,
12377 Elf_Internal_Rela
* reloc
,
12378 unsigned char * start
,
12379 unsigned char * end
,
12380 Elf_Internal_Sym
* symtab
,
12381 unsigned long num_syms
)
12383 unsigned int reloc_type
= 0;
12384 unsigned long sym_index
= 0;
12388 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12389 sym_index
= get_reloc_symindex (reloc
->r_info
);
12392 switch (filedata
->file_header
.e_machine
)
12395 case EM_MSP430_OLD
:
12397 static Elf_Internal_Sym
* saved_sym
= NULL
;
12405 switch (reloc_type
)
12407 case 10: /* R_MSP430_SYM_DIFF */
12408 if (uses_msp430x_relocs (filedata
))
12410 /* Fall through. */
12411 case 21: /* R_MSP430X_SYM_DIFF */
12413 if (sym_index
>= num_syms
)
12414 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12417 saved_sym
= symtab
+ sym_index
;
12420 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12421 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12422 goto handle_sym_diff
;
12424 case 5: /* R_MSP430_16_BYTE */
12425 case 9: /* R_MSP430_8 */
12426 if (uses_msp430x_relocs (filedata
))
12428 goto handle_sym_diff
;
12430 case 2: /* R_MSP430_ABS16 */
12431 case 15: /* R_MSP430X_ABS16 */
12432 if (! uses_msp430x_relocs (filedata
))
12434 goto handle_sym_diff
;
12437 if (saved_sym
!= NULL
)
12439 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12442 if (sym_index
>= num_syms
)
12443 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12447 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12448 - saved_sym
->st_value
);
12450 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12451 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12454 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12455 (long) reloc
->r_offset
);
12464 if (saved_sym
!= NULL
)
12465 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12472 case EM_CYGNUS_MN10300
:
12474 static Elf_Internal_Sym
* saved_sym
= NULL
;
12482 switch (reloc_type
)
12484 case 34: /* R_MN10300_ALIGN */
12486 case 33: /* R_MN10300_SYM_DIFF */
12487 if (sym_index
>= num_syms
)
12488 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12491 saved_sym
= symtab
+ sym_index
;
12494 case 1: /* R_MN10300_32 */
12495 case 2: /* R_MN10300_16 */
12496 if (saved_sym
!= NULL
)
12498 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12501 if (sym_index
>= num_syms
)
12502 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12506 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12507 - saved_sym
->st_value
);
12509 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12510 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12512 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12513 (long) reloc
->r_offset
);
12521 if (saved_sym
!= NULL
)
12522 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12530 static bfd_vma saved_sym1
= 0;
12531 static bfd_vma saved_sym2
= 0;
12532 static bfd_vma value
;
12536 saved_sym1
= saved_sym2
= 0;
12540 switch (reloc_type
)
12542 case 0x80: /* R_RL78_SYM. */
12543 saved_sym1
= saved_sym2
;
12544 if (sym_index
>= num_syms
)
12545 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12549 saved_sym2
= symtab
[sym_index
].st_value
;
12550 saved_sym2
+= reloc
->r_addend
;
12554 case 0x83: /* R_RL78_OPsub. */
12555 value
= saved_sym1
- saved_sym2
;
12556 saved_sym2
= saved_sym1
= 0;
12560 case 0x41: /* R_RL78_ABS32. */
12561 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12562 byte_put (start
+ reloc
->r_offset
, value
, 4);
12564 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12565 (long) reloc
->r_offset
);
12569 case 0x43: /* R_RL78_ABS16. */
12570 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12571 byte_put (start
+ reloc
->r_offset
, value
, 2);
12573 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12574 (long) reloc
->r_offset
);
12588 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12589 DWARF debug sections. This is a target specific test. Note - we do not
12590 go through the whole including-target-headers-multiple-times route, (as
12591 we have already done with <elf/h8.h>) because this would become very
12592 messy and even then this function would have to contain target specific
12593 information (the names of the relocs instead of their numeric values).
12594 FIXME: This is not the correct way to solve this problem. The proper way
12595 is to have target specific reloc sizing and typing functions created by
12596 the reloc-macros.h header, in the same way that it already creates the
12597 reloc naming functions. */
12600 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12602 /* Please keep this table alpha-sorted for ease of visual lookup. */
12603 switch (filedata
->file_header
.e_machine
)
12607 return reloc_type
== 1; /* R_386_32. */
12609 return reloc_type
== 1; /* R_68K_32. */
12611 return reloc_type
== 1; /* R_860_32. */
12613 return reloc_type
== 2; /* R_960_32. */
12615 return (reloc_type
== 258
12616 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12618 return reloc_type
== 11; /* R_BPF_DATA_32 */
12619 case EM_ADAPTEVA_EPIPHANY
:
12620 return reloc_type
== 3;
12622 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12624 return reloc_type
== 1; /* R_ARC_32. */
12625 case EM_ARC_COMPACT
:
12626 case EM_ARC_COMPACT2
:
12627 return reloc_type
== 4; /* R_ARC_32. */
12629 return reloc_type
== 2; /* R_ARM_ABS32 */
12632 return reloc_type
== 1;
12634 return reloc_type
== 0x12; /* R_byte4_data. */
12636 return reloc_type
== 3; /* R_CRIS_32. */
12638 return reloc_type
== 3; /* R_CR16_NUM32. */
12640 return reloc_type
== 15; /* R_CRX_NUM32. */
12642 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12643 case EM_CYGNUS_FRV
:
12644 return reloc_type
== 1;
12645 case EM_CYGNUS_D10V
:
12647 return reloc_type
== 6; /* R_D10V_32. */
12648 case EM_CYGNUS_D30V
:
12650 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12652 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12653 case EM_CYGNUS_FR30
:
12655 return reloc_type
== 3; /* R_FR30_32. */
12657 return reloc_type
== 1; /* R_FT32_32. */
12661 return reloc_type
== 1; /* R_H8_DIR32. */
12663 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12664 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12665 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12666 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12669 return reloc_type
== 2; /* R_IP2K_32. */
12671 return reloc_type
== 2; /* R_IQ2000_32. */
12672 case EM_LATTICEMICO32
:
12673 return reloc_type
== 3; /* R_LM32_32. */
12676 return reloc_type
== 3; /* R_M32C_32. */
12678 return reloc_type
== 34; /* R_M32R_32_RELA. */
12681 return reloc_type
== 6; /* R_M68HC11_32. */
12683 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12684 reloc_type
== 6; /* R_S12Z_CW32. */
12686 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12687 case EM_CYGNUS_MEP
:
12688 return reloc_type
== 4; /* R_MEP_32. */
12690 return reloc_type
== 2; /* R_METAG_ADDR32. */
12691 case EM_MICROBLAZE
:
12692 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12694 return reloc_type
== 2; /* R_MIPS_32. */
12696 return reloc_type
== 4; /* R_MMIX_32. */
12697 case EM_CYGNUS_MN10200
:
12699 return reloc_type
== 1; /* R_MN10200_32. */
12700 case EM_CYGNUS_MN10300
:
12702 return reloc_type
== 1; /* R_MN10300_32. */
12704 return reloc_type
== 1; /* R_MOXIE_32. */
12705 case EM_MSP430_OLD
:
12707 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12709 return reloc_type
== 2; /* R_MT_32. */
12711 return reloc_type
== 20; /* R_NDS32_RELA. */
12712 case EM_ALTERA_NIOS2
:
12713 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12715 return reloc_type
== 1; /* R_NIOS_32. */
12717 return reloc_type
== 1; /* R_OR1K_32. */
12719 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12720 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12721 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12724 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12726 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12728 return reloc_type
== 1; /* R_PPC_ADDR32. */
12730 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12732 return reloc_type
== 1; /* R_RISCV_32. */
12734 return reloc_type
== 1; /* R_RL78_DIR32. */
12736 return reloc_type
== 1; /* R_RX_DIR32. */
12738 return reloc_type
== 1; /* R_I370_ADDR31. */
12741 return reloc_type
== 4; /* R_S390_32. */
12743 return reloc_type
== 8; /* R_SCORE_ABS32. */
12745 return reloc_type
== 1; /* R_SH_DIR32. */
12746 case EM_SPARC32PLUS
:
12749 return reloc_type
== 3 /* R_SPARC_32. */
12750 || reloc_type
== 23; /* R_SPARC_UA32. */
12752 return reloc_type
== 6; /* R_SPU_ADDR32 */
12754 return reloc_type
== 1; /* R_C6000_ABS32. */
12756 return reloc_type
== 2; /* R_TILEGX_32. */
12758 return reloc_type
== 1; /* R_TILEPRO_32. */
12759 case EM_CYGNUS_V850
:
12761 return reloc_type
== 6; /* R_V850_ABS32. */
12763 return reloc_type
== 0x33; /* R_V810_WORD. */
12765 return reloc_type
== 1; /* R_VAX_32. */
12767 return reloc_type
== 3; /* R_VISIUM_32. */
12768 case EM_WEBASSEMBLY
:
12769 return reloc_type
== 1; /* R_WASM32_32. */
12773 return reloc_type
== 10; /* R_X86_64_32. */
12776 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12778 return reloc_type
== 4; /* R_XGATE_32. */
12780 return reloc_type
== 1; /* R_XSTROMY16_32. */
12781 case EM_XTENSA_OLD
:
12783 return reloc_type
== 1; /* R_XTENSA_32. */
12785 return reloc_type
== 6; /* R_Z80_32. */
12788 static unsigned int prev_warn
= 0;
12790 /* Avoid repeating the same warning multiple times. */
12791 if (prev_warn
!= filedata
->file_header
.e_machine
)
12792 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12793 filedata
->file_header
.e_machine
);
12794 prev_warn
= filedata
->file_header
.e_machine
;
12800 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12801 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12804 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12806 switch (filedata
->file_header
.e_machine
)
12807 /* Please keep this table alpha-sorted for ease of visual lookup. */
12811 return reloc_type
== 2; /* R_386_PC32. */
12813 return reloc_type
== 4; /* R_68K_PC32. */
12815 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12816 case EM_ADAPTEVA_EPIPHANY
:
12817 return reloc_type
== 6;
12819 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12820 case EM_ARC_COMPACT
:
12821 case EM_ARC_COMPACT2
:
12822 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12824 return reloc_type
== 3; /* R_ARM_REL32 */
12827 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12828 case EM_MICROBLAZE
:
12829 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12831 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12833 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12835 return reloc_type
== 26; /* R_PPC_REL32. */
12837 return reloc_type
== 26; /* R_PPC64_REL32. */
12839 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12842 return reloc_type
== 5; /* R_390_PC32. */
12844 return reloc_type
== 2; /* R_SH_REL32. */
12845 case EM_SPARC32PLUS
:
12848 return reloc_type
== 6; /* R_SPARC_DISP32. */
12850 return reloc_type
== 13; /* R_SPU_REL32. */
12852 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12854 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12856 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12860 return reloc_type
== 2; /* R_X86_64_PC32. */
12862 return reloc_type
== 4; /* R_VAX_PCREL32. */
12863 case EM_XTENSA_OLD
:
12865 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12867 /* Do not abort or issue an error message here. Not all targets use
12868 pc-relative 32-bit relocs in their DWARF debug information and we
12869 have already tested for target coverage in is_32bit_abs_reloc. A
12870 more helpful warning message will be generated by apply_relocations
12871 anyway, so just return. */
12876 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12877 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12880 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12882 switch (filedata
->file_header
.e_machine
)
12885 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12887 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12889 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12890 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12892 return reloc_type
== 80; /* R_PARISC_DIR64. */
12894 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12896 return reloc_type
== 2; /* R_RISCV_64. */
12897 case EM_SPARC32PLUS
:
12900 return reloc_type
== 32 /* R_SPARC_64. */
12901 || reloc_type
== 54; /* R_SPARC_UA64. */
12905 return reloc_type
== 1; /* R_X86_64_64. */
12908 return reloc_type
== 22; /* R_S390_64. */
12910 return reloc_type
== 1; /* R_TILEGX_64. */
12912 return reloc_type
== 18; /* R_MIPS_64. */
12918 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12919 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12922 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12924 switch (filedata
->file_header
.e_machine
)
12927 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12929 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12931 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12932 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12934 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12936 return reloc_type
== 44; /* R_PPC64_REL64. */
12937 case EM_SPARC32PLUS
:
12940 return reloc_type
== 46; /* R_SPARC_DISP64. */
12944 return reloc_type
== 24; /* R_X86_64_PC64. */
12947 return reloc_type
== 23; /* R_S390_PC64. */
12949 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12955 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12956 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12959 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12961 switch (filedata
->file_header
.e_machine
)
12963 case EM_CYGNUS_MN10200
:
12965 return reloc_type
== 4; /* R_MN10200_24. */
12967 return reloc_type
== 5; /* R_FT32_20. */
12969 return reloc_type
== 5; /* R_Z80_24. */
12975 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12976 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12979 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12981 /* Please keep this table alpha-sorted for ease of visual lookup. */
12982 switch (filedata
->file_header
.e_machine
)
12985 case EM_ARC_COMPACT
:
12986 case EM_ARC_COMPACT2
:
12987 return reloc_type
== 2; /* R_ARC_16. */
12988 case EM_ADAPTEVA_EPIPHANY
:
12989 return reloc_type
== 5;
12992 return reloc_type
== 4; /* R_AVR_16. */
12993 case EM_CYGNUS_D10V
:
12995 return reloc_type
== 3; /* R_D10V_16. */
12997 return reloc_type
== 2; /* R_FT32_16. */
13001 return reloc_type
== R_H8_DIR16
;
13004 return reloc_type
== 1; /* R_IP2K_16. */
13007 return reloc_type
== 1; /* R_M32C_16 */
13008 case EM_CYGNUS_MN10200
:
13010 return reloc_type
== 2; /* R_MN10200_16. */
13011 case EM_CYGNUS_MN10300
:
13013 return reloc_type
== 2; /* R_MN10300_16. */
13015 if (uses_msp430x_relocs (filedata
))
13016 return reloc_type
== 2; /* R_MSP430_ABS16. */
13017 /* Fall through. */
13018 case EM_MSP430_OLD
:
13019 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13021 return reloc_type
== 19; /* R_NDS32_RELA. */
13022 case EM_ALTERA_NIOS2
:
13023 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13025 return reloc_type
== 9; /* R_NIOS_16. */
13027 return reloc_type
== 2; /* R_OR1K_16. */
13029 return reloc_type
== 55; /* R_RISCV_SET16. */
13031 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13033 return reloc_type
== 2; /* R_C6000_ABS16. */
13035 return reloc_type
== 2; /* R_VISIUM_16. */
13038 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13040 return reloc_type
== 3; /* R_XGATE_16. */
13042 return reloc_type
== 4; /* R_Z80_16. */
13048 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13049 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13052 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13054 switch (filedata
->file_header
.e_machine
)
13057 return reloc_type
== 54; /* R_RISCV_SET8. */
13059 return reloc_type
== 1; /* R_Z80_8. */
13065 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13066 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13069 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13071 switch (filedata
->file_header
.e_machine
)
13074 return reloc_type
== 53; /* R_RISCV_SET6. */
13080 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13081 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13084 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13086 /* Please keep this table alpha-sorted for ease of visual lookup. */
13087 switch (filedata
->file_header
.e_machine
)
13090 return reloc_type
== 35; /* R_RISCV_ADD32. */
13096 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13097 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13100 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13102 /* Please keep this table alpha-sorted for ease of visual lookup. */
13103 switch (filedata
->file_header
.e_machine
)
13106 return reloc_type
== 39; /* R_RISCV_SUB32. */
13112 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13113 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13116 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13118 /* Please keep this table alpha-sorted for ease of visual lookup. */
13119 switch (filedata
->file_header
.e_machine
)
13122 return reloc_type
== 36; /* R_RISCV_ADD64. */
13128 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13129 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13132 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13134 /* Please keep this table alpha-sorted for ease of visual lookup. */
13135 switch (filedata
->file_header
.e_machine
)
13138 return reloc_type
== 40; /* R_RISCV_SUB64. */
13144 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13145 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13148 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13150 /* Please keep this table alpha-sorted for ease of visual lookup. */
13151 switch (filedata
->file_header
.e_machine
)
13154 return reloc_type
== 34; /* R_RISCV_ADD16. */
13160 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13161 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13164 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13166 /* Please keep this table alpha-sorted for ease of visual lookup. */
13167 switch (filedata
->file_header
.e_machine
)
13170 return reloc_type
== 38; /* R_RISCV_SUB16. */
13176 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13177 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13180 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13182 /* Please keep this table alpha-sorted for ease of visual lookup. */
13183 switch (filedata
->file_header
.e_machine
)
13186 return reloc_type
== 33; /* R_RISCV_ADD8. */
13192 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13193 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13196 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13198 /* Please keep this table alpha-sorted for ease of visual lookup. */
13199 switch (filedata
->file_header
.e_machine
)
13202 return reloc_type
== 37; /* R_RISCV_SUB8. */
13208 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13209 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13212 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13214 switch (filedata
->file_header
.e_machine
)
13217 return reloc_type
== 52; /* R_RISCV_SUB6. */
13223 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13224 relocation entries (possibly formerly used for SHT_GROUP sections). */
13227 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13229 switch (filedata
->file_header
.e_machine
)
13231 case EM_386
: /* R_386_NONE. */
13232 case EM_68K
: /* R_68K_NONE. */
13233 case EM_ADAPTEVA_EPIPHANY
:
13234 case EM_ALPHA
: /* R_ALPHA_NONE. */
13235 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13236 case EM_ARC
: /* R_ARC_NONE. */
13237 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13238 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13239 case EM_ARM
: /* R_ARM_NONE. */
13240 case EM_C166
: /* R_XC16X_NONE. */
13241 case EM_CRIS
: /* R_CRIS_NONE. */
13242 case EM_FT32
: /* R_FT32_NONE. */
13243 case EM_IA_64
: /* R_IA64_NONE. */
13244 case EM_K1OM
: /* R_X86_64_NONE. */
13245 case EM_L1OM
: /* R_X86_64_NONE. */
13246 case EM_M32R
: /* R_M32R_NONE. */
13247 case EM_MIPS
: /* R_MIPS_NONE. */
13248 case EM_MN10300
: /* R_MN10300_NONE. */
13249 case EM_MOXIE
: /* R_MOXIE_NONE. */
13250 case EM_NIOS32
: /* R_NIOS_NONE. */
13251 case EM_OR1K
: /* R_OR1K_NONE. */
13252 case EM_PARISC
: /* R_PARISC_NONE. */
13253 case EM_PPC64
: /* R_PPC64_NONE. */
13254 case EM_PPC
: /* R_PPC_NONE. */
13255 case EM_RISCV
: /* R_RISCV_NONE. */
13256 case EM_S390
: /* R_390_NONE. */
13258 case EM_SH
: /* R_SH_NONE. */
13259 case EM_SPARC32PLUS
:
13260 case EM_SPARC
: /* R_SPARC_NONE. */
13262 case EM_TILEGX
: /* R_TILEGX_NONE. */
13263 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13264 case EM_TI_C6000
:/* R_C6000_NONE. */
13265 case EM_X86_64
: /* R_X86_64_NONE. */
13267 case EM_Z80
: /* R_Z80_NONE. */
13268 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13269 return reloc_type
== 0;
13272 return reloc_type
== 0 || reloc_type
== 256;
13275 return (reloc_type
== 0 /* R_AVR_NONE. */
13276 || reloc_type
== 30 /* R_AVR_DIFF8. */
13277 || reloc_type
== 31 /* R_AVR_DIFF16. */
13278 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13280 return reloc_type
== 3; /* R_METAG_NONE. */
13282 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13283 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13284 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13285 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13286 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13288 return (reloc_type
== 0 /* R_PRU_NONE. */
13289 || reloc_type
== 65 /* R_PRU_DIFF8. */
13290 || reloc_type
== 66 /* R_PRU_DIFF16. */
13291 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13292 case EM_XTENSA_OLD
:
13294 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13295 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13296 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13297 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13302 /* Returns TRUE if there is a relocation against
13303 section NAME at OFFSET bytes. */
13306 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13308 Elf_Internal_Rela
* relocs
;
13309 Elf_Internal_Rela
* rp
;
13311 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13314 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13316 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13317 if (rp
->r_offset
== offset
)
13323 /* Apply relocations to a section.
13324 Returns TRUE upon success, FALSE otherwise.
13325 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13326 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13327 will be set to the number of relocs loaded.
13329 Note: So far support has been added only for those relocations
13330 which can be found in debug sections. FIXME: Add support for
13331 more relocations ? */
13334 apply_relocations (Filedata
* filedata
,
13335 const Elf_Internal_Shdr
* section
,
13336 unsigned char * start
,
13337 bfd_size_type size
,
13338 void ** relocs_return
,
13339 unsigned long * num_relocs_return
)
13341 Elf_Internal_Shdr
* relsec
;
13342 unsigned char * end
= start
+ size
;
13344 if (relocs_return
!= NULL
)
13346 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13347 * num_relocs_return
= 0;
13350 if (filedata
->file_header
.e_type
!= ET_REL
)
13351 /* No relocs to apply. */
13354 /* Find the reloc section associated with the section. */
13355 for (relsec
= filedata
->section_headers
;
13356 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13359 bfd_boolean is_rela
;
13360 unsigned long num_relocs
;
13361 Elf_Internal_Rela
* relocs
;
13362 Elf_Internal_Rela
* rp
;
13363 Elf_Internal_Shdr
* symsec
;
13364 Elf_Internal_Sym
* symtab
;
13365 unsigned long num_syms
;
13366 Elf_Internal_Sym
* sym
;
13368 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13369 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13370 || filedata
->section_headers
+ relsec
->sh_info
!= section
13371 || relsec
->sh_size
== 0
13372 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13375 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13376 if (symsec
->sh_type
!= SHT_SYMTAB
13377 && symsec
->sh_type
!= SHT_DYNSYM
)
13380 is_rela
= relsec
->sh_type
== SHT_RELA
;
13384 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13385 relsec
->sh_size
, & relocs
, & num_relocs
))
13390 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13391 relsec
->sh_size
, & relocs
, & num_relocs
))
13395 /* SH uses RELA but uses in place value instead of the addend field. */
13396 if (filedata
->file_header
.e_machine
== EM_SH
)
13399 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13401 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13404 unsigned int reloc_type
;
13405 unsigned int reloc_size
;
13406 bfd_boolean reloc_inplace
= FALSE
;
13407 bfd_boolean reloc_subtract
= FALSE
;
13408 unsigned char * rloc
;
13409 unsigned long sym_index
;
13411 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13413 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13415 else if (is_none_reloc (filedata
, reloc_type
))
13417 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13418 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13420 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13421 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13423 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13425 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13427 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13428 || is_6bit_abs_reloc (filedata
, reloc_type
))
13430 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13432 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13435 reloc_inplace
= TRUE
;
13437 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13439 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13442 reloc_inplace
= TRUE
;
13444 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13446 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13449 reloc_inplace
= TRUE
;
13451 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13453 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13456 reloc_inplace
= TRUE
;
13458 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13462 reloc_inplace
= TRUE
;
13466 static unsigned int prev_reloc
= 0;
13468 if (reloc_type
!= prev_reloc
)
13469 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13470 reloc_type
, printable_section_name (filedata
, section
));
13471 prev_reloc
= reloc_type
;
13475 rloc
= start
+ rp
->r_offset
;
13476 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13478 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13479 (unsigned long) rp
->r_offset
,
13480 printable_section_name (filedata
, section
));
13484 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13485 if (sym_index
>= num_syms
)
13487 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13488 sym_index
, printable_section_name (filedata
, section
));
13491 sym
= symtab
+ sym_index
;
13493 /* If the reloc has a symbol associated with it,
13494 make sure that it is of an appropriate type.
13496 Relocations against symbols without type can happen.
13497 Gcc -feliminate-dwarf2-dups may generate symbols
13498 without type for debug info.
13500 Icc generates relocations against function symbols
13501 instead of local labels.
13503 Relocations against object symbols can happen, eg when
13504 referencing a global array. For an example of this see
13505 the _clz.o binary in libgcc.a. */
13507 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13508 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13510 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13511 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13512 printable_section_name (filedata
, relsec
),
13513 (long int)(rp
- relocs
));
13519 addend
+= rp
->r_addend
;
13520 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13521 partial_inplace. */
13523 || (filedata
->file_header
.e_machine
== EM_XTENSA
13524 && reloc_type
== 1)
13525 || ((filedata
->file_header
.e_machine
== EM_PJ
13526 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13527 && reloc_type
== 1)
13528 || ((filedata
->file_header
.e_machine
== EM_D30V
13529 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13530 && reloc_type
== 12)
13533 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13534 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13536 addend
+= byte_get (rloc
, reloc_size
);
13539 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13540 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13542 /* On HPPA, all pc-relative relocations are biased by 8. */
13543 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13545 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13548 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13549 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13551 if (reloc_subtract
)
13552 addend
-= sym
->st_value
;
13554 addend
+= sym
->st_value
;
13555 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13556 byte_put (rloc
, addend
, reloc_size
);
13558 else if (reloc_subtract
)
13559 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13561 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13565 /* Let the target specific reloc processing code know that
13566 we have finished with these relocs. */
13567 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13571 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13572 * num_relocs_return
= num_relocs
;
13583 #ifdef SUPPORT_DISASSEMBLY
13585 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13587 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13589 /* FIXME: XXX -- to be done --- XXX */
13595 /* Reads in the contents of SECTION from FILE, returning a pointer
13596 to a malloc'ed buffer or NULL if something went wrong. */
13599 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13601 bfd_size_type num_bytes
= section
->sh_size
;
13603 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13605 printf (_("Section '%s' has no data to dump.\n"),
13606 printable_section_name (filedata
, section
));
13610 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13611 _("section contents"));
13614 /* Uncompresses a section that was compressed using zlib, in place. */
13617 uncompress_section_contents (unsigned char ** buffer
,
13618 dwarf_size_type uncompressed_size
,
13619 dwarf_size_type
* size
)
13621 dwarf_size_type compressed_size
= *size
;
13622 unsigned char * compressed_buffer
= *buffer
;
13623 unsigned char * uncompressed_buffer
;
13627 /* It is possible the section consists of several compressed
13628 buffers concatenated together, so we uncompress in a loop. */
13629 /* PR 18313: The state field in the z_stream structure is supposed
13630 to be invisible to the user (ie us), but some compilers will
13631 still complain about it being used without initialisation. So
13632 we first zero the entire z_stream structure and then set the fields
13634 memset (& strm
, 0, sizeof strm
);
13635 strm
.avail_in
= compressed_size
;
13636 strm
.next_in
= (Bytef
*) compressed_buffer
;
13637 strm
.avail_out
= uncompressed_size
;
13638 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13640 rc
= inflateInit (& strm
);
13641 while (strm
.avail_in
> 0)
13645 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13646 + (uncompressed_size
- strm
.avail_out
));
13647 rc
= inflate (&strm
, Z_FINISH
);
13648 if (rc
!= Z_STREAM_END
)
13650 rc
= inflateReset (& strm
);
13652 rc
= inflateEnd (& strm
);
13654 || strm
.avail_out
!= 0)
13657 *buffer
= uncompressed_buffer
;
13658 *size
= uncompressed_size
;
13662 free (uncompressed_buffer
);
13663 /* Indicate decompression failure. */
13669 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13671 Elf_Internal_Shdr
* relsec
;
13672 bfd_size_type num_bytes
;
13673 unsigned char * data
;
13674 unsigned char * end
;
13675 unsigned char * real_start
;
13676 unsigned char * start
;
13677 bfd_boolean some_strings_shown
;
13679 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13681 /* PR 21820: Do not fail if the section was empty. */
13682 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13684 num_bytes
= section
->sh_size
;
13686 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13688 if (decompress_dumps
)
13690 dwarf_size_type new_size
= num_bytes
;
13691 dwarf_size_type uncompressed_size
= 0;
13693 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13695 Elf_Internal_Chdr chdr
;
13696 unsigned int compression_header_size
13697 = get_compression_header (& chdr
, (unsigned char *) start
,
13699 if (compression_header_size
== 0)
13700 /* An error message will have already been generated
13701 by get_compression_header. */
13704 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13706 warn (_("section '%s' has unsupported compress type: %d\n"),
13707 printable_section_name (filedata
, section
), chdr
.ch_type
);
13710 uncompressed_size
= chdr
.ch_size
;
13711 start
+= compression_header_size
;
13712 new_size
-= compression_header_size
;
13714 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13716 /* Read the zlib header. In this case, it should be "ZLIB"
13717 followed by the uncompressed section size, 8 bytes in
13718 big-endian order. */
13719 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13720 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13721 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13722 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13723 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13724 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13725 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13726 uncompressed_size
+= start
[11];
13731 if (uncompressed_size
)
13733 if (uncompress_section_contents (& start
,
13734 uncompressed_size
, & new_size
))
13735 num_bytes
= new_size
;
13738 error (_("Unable to decompress section %s\n"),
13739 printable_section_name (filedata
, section
));
13744 start
= real_start
;
13747 /* If the section being dumped has relocations against it the user might
13748 be expecting these relocations to have been applied. Check for this
13749 case and issue a warning message in order to avoid confusion.
13750 FIXME: Maybe we ought to have an option that dumps a section with
13751 relocs applied ? */
13752 for (relsec
= filedata
->section_headers
;
13753 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13756 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13757 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13758 || filedata
->section_headers
+ relsec
->sh_info
!= section
13759 || relsec
->sh_size
== 0
13760 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13763 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13768 end
= start
+ num_bytes
;
13769 some_strings_shown
= FALSE
;
13771 #ifdef HAVE_MBSTATE_T
13773 /* Initialise the multibyte conversion state. */
13774 memset (& state
, 0, sizeof (state
));
13777 bfd_boolean continuing
= FALSE
;
13781 while (!ISPRINT (* data
))
13782 if (++ data
>= end
)
13787 size_t maxlen
= end
- data
;
13792 continuing
= FALSE
;
13797 /* PR 11128: Use two separate invocations in order to work
13798 around bugs in the Solaris 8 implementation of printf. */
13799 printf (" [%6tx] ", data
- start
);
13801 printf (" [%6Ix] ", (size_t) (data
- start
));
13816 /* PR 25543: Treat new-lines as string-ending characters. */
13825 /* Do not print control characters directly as they can affect terminal
13826 settings. Such characters usually appear in the names generated
13827 by the assembler for local labels. */
13830 printf ("^%c", c
+ 0x40);
13832 else if (ISPRINT (c
))
13839 #ifdef HAVE_MBSTATE_T
13842 /* Let printf do the hard work of displaying multibyte characters. */
13843 printf ("%.1s", data
- 1);
13844 #ifdef HAVE_MBSTATE_T
13845 /* Try to find out how many bytes made up the character that was
13846 just printed. Advance the symbol pointer past the bytes that
13848 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13852 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13862 printf (_("<corrupt>\n"));
13865 some_strings_shown
= TRUE
;
13869 if (! some_strings_shown
)
13870 printf (_(" No strings found in this section."));
13883 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13884 Filedata
* filedata
,
13885 bfd_boolean relocate
)
13887 Elf_Internal_Shdr
* relsec
;
13888 bfd_size_type bytes
;
13889 bfd_size_type section_size
;
13891 unsigned char * data
;
13892 unsigned char * real_start
;
13893 unsigned char * start
;
13895 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13897 /* PR 21820: Do not fail if the section was empty. */
13898 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13900 section_size
= section
->sh_size
;
13902 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13904 if (decompress_dumps
)
13906 dwarf_size_type new_size
= section_size
;
13907 dwarf_size_type uncompressed_size
= 0;
13909 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13911 Elf_Internal_Chdr chdr
;
13912 unsigned int compression_header_size
13913 = get_compression_header (& chdr
, start
, section_size
);
13915 if (compression_header_size
== 0)
13916 /* An error message will have already been generated
13917 by get_compression_header. */
13920 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13922 warn (_("section '%s' has unsupported compress type: %d\n"),
13923 printable_section_name (filedata
, section
), chdr
.ch_type
);
13926 uncompressed_size
= chdr
.ch_size
;
13927 start
+= compression_header_size
;
13928 new_size
-= compression_header_size
;
13930 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13932 /* Read the zlib header. In this case, it should be "ZLIB"
13933 followed by the uncompressed section size, 8 bytes in
13934 big-endian order. */
13935 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13936 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13937 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13938 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13939 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13940 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13941 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13942 uncompressed_size
+= start
[11];
13947 if (uncompressed_size
)
13949 if (uncompress_section_contents (& start
, uncompressed_size
,
13952 section_size
= new_size
;
13956 error (_("Unable to decompress section %s\n"),
13957 printable_section_name (filedata
, section
));
13958 /* FIXME: Print the section anyway ? */
13963 start
= real_start
;
13968 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13973 /* If the section being dumped has relocations against it the user might
13974 be expecting these relocations to have been applied. Check for this
13975 case and issue a warning message in order to avoid confusion.
13976 FIXME: Maybe we ought to have an option that dumps a section with
13977 relocs applied ? */
13978 for (relsec
= filedata
->section_headers
;
13979 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13982 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13983 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13984 || filedata
->section_headers
+ relsec
->sh_info
!= section
13985 || relsec
->sh_size
== 0
13986 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13989 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13994 addr
= section
->sh_addr
;
13995 bytes
= section_size
;
14004 lbytes
= (bytes
> 16 ? 16 : bytes
);
14006 printf (" 0x%8.8lx ", (unsigned long) addr
);
14008 for (j
= 0; j
< 16; j
++)
14011 printf ("%2.2x", data
[j
]);
14019 for (j
= 0; j
< lbytes
; j
++)
14022 if (k
>= ' ' && k
< 0x7f)
14045 static ctf_sect_t
*
14046 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14048 buf
->cts_name
= SECTION_NAME (shdr
);
14049 buf
->cts_size
= shdr
->sh_size
;
14050 buf
->cts_entsize
= shdr
->sh_entsize
;
14055 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14056 it is passed, or a pointer to newly-allocated storage, in which case
14057 dump_ctf() will free it when it no longer needs it. */
14059 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14060 char *s
, void *arg
)
14062 const char *blanks
= arg
;
14065 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14071 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14073 Elf_Internal_Shdr
* parent_sec
= NULL
;
14074 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14075 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14076 void * data
= NULL
;
14077 void * symdata
= NULL
;
14078 void * strdata
= NULL
;
14079 void * parentdata
= NULL
;
14080 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14081 ctf_sect_t
* symsectp
= NULL
;
14082 ctf_sect_t
* strsectp
= NULL
;
14083 ctf_file_t
* ctf
= NULL
;
14084 ctf_file_t
* parent
= NULL
;
14086 const char *things
[] = {"Header", "Labels", "Data objects",
14087 "Function objects", "Variables", "Types", "Strings",
14089 const char **thing
;
14091 bfd_boolean ret
= FALSE
;
14094 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14095 data
= get_section_contents (section
, filedata
);
14096 ctfsect
.cts_data
= data
;
14098 if (!dump_ctf_symtab_name
)
14099 dump_ctf_symtab_name
= strdup (".symtab");
14101 if (!dump_ctf_strtab_name
)
14102 dump_ctf_strtab_name
= strdup (".strtab");
14104 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14106 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14108 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14111 if ((symdata
= (void *) get_data (NULL
, filedata
,
14112 symtab_sec
->sh_offset
, 1,
14113 symtab_sec
->sh_size
,
14114 _("symbols"))) == NULL
)
14116 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14117 symsect
.cts_data
= symdata
;
14119 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14121 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14123 error (_("No string table section named %s\n"),
14124 dump_ctf_strtab_name
);
14127 if ((strdata
= (void *) get_data (NULL
, filedata
,
14128 strtab_sec
->sh_offset
, 1,
14129 strtab_sec
->sh_size
,
14130 _("strings"))) == NULL
)
14132 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14133 strsect
.cts_data
= strdata
;
14135 if (dump_ctf_parent_name
)
14137 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14139 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14142 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14143 parent_sec
->sh_offset
, 1,
14144 parent_sec
->sh_size
,
14145 _("CTF parent"))) == NULL
)
14147 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14148 parentsect
.cts_data
= parentdata
;
14151 /* Load the CTF file and dump it. */
14153 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14155 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14161 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14163 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14167 ctf_import (ctf
, parent
);
14172 printf (_("\nDump of CTF section '%s':\n"),
14173 printable_section_name (filedata
, section
));
14175 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14177 ctf_dump_state_t
*s
= NULL
;
14180 printf ("\n %s:\n", *thing
);
14181 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14182 (void *) " ")) != NULL
)
14184 printf ("%s\n", item
);
14188 if (ctf_errno (ctf
))
14190 error (_("Iteration failed: %s, %s\n"), *thing
,
14191 ctf_errmsg (ctf_errno (ctf
)));
14197 ctf_file_close (ctf
);
14198 ctf_file_close (parent
);
14207 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14208 const Elf_Internal_Shdr
* sec
,
14211 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14213 Filedata
* filedata
= (Filedata
*) data
;
14215 if (section
->start
!= NULL
)
14217 /* If it is already loaded, do nothing. */
14218 if (streq (section
->filename
, filedata
->file_name
))
14220 free (section
->start
);
14223 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14224 section
->address
= sec
->sh_addr
;
14225 section
->user_data
= NULL
;
14226 section
->filename
= filedata
->file_name
;
14227 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14229 sec
->sh_size
, buf
);
14230 if (section
->start
== NULL
)
14234 unsigned char *start
= section
->start
;
14235 dwarf_size_type size
= sec
->sh_size
;
14236 dwarf_size_type uncompressed_size
= 0;
14238 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14240 Elf_Internal_Chdr chdr
;
14241 unsigned int compression_header_size
;
14243 if (size
< (is_32bit_elf
14244 ? sizeof (Elf32_External_Chdr
)
14245 : sizeof (Elf64_External_Chdr
)))
14247 warn (_("compressed section %s is too small to contain a compression header\n"),
14252 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14253 if (compression_header_size
== 0)
14254 /* An error message will have already been generated
14255 by get_compression_header. */
14258 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14260 warn (_("section '%s' has unsupported compress type: %d\n"),
14261 section
->name
, chdr
.ch_type
);
14264 uncompressed_size
= chdr
.ch_size
;
14265 start
+= compression_header_size
;
14266 size
-= compression_header_size
;
14268 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14270 /* Read the zlib header. In this case, it should be "ZLIB"
14271 followed by the uncompressed section size, 8 bytes in
14272 big-endian order. */
14273 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14274 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14275 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14276 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14277 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14278 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14279 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14280 uncompressed_size
+= start
[11];
14285 if (uncompressed_size
)
14287 if (uncompress_section_contents (&start
, uncompressed_size
,
14290 /* Free the compressed buffer, update the section buffer
14291 and the section size if uncompress is successful. */
14292 free (section
->start
);
14293 section
->start
= start
;
14297 error (_("Unable to decompress section %s\n"),
14298 printable_section_name (filedata
, sec
));
14303 section
->size
= size
;
14306 if (section
->start
== NULL
)
14309 if (debug_displays
[debug
].relocate
)
14311 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14312 & section
->reloc_info
, & section
->num_relocs
))
14317 section
->reloc_info
= NULL
;
14318 section
->num_relocs
= 0;
14324 #if HAVE_LIBDEBUGINFOD
14325 /* Return a hex string representation of the build-id. */
14327 get_build_id (void * data
)
14329 Filedata
* filedata
= (Filedata
*)data
;
14330 Elf_Internal_Shdr
* shdr
;
14333 /* Iterate through notes to find note.gnu.build-id.
14334 FIXME: Only the first note in any note section is examined. */
14335 for (i
= 0, shdr
= filedata
->section_headers
;
14336 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14339 if (shdr
->sh_type
!= SHT_NOTE
)
14344 size_t data_remaining
;
14346 Elf_External_Note
* enote
;
14347 Elf_Internal_Note inote
;
14349 bfd_vma offset
= shdr
->sh_offset
;
14350 bfd_vma align
= shdr
->sh_addralign
;
14351 bfd_vma length
= shdr
->sh_size
;
14353 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14359 else if (align
!= 4 && align
!= 8)
14365 end
= (char *) enote
+ length
;
14366 data_remaining
= end
- (char *) enote
;
14368 if (!is_ia64_vms (filedata
))
14370 min_notesz
= offsetof (Elf_External_Note
, name
);
14371 if (data_remaining
< min_notesz
)
14374 malformed note encountered in section %s whilst scanning for build-id note\n"),
14375 printable_section_name (filedata
, shdr
));
14379 data_remaining
-= min_notesz
;
14381 inote
.type
= BYTE_GET (enote
->type
);
14382 inote
.namesz
= BYTE_GET (enote
->namesz
);
14383 inote
.namedata
= enote
->name
;
14384 inote
.descsz
= BYTE_GET (enote
->descsz
);
14385 inote
.descdata
= ((char *) enote
14386 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14387 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14388 next
= ((char *) enote
14389 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14393 Elf64_External_VMS_Note
*vms_enote
;
14395 /* PR binutils/15191
14396 Make sure that there is enough data to read. */
14397 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14398 if (data_remaining
< min_notesz
)
14401 malformed note encountered in section %s whilst scanning for build-id note\n"),
14402 printable_section_name (filedata
, shdr
));
14406 data_remaining
-= min_notesz
;
14408 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14409 inote
.type
= BYTE_GET (vms_enote
->type
);
14410 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14411 inote
.namedata
= vms_enote
->name
;
14412 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14413 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14414 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14415 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14418 /* Skip malformed notes. */
14419 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14420 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14421 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14422 || ((size_t) (next
- inote
.descdata
)
14423 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14426 malformed note encountered in section %s whilst scanning for build-id note\n"),
14427 printable_section_name (filedata
, shdr
));
14432 /* Check if this is the build-id note. If so then convert the build-id
14433 bytes to a hex string. */
14434 if (inote
.namesz
> 0
14435 && const_strneq (inote
.namedata
, "GNU")
14436 && inote
.type
== NT_GNU_BUILD_ID
)
14441 build_id
= malloc (inote
.descsz
* 2 + 1);
14442 if (build_id
== NULL
)
14448 for (j
= 0; j
< inote
.descsz
; ++j
)
14449 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14450 build_id
[inote
.descsz
* 2] = '\0';
14453 return (unsigned char *) build_id
;
14460 #endif /* HAVE_LIBDEBUGINFOD */
14462 /* If this is not NULL, load_debug_section will only look for sections
14463 within the list of sections given here. */
14464 static unsigned int * section_subset
= NULL
;
14467 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14469 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14470 Elf_Internal_Shdr
* sec
;
14471 Filedata
* filedata
= (Filedata
*) data
;
14473 /* Without section headers we cannot find any sections. */
14474 if (filedata
->section_headers
== NULL
)
14477 if (filedata
->string_table
== NULL
14478 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14479 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14481 Elf_Internal_Shdr
* strs
;
14483 /* Read in the string table, so that we have section names to scan. */
14484 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14486 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14488 filedata
->string_table
14489 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14490 1, strs
->sh_size
, _("string table"));
14492 filedata
->string_table_length
14493 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14497 /* Locate the debug section. */
14498 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14500 section
->name
= section
->uncompressed_name
;
14503 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14505 section
->name
= section
->compressed_name
;
14510 /* If we're loading from a subset of sections, and we've loaded
14511 a section matching this name before, it's likely that it's a
14513 if (section_subset
!= NULL
)
14514 free_debug_section (debug
);
14516 return load_specific_debug_section (debug
, sec
, data
);
14520 free_debug_section (enum dwarf_section_display_enum debug
)
14522 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14524 if (section
->start
== NULL
)
14527 free ((char *) section
->start
);
14528 section
->start
= NULL
;
14529 section
->address
= 0;
14532 if (section
->reloc_info
!= NULL
)
14534 free (section
->reloc_info
);
14535 section
->reloc_info
= NULL
;
14536 section
->num_relocs
= 0;
14541 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14543 char * name
= SECTION_NAME (section
);
14544 const char * print_name
= printable_section_name (filedata
, section
);
14545 bfd_size_type length
;
14546 bfd_boolean result
= TRUE
;
14549 length
= section
->sh_size
;
14552 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14555 if (section
->sh_type
== SHT_NOBITS
)
14557 /* There is no point in dumping the contents of a debugging section
14558 which has the NOBITS type - the bits in the file will be random.
14559 This can happen when a file containing a .eh_frame section is
14560 stripped with the --only-keep-debug command line option. */
14561 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14566 if (const_strneq (name
, ".gnu.linkonce.wi."))
14567 name
= ".debug_info";
14569 /* See if we know how to display the contents of this section. */
14570 for (i
= 0; i
< max
; i
++)
14572 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14573 struct dwarf_section_display
* display
= debug_displays
+ i
;
14574 struct dwarf_section
* sec
= & display
->section
;
14576 if (streq (sec
->uncompressed_name
, name
)
14577 || (id
== line
&& const_strneq (name
, ".debug_line."))
14578 || streq (sec
->compressed_name
, name
))
14580 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14583 free_debug_section (id
);
14585 if (i
== line
&& const_strneq (name
, ".debug_line."))
14587 else if (streq (sec
->uncompressed_name
, name
))
14588 sec
->name
= sec
->uncompressed_name
;
14590 sec
->name
= sec
->compressed_name
;
14592 if (load_specific_debug_section (id
, section
, filedata
))
14594 /* If this debug section is part of a CU/TU set in a .dwp file,
14595 restrict load_debug_section to the sections in that set. */
14596 section_subset
= find_cu_tu_set (filedata
, shndx
);
14598 result
&= display
->display (sec
, filedata
);
14600 section_subset
= NULL
;
14602 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14603 free_debug_section (id
);
14611 printf (_("Unrecognized debug section: %s\n"), print_name
);
14618 /* Set DUMP_SECTS for all sections where dumps were requested
14619 based on section name. */
14622 initialise_dumps_byname (Filedata
* filedata
)
14624 struct dump_list_entry
* cur
;
14626 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14629 bfd_boolean any
= FALSE
;
14631 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14632 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14634 request_dump_bynumber (filedata
, i
, cur
->type
);
14639 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14645 process_section_contents (Filedata
* filedata
)
14647 Elf_Internal_Shdr
* section
;
14649 bfd_boolean res
= TRUE
;
14654 initialise_dumps_byname (filedata
);
14656 for (i
= 0, section
= filedata
->section_headers
;
14657 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14660 dump_type dump
= filedata
->dump_sects
[i
];
14662 #ifdef SUPPORT_DISASSEMBLY
14663 if (dump
& DISASS_DUMP
)
14665 if (! disassemble_section (section
, filedata
))
14669 if (dump
& HEX_DUMP
)
14671 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14675 if (dump
& RELOC_DUMP
)
14677 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14681 if (dump
& STRING_DUMP
)
14683 if (! dump_section_as_strings (section
, filedata
))
14687 if (dump
& DEBUG_DUMP
)
14689 if (! display_debug_section (i
, section
, filedata
))
14693 if (dump
& CTF_DUMP
)
14695 if (! dump_section_as_ctf (section
, filedata
))
14700 /* Check to see if the user requested a
14701 dump of a section that does not exist. */
14702 while (i
< filedata
->num_dump_sects
)
14704 if (filedata
->dump_sects
[i
])
14706 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14716 process_mips_fpe_exception (int mask
)
14720 bfd_boolean first
= TRUE
;
14722 if (mask
& OEX_FPU_INEX
)
14723 fputs ("INEX", stdout
), first
= FALSE
;
14724 if (mask
& OEX_FPU_UFLO
)
14725 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14726 if (mask
& OEX_FPU_OFLO
)
14727 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14728 if (mask
& OEX_FPU_DIV0
)
14729 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14730 if (mask
& OEX_FPU_INVAL
)
14731 printf ("%sINVAL", first
? "" : "|");
14734 fputs ("0", stdout
);
14737 /* Display's the value of TAG at location P. If TAG is
14738 greater than 0 it is assumed to be an unknown tag, and
14739 a message is printed to this effect. Otherwise it is
14740 assumed that a message has already been printed.
14742 If the bottom bit of TAG is set it assumed to have a
14743 string value, otherwise it is assumed to have an integer
14746 Returns an updated P pointing to the first unread byte
14747 beyond the end of TAG's value.
14749 Reads at or beyond END will not be made. */
14751 static unsigned char *
14752 display_tag_value (signed int tag
,
14754 const unsigned char * const end
)
14759 printf (" Tag_unknown_%d: ", tag
);
14763 warn (_("<corrupt tag>\n"));
14767 /* PR 17531 file: 027-19978-0.004. */
14768 size_t maxlen
= (end
- p
) - 1;
14773 print_symbol ((int) maxlen
, (const char *) p
);
14774 p
+= strnlen ((char *) p
, maxlen
) + 1;
14778 printf (_("<corrupt string tag>"));
14779 p
= (unsigned char *) end
;
14785 READ_ULEB (val
, p
, end
);
14786 printf ("%ld (0x%lx)\n", val
, val
);
14793 /* ARC ABI attributes section. */
14795 static unsigned char *
14796 display_arc_attribute (unsigned char * p
,
14797 const unsigned char * const end
)
14802 READ_ULEB (tag
, p
, end
);
14806 case Tag_ARC_PCS_config
:
14807 READ_ULEB (val
, p
, end
);
14808 printf (" Tag_ARC_PCS_config: ");
14812 printf (_("Absent/Non standard\n"));
14815 printf (_("Bare metal/mwdt\n"));
14818 printf (_("Bare metal/newlib\n"));
14821 printf (_("Linux/uclibc\n"));
14824 printf (_("Linux/glibc\n"));
14827 printf (_("Unknown\n"));
14832 case Tag_ARC_CPU_base
:
14833 READ_ULEB (val
, p
, end
);
14834 printf (" Tag_ARC_CPU_base: ");
14839 printf (_("Absent\n"));
14841 case TAG_CPU_ARC6xx
:
14842 printf ("ARC6xx\n");
14844 case TAG_CPU_ARC7xx
:
14845 printf ("ARC7xx\n");
14847 case TAG_CPU_ARCEM
:
14848 printf ("ARCEM\n");
14850 case TAG_CPU_ARCHS
:
14851 printf ("ARCHS\n");
14856 case Tag_ARC_CPU_variation
:
14857 READ_ULEB (val
, p
, end
);
14858 printf (" Tag_ARC_CPU_variation: ");
14862 if (val
> 0 && val
< 16)
14863 printf ("Core%d\n", val
);
14865 printf ("Unknown\n");
14869 printf (_("Absent\n"));
14874 case Tag_ARC_CPU_name
:
14875 printf (" Tag_ARC_CPU_name: ");
14876 p
= display_tag_value (-1, p
, end
);
14879 case Tag_ARC_ABI_rf16
:
14880 READ_ULEB (val
, p
, end
);
14881 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14884 case Tag_ARC_ABI_osver
:
14885 READ_ULEB (val
, p
, end
);
14886 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14889 case Tag_ARC_ABI_pic
:
14890 case Tag_ARC_ABI_sda
:
14891 READ_ULEB (val
, p
, end
);
14892 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14893 : " Tag_ARC_ABI_pic: ");
14897 printf (_("Absent\n"));
14906 printf (_("Unknown\n"));
14911 case Tag_ARC_ABI_tls
:
14912 READ_ULEB (val
, p
, end
);
14913 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14916 case Tag_ARC_ABI_enumsize
:
14917 READ_ULEB (val
, p
, end
);
14918 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14922 case Tag_ARC_ABI_exceptions
:
14923 READ_ULEB (val
, p
, end
);
14924 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14928 case Tag_ARC_ABI_double_size
:
14929 READ_ULEB (val
, p
, end
);
14930 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14933 case Tag_ARC_ISA_config
:
14934 printf (" Tag_ARC_ISA_config: ");
14935 p
= display_tag_value (-1, p
, end
);
14938 case Tag_ARC_ISA_apex
:
14939 printf (" Tag_ARC_ISA_apex: ");
14940 p
= display_tag_value (-1, p
, end
);
14943 case Tag_ARC_ISA_mpy_option
:
14944 READ_ULEB (val
, p
, end
);
14945 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14948 case Tag_ARC_ATR_version
:
14949 READ_ULEB (val
, p
, end
);
14950 printf (" Tag_ARC_ATR_version: %d\n", val
);
14954 return display_tag_value (tag
& 1, p
, end
);
14960 /* ARM EABI attributes section. */
14965 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14967 const char ** table
;
14968 } arm_attr_public_tag
;
14970 static const char * arm_attr_tag_CPU_arch
[] =
14971 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14972 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14973 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14974 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14975 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14976 {"No", "Thumb-1", "Thumb-2", "Yes"};
14977 static const char * arm_attr_tag_FP_arch
[] =
14978 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14979 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14980 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14981 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14982 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14983 "NEON for ARMv8.1"};
14984 static const char * arm_attr_tag_PCS_config
[] =
14985 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14986 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14987 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14988 {"V6", "SB", "TLS", "Unused"};
14989 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14990 {"Absolute", "PC-relative", "SB-relative", "None"};
14991 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14992 {"Absolute", "PC-relative", "None"};
14993 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14994 {"None", "direct", "GOT-indirect"};
14995 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14996 {"None", "??? 1", "2", "??? 3", "4"};
14997 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14998 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14999 {"Unused", "Needed", "Sign only"};
15000 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15001 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15002 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15003 {"Unused", "Finite", "RTABI", "IEEE 754"};
15004 static const char * arm_attr_tag_ABI_enum_size
[] =
15005 {"Unused", "small", "int", "forced to int"};
15006 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15007 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15008 static const char * arm_attr_tag_ABI_VFP_args
[] =
15009 {"AAPCS", "VFP registers", "custom", "compatible"};
15010 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15011 {"AAPCS", "WMMX registers", "custom"};
15012 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15013 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15014 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15015 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15016 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15017 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15018 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15019 static const char * arm_attr_tag_FP_HP_extension
[] =
15020 {"Not Allowed", "Allowed"};
15021 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15022 {"None", "IEEE 754", "Alternative Format"};
15023 static const char * arm_attr_tag_DSP_extension
[] =
15024 {"Follow architecture", "Allowed"};
15025 static const char * arm_attr_tag_MPextension_use
[] =
15026 {"Not Allowed", "Allowed"};
15027 static const char * arm_attr_tag_DIV_use
[] =
15028 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15029 "Allowed in v7-A with integer division extension"};
15030 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15031 static const char * arm_attr_tag_Virtualization_use
[] =
15032 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15033 "TrustZone and Virtualization Extensions"};
15034 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15035 {"Not Allowed", "Allowed"};
15037 static const char * arm_attr_tag_MVE_arch
[] =
15038 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15040 #define LOOKUP(id, name) \
15041 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15042 static arm_attr_public_tag arm_attr_public_tags
[] =
15044 {4, "CPU_raw_name", 1, NULL
},
15045 {5, "CPU_name", 1, NULL
},
15046 LOOKUP(6, CPU_arch
),
15047 {7, "CPU_arch_profile", 0, NULL
},
15048 LOOKUP(8, ARM_ISA_use
),
15049 LOOKUP(9, THUMB_ISA_use
),
15050 LOOKUP(10, FP_arch
),
15051 LOOKUP(11, WMMX_arch
),
15052 LOOKUP(12, Advanced_SIMD_arch
),
15053 LOOKUP(13, PCS_config
),
15054 LOOKUP(14, ABI_PCS_R9_use
),
15055 LOOKUP(15, ABI_PCS_RW_data
),
15056 LOOKUP(16, ABI_PCS_RO_data
),
15057 LOOKUP(17, ABI_PCS_GOT_use
),
15058 LOOKUP(18, ABI_PCS_wchar_t
),
15059 LOOKUP(19, ABI_FP_rounding
),
15060 LOOKUP(20, ABI_FP_denormal
),
15061 LOOKUP(21, ABI_FP_exceptions
),
15062 LOOKUP(22, ABI_FP_user_exceptions
),
15063 LOOKUP(23, ABI_FP_number_model
),
15064 {24, "ABI_align_needed", 0, NULL
},
15065 {25, "ABI_align_preserved", 0, NULL
},
15066 LOOKUP(26, ABI_enum_size
),
15067 LOOKUP(27, ABI_HardFP_use
),
15068 LOOKUP(28, ABI_VFP_args
),
15069 LOOKUP(29, ABI_WMMX_args
),
15070 LOOKUP(30, ABI_optimization_goals
),
15071 LOOKUP(31, ABI_FP_optimization_goals
),
15072 {32, "compatibility", 0, NULL
},
15073 LOOKUP(34, CPU_unaligned_access
),
15074 LOOKUP(36, FP_HP_extension
),
15075 LOOKUP(38, ABI_FP_16bit_format
),
15076 LOOKUP(42, MPextension_use
),
15077 LOOKUP(44, DIV_use
),
15078 LOOKUP(46, DSP_extension
),
15079 LOOKUP(48, MVE_arch
),
15080 {64, "nodefaults", 0, NULL
},
15081 {65, "also_compatible_with", 0, NULL
},
15082 LOOKUP(66, T2EE_use
),
15083 {67, "conformance", 1, NULL
},
15084 LOOKUP(68, Virtualization_use
),
15085 LOOKUP(70, MPextension_use_legacy
)
15089 static unsigned char *
15090 display_arm_attribute (unsigned char * p
,
15091 const unsigned char * const end
)
15095 arm_attr_public_tag
* attr
;
15099 READ_ULEB (tag
, p
, end
);
15101 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15103 if (arm_attr_public_tags
[i
].tag
== tag
)
15105 attr
= &arm_attr_public_tags
[i
];
15112 printf (" Tag_%s: ", attr
->name
);
15113 switch (attr
->type
)
15118 case 7: /* Tag_CPU_arch_profile. */
15119 READ_ULEB (val
, p
, end
);
15122 case 0: printf (_("None\n")); break;
15123 case 'A': printf (_("Application\n")); break;
15124 case 'R': printf (_("Realtime\n")); break;
15125 case 'M': printf (_("Microcontroller\n")); break;
15126 case 'S': printf (_("Application or Realtime\n")); break;
15127 default: printf ("??? (%d)\n", val
); break;
15131 case 24: /* Tag_align_needed. */
15132 READ_ULEB (val
, p
, end
);
15135 case 0: printf (_("None\n")); break;
15136 case 1: printf (_("8-byte\n")); break;
15137 case 2: printf (_("4-byte\n")); break;
15138 case 3: printf ("??? 3\n"); break;
15141 printf (_("8-byte and up to %d-byte extended\n"),
15144 printf ("??? (%d)\n", val
);
15149 case 25: /* Tag_align_preserved. */
15150 READ_ULEB (val
, p
, end
);
15153 case 0: printf (_("None\n")); break;
15154 case 1: printf (_("8-byte, except leaf SP\n")); break;
15155 case 2: printf (_("8-byte\n")); break;
15156 case 3: printf ("??? 3\n"); break;
15159 printf (_("8-byte and up to %d-byte extended\n"),
15162 printf ("??? (%d)\n", val
);
15167 case 32: /* Tag_compatibility. */
15169 READ_ULEB (val
, p
, end
);
15170 printf (_("flag = %d, vendor = "), val
);
15173 size_t maxlen
= (end
- p
) - 1;
15175 print_symbol ((int) maxlen
, (const char *) p
);
15176 p
+= strnlen ((char *) p
, maxlen
) + 1;
15180 printf (_("<corrupt>"));
15181 p
= (unsigned char *) end
;
15187 case 64: /* Tag_nodefaults. */
15188 /* PR 17531: file: 001-505008-0.01. */
15191 printf (_("True\n"));
15194 case 65: /* Tag_also_compatible_with. */
15195 READ_ULEB (val
, p
, end
);
15196 if (val
== 6 /* Tag_CPU_arch. */)
15198 READ_ULEB (val
, p
, end
);
15199 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15200 printf ("??? (%d)\n", val
);
15202 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15206 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15211 printf (_("<unknown: %d>\n"), tag
);
15217 return display_tag_value (-1, p
, end
);
15219 return display_tag_value (0, p
, end
);
15222 assert (attr
->type
& 0x80);
15223 READ_ULEB (val
, p
, end
);
15224 type
= attr
->type
& 0x7f;
15226 printf ("??? (%d)\n", val
);
15228 printf ("%s\n", attr
->table
[val
]);
15233 return display_tag_value (tag
, p
, end
);
15236 static unsigned char *
15237 display_gnu_attribute (unsigned char * p
,
15238 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15239 const unsigned char * const end
)
15244 READ_ULEB (tag
, p
, end
);
15246 /* Tag_compatibility is the only generic GNU attribute defined at
15250 READ_ULEB (val
, p
, end
);
15252 printf (_("flag = %d, vendor = "), val
);
15255 printf (_("<corrupt>\n"));
15256 warn (_("corrupt vendor attribute\n"));
15262 size_t maxlen
= (end
- p
) - 1;
15264 print_symbol ((int) maxlen
, (const char *) p
);
15265 p
+= strnlen ((char *) p
, maxlen
) + 1;
15269 printf (_("<corrupt>"));
15270 p
= (unsigned char *) end
;
15277 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15278 return display_proc_gnu_attribute (p
, tag
, end
);
15280 return display_tag_value (tag
, p
, end
);
15283 static unsigned char *
15284 display_power_gnu_attribute (unsigned char * p
,
15286 const unsigned char * const end
)
15290 if (tag
== Tag_GNU_Power_ABI_FP
)
15292 printf (" Tag_GNU_Power_ABI_FP: ");
15295 printf (_("<corrupt>\n"));
15298 READ_ULEB (val
, p
, end
);
15301 printf ("(%#x), ", val
);
15306 printf (_("unspecified hard/soft float, "));
15309 printf (_("hard float, "));
15312 printf (_("soft float, "));
15315 printf (_("single-precision hard float, "));
15322 printf (_("unspecified long double\n"));
15325 printf (_("128-bit IBM long double\n"));
15328 printf (_("64-bit long double\n"));
15331 printf (_("128-bit IEEE long double\n"));
15337 if (tag
== Tag_GNU_Power_ABI_Vector
)
15339 printf (" Tag_GNU_Power_ABI_Vector: ");
15342 printf (_("<corrupt>\n"));
15345 READ_ULEB (val
, p
, end
);
15348 printf ("(%#x), ", val
);
15353 printf (_("unspecified\n"));
15356 printf (_("generic\n"));
15359 printf ("AltiVec\n");
15368 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15370 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15373 printf (_("<corrupt>\n"));
15376 READ_ULEB (val
, p
, end
);
15379 printf ("(%#x), ", val
);
15384 printf (_("unspecified\n"));
15387 printf ("r3/r4\n");
15390 printf (_("memory\n"));
15399 return display_tag_value (tag
& 1, p
, end
);
15402 static unsigned char *
15403 display_s390_gnu_attribute (unsigned char * p
,
15405 const unsigned char * const end
)
15409 if (tag
== Tag_GNU_S390_ABI_Vector
)
15411 printf (" Tag_GNU_S390_ABI_Vector: ");
15412 READ_ULEB (val
, p
, end
);
15417 printf (_("any\n"));
15420 printf (_("software\n"));
15423 printf (_("hardware\n"));
15426 printf ("??? (%d)\n", val
);
15432 return display_tag_value (tag
& 1, p
, end
);
15436 display_sparc_hwcaps (unsigned int mask
)
15440 bfd_boolean first
= TRUE
;
15442 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15443 fputs ("mul32", stdout
), first
= FALSE
;
15444 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15445 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15446 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15447 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15448 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15449 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15450 if (mask
& ELF_SPARC_HWCAP_POPC
)
15451 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15452 if (mask
& ELF_SPARC_HWCAP_VIS
)
15453 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15454 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15455 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15456 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15457 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15458 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15459 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15460 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15461 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15462 if (mask
& ELF_SPARC_HWCAP_HPC
)
15463 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15464 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15465 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15466 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15467 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15468 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15469 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15470 if (mask
& ELF_SPARC_HWCAP_IMA
)
15471 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15472 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15473 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15476 fputc ('0', stdout
);
15477 fputc ('\n', stdout
);
15481 display_sparc_hwcaps2 (unsigned int mask
)
15485 bfd_boolean first
= TRUE
;
15487 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15488 fputs ("fjathplus", stdout
), first
= FALSE
;
15489 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15490 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15491 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15492 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15493 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15494 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15495 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15496 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15497 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15498 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15499 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15500 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15501 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15502 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15503 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15504 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15505 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15506 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15507 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15508 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15511 fputc ('0', stdout
);
15512 fputc ('\n', stdout
);
15515 static unsigned char *
15516 display_sparc_gnu_attribute (unsigned char * p
,
15518 const unsigned char * const end
)
15522 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15524 READ_ULEB (val
, p
, end
);
15525 printf (" Tag_GNU_Sparc_HWCAPS: ");
15526 display_sparc_hwcaps (val
);
15529 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15531 READ_ULEB (val
, p
, end
);
15532 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15533 display_sparc_hwcaps2 (val
);
15537 return display_tag_value (tag
, p
, end
);
15541 print_mips_fp_abi_value (unsigned int val
)
15545 case Val_GNU_MIPS_ABI_FP_ANY
:
15546 printf (_("Hard or soft float\n"));
15548 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15549 printf (_("Hard float (double precision)\n"));
15551 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15552 printf (_("Hard float (single precision)\n"));
15554 case Val_GNU_MIPS_ABI_FP_SOFT
:
15555 printf (_("Soft float\n"));
15557 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15558 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15560 case Val_GNU_MIPS_ABI_FP_XX
:
15561 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15563 case Val_GNU_MIPS_ABI_FP_64
:
15564 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15566 case Val_GNU_MIPS_ABI_FP_64A
:
15567 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15569 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15570 printf (_("NaN 2008 compatibility\n"));
15573 printf ("??? (%d)\n", val
);
15578 static unsigned char *
15579 display_mips_gnu_attribute (unsigned char * p
,
15581 const unsigned char * const end
)
15583 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15587 printf (" Tag_GNU_MIPS_ABI_FP: ");
15588 READ_ULEB (val
, p
, end
);
15589 print_mips_fp_abi_value (val
);
15593 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15597 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15598 READ_ULEB (val
, p
, end
);
15602 case Val_GNU_MIPS_ABI_MSA_ANY
:
15603 printf (_("Any MSA or not\n"));
15605 case Val_GNU_MIPS_ABI_MSA_128
:
15606 printf (_("128-bit MSA\n"));
15609 printf ("??? (%d)\n", val
);
15615 return display_tag_value (tag
& 1, p
, end
);
15618 static unsigned char *
15619 display_tic6x_attribute (unsigned char * p
,
15620 const unsigned char * const end
)
15625 READ_ULEB (tag
, p
, end
);
15630 printf (" Tag_ISA: ");
15631 READ_ULEB (val
, p
, end
);
15635 case C6XABI_Tag_ISA_none
:
15636 printf (_("None\n"));
15638 case C6XABI_Tag_ISA_C62X
:
15641 case C6XABI_Tag_ISA_C67X
:
15644 case C6XABI_Tag_ISA_C67XP
:
15645 printf ("C67x+\n");
15647 case C6XABI_Tag_ISA_C64X
:
15650 case C6XABI_Tag_ISA_C64XP
:
15651 printf ("C64x+\n");
15653 case C6XABI_Tag_ISA_C674X
:
15654 printf ("C674x\n");
15657 printf ("??? (%d)\n", val
);
15662 case Tag_ABI_wchar_t
:
15663 printf (" Tag_ABI_wchar_t: ");
15664 READ_ULEB (val
, p
, end
);
15668 printf (_("Not used\n"));
15671 printf (_("2 bytes\n"));
15674 printf (_("4 bytes\n"));
15677 printf ("??? (%d)\n", val
);
15682 case Tag_ABI_stack_align_needed
:
15683 printf (" Tag_ABI_stack_align_needed: ");
15684 READ_ULEB (val
, p
, end
);
15688 printf (_("8-byte\n"));
15691 printf (_("16-byte\n"));
15694 printf ("??? (%d)\n", val
);
15699 case Tag_ABI_stack_align_preserved
:
15700 READ_ULEB (val
, p
, end
);
15701 printf (" Tag_ABI_stack_align_preserved: ");
15705 printf (_("8-byte\n"));
15708 printf (_("16-byte\n"));
15711 printf ("??? (%d)\n", val
);
15717 READ_ULEB (val
, p
, end
);
15718 printf (" Tag_ABI_DSBT: ");
15722 printf (_("DSBT addressing not used\n"));
15725 printf (_("DSBT addressing used\n"));
15728 printf ("??? (%d)\n", val
);
15734 READ_ULEB (val
, p
, end
);
15735 printf (" Tag_ABI_PID: ");
15739 printf (_("Data addressing position-dependent\n"));
15742 printf (_("Data addressing position-independent, GOT near DP\n"));
15745 printf (_("Data addressing position-independent, GOT far from DP\n"));
15748 printf ("??? (%d)\n", val
);
15754 READ_ULEB (val
, p
, end
);
15755 printf (" Tag_ABI_PIC: ");
15759 printf (_("Code addressing position-dependent\n"));
15762 printf (_("Code addressing position-independent\n"));
15765 printf ("??? (%d)\n", val
);
15770 case Tag_ABI_array_object_alignment
:
15771 READ_ULEB (val
, p
, end
);
15772 printf (" Tag_ABI_array_object_alignment: ");
15776 printf (_("8-byte\n"));
15779 printf (_("4-byte\n"));
15782 printf (_("16-byte\n"));
15785 printf ("??? (%d)\n", val
);
15790 case Tag_ABI_array_object_align_expected
:
15791 READ_ULEB (val
, p
, end
);
15792 printf (" Tag_ABI_array_object_align_expected: ");
15796 printf (_("8-byte\n"));
15799 printf (_("4-byte\n"));
15802 printf (_("16-byte\n"));
15805 printf ("??? (%d)\n", val
);
15810 case Tag_ABI_compatibility
:
15812 READ_ULEB (val
, p
, end
);
15813 printf (" Tag_ABI_compatibility: ");
15814 printf (_("flag = %d, vendor = "), val
);
15817 size_t maxlen
= (end
- p
) - 1;
15819 print_symbol ((int) maxlen
, (const char *) p
);
15820 p
+= strnlen ((char *) p
, maxlen
) + 1;
15824 printf (_("<corrupt>"));
15825 p
= (unsigned char *) end
;
15831 case Tag_ABI_conformance
:
15833 printf (" Tag_ABI_conformance: \"");
15836 size_t maxlen
= (end
- p
) - 1;
15838 print_symbol ((int) maxlen
, (const char *) p
);
15839 p
+= strnlen ((char *) p
, maxlen
) + 1;
15843 printf (_("<corrupt>"));
15844 p
= (unsigned char *) end
;
15851 return display_tag_value (tag
, p
, end
);
15855 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15857 unsigned long addr
= 0;
15858 size_t bytes
= end
- p
;
15865 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15867 printf (" 0x%8.8lx ", addr
);
15869 for (j
= 0; j
< 16; j
++)
15872 printf ("%2.2x", p
[j
]);
15880 for (j
= 0; j
< lbytes
; j
++)
15883 if (k
>= ' ' && k
< 0x7f)
15899 static unsigned char *
15900 display_msp430x_attribute (unsigned char * p
,
15901 const unsigned char * const end
)
15906 READ_ULEB (tag
, p
, end
);
15910 case OFBA_MSPABI_Tag_ISA
:
15911 printf (" Tag_ISA: ");
15912 READ_ULEB (val
, p
, end
);
15915 case 0: printf (_("None\n")); break;
15916 case 1: printf (_("MSP430\n")); break;
15917 case 2: printf (_("MSP430X\n")); break;
15918 default: printf ("??? (%d)\n", val
); break;
15922 case OFBA_MSPABI_Tag_Code_Model
:
15923 printf (" Tag_Code_Model: ");
15924 READ_ULEB (val
, p
, end
);
15927 case 0: printf (_("None\n")); break;
15928 case 1: printf (_("Small\n")); break;
15929 case 2: printf (_("Large\n")); break;
15930 default: printf ("??? (%d)\n", val
); break;
15934 case OFBA_MSPABI_Tag_Data_Model
:
15935 printf (" Tag_Data_Model: ");
15936 READ_ULEB (val
, p
, end
);
15939 case 0: printf (_("None\n")); break;
15940 case 1: printf (_("Small\n")); break;
15941 case 2: printf (_("Large\n")); break;
15942 case 3: printf (_("Restricted Large\n")); break;
15943 default: printf ("??? (%d)\n", val
); break;
15948 printf (_(" <unknown tag %d>: "), tag
);
15955 size_t maxlen
= (end
- p
) - 1;
15957 print_symbol ((int) maxlen
, (const char *) p
);
15958 p
+= strnlen ((char *) p
, maxlen
) + 1;
15962 printf (_("<corrupt>"));
15963 p
= (unsigned char *) end
;
15969 READ_ULEB (val
, p
, end
);
15970 printf ("%d (0x%x)\n", val
, val
);
15979 static unsigned char *
15980 display_msp430_gnu_attribute (unsigned char * p
,
15982 const unsigned char * const end
)
15984 if (tag
== Tag_GNU_MSP430_Data_Region
)
15988 printf (" Tag_GNU_MSP430_Data_Region: ");
15989 READ_ULEB (val
, p
, end
);
15993 case Val_GNU_MSP430_Data_Region_Any
:
15994 printf (_("Any Region\n"));
15996 case Val_GNU_MSP430_Data_Region_Lower
:
15997 printf (_("Lower Region Only\n"));
16000 printf ("??? (%u)\n", val
);
16004 return display_tag_value (tag
& 1, p
, end
);
16007 struct riscv_attr_tag_t
{
16012 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16014 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16017 T(priv_spec_minor
),
16018 T(priv_spec_revision
),
16019 T(unaligned_access
),
16024 static unsigned char *
16025 display_riscv_attribute (unsigned char *p
,
16026 const unsigned char * const end
)
16030 struct riscv_attr_tag_t
*attr
= NULL
;
16033 READ_ULEB (tag
, p
, end
);
16035 /* Find the name of attribute. */
16036 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16038 if (riscv_attr_tag
[i
].tag
== tag
)
16040 attr
= &riscv_attr_tag
[i
];
16046 printf (" %s: ", attr
->name
);
16048 return display_tag_value (tag
, p
, end
);
16052 case Tag_RISCV_priv_spec
:
16053 case Tag_RISCV_priv_spec_minor
:
16054 case Tag_RISCV_priv_spec_revision
:
16055 READ_ULEB (val
, p
, end
);
16056 printf (_("%u\n"), val
);
16058 case Tag_RISCV_unaligned_access
:
16059 READ_ULEB (val
, p
, end
);
16063 printf (_("No unaligned access\n"));
16066 printf (_("Unaligned access\n"));
16070 case Tag_RISCV_stack_align
:
16071 READ_ULEB (val
, p
, end
);
16072 printf (_("%u-bytes\n"), val
);
16074 case Tag_RISCV_arch
:
16075 p
= display_tag_value (-1, p
, end
);
16078 return display_tag_value (tag
, p
, end
);
16085 process_attributes (Filedata
* filedata
,
16086 const char * public_name
,
16087 unsigned int proc_type
,
16088 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16089 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16091 Elf_Internal_Shdr
* sect
;
16093 bfd_boolean res
= TRUE
;
16095 /* Find the section header so that we get the size. */
16096 for (i
= 0, sect
= filedata
->section_headers
;
16097 i
< filedata
->file_header
.e_shnum
;
16100 unsigned char * contents
;
16103 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16106 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16107 sect
->sh_size
, _("attributes"));
16108 if (contents
== NULL
)
16115 /* The first character is the version of the attributes.
16116 Currently only version 1, (aka 'A') is recognised here. */
16119 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16124 bfd_vma section_len
;
16126 section_len
= sect
->sh_size
- 1;
16129 while (section_len
> 0)
16132 unsigned int namelen
;
16133 bfd_boolean public_section
;
16134 bfd_boolean gnu_section
;
16136 if (section_len
<= 4)
16138 error (_("Tag section ends prematurely\n"));
16142 attr_len
= byte_get (p
, 4);
16145 if (attr_len
> section_len
)
16147 error (_("Bad attribute length (%u > %u)\n"),
16148 (unsigned) attr_len
, (unsigned) section_len
);
16149 attr_len
= section_len
;
16152 /* PR 17531: file: 001-101425-0.004 */
16153 else if (attr_len
< 5)
16155 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16160 section_len
-= attr_len
;
16163 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16164 if (namelen
== 0 || namelen
>= attr_len
)
16166 error (_("Corrupt attribute section name\n"));
16171 printf (_("Attribute Section: "));
16172 print_symbol (INT_MAX
, (const char *) p
);
16175 if (public_name
&& streq ((char *) p
, public_name
))
16176 public_section
= TRUE
;
16178 public_section
= FALSE
;
16180 if (streq ((char *) p
, "gnu"))
16181 gnu_section
= TRUE
;
16183 gnu_section
= FALSE
;
16186 attr_len
-= namelen
;
16188 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16193 unsigned char * end
;
16195 /* PR binutils/17531: Safe handling of corrupt files. */
16198 error (_("Unused bytes at end of section\n"));
16205 size
= byte_get (p
, 4);
16206 if (size
> attr_len
)
16208 error (_("Bad subsection length (%u > %u)\n"),
16209 (unsigned) size
, (unsigned) attr_len
);
16213 /* PR binutils/17531: Safe handling of corrupt files. */
16216 error (_("Bad subsection length (%u < 6)\n"),
16224 end
= p
+ size
- 1;
16225 assert (end
<= contents
+ sect
->sh_size
);
16231 printf (_("File Attributes\n"));
16234 printf (_("Section Attributes:"));
16237 printf (_("Symbol Attributes:"));
16238 /* Fall through. */
16242 READ_ULEB (val
, p
, end
);
16245 printf (" %d", val
);
16250 printf (_("Unknown tag: %d\n"), tag
);
16251 public_section
= FALSE
;
16255 if (public_section
&& display_pub_attribute
!= NULL
)
16258 p
= display_pub_attribute (p
, end
);
16261 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16264 p
= display_gnu_attribute (p
,
16265 display_proc_gnu_attribute
,
16271 printf (_(" Unknown attribute:\n"));
16272 display_raw_attribute (p
, end
);
16287 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16288 Print the Address, Access and Initial fields of an entry at VMA ADDR
16289 and return the VMA of the next entry, or -1 if there was a problem.
16290 Does not read from DATA_END or beyond. */
16293 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16294 unsigned char * data_end
)
16297 print_vma (addr
, LONG_HEX
);
16299 if (addr
< pltgot
+ 0xfff0)
16300 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16302 printf ("%10s", "");
16305 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16309 unsigned char * from
= data
+ addr
- pltgot
;
16311 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16313 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16314 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16315 return (bfd_vma
) -1;
16319 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16320 print_vma (entry
, LONG_HEX
);
16323 return addr
+ (is_32bit_elf
? 4 : 8);
16326 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16327 PLTGOT. Print the Address and Initial fields of an entry at VMA
16328 ADDR and return the VMA of the next entry. */
16331 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16334 print_vma (addr
, LONG_HEX
);
16337 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16342 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16343 print_vma (entry
, LONG_HEX
);
16345 return addr
+ (is_32bit_elf
? 4 : 8);
16349 print_mips_ases (unsigned int mask
)
16351 if (mask
& AFL_ASE_DSP
)
16352 fputs ("\n\tDSP ASE", stdout
);
16353 if (mask
& AFL_ASE_DSPR2
)
16354 fputs ("\n\tDSP R2 ASE", stdout
);
16355 if (mask
& AFL_ASE_DSPR3
)
16356 fputs ("\n\tDSP R3 ASE", stdout
);
16357 if (mask
& AFL_ASE_EVA
)
16358 fputs ("\n\tEnhanced VA Scheme", stdout
);
16359 if (mask
& AFL_ASE_MCU
)
16360 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16361 if (mask
& AFL_ASE_MDMX
)
16362 fputs ("\n\tMDMX ASE", stdout
);
16363 if (mask
& AFL_ASE_MIPS3D
)
16364 fputs ("\n\tMIPS-3D ASE", stdout
);
16365 if (mask
& AFL_ASE_MT
)
16366 fputs ("\n\tMT ASE", stdout
);
16367 if (mask
& AFL_ASE_SMARTMIPS
)
16368 fputs ("\n\tSmartMIPS ASE", stdout
);
16369 if (mask
& AFL_ASE_VIRT
)
16370 fputs ("\n\tVZ ASE", stdout
);
16371 if (mask
& AFL_ASE_MSA
)
16372 fputs ("\n\tMSA ASE", stdout
);
16373 if (mask
& AFL_ASE_MIPS16
)
16374 fputs ("\n\tMIPS16 ASE", stdout
);
16375 if (mask
& AFL_ASE_MICROMIPS
)
16376 fputs ("\n\tMICROMIPS ASE", stdout
);
16377 if (mask
& AFL_ASE_XPA
)
16378 fputs ("\n\tXPA ASE", stdout
);
16379 if (mask
& AFL_ASE_MIPS16E2
)
16380 fputs ("\n\tMIPS16e2 ASE", stdout
);
16381 if (mask
& AFL_ASE_CRC
)
16382 fputs ("\n\tCRC ASE", stdout
);
16383 if (mask
& AFL_ASE_GINV
)
16384 fputs ("\n\tGINV ASE", stdout
);
16385 if (mask
& AFL_ASE_LOONGSON_MMI
)
16386 fputs ("\n\tLoongson MMI ASE", stdout
);
16387 if (mask
& AFL_ASE_LOONGSON_CAM
)
16388 fputs ("\n\tLoongson CAM ASE", stdout
);
16389 if (mask
& AFL_ASE_LOONGSON_EXT
)
16390 fputs ("\n\tLoongson EXT ASE", stdout
);
16391 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16392 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16394 fprintf (stdout
, "\n\t%s", _("None"));
16395 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16396 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16400 print_mips_isa_ext (unsigned int isa_ext
)
16405 fputs (_("None"), stdout
);
16408 fputs ("RMI XLR", stdout
);
16410 case AFL_EXT_OCTEON3
:
16411 fputs ("Cavium Networks Octeon3", stdout
);
16413 case AFL_EXT_OCTEON2
:
16414 fputs ("Cavium Networks Octeon2", stdout
);
16416 case AFL_EXT_OCTEONP
:
16417 fputs ("Cavium Networks OcteonP", stdout
);
16419 case AFL_EXT_OCTEON
:
16420 fputs ("Cavium Networks Octeon", stdout
);
16423 fputs ("Toshiba R5900", stdout
);
16426 fputs ("MIPS R4650", stdout
);
16429 fputs ("LSI R4010", stdout
);
16432 fputs ("NEC VR4100", stdout
);
16435 fputs ("Toshiba R3900", stdout
);
16437 case AFL_EXT_10000
:
16438 fputs ("MIPS R10000", stdout
);
16441 fputs ("Broadcom SB-1", stdout
);
16444 fputs ("NEC VR4111/VR4181", stdout
);
16447 fputs ("NEC VR4120", stdout
);
16450 fputs ("NEC VR5400", stdout
);
16453 fputs ("NEC VR5500", stdout
);
16455 case AFL_EXT_LOONGSON_2E
:
16456 fputs ("ST Microelectronics Loongson 2E", stdout
);
16458 case AFL_EXT_LOONGSON_2F
:
16459 fputs ("ST Microelectronics Loongson 2F", stdout
);
16461 case AFL_EXT_INTERAPTIV_MR2
:
16462 fputs ("Imagination interAptiv MR2", stdout
);
16465 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16470 get_mips_reg_size (int reg_size
)
16472 return (reg_size
== AFL_REG_NONE
) ? 0
16473 : (reg_size
== AFL_REG_32
) ? 32
16474 : (reg_size
== AFL_REG_64
) ? 64
16475 : (reg_size
== AFL_REG_128
) ? 128
16480 process_mips_specific (Filedata
* filedata
)
16482 Elf_Internal_Dyn
* entry
;
16483 Elf_Internal_Shdr
*sect
= NULL
;
16484 size_t liblist_offset
= 0;
16485 size_t liblistno
= 0;
16486 size_t conflictsno
= 0;
16487 size_t options_offset
= 0;
16488 size_t conflicts_offset
= 0;
16489 size_t pltrelsz
= 0;
16491 bfd_vma pltgot
= 0;
16492 bfd_vma mips_pltgot
= 0;
16493 bfd_vma jmprel
= 0;
16494 bfd_vma local_gotno
= 0;
16495 bfd_vma gotsym
= 0;
16496 bfd_vma symtabno
= 0;
16497 bfd_boolean res
= TRUE
;
16499 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16500 display_mips_gnu_attribute
))
16503 sect
= find_section (filedata
, ".MIPS.abiflags");
16507 Elf_External_ABIFlags_v0
*abiflags_ext
;
16508 Elf_Internal_ABIFlags_v0 abiflags_in
;
16510 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16512 error (_("Corrupt MIPS ABI Flags section.\n"));
16517 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16518 sect
->sh_size
, _("MIPS ABI Flags section"));
16521 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16522 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16523 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16524 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16525 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16526 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16527 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16528 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16529 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16530 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16531 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16533 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16534 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16535 if (abiflags_in
.isa_rev
> 1)
16536 printf ("r%d", abiflags_in
.isa_rev
);
16537 printf ("\nGPR size: %d",
16538 get_mips_reg_size (abiflags_in
.gpr_size
));
16539 printf ("\nCPR1 size: %d",
16540 get_mips_reg_size (abiflags_in
.cpr1_size
));
16541 printf ("\nCPR2 size: %d",
16542 get_mips_reg_size (abiflags_in
.cpr2_size
));
16543 fputs ("\nFP ABI: ", stdout
);
16544 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16545 fputs ("ISA Extension: ", stdout
);
16546 print_mips_isa_ext (abiflags_in
.isa_ext
);
16547 fputs ("\nASEs:", stdout
);
16548 print_mips_ases (abiflags_in
.ases
);
16549 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16550 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16551 fputc ('\n', stdout
);
16552 free (abiflags_ext
);
16557 /* We have a lot of special sections. Thanks SGI! */
16558 if (dynamic_section
== NULL
)
16560 /* No dynamic information available. See if there is static GOT. */
16561 sect
= find_section (filedata
, ".got");
16564 unsigned char *data_end
;
16565 unsigned char *data
;
16569 pltgot
= sect
->sh_addr
;
16572 addr_size
= (is_32bit_elf
? 4 : 8);
16573 end
= pltgot
+ sect
->sh_size
;
16575 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16577 _("Global Offset Table data"));
16578 /* PR 12855: Null data is handled gracefully throughout. */
16579 data_end
= data
+ (end
- pltgot
);
16581 printf (_("\nStatic GOT:\n"));
16582 printf (_(" Canonical gp value: "));
16583 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16586 /* In a dynamic binary GOT[0] is reserved for the dynamic
16587 loader to store the lazy resolver pointer, however in
16588 a static binary it may well have been omitted and GOT
16589 reduced to a table of addresses.
16590 PR 21344: Check for the entry being fully available
16591 before fetching it. */
16593 && data
+ ent
- pltgot
+ addr_size
<= data_end
16594 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16596 printf (_(" Reserved entries:\n"));
16597 printf (_(" %*s %10s %*s\n"),
16598 addr_size
* 2, _("Address"), _("Access"),
16599 addr_size
* 2, _("Value"));
16600 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16602 if (ent
== (bfd_vma
) -1)
16603 goto sgot_print_fail
;
16605 /* Check for the MSB of GOT[1] being set, identifying a
16606 GNU object. This entry will be used by some runtime
16607 loaders, to store the module pointer. Otherwise this
16608 is an ordinary local entry.
16609 PR 21344: Check for the entry being fully available
16610 before fetching it. */
16612 && data
+ ent
- pltgot
+ addr_size
<= data_end
16613 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16614 >> (addr_size
* 8 - 1)) != 0)
16616 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16618 if (ent
== (bfd_vma
) -1)
16619 goto sgot_print_fail
;
16624 if (data
!= NULL
&& ent
< end
)
16626 printf (_(" Local entries:\n"));
16627 printf (" %*s %10s %*s\n",
16628 addr_size
* 2, _("Address"), _("Access"),
16629 addr_size
* 2, _("Value"));
16632 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16634 if (ent
== (bfd_vma
) -1)
16635 goto sgot_print_fail
;
16647 for (entry
= dynamic_section
;
16648 /* PR 17531 file: 012-50589-0.004. */
16649 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16651 switch (entry
->d_tag
)
16653 case DT_MIPS_LIBLIST
:
16655 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16656 liblistno
* sizeof (Elf32_External_Lib
));
16658 case DT_MIPS_LIBLISTNO
:
16659 liblistno
= entry
->d_un
.d_val
;
16661 case DT_MIPS_OPTIONS
:
16662 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16664 case DT_MIPS_CONFLICT
:
16666 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16667 conflictsno
* sizeof (Elf32_External_Conflict
));
16669 case DT_MIPS_CONFLICTNO
:
16670 conflictsno
= entry
->d_un
.d_val
;
16673 pltgot
= entry
->d_un
.d_ptr
;
16675 case DT_MIPS_LOCAL_GOTNO
:
16676 local_gotno
= entry
->d_un
.d_val
;
16678 case DT_MIPS_GOTSYM
:
16679 gotsym
= entry
->d_un
.d_val
;
16681 case DT_MIPS_SYMTABNO
:
16682 symtabno
= entry
->d_un
.d_val
;
16684 case DT_MIPS_PLTGOT
:
16685 mips_pltgot
= entry
->d_un
.d_ptr
;
16688 pltrel
= entry
->d_un
.d_val
;
16691 pltrelsz
= entry
->d_un
.d_val
;
16694 jmprel
= entry
->d_un
.d_ptr
;
16700 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16702 Elf32_External_Lib
* elib
;
16705 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16706 sizeof (Elf32_External_Lib
),
16708 _("liblist section data"));
16711 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16712 "\nSection '.liblist' contains %lu entries:\n",
16713 (unsigned long) liblistno
),
16714 (unsigned long) liblistno
);
16715 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16718 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16725 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16726 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16727 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16728 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16729 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16731 tmp
= gmtime (&atime
);
16732 snprintf (timebuf
, sizeof (timebuf
),
16733 "%04u-%02u-%02uT%02u:%02u:%02u",
16734 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16735 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16737 printf ("%3lu: ", (unsigned long) cnt
);
16738 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16739 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16741 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16742 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16743 liblist
.l_version
);
16745 if (liblist
.l_flags
== 0)
16749 static const struct
16756 { " EXACT_MATCH", LL_EXACT_MATCH
},
16757 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16758 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16759 { " EXPORTS", LL_EXPORTS
},
16760 { " DELAY_LOAD", LL_DELAY_LOAD
},
16761 { " DELTA", LL_DELTA
}
16763 int flags
= liblist
.l_flags
;
16766 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16767 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16769 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16770 flags
^= l_flags_vals
[fcnt
].bit
;
16773 printf (" %#x", (unsigned int) flags
);
16785 if (options_offset
!= 0)
16787 Elf_External_Options
* eopt
;
16790 sect
= filedata
->section_headers
;
16792 /* Find the section header so that we get the size. */
16793 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16794 /* PR 17533 file: 012-277276-0.004. */
16797 error (_("No MIPS_OPTIONS header found\n"));
16801 if (sect
->sh_size
< sizeof (* eopt
))
16803 error (_("The MIPS options section is too small.\n"));
16807 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16808 sect
->sh_size
, _("options"));
16811 Elf_Internal_Options
* iopt
;
16812 Elf_Internal_Options
* option
;
16813 Elf_Internal_Options
* iopt_end
;
16815 iopt
= (Elf_Internal_Options
*)
16816 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16819 error (_("Out of memory allocating space for MIPS options\n"));
16826 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16828 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16830 Elf_External_Options
* eoption
;
16832 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16834 option
->kind
= BYTE_GET (eoption
->kind
);
16835 option
->size
= BYTE_GET (eoption
->size
);
16836 option
->section
= BYTE_GET (eoption
->section
);
16837 option
->info
= BYTE_GET (eoption
->info
);
16839 /* PR 17531: file: ffa0fa3b. */
16840 if (option
->size
< sizeof (* eopt
)
16841 || offset
+ option
->size
> sect
->sh_size
)
16843 error (_("Invalid size (%u) for MIPS option\n"),
16849 offset
+= option
->size
;
16855 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16856 "\nSection '%s' contains %d entries:\n",
16858 printable_section_name (filedata
, sect
), cnt
);
16867 switch (option
->kind
)
16870 /* This shouldn't happen. */
16871 printf (" NULL %d %lx", option
->section
, option
->info
);
16875 printf (" REGINFO ");
16876 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16878 Elf32_External_RegInfo
* ereg
;
16879 Elf32_RegInfo reginfo
;
16882 if (option
+ 2 > iopt_end
)
16884 printf (_("<corrupt>\n"));
16885 error (_("Truncated MIPS REGINFO option\n"));
16890 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16892 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16893 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16894 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16895 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16896 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16897 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16899 printf ("GPR %08lx GP 0x%lx\n",
16900 reginfo
.ri_gprmask
,
16901 (unsigned long) reginfo
.ri_gp_value
);
16902 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16903 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16904 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16909 Elf64_External_RegInfo
* ereg
;
16910 Elf64_Internal_RegInfo reginfo
;
16912 if (option
+ 2 > iopt_end
)
16914 printf (_("<corrupt>\n"));
16915 error (_("Truncated MIPS REGINFO option\n"));
16920 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16921 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16922 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16923 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16924 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16925 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16926 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16928 printf ("GPR %08lx GP 0x",
16929 reginfo
.ri_gprmask
);
16930 printf_vma (reginfo
.ri_gp_value
);
16933 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16934 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16935 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16940 case ODK_EXCEPTIONS
:
16941 fputs (" EXCEPTIONS fpe_min(", stdout
);
16942 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16943 fputs (") fpe_max(", stdout
);
16944 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16945 fputs (")", stdout
);
16947 if (option
->info
& OEX_PAGE0
)
16948 fputs (" PAGE0", stdout
);
16949 if (option
->info
& OEX_SMM
)
16950 fputs (" SMM", stdout
);
16951 if (option
->info
& OEX_FPDBUG
)
16952 fputs (" FPDBUG", stdout
);
16953 if (option
->info
& OEX_DISMISS
)
16954 fputs (" DISMISS", stdout
);
16958 fputs (" PAD ", stdout
);
16959 if (option
->info
& OPAD_PREFIX
)
16960 fputs (" PREFIX", stdout
);
16961 if (option
->info
& OPAD_POSTFIX
)
16962 fputs (" POSTFIX", stdout
);
16963 if (option
->info
& OPAD_SYMBOL
)
16964 fputs (" SYMBOL", stdout
);
16968 fputs (" HWPATCH ", stdout
);
16969 if (option
->info
& OHW_R4KEOP
)
16970 fputs (" R4KEOP", stdout
);
16971 if (option
->info
& OHW_R8KPFETCH
)
16972 fputs (" R8KPFETCH", stdout
);
16973 if (option
->info
& OHW_R5KEOP
)
16974 fputs (" R5KEOP", stdout
);
16975 if (option
->info
& OHW_R5KCVTL
)
16976 fputs (" R5KCVTL", stdout
);
16980 fputs (" FILL ", stdout
);
16981 /* XXX Print content of info word? */
16985 fputs (" TAGS ", stdout
);
16986 /* XXX Print content of info word? */
16990 fputs (" HWAND ", stdout
);
16991 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16992 fputs (" R4KEOP_CHECKED", stdout
);
16993 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16994 fputs (" R4KEOP_CLEAN", stdout
);
16998 fputs (" HWOR ", stdout
);
16999 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17000 fputs (" R4KEOP_CHECKED", stdout
);
17001 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17002 fputs (" R4KEOP_CLEAN", stdout
);
17006 printf (" GP_GROUP %#06lx self-contained %#06lx",
17007 option
->info
& OGP_GROUP
,
17008 (option
->info
& OGP_SELF
) >> 16);
17012 printf (" IDENT %#06lx self-contained %#06lx",
17013 option
->info
& OGP_GROUP
,
17014 (option
->info
& OGP_SELF
) >> 16);
17018 /* This shouldn't happen. */
17019 printf (" %3d ??? %d %lx",
17020 option
->kind
, option
->section
, option
->info
);
17024 len
= sizeof (* eopt
);
17025 while (len
< option
->size
)
17027 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17029 if (ISPRINT (datum
))
17030 printf ("%c", datum
);
17032 printf ("\\%03o", datum
);
17035 fputs ("\n", stdout
);
17037 offset
+= option
->size
;
17047 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17049 Elf32_Conflict
* iconf
;
17052 if (dynamic_symbols
== NULL
)
17054 error (_("conflict list found without a dynamic symbol table\n"));
17058 /* PR 21345 - print a slightly more helpful error message
17059 if we are sure that the cmalloc will fail. */
17060 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17062 error (_("Overlarge number of conflicts detected: %lx\n"),
17063 (long) conflictsno
);
17067 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17070 error (_("Out of memory allocating space for dynamic conflicts\n"));
17076 Elf32_External_Conflict
* econf32
;
17078 econf32
= (Elf32_External_Conflict
*)
17079 get_data (NULL
, filedata
, conflicts_offset
,
17080 sizeof (*econf32
), conflictsno
, _("conflict"));
17087 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17088 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17094 Elf64_External_Conflict
* econf64
;
17096 econf64
= (Elf64_External_Conflict
*)
17097 get_data (NULL
, filedata
, conflicts_offset
,
17098 sizeof (*econf64
), conflictsno
, _("conflict"));
17105 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17106 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17111 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17112 "\nSection '.conflict' contains %lu entries:\n",
17113 (unsigned long) conflictsno
),
17114 (unsigned long) conflictsno
);
17115 puts (_(" Num: Index Value Name"));
17117 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17119 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17121 if (iconf
[cnt
] >= num_dynamic_syms
)
17122 printf (_("<corrupt symbol index>"));
17125 Elf_Internal_Sym
* psym
;
17127 psym
= & dynamic_symbols
[iconf
[cnt
]];
17128 print_vma (psym
->st_value
, FULL_HEX
);
17130 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17131 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
17133 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17141 if (pltgot
!= 0 && local_gotno
!= 0)
17143 bfd_vma ent
, local_end
, global_end
;
17145 unsigned char * data
;
17146 unsigned char * data_end
;
17150 addr_size
= (is_32bit_elf
? 4 : 8);
17151 local_end
= pltgot
+ local_gotno
* addr_size
;
17153 /* PR binutils/17533 file: 012-111227-0.004 */
17154 if (symtabno
< gotsym
)
17156 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17157 (unsigned long) gotsym
, (unsigned long) symtabno
);
17161 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17162 /* PR 17531: file: 54c91a34. */
17163 if (global_end
< local_end
)
17165 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17169 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17170 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17171 global_end
- pltgot
, 1,
17172 _("Global Offset Table data"));
17173 /* PR 12855: Null data is handled gracefully throughout. */
17174 data_end
= data
+ (global_end
- pltgot
);
17176 printf (_("\nPrimary GOT:\n"));
17177 printf (_(" Canonical gp value: "));
17178 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17181 printf (_(" Reserved entries:\n"));
17182 printf (_(" %*s %10s %*s Purpose\n"),
17183 addr_size
* 2, _("Address"), _("Access"),
17184 addr_size
* 2, _("Initial"));
17185 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17186 printf (_(" Lazy resolver\n"));
17187 if (ent
== (bfd_vma
) -1)
17188 goto got_print_fail
;
17190 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17191 This entry will be used by some runtime loaders, to store the
17192 module pointer. Otherwise this is an ordinary local entry.
17193 PR 21344: Check for the entry being fully available before
17196 && data
+ ent
- pltgot
+ addr_size
<= data_end
17197 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17198 >> (addr_size
* 8 - 1)) != 0)
17200 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17201 printf (_(" Module pointer (GNU extension)\n"));
17202 if (ent
== (bfd_vma
) -1)
17203 goto got_print_fail
;
17207 if (data
!= NULL
&& ent
< local_end
)
17209 printf (_(" Local entries:\n"));
17210 printf (" %*s %10s %*s\n",
17211 addr_size
* 2, _("Address"), _("Access"),
17212 addr_size
* 2, _("Initial"));
17213 while (ent
< local_end
)
17215 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17217 if (ent
== (bfd_vma
) -1)
17218 goto got_print_fail
;
17223 if (data
!= NULL
&& gotsym
< symtabno
)
17227 printf (_(" Global entries:\n"));
17228 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17229 addr_size
* 2, _("Address"),
17231 addr_size
* 2, _("Initial"),
17232 addr_size
* 2, _("Sym.Val."),
17234 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17235 _("Ndx"), _("Name"));
17237 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17239 for (i
= gotsym
; i
< symtabno
; i
++)
17241 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17244 if (dynamic_symbols
== NULL
)
17245 printf (_("<no dynamic symbols>"));
17246 else if (i
< num_dynamic_syms
)
17248 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17250 print_vma (psym
->st_value
, LONG_HEX
);
17251 printf (" %-7s %3s ",
17252 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17253 get_symbol_index_type (filedata
, psym
->st_shndx
));
17255 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17256 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17258 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17261 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17262 (unsigned long) i
);
17265 if (ent
== (bfd_vma
) -1)
17276 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17279 size_t offset
, rel_offset
;
17280 unsigned long count
, i
;
17281 unsigned char * data
;
17282 int addr_size
, sym_width
;
17283 Elf_Internal_Rela
* rels
;
17285 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17286 if (pltrel
== DT_RELA
)
17288 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17293 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17298 addr_size
= (is_32bit_elf
? 4 : 8);
17299 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17301 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17302 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17303 1, _("Procedure Linkage Table data"));
17307 printf ("\nPLT GOT:\n\n");
17308 printf (_(" Reserved entries:\n"));
17309 printf (_(" %*s %*s Purpose\n"),
17310 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17311 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17312 printf (_(" PLT lazy resolver\n"));
17313 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17314 printf (_(" Module pointer\n"));
17317 printf (_(" Entries:\n"));
17318 printf (" %*s %*s %*s %-7s %3s %s\n",
17319 addr_size
* 2, _("Address"),
17320 addr_size
* 2, _("Initial"),
17321 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17322 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17323 for (i
= 0; i
< count
; i
++)
17325 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17327 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17330 if (idx
>= num_dynamic_syms
)
17331 printf (_("<corrupt symbol index: %lu>"), idx
);
17334 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17336 print_vma (psym
->st_value
, LONG_HEX
);
17337 printf (" %-7s %3s ",
17338 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17339 get_symbol_index_type (filedata
, psym
->st_shndx
));
17340 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17341 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17343 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17358 process_nds32_specific (Filedata
* filedata
)
17360 Elf_Internal_Shdr
*sect
= NULL
;
17362 sect
= find_section (filedata
, ".nds32_e_flags");
17365 unsigned int *flag
;
17367 printf ("\nNDS32 elf flags section:\n");
17368 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17369 sect
->sh_size
, _("NDS32 elf flags section"));
17374 switch ((*flag
) & 0x3)
17377 printf ("(VEC_SIZE):\tNo entry.\n");
17380 printf ("(VEC_SIZE):\t4 bytes\n");
17383 printf ("(VEC_SIZE):\t16 bytes\n");
17386 printf ("(VEC_SIZE):\treserved\n");
17395 process_gnu_liblist (Filedata
* filedata
)
17397 Elf_Internal_Shdr
* section
;
17398 Elf_Internal_Shdr
* string_sec
;
17399 Elf32_External_Lib
* elib
;
17401 size_t strtab_size
;
17403 unsigned long num_liblist
;
17405 bfd_boolean res
= TRUE
;
17410 for (i
= 0, section
= filedata
->section_headers
;
17411 i
< filedata
->file_header
.e_shnum
;
17414 switch (section
->sh_type
)
17416 case SHT_GNU_LIBLIST
:
17417 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17420 elib
= (Elf32_External_Lib
*)
17421 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17422 _("liblist section data"));
17430 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17431 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17432 string_sec
->sh_size
,
17433 _("liblist string table"));
17435 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17442 strtab_size
= string_sec
->sh_size
;
17444 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17445 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17446 "\nLibrary list section '%s' contains %lu entries:\n",
17448 printable_section_name (filedata
, section
),
17451 puts (_(" Library Time Stamp Checksum Version Flags"));
17453 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17461 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17462 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17463 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17464 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17465 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17467 tmp
= gmtime (&atime
);
17468 snprintf (timebuf
, sizeof (timebuf
),
17469 "%04u-%02u-%02uT%02u:%02u:%02u",
17470 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17471 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17473 printf ("%3lu: ", (unsigned long) cnt
);
17475 printf ("%-20s", liblist
.l_name
< strtab_size
17476 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17478 printf ("%-20.20s", liblist
.l_name
< strtab_size
17479 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17480 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17481 liblist
.l_version
, liblist
.l_flags
);
17492 static const char *
17493 get_note_type (Filedata
* filedata
, unsigned e_type
)
17495 static char buff
[64];
17497 if (filedata
->file_header
.e_type
== ET_CORE
)
17501 return _("NT_AUXV (auxiliary vector)");
17503 return _("NT_PRSTATUS (prstatus structure)");
17505 return _("NT_FPREGSET (floating point registers)");
17507 return _("NT_PRPSINFO (prpsinfo structure)");
17508 case NT_TASKSTRUCT
:
17509 return _("NT_TASKSTRUCT (task structure)");
17511 return _("NT_PRXFPREG (user_xfpregs structure)");
17513 return _("NT_PPC_VMX (ppc Altivec registers)");
17515 return _("NT_PPC_VSX (ppc VSX registers)");
17517 return _("NT_PPC_TAR (ppc TAR register)");
17519 return _("NT_PPC_PPR (ppc PPR register)");
17521 return _("NT_PPC_DSCR (ppc DSCR register)");
17523 return _("NT_PPC_EBB (ppc EBB registers)");
17525 return _("NT_PPC_PMU (ppc PMU registers)");
17526 case NT_PPC_TM_CGPR
:
17527 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17528 case NT_PPC_TM_CFPR
:
17529 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17530 case NT_PPC_TM_CVMX
:
17531 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17532 case NT_PPC_TM_CVSX
:
17533 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17534 case NT_PPC_TM_SPR
:
17535 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17536 case NT_PPC_TM_CTAR
:
17537 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17538 case NT_PPC_TM_CPPR
:
17539 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17540 case NT_PPC_TM_CDSCR
:
17541 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17543 return _("NT_386_TLS (x86 TLS information)");
17544 case NT_386_IOPERM
:
17545 return _("NT_386_IOPERM (x86 I/O permissions)");
17546 case NT_X86_XSTATE
:
17547 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17548 case NT_S390_HIGH_GPRS
:
17549 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17550 case NT_S390_TIMER
:
17551 return _("NT_S390_TIMER (s390 timer register)");
17552 case NT_S390_TODCMP
:
17553 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17554 case NT_S390_TODPREG
:
17555 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17557 return _("NT_S390_CTRS (s390 control registers)");
17558 case NT_S390_PREFIX
:
17559 return _("NT_S390_PREFIX (s390 prefix register)");
17560 case NT_S390_LAST_BREAK
:
17561 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17562 case NT_S390_SYSTEM_CALL
:
17563 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17565 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17566 case NT_S390_VXRS_LOW
:
17567 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17568 case NT_S390_VXRS_HIGH
:
17569 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17570 case NT_S390_GS_CB
:
17571 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17572 case NT_S390_GS_BC
:
17573 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17575 return _("NT_ARM_VFP (arm VFP registers)");
17577 return _("NT_ARM_TLS (AArch TLS registers)");
17578 case NT_ARM_HW_BREAK
:
17579 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17580 case NT_ARM_HW_WATCH
:
17581 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17583 return _("NT_PSTATUS (pstatus structure)");
17585 return _("NT_FPREGS (floating point registers)");
17587 return _("NT_PSINFO (psinfo structure)");
17589 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17591 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17592 case NT_WIN32PSTATUS
:
17593 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17595 return _("NT_SIGINFO (siginfo_t data)");
17597 return _("NT_FILE (mapped files)");
17605 return _("NT_VERSION (version)");
17607 return _("NT_ARCH (architecture)");
17608 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17610 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17616 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17621 print_core_note (Elf_Internal_Note
*pnote
)
17623 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17624 bfd_vma count
, page_size
;
17625 unsigned char *descdata
, *filenames
, *descend
;
17627 if (pnote
->type
!= NT_FILE
)
17637 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17638 /* Still "successful". */
17643 if (pnote
->descsz
< 2 * addr_size
)
17645 error (_(" Malformed note - too short for header\n"));
17649 descdata
= (unsigned char *) pnote
->descdata
;
17650 descend
= descdata
+ pnote
->descsz
;
17652 if (descdata
[pnote
->descsz
- 1] != '\0')
17654 error (_(" Malformed note - does not end with \\0\n"));
17658 count
= byte_get (descdata
, addr_size
);
17659 descdata
+= addr_size
;
17661 page_size
= byte_get (descdata
, addr_size
);
17662 descdata
+= addr_size
;
17664 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17665 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17667 error (_(" Malformed note - too short for supplied file count\n"));
17671 printf (_(" Page size: "));
17672 print_vma (page_size
, DEC
);
17675 printf (_(" %*s%*s%*s\n"),
17676 (int) (2 + 2 * addr_size
), _("Start"),
17677 (int) (4 + 2 * addr_size
), _("End"),
17678 (int) (4 + 2 * addr_size
), _("Page Offset"));
17679 filenames
= descdata
+ count
* 3 * addr_size
;
17680 while (count
-- > 0)
17682 bfd_vma start
, end
, file_ofs
;
17684 if (filenames
== descend
)
17686 error (_(" Malformed note - filenames end too early\n"));
17690 start
= byte_get (descdata
, addr_size
);
17691 descdata
+= addr_size
;
17692 end
= byte_get (descdata
, addr_size
);
17693 descdata
+= addr_size
;
17694 file_ofs
= byte_get (descdata
, addr_size
);
17695 descdata
+= addr_size
;
17698 print_vma (start
, FULL_HEX
);
17700 print_vma (end
, FULL_HEX
);
17702 print_vma (file_ofs
, FULL_HEX
);
17703 printf ("\n %s\n", filenames
);
17705 filenames
+= 1 + strlen ((char *) filenames
);
17711 static const char *
17712 get_gnu_elf_note_type (unsigned e_type
)
17714 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17717 case NT_GNU_ABI_TAG
:
17718 return _("NT_GNU_ABI_TAG (ABI version tag)");
17720 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17721 case NT_GNU_BUILD_ID
:
17722 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17723 case NT_GNU_GOLD_VERSION
:
17724 return _("NT_GNU_GOLD_VERSION (gold version)");
17725 case NT_GNU_PROPERTY_TYPE_0
:
17726 return _("NT_GNU_PROPERTY_TYPE_0");
17727 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17728 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17729 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17730 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17733 static char buff
[64];
17735 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17742 decode_x86_compat_isa (unsigned int bitmask
)
17746 unsigned int bit
= bitmask
& (- bitmask
);
17751 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17754 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17757 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17760 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17763 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17766 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17769 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17772 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17775 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17778 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17781 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17784 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17785 printf ("AVX512F");
17787 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17788 printf ("AVX512CD");
17790 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17791 printf ("AVX512ER");
17793 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17794 printf ("AVX512PF");
17796 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17797 printf ("AVX512VL");
17799 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17800 printf ("AVX512DQ");
17802 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17803 printf ("AVX512BW");
17806 printf (_("<unknown: %x>"), bit
);
17815 decode_x86_isa (unsigned int bitmask
)
17819 printf (_("<None>"));
17825 unsigned int bit
= bitmask
& (- bitmask
);
17830 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17833 case GNU_PROPERTY_X86_ISA_1_SSE
:
17836 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17839 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17842 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17845 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17848 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17851 case GNU_PROPERTY_X86_ISA_1_AVX
:
17854 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17857 case GNU_PROPERTY_X86_ISA_1_FMA
:
17860 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17861 printf ("AVX512F");
17863 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17864 printf ("AVX512CD");
17866 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17867 printf ("AVX512ER");
17869 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17870 printf ("AVX512PF");
17872 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17873 printf ("AVX512VL");
17875 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17876 printf ("AVX512DQ");
17878 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17879 printf ("AVX512BW");
17881 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17882 printf ("AVX512_4FMAPS");
17884 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17885 printf ("AVX512_4VNNIW");
17887 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17888 printf ("AVX512_BITALG");
17890 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17891 printf ("AVX512_IFMA");
17893 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17894 printf ("AVX512_VBMI");
17896 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17897 printf ("AVX512_VBMI2");
17899 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17900 printf ("AVX512_VNNI");
17902 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17903 printf ("AVX512_BF16");
17906 printf (_("<unknown: %x>"), bit
);
17915 decode_x86_feature_1 (unsigned int bitmask
)
17919 printf (_("<None>"));
17925 unsigned int bit
= bitmask
& (- bitmask
);
17930 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17933 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17937 printf (_("<unknown: %x>"), bit
);
17946 decode_x86_feature_2 (unsigned int bitmask
)
17950 printf (_("<None>"));
17956 unsigned int bit
= bitmask
& (- bitmask
);
17961 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17964 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17967 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17970 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17973 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17976 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17979 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17982 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17985 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17986 printf ("XSAVEOPT");
17988 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17992 printf (_("<unknown: %x>"), bit
);
18001 decode_aarch64_feature_1_and (unsigned int bitmask
)
18005 unsigned int bit
= bitmask
& (- bitmask
);
18010 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18014 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18019 printf (_("<unknown: %x>"), bit
);
18028 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18030 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18031 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18032 unsigned int size
= is_32bit_elf
? 4 : 8;
18034 printf (_(" Properties: "));
18036 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18038 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18042 while (ptr
< ptr_end
)
18046 unsigned int datasz
;
18048 if ((size_t) (ptr_end
- ptr
) < 8)
18050 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18054 type
= byte_get (ptr
, 4);
18055 datasz
= byte_get (ptr
+ 4, 4);
18059 if (datasz
> (size_t) (ptr_end
- ptr
))
18061 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18066 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18068 if (filedata
->file_header
.e_machine
== EM_X86_64
18069 || filedata
->file_header
.e_machine
== EM_IAMCU
18070 || filedata
->file_header
.e_machine
== EM_386
)
18072 unsigned int bitmask
;
18075 bitmask
= byte_get (ptr
, 4);
18081 case GNU_PROPERTY_X86_ISA_1_USED
:
18083 printf (_("x86 ISA used: <corrupt length: %#x> "),
18087 printf ("x86 ISA used: ");
18088 decode_x86_isa (bitmask
);
18092 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18094 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18098 printf ("x86 ISA needed: ");
18099 decode_x86_isa (bitmask
);
18103 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18105 printf (_("x86 feature: <corrupt length: %#x> "),
18109 printf ("x86 feature: ");
18110 decode_x86_feature_1 (bitmask
);
18114 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18116 printf (_("x86 feature used: <corrupt length: %#x> "),
18120 printf ("x86 feature used: ");
18121 decode_x86_feature_2 (bitmask
);
18125 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18127 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18130 printf ("x86 feature needed: ");
18131 decode_x86_feature_2 (bitmask
);
18135 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18137 printf (_("x86 ISA used: <corrupt length: %#x> "),
18141 printf ("x86 ISA used: ");
18142 decode_x86_compat_isa (bitmask
);
18146 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18148 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18152 printf ("x86 ISA needed: ");
18153 decode_x86_compat_isa (bitmask
);
18161 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18163 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18165 printf ("AArch64 feature: ");
18167 printf (_("<corrupt length: %#x> "), datasz
);
18169 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18178 case GNU_PROPERTY_STACK_SIZE
:
18179 printf (_("stack size: "));
18180 if (datasz
!= size
)
18181 printf (_("<corrupt length: %#x> "), datasz
);
18183 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18186 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18187 printf ("no copy on protected ");
18189 printf (_("<corrupt length: %#x> "), datasz
);
18197 if (type
< GNU_PROPERTY_LOPROC
)
18198 printf (_("<unknown type %#x data: "), type
);
18199 else if (type
< GNU_PROPERTY_LOUSER
)
18200 printf (_("<procesor-specific type %#x data: "), type
);
18202 printf (_("<application-specific type %#x data: "), type
);
18203 for (j
= 0; j
< datasz
; ++j
)
18204 printf ("%02x ", ptr
[j
] & 0xff);
18208 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18209 if (ptr
== ptr_end
)
18222 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18224 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18225 switch (pnote
->type
)
18227 case NT_GNU_BUILD_ID
:
18231 printf (_(" Build ID: "));
18232 for (i
= 0; i
< pnote
->descsz
; ++i
)
18233 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18238 case NT_GNU_ABI_TAG
:
18240 unsigned long os
, major
, minor
, subminor
;
18241 const char *osname
;
18243 /* PR 17531: file: 030-599401-0.004. */
18244 if (pnote
->descsz
< 16)
18246 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18250 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18251 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18252 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18253 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18257 case GNU_ABI_TAG_LINUX
:
18260 case GNU_ABI_TAG_HURD
:
18263 case GNU_ABI_TAG_SOLARIS
:
18264 osname
= "Solaris";
18266 case GNU_ABI_TAG_FREEBSD
:
18267 osname
= "FreeBSD";
18269 case GNU_ABI_TAG_NETBSD
:
18272 case GNU_ABI_TAG_SYLLABLE
:
18273 osname
= "Syllable";
18275 case GNU_ABI_TAG_NACL
:
18279 osname
= "Unknown";
18283 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18284 major
, minor
, subminor
);
18288 case NT_GNU_GOLD_VERSION
:
18292 printf (_(" Version: "));
18293 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18294 printf ("%c", pnote
->descdata
[i
]);
18301 unsigned long num_entries
, mask
;
18303 /* Hardware capabilities information. Word 0 is the number of entries.
18304 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18305 is a series of entries, where each entry is a single byte followed
18306 by a nul terminated string. The byte gives the bit number to test
18307 if enabled in the bitmask. */
18308 printf (_(" Hardware Capabilities: "));
18309 if (pnote
->descsz
< 8)
18311 error (_("<corrupt GNU_HWCAP>\n"));
18314 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18315 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18316 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18317 /* FIXME: Add code to display the entries... */
18321 case NT_GNU_PROPERTY_TYPE_0
:
18322 print_gnu_property_note (filedata
, pnote
);
18326 /* Handle unrecognised types. An error message should have already been
18327 created by get_gnu_elf_note_type(), so all that we need to do is to
18328 display the data. */
18332 printf (_(" Description data: "));
18333 for (i
= 0; i
< pnote
->descsz
; ++i
)
18334 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18343 static const char *
18344 get_v850_elf_note_type (enum v850_notes n_type
)
18346 static char buff
[64];
18350 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18351 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18352 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18353 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18354 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18355 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18357 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18363 print_v850_note (Elf_Internal_Note
* pnote
)
18367 if (pnote
->descsz
!= 4)
18370 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18374 printf (_("not set\n"));
18378 switch (pnote
->type
)
18380 case V850_NOTE_ALIGNMENT
:
18383 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18384 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18388 case V850_NOTE_DATA_SIZE
:
18391 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18392 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18396 case V850_NOTE_FPU_INFO
:
18399 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18400 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18404 case V850_NOTE_MMU_INFO
:
18405 case V850_NOTE_CACHE_INFO
:
18406 case V850_NOTE_SIMD_INFO
:
18407 if (val
== EF_RH850_SIMD
)
18409 printf (_("yes\n"));
18415 /* An 'unknown note type' message will already have been displayed. */
18419 printf (_("unknown value: %x\n"), val
);
18424 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18426 unsigned int version
;
18428 switch (pnote
->type
)
18430 case NT_NETBSD_IDENT
:
18431 if (pnote
->descsz
< 1)
18433 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18434 if ((version
/ 10000) % 100)
18435 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18436 version
, version
/ 100000000, (version
/ 1000000) % 100,
18437 (version
/ 10000) % 100 > 26 ? "Z" : "",
18438 'A' + (version
/ 10000) % 26);
18440 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18441 version
, version
/ 100000000, (version
/ 1000000) % 100,
18442 (version
/ 100) % 100);
18445 case NT_NETBSD_MARCH
:
18446 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18450 #ifdef NT_NETBSD_PAX
18451 case NT_NETBSD_PAX
:
18452 if (pnote
->descsz
< 1)
18454 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18455 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18456 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18457 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18458 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18459 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18460 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18461 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18466 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18467 pnote
->descsz
, pnote
->type
);
18471 static const char *
18472 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18476 case NT_FREEBSD_THRMISC
:
18477 return _("NT_THRMISC (thrmisc structure)");
18478 case NT_FREEBSD_PROCSTAT_PROC
:
18479 return _("NT_PROCSTAT_PROC (proc data)");
18480 case NT_FREEBSD_PROCSTAT_FILES
:
18481 return _("NT_PROCSTAT_FILES (files data)");
18482 case NT_FREEBSD_PROCSTAT_VMMAP
:
18483 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18484 case NT_FREEBSD_PROCSTAT_GROUPS
:
18485 return _("NT_PROCSTAT_GROUPS (groups data)");
18486 case NT_FREEBSD_PROCSTAT_UMASK
:
18487 return _("NT_PROCSTAT_UMASK (umask data)");
18488 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18489 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18490 case NT_FREEBSD_PROCSTAT_OSREL
:
18491 return _("NT_PROCSTAT_OSREL (osreldate data)");
18492 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18493 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18494 case NT_FREEBSD_PROCSTAT_AUXV
:
18495 return _("NT_PROCSTAT_AUXV (auxv data)");
18496 case NT_FREEBSD_PTLWPINFO
:
18497 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18499 return get_note_type (filedata
, e_type
);
18502 static const char *
18503 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18505 static char buff
[64];
18509 case NT_NETBSDCORE_PROCINFO
:
18510 /* NetBSD core "procinfo" structure. */
18511 return _("NetBSD procinfo structure");
18513 #ifdef NT_NETBSDCORE_AUXV
18514 case NT_NETBSDCORE_AUXV
:
18515 return _("NetBSD ELF auxiliary vector data");
18518 #ifdef NT_NETBSDCORE_LWPSTATUS
18519 case NT_NETBSDCORE_LWPSTATUS
:
18520 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18524 /* As of Jan 2020 there are no other machine-independent notes
18525 defined for NetBSD core files. If the note type is less
18526 than the start of the machine-dependent note types, we don't
18529 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18531 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18537 switch (filedata
->file_header
.e_machine
)
18539 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18540 and PT_GETFPREGS == mach+2. */
18545 case EM_SPARC32PLUS
:
18549 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18550 return _("PT_GETREGS (reg structure)");
18551 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18552 return _("PT_GETFPREGS (fpreg structure)");
18558 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18559 There's also old PT___GETREGS40 == mach + 1 for old reg
18560 structure which lacks GBR. */
18564 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18565 return _("PT___GETREGS40 (old reg structure)");
18566 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18567 return _("PT_GETREGS (reg structure)");
18568 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18569 return _("PT_GETFPREGS (fpreg structure)");
18575 /* On all other arch's, PT_GETREGS == mach+1 and
18576 PT_GETFPREGS == mach+3. */
18580 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18581 return _("PT_GETREGS (reg structure)");
18582 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18583 return _("PT_GETFPREGS (fpreg structure)");
18589 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18590 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18594 static const char *
18595 get_stapsdt_note_type (unsigned e_type
)
18597 static char buff
[64];
18602 return _("NT_STAPSDT (SystemTap probe descriptors)");
18608 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18613 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18615 size_t len
, maxlen
;
18616 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18617 char *data
= pnote
->descdata
;
18618 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18619 bfd_vma pc
, base_addr
, semaphore
;
18620 char *provider
, *probe
, *arg_fmt
;
18622 if (pnote
->descsz
< (addr_size
* 3))
18623 goto stapdt_note_too_small
;
18625 pc
= byte_get ((unsigned char *) data
, addr_size
);
18628 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18631 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18634 if (data
>= data_end
)
18635 goto stapdt_note_too_small
;
18636 maxlen
= data_end
- data
;
18637 len
= strnlen (data
, maxlen
);
18644 goto stapdt_note_too_small
;
18646 if (data
>= data_end
)
18647 goto stapdt_note_too_small
;
18648 maxlen
= data_end
- data
;
18649 len
= strnlen (data
, maxlen
);
18656 goto stapdt_note_too_small
;
18658 if (data
>= data_end
)
18659 goto stapdt_note_too_small
;
18660 maxlen
= data_end
- data
;
18661 len
= strnlen (data
, maxlen
);
18668 goto stapdt_note_too_small
;
18670 printf (_(" Provider: %s\n"), provider
);
18671 printf (_(" Name: %s\n"), probe
);
18672 printf (_(" Location: "));
18673 print_vma (pc
, FULL_HEX
);
18674 printf (_(", Base: "));
18675 print_vma (base_addr
, FULL_HEX
);
18676 printf (_(", Semaphore: "));
18677 print_vma (semaphore
, FULL_HEX
);
18679 printf (_(" Arguments: %s\n"), arg_fmt
);
18681 return data
== data_end
;
18683 stapdt_note_too_small
:
18684 printf (_(" <corrupt - note is too small>\n"));
18685 error (_("corrupt stapdt note - the data size is too small\n"));
18689 static const char *
18690 get_ia64_vms_note_type (unsigned e_type
)
18692 static char buff
[64];
18697 return _("NT_VMS_MHD (module header)");
18699 return _("NT_VMS_LNM (language name)");
18701 return _("NT_VMS_SRC (source files)");
18703 return "NT_VMS_TITLE";
18705 return _("NT_VMS_EIDC (consistency check)");
18706 case NT_VMS_FPMODE
:
18707 return _("NT_VMS_FPMODE (FP mode)");
18708 case NT_VMS_LINKTIME
:
18709 return "NT_VMS_LINKTIME";
18710 case NT_VMS_IMGNAM
:
18711 return _("NT_VMS_IMGNAM (image name)");
18713 return _("NT_VMS_IMGID (image id)");
18714 case NT_VMS_LINKID
:
18715 return _("NT_VMS_LINKID (link id)");
18716 case NT_VMS_IMGBID
:
18717 return _("NT_VMS_IMGBID (build id)");
18718 case NT_VMS_GSTNAM
:
18719 return _("NT_VMS_GSTNAM (sym table name)");
18720 case NT_VMS_ORIG_DYN
:
18721 return "NT_VMS_ORIG_DYN";
18722 case NT_VMS_PATCHTIME
:
18723 return "NT_VMS_PATCHTIME";
18725 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18731 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18733 int maxlen
= pnote
->descsz
;
18735 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18736 goto desc_size_fail
;
18738 switch (pnote
->type
)
18742 goto desc_size_fail
;
18744 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18746 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18747 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18748 if (l
+ 34 < maxlen
)
18750 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18751 if (l
+ 35 < maxlen
)
18752 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18754 printf (_(" Module version : <missing>\n"));
18758 printf (_(" Module name : <missing>\n"));
18759 printf (_(" Module version : <missing>\n"));
18764 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18768 case NT_VMS_FPMODE
:
18769 printf (_(" Floating Point mode: "));
18771 goto desc_size_fail
;
18772 /* FIXME: Generate an error if descsz > 8 ? */
18774 printf ("0x%016" BFD_VMA_FMT
"x\n",
18775 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18778 case NT_VMS_LINKTIME
:
18779 printf (_(" Link time: "));
18781 goto desc_size_fail
;
18782 /* FIXME: Generate an error if descsz > 8 ? */
18785 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18789 case NT_VMS_PATCHTIME
:
18790 printf (_(" Patch time: "));
18792 goto desc_size_fail
;
18793 /* FIXME: Generate an error if descsz > 8 ? */
18796 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18800 case NT_VMS_ORIG_DYN
:
18802 goto desc_size_fail
;
18804 printf (_(" Major id: %u, minor id: %u\n"),
18805 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18806 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18807 printf (_(" Last modified : "));
18809 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18810 printf (_("\n Link flags : "));
18811 printf ("0x%016" BFD_VMA_FMT
"x\n",
18812 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18813 printf (_(" Header flags: 0x%08x\n"),
18814 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18815 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18819 case NT_VMS_IMGNAM
:
18820 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18823 case NT_VMS_GSTNAM
:
18824 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18828 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18831 case NT_VMS_LINKID
:
18832 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18842 printf (_(" <corrupt - data size is too small>\n"));
18843 error (_("corrupt IA64 note: data size is too small\n"));
18847 struct build_attr_cache
{
18848 Filedata
*filedata
;
18850 unsigned long strtablen
;
18851 Elf_Internal_Sym
*symtab
;
18852 unsigned long nsyms
;
18855 /* Find the symbol associated with a build attribute that is attached
18856 to address OFFSET. If PNAME is non-NULL then store the name of
18857 the symbol (if found) in the provided pointer, Returns NULL if a
18858 symbol could not be found. */
18860 static Elf_Internal_Sym
*
18861 get_symbol_for_build_attribute (Filedata
* filedata
,
18862 unsigned long offset
,
18863 bfd_boolean is_open_attr
,
18864 const char ** pname
)
18866 Elf_Internal_Sym
*saved_sym
= NULL
;
18867 Elf_Internal_Sym
*sym
;
18869 if (filedata
->section_headers
!= NULL
18870 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18872 Elf_Internal_Shdr
* symsec
;
18874 free (ba_cache
.strtab
);
18875 ba_cache
.strtab
= NULL
;
18876 free (ba_cache
.symtab
);
18877 ba_cache
.symtab
= NULL
;
18879 /* Load the symbol and string sections. */
18880 for (symsec
= filedata
->section_headers
;
18881 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18884 if (symsec
->sh_type
== SHT_SYMTAB
18885 && get_symtab (filedata
, symsec
,
18886 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18887 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18890 ba_cache
.filedata
= filedata
;
18893 if (ba_cache
.symtab
== NULL
)
18896 /* Find a symbol whose value matches offset. */
18897 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18898 if (sym
->st_value
== offset
)
18900 if (sym
->st_name
>= ba_cache
.strtablen
)
18901 /* Huh ? This should not happen. */
18904 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18907 /* The AArch64 and ARM architectures define mapping symbols
18908 (eg $d, $x, $t) which we want to ignore. */
18909 if (ba_cache
.strtab
[sym
->st_name
] == '$'
18910 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
18911 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
18916 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18917 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18918 FUNC symbols entirely. */
18919 switch (ELF_ST_TYPE (sym
->st_info
))
18926 /* If the symbol has a size associated
18927 with it then we can stop searching. */
18928 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
18933 /* Ignore function symbols. */
18940 switch (ELF_ST_BIND (sym
->st_info
))
18943 if (saved_sym
== NULL
18944 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18949 if (saved_sym
== NULL
)
18959 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18967 if (saved_sym
&& pname
)
18968 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
18973 /* Returns true iff addr1 and addr2 are in the same section. */
18976 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18978 Elf_Internal_Shdr
* a1
;
18979 Elf_Internal_Shdr
* a2
;
18981 a1
= find_section_by_address (filedata
, addr1
);
18982 a2
= find_section_by_address (filedata
, addr2
);
18984 return a1
== a2
&& a1
!= NULL
;
18988 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18989 Filedata
* filedata
)
18991 static unsigned long global_offset
= 0;
18992 static unsigned long global_end
= 0;
18993 static unsigned long func_offset
= 0;
18994 static unsigned long func_end
= 0;
18996 Elf_Internal_Sym
* sym
;
18998 unsigned long start
;
19000 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19002 switch (pnote
->descsz
)
19005 /* A zero-length description means that the range of
19006 the previous note of the same type should be used. */
19009 if (global_end
> global_offset
)
19010 printf (_(" Applies to region from %#lx to %#lx\n"),
19011 global_offset
, global_end
);
19013 printf (_(" Applies to region from %#lx\n"), global_offset
);
19017 if (func_end
> func_offset
)
19018 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19020 printf (_(" Applies to region from %#lx\n"), func_offset
);
19025 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19032 /* FIXME: We should check that version 3+ notes are being used here... */
19033 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19034 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19038 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19044 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19045 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19049 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19050 printf (_(" <invalid descsz>"));
19055 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19056 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19057 in order to avoid them being confused with the start address of the
19058 first function in the file... */
19059 if (sym
== NULL
&& is_open_attr
)
19060 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19063 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19064 end
= start
+ sym
->st_size
;
19068 /* FIXME: Need to properly allow for section alignment.
19069 16 is just the alignment used on x86_64. */
19071 && start
> BFD_ALIGN (global_end
, 16)
19072 /* Build notes are not guaranteed to be organised in order of
19073 increasing address, but we should find the all of the notes
19074 for one section in the same place. */
19075 && same_section (filedata
, start
, global_end
))
19076 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19077 global_end
+ 1, start
- 1);
19079 printf (_(" Applies to region from %#lx"), start
);
19080 global_offset
= start
;
19084 printf (_(" to %#lx"), end
);
19090 printf (_(" Applies to region from %#lx"), start
);
19091 func_offset
= start
;
19095 printf (_(" to %#lx"), end
);
19101 printf (_(" (%s)"), name
);
19108 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19110 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19111 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19112 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19114 char name_attribute
;
19115 const char * expected_types
;
19116 const char * name
= pnote
->namedata
;
19120 if (name
== NULL
|| pnote
->namesz
< 2)
19122 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19123 print_symbol (-20, _(" <corrupt name>"));
19132 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19133 if (name
[0] == 'G' && name
[1] == 'A')
19135 if (pnote
->namesz
< 4)
19137 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19138 print_symbol (-20, _(" <corrupt name>"));
19147 switch ((name_type
= * name
))
19149 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19150 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19151 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19152 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19153 printf ("%c", * name
);
19157 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19158 print_symbol (-20, _("<unknown name type>"));
19165 switch ((name_attribute
= * name
))
19167 case GNU_BUILD_ATTRIBUTE_VERSION
:
19168 text
= _("<version>");
19169 expected_types
= string_expected
;
19172 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19173 text
= _("<stack prot>");
19174 expected_types
= "!+*";
19177 case GNU_BUILD_ATTRIBUTE_RELRO
:
19178 text
= _("<relro>");
19179 expected_types
= bool_expected
;
19182 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19183 text
= _("<stack size>");
19184 expected_types
= number_expected
;
19187 case GNU_BUILD_ATTRIBUTE_TOOL
:
19188 text
= _("<tool>");
19189 expected_types
= string_expected
;
19192 case GNU_BUILD_ATTRIBUTE_ABI
:
19194 expected_types
= "$*";
19197 case GNU_BUILD_ATTRIBUTE_PIC
:
19199 expected_types
= number_expected
;
19202 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19203 text
= _("<short enum>");
19204 expected_types
= bool_expected
;
19208 if (ISPRINT (* name
))
19210 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19212 if (len
> left
&& ! do_wide
)
19214 printf ("%.*s:", len
, name
);
19220 static char tmpbuf
[128];
19222 error (_("unrecognised byte in name field: %d\n"), * name
);
19223 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19227 expected_types
= "*$!+";
19232 left
-= printf ("%s", text
);
19234 if (strchr (expected_types
, name_type
) == NULL
)
19235 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19237 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19239 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19240 (unsigned long) pnote
->namesz
,
19241 (long) (name
- pnote
->namedata
));
19245 if (left
< 1 && ! do_wide
)
19250 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19252 unsigned int bytes
;
19253 unsigned long long val
= 0;
19254 unsigned int shift
= 0;
19255 char * decoded
= NULL
;
19257 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19259 /* The -1 is because the name field is always 0 terminated, and we
19260 want to be able to ensure that the shift in the while loop below
19261 will not overflow. */
19264 if (bytes
> sizeof (val
))
19266 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19268 bytes
= sizeof (val
);
19270 /* We do not bother to warn if bytes == 0 as this can
19271 happen with some early versions of the gcc plugin. */
19275 unsigned long byte
= (* name
++) & 0xff;
19277 val
|= byte
<< shift
;
19281 switch (name_attribute
)
19283 case GNU_BUILD_ATTRIBUTE_PIC
:
19286 case 0: decoded
= "static"; break;
19287 case 1: decoded
= "pic"; break;
19288 case 2: decoded
= "PIC"; break;
19289 case 3: decoded
= "pie"; break;
19290 case 4: decoded
= "PIE"; break;
19294 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19297 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19298 case 0: decoded
= "off"; break;
19299 case 1: decoded
= "on"; break;
19300 case 2: decoded
= "all"; break;
19301 case 3: decoded
= "strong"; break;
19302 case 4: decoded
= "explicit"; break;
19310 if (decoded
!= NULL
)
19312 print_symbol (-left
, decoded
);
19323 left
-= printf ("0x%llx", val
);
19325 left
-= printf ("0x%-.*llx", left
, val
);
19329 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19330 left
-= print_symbol (- left
, name
);
19332 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19333 left
-= print_symbol (- left
, "true");
19335 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19336 left
-= print_symbol (- left
, "false");
19340 if (do_wide
&& left
> 0)
19341 printf ("%-*s", left
, " ");
19346 /* Note that by the ELF standard, the name field is already null byte
19347 terminated, and namesz includes the terminating null byte.
19348 I.E. the value of namesz for the name "FSF" is 4.
19350 If the value of namesz is zero, there is no name present. */
19353 process_note (Elf_Internal_Note
* pnote
,
19354 Filedata
* filedata
)
19356 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19359 if (pnote
->namesz
== 0)
19360 /* If there is no note name, then use the default set of
19361 note type strings. */
19362 nt
= get_note_type (filedata
, pnote
->type
);
19364 else if (const_strneq (pnote
->namedata
, "GNU"))
19365 /* GNU-specific object file notes. */
19366 nt
= get_gnu_elf_note_type (pnote
->type
);
19368 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19369 /* FreeBSD-specific core file notes. */
19370 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19372 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19373 /* NetBSD-specific core file notes. */
19374 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19376 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19377 /* NetBSD-specific core file notes. */
19378 return process_netbsd_elf_note (pnote
);
19380 else if (const_strneq (pnote
->namedata
, "PaX"))
19381 /* NetBSD-specific core file notes. */
19382 return process_netbsd_elf_note (pnote
);
19384 else if (strneq (pnote
->namedata
, "SPU/", 4))
19386 /* SPU-specific core file notes. */
19387 nt
= pnote
->namedata
+ 4;
19391 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19392 /* VMS/ia64-specific file notes. */
19393 nt
= get_ia64_vms_note_type (pnote
->type
);
19395 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19396 nt
= get_stapsdt_note_type (pnote
->type
);
19399 /* Don't recognize this note name; just use the default set of
19400 note type strings. */
19401 nt
= get_note_type (filedata
, pnote
->type
);
19405 if (((const_strneq (pnote
->namedata
, "GA")
19406 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19407 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19408 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19409 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19410 print_gnu_build_attribute_name (pnote
);
19412 print_symbol (-20, name
);
19415 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19417 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19419 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19420 return print_ia64_vms_note (pnote
);
19421 else if (const_strneq (pnote
->namedata
, "GNU"))
19422 return print_gnu_note (filedata
, pnote
);
19423 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19424 return print_stapsdt_note (pnote
);
19425 else if (const_strneq (pnote
->namedata
, "CORE"))
19426 return print_core_note (pnote
);
19427 else if (((const_strneq (pnote
->namedata
, "GA")
19428 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19429 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19430 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19431 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19432 return print_gnu_build_attribute_description (pnote
, filedata
);
19438 printf (_(" description data: "));
19439 for (i
= 0; i
< pnote
->descsz
; i
++)
19440 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19452 process_notes_at (Filedata
* filedata
,
19453 Elf_Internal_Shdr
* section
,
19458 Elf_External_Note
* pnotes
;
19459 Elf_External_Note
* external
;
19461 bfd_boolean res
= TRUE
;
19468 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19471 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19479 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19482 if (pnotes
== NULL
)
19488 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19490 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19491 (unsigned long) offset
, (unsigned long) length
);
19493 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19494 specifies that notes should be aligned to 4 bytes in 32-bit
19495 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19496 we also support 4 byte alignment in 64-bit objects. If section
19497 alignment is less than 4, we treate alignment as 4 bytes. */
19500 else if (align
!= 4 && align
!= 8)
19502 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19508 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19510 end
= (char *) pnotes
+ length
;
19511 while ((char *) external
< end
)
19513 Elf_Internal_Note inote
;
19516 char * temp
= NULL
;
19517 size_t data_remaining
= end
- (char *) external
;
19519 if (!is_ia64_vms (filedata
))
19521 /* PR binutils/15191
19522 Make sure that there is enough data to read. */
19523 min_notesz
= offsetof (Elf_External_Note
, name
);
19524 if (data_remaining
< min_notesz
)
19526 warn (ngettext ("Corrupt note: only %ld byte remains, "
19527 "not enough for a full note\n",
19528 "Corrupt note: only %ld bytes remain, "
19529 "not enough for a full note\n",
19531 (long) data_remaining
);
19534 data_remaining
-= min_notesz
;
19536 inote
.type
= BYTE_GET (external
->type
);
19537 inote
.namesz
= BYTE_GET (external
->namesz
);
19538 inote
.namedata
= external
->name
;
19539 inote
.descsz
= BYTE_GET (external
->descsz
);
19540 inote
.descdata
= ((char *) external
19541 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19542 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19543 next
= ((char *) external
19544 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19548 Elf64_External_VMS_Note
*vms_external
;
19550 /* PR binutils/15191
19551 Make sure that there is enough data to read. */
19552 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19553 if (data_remaining
< min_notesz
)
19555 warn (ngettext ("Corrupt note: only %ld byte remains, "
19556 "not enough for a full note\n",
19557 "Corrupt note: only %ld bytes remain, "
19558 "not enough for a full note\n",
19560 (long) data_remaining
);
19563 data_remaining
-= min_notesz
;
19565 vms_external
= (Elf64_External_VMS_Note
*) external
;
19566 inote
.type
= BYTE_GET (vms_external
->type
);
19567 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19568 inote
.namedata
= vms_external
->name
;
19569 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19570 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19571 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19572 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19575 /* PR 17531: file: 3443835e. */
19576 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19577 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19578 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19579 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19580 || ((size_t) (next
- inote
.descdata
)
19581 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19583 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19584 (unsigned long) ((char *) external
- (char *) pnotes
));
19585 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19586 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19590 external
= (Elf_External_Note
*) next
;
19592 /* Verify that name is null terminated. It appears that at least
19593 one version of Linux (RedHat 6.0) generates corefiles that don't
19594 comply with the ELF spec by failing to include the null byte in
19596 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19598 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19600 temp
= (char *) malloc (inote
.namesz
+ 1);
19603 error (_("Out of memory allocating space for inote name\n"));
19608 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19609 inote
.namedata
= temp
;
19611 inote
.namedata
[inote
.namesz
] = 0;
19614 if (! process_note (& inote
, filedata
))
19630 process_corefile_note_segments (Filedata
* filedata
)
19632 Elf_Internal_Phdr
* segment
;
19634 bfd_boolean res
= TRUE
;
19636 if (! get_program_headers (filedata
))
19639 for (i
= 0, segment
= filedata
->program_headers
;
19640 i
< filedata
->file_header
.e_phnum
;
19643 if (segment
->p_type
== PT_NOTE
)
19644 if (! process_notes_at (filedata
, NULL
,
19645 (bfd_vma
) segment
->p_offset
,
19646 (bfd_vma
) segment
->p_filesz
,
19647 (bfd_vma
) segment
->p_align
))
19655 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19657 Elf_External_Note
* pnotes
;
19658 Elf_External_Note
* external
;
19660 bfd_boolean res
= TRUE
;
19665 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19667 if (pnotes
== NULL
)
19671 end
= (char*) pnotes
+ length
;
19673 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19674 (unsigned long) offset
, (unsigned long) length
);
19676 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19678 Elf_External_Note
* next
;
19679 Elf_Internal_Note inote
;
19681 inote
.type
= BYTE_GET (external
->type
);
19682 inote
.namesz
= BYTE_GET (external
->namesz
);
19683 inote
.namedata
= external
->name
;
19684 inote
.descsz
= BYTE_GET (external
->descsz
);
19685 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19686 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19688 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19690 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19691 inote
.descdata
= inote
.namedata
;
19695 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19697 if ( ((char *) next
> end
)
19698 || ((char *) next
< (char *) pnotes
))
19700 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19701 (unsigned long) ((char *) external
- (char *) pnotes
));
19702 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19703 inote
.type
, inote
.namesz
, inote
.descsz
);
19709 /* Prevent out-of-bounds indexing. */
19710 if ( inote
.namedata
+ inote
.namesz
> end
19711 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19713 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19714 (unsigned long) ((char *) external
- (char *) pnotes
));
19715 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19716 inote
.type
, inote
.namesz
, inote
.descsz
);
19720 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19722 if (! print_v850_note (& inote
))
19725 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19726 inote
.namesz
, inote
.descsz
);
19736 process_note_sections (Filedata
* filedata
)
19738 Elf_Internal_Shdr
* section
;
19740 unsigned int n
= 0;
19741 bfd_boolean res
= TRUE
;
19743 for (i
= 0, section
= filedata
->section_headers
;
19744 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19747 if (section
->sh_type
== SHT_NOTE
)
19749 if (! process_notes_at (filedata
, section
,
19750 (bfd_vma
) section
->sh_offset
,
19751 (bfd_vma
) section
->sh_size
,
19752 (bfd_vma
) section
->sh_addralign
))
19757 if (( filedata
->file_header
.e_machine
== EM_V800
19758 || filedata
->file_header
.e_machine
== EM_V850
19759 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19760 && section
->sh_type
== SHT_RENESAS_INFO
)
19762 if (! process_v850_notes (filedata
,
19763 (bfd_vma
) section
->sh_offset
,
19764 (bfd_vma
) section
->sh_size
))
19771 /* Try processing NOTE segments instead. */
19772 return process_corefile_note_segments (filedata
);
19778 process_notes (Filedata
* filedata
)
19780 /* If we have not been asked to display the notes then do nothing. */
19784 if (filedata
->file_header
.e_type
!= ET_CORE
)
19785 return process_note_sections (filedata
);
19787 /* No program headers means no NOTE segment. */
19788 if (filedata
->file_header
.e_phnum
> 0)
19789 return process_corefile_note_segments (filedata
);
19791 printf (_("No note segments present in the core file.\n"));
19795 static unsigned char *
19796 display_public_gnu_attributes (unsigned char * start
,
19797 const unsigned char * const end
)
19799 printf (_(" Unknown GNU attribute: %s\n"), start
);
19801 start
+= strnlen ((char *) start
, end
- start
);
19802 display_raw_attribute (start
, end
);
19804 return (unsigned char *) end
;
19807 static unsigned char *
19808 display_generic_attribute (unsigned char * start
,
19810 const unsigned char * const end
)
19813 return (unsigned char *) end
;
19815 return display_tag_value (tag
, start
, end
);
19819 process_arch_specific (Filedata
* filedata
)
19824 switch (filedata
->file_header
.e_machine
)
19827 case EM_ARC_COMPACT
:
19828 case EM_ARC_COMPACT2
:
19829 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19830 display_arc_attribute
,
19831 display_generic_attribute
);
19833 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19834 display_arm_attribute
,
19835 display_generic_attribute
);
19838 case EM_MIPS_RS3_LE
:
19839 return process_mips_specific (filedata
);
19842 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19843 display_msp430x_attribute
,
19844 display_msp430_gnu_attribute
);
19847 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19848 display_riscv_attribute
,
19849 display_generic_attribute
);
19852 return process_nds32_specific (filedata
);
19856 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19857 display_power_gnu_attribute
);
19861 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19862 display_s390_gnu_attribute
);
19865 case EM_SPARC32PLUS
:
19867 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19868 display_sparc_gnu_attribute
);
19871 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19872 display_tic6x_attribute
,
19873 display_generic_attribute
);
19876 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19877 display_public_gnu_attributes
,
19878 display_generic_attribute
);
19883 get_file_header (Filedata
* filedata
)
19885 /* Read in the identity array. */
19886 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19889 /* Determine how to read the rest of the header. */
19890 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19895 byte_get
= byte_get_little_endian
;
19896 byte_put
= byte_put_little_endian
;
19899 byte_get
= byte_get_big_endian
;
19900 byte_put
= byte_put_big_endian
;
19904 /* For now we only support 32 bit and 64 bit ELF files. */
19905 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19907 /* Read in the rest of the header. */
19910 Elf32_External_Ehdr ehdr32
;
19912 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19915 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19916 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19917 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19918 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19919 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19920 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19921 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19922 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19923 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19924 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19925 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19926 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19927 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19931 Elf64_External_Ehdr ehdr64
;
19933 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19934 we will not be able to cope with the 64bit data found in
19935 64 ELF files. Detect this now and abort before we start
19936 overwriting things. */
19937 if (sizeof (bfd_vma
) < 8)
19939 error (_("This instance of readelf has been built without support for a\n\
19940 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19944 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19947 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19948 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19949 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19950 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19951 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19952 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19953 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19954 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19955 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19956 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19957 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19958 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19959 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19962 if (filedata
->file_header
.e_shoff
)
19964 /* There may be some extensions in the first section header. Don't
19965 bomb if we can't read it. */
19967 get_32bit_section_headers (filedata
, TRUE
);
19969 get_64bit_section_headers (filedata
, TRUE
);
19976 close_file (Filedata
* filedata
)
19980 if (filedata
->handle
)
19981 fclose (filedata
->handle
);
19987 close_debug_file (void * data
)
19989 close_file ((Filedata
*) data
);
19993 open_file (const char * pathname
)
19995 struct stat statbuf
;
19996 Filedata
* filedata
= NULL
;
19998 if (stat (pathname
, & statbuf
) < 0
19999 || ! S_ISREG (statbuf
.st_mode
))
20002 filedata
= calloc (1, sizeof * filedata
);
20003 if (filedata
== NULL
)
20006 filedata
->handle
= fopen (pathname
, "rb");
20007 if (filedata
->handle
== NULL
)
20010 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20011 filedata
->file_name
= pathname
;
20013 if (! get_file_header (filedata
))
20016 if (filedata
->file_header
.e_shoff
)
20020 /* Read the section headers again, this time for real. */
20022 res
= get_32bit_section_headers (filedata
, FALSE
);
20024 res
= get_64bit_section_headers (filedata
, FALSE
);
20035 if (filedata
->handle
)
20036 fclose (filedata
->handle
);
20043 open_debug_file (const char * pathname
)
20045 return open_file (pathname
);
20048 /* Process one ELF object file according to the command line options.
20049 This file may actually be stored in an archive. The file is
20050 positioned at the start of the ELF object. Returns TRUE if no
20051 problems were encountered, FALSE otherwise. */
20054 process_object (Filedata
* filedata
)
20056 bfd_boolean have_separate_files
;
20058 bfd_boolean res
= TRUE
;
20060 if (! get_file_header (filedata
))
20062 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20066 /* Initialise per file variables. */
20067 for (i
= ARRAY_SIZE (version_info
); i
--;)
20068 version_info
[i
] = 0;
20070 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
20071 dynamic_info
[i
] = 0;
20072 dynamic_info_DT_GNU_HASH
= 0;
20073 dynamic_info_DT_MIPS_XHASH
= 0;
20075 /* Process the file. */
20077 printf (_("\nFile: %s\n"), filedata
->file_name
);
20079 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20080 Note we do this even if cmdline_dump_sects is empty because we
20081 must make sure that the dump_sets array is zeroed out before each
20082 object file is processed. */
20083 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
20084 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
20086 if (cmdline
.num_dump_sects
> 0)
20088 if (filedata
->num_dump_sects
== 0)
20089 /* A sneaky way of allocating the dump_sects array. */
20090 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
20092 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
20093 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
20094 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
20097 if (! process_file_header (filedata
))
20100 if (! process_section_headers (filedata
))
20102 /* Without loaded section headers we cannot process lots of things. */
20103 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20105 if (! do_using_dynamic
)
20106 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20109 if (! process_section_groups (filedata
))
20110 /* Without loaded section groups we cannot process unwind. */
20113 if (process_program_headers (filedata
))
20114 process_dynamic_section (filedata
);
20118 if (! process_relocs (filedata
))
20121 if (! process_unwind (filedata
))
20124 if (! process_symbol_table (filedata
))
20127 if (! process_syminfo (filedata
))
20130 if (! process_version_sections (filedata
))
20133 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20134 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20136 have_separate_files
= FALSE
;
20138 if (! process_section_contents (filedata
))
20141 if (have_separate_files
)
20145 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20147 if (! process_section_headers (d
->handle
))
20149 else if (! process_section_contents (d
->handle
))
20153 /* The file handles are closed by the call to free_debug_memory() below. */
20156 if (! process_notes (filedata
))
20159 if (! process_gnu_liblist (filedata
))
20162 if (! process_arch_specific (filedata
))
20165 free (filedata
->program_headers
);
20166 filedata
->program_headers
= NULL
;
20168 free (filedata
->section_headers
);
20169 filedata
->section_headers
= NULL
;
20171 free (filedata
->string_table
);
20172 filedata
->string_table
= NULL
;
20173 filedata
->string_table_length
= 0;
20175 if (filedata
->dump_sects
!= NULL
)
20177 free (filedata
->dump_sects
);
20178 filedata
->dump_sects
= NULL
;
20179 filedata
->num_dump_sects
= 0;
20182 if (dynamic_strings
)
20184 free (dynamic_strings
);
20185 dynamic_strings
= NULL
;
20186 dynamic_strings_length
= 0;
20189 if (dynamic_symbols
)
20191 free (dynamic_symbols
);
20192 dynamic_symbols
= NULL
;
20193 num_dynamic_syms
= 0;
20196 if (dynamic_syminfo
)
20198 free (dynamic_syminfo
);
20199 dynamic_syminfo
= NULL
;
20202 if (dynamic_section
)
20204 free (dynamic_section
);
20205 dynamic_section
= NULL
;
20208 while (symtab_shndx_list
!= NULL
)
20210 elf_section_list
*next
= symtab_shndx_list
->next
;
20211 free (symtab_shndx_list
);
20212 symtab_shndx_list
= next
;
20215 if (section_headers_groups
)
20217 free (section_headers_groups
);
20218 section_headers_groups
= NULL
;
20221 if (section_groups
)
20223 struct group_list
* g
;
20224 struct group_list
* next
;
20226 for (i
= 0; i
< group_count
; i
++)
20228 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
20235 free (section_groups
);
20236 section_groups
= NULL
;
20239 free_debug_memory ();
20244 /* Process an ELF archive.
20245 On entry the file is positioned just after the ARMAG string.
20246 Returns TRUE upon success, FALSE otherwise. */
20249 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20251 struct archive_info arch
;
20252 struct archive_info nested_arch
;
20254 bfd_boolean ret
= TRUE
;
20258 /* The ARCH structure is used to hold information about this archive. */
20259 arch
.file_name
= NULL
;
20261 arch
.index_array
= NULL
;
20262 arch
.sym_table
= NULL
;
20263 arch
.longnames
= NULL
;
20265 /* The NESTED_ARCH structure is used as a single-item cache of information
20266 about a nested archive (when members of a thin archive reside within
20267 another regular archive file). */
20268 nested_arch
.file_name
= NULL
;
20269 nested_arch
.file
= NULL
;
20270 nested_arch
.index_array
= NULL
;
20271 nested_arch
.sym_table
= NULL
;
20272 nested_arch
.longnames
= NULL
;
20274 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20275 filedata
->file_size
, is_thin_archive
,
20276 do_archive_index
) != 0)
20282 if (do_archive_index
)
20284 if (arch
.sym_table
== NULL
)
20285 error (_("%s: unable to dump the index as none was found\n"),
20286 filedata
->file_name
);
20289 unsigned long i
, l
;
20290 unsigned long current_pos
;
20292 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20293 "in the symbol table)\n"),
20294 filedata
->file_name
, (unsigned long) arch
.index_num
,
20297 current_pos
= ftell (filedata
->handle
);
20299 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20302 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20305 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20308 if (member_name
!= NULL
)
20310 char * qualified_name
20311 = make_qualified_name (&arch
, &nested_arch
,
20314 if (qualified_name
!= NULL
)
20316 printf (_("Contents of binary %s at offset "),
20318 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20320 free (qualified_name
);
20322 free (member_name
);
20326 if (l
>= arch
.sym_size
)
20328 error (_("%s: end of the symbol table reached "
20329 "before the end of the index\n"),
20330 filedata
->file_name
);
20334 /* PR 17531: file: 0b6630b2. */
20335 printf ("\t%.*s\n",
20336 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20337 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20340 if (arch
.uses_64bit_indices
)
20345 if (l
< arch
.sym_size
)
20347 error (ngettext ("%s: %ld byte remains in the symbol table, "
20348 "but without corresponding entries in "
20349 "the index table\n",
20350 "%s: %ld bytes remain in the symbol table, "
20351 "but without corresponding entries in "
20352 "the index table\n",
20353 arch
.sym_size
- l
),
20354 filedata
->file_name
, arch
.sym_size
- l
);
20358 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20360 error (_("%s: failed to seek back to start of object files "
20361 "in the archive\n"),
20362 filedata
->file_name
);
20368 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20369 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20370 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20371 && !do_section_groups
&& !do_dyn_syms
)
20373 ret
= TRUE
; /* Archive index only. */
20382 char * qualified_name
;
20384 /* Read the next archive header. */
20385 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20387 error (_("%s: failed to seek to next archive header\n"),
20392 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20393 if (got
!= sizeof arch
.arhdr
)
20397 /* PR 24049 - we cannot use filedata->file_name as this will
20398 have already been freed. */
20399 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20404 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20406 error (_("%s: did not find a valid archive header\n"),
20412 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20414 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20415 if (archive_file_size
& 01)
20416 ++archive_file_size
;
20418 name
= get_archive_member_name (&arch
, &nested_arch
);
20421 error (_("%s: bad archive file name\n"), arch
.file_name
);
20425 namelen
= strlen (name
);
20427 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20428 if (qualified_name
== NULL
)
20430 error (_("%s: bad archive file name\n"), arch
.file_name
);
20436 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20438 /* This is a proxy for an external member of a thin archive. */
20439 Filedata
* member_filedata
;
20440 char * member_file_name
= adjust_relative_path
20441 (filedata
->file_name
, name
, namelen
);
20444 if (member_file_name
== NULL
)
20446 free (qualified_name
);
20451 member_filedata
= open_file (member_file_name
);
20452 if (member_filedata
== NULL
)
20454 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20455 free (member_file_name
);
20456 free (qualified_name
);
20461 archive_file_offset
= arch
.nested_member_origin
;
20462 member_filedata
->file_name
= qualified_name
;
20464 if (! process_object (member_filedata
))
20467 close_file (member_filedata
);
20468 free (member_file_name
);
20470 else if (is_thin_archive
)
20472 Filedata thin_filedata
;
20474 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20476 /* PR 15140: Allow for corrupt thin archives. */
20477 if (nested_arch
.file
== NULL
)
20479 error (_("%s: contains corrupt thin archive: %s\n"),
20480 qualified_name
, name
);
20481 free (qualified_name
);
20488 /* This is a proxy for a member of a nested archive. */
20489 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20491 /* The nested archive file will have been opened and setup by
20492 get_archive_member_name. */
20493 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20495 error (_("%s: failed to seek to archive member.\n"),
20496 nested_arch
.file_name
);
20497 free (qualified_name
);
20502 thin_filedata
.handle
= nested_arch
.file
;
20503 thin_filedata
.file_name
= qualified_name
;
20505 if (! process_object (& thin_filedata
))
20511 archive_file_offset
= arch
.next_arhdr_offset
;
20512 filedata
->file_name
= qualified_name
;
20513 if (! process_object (filedata
))
20515 arch
.next_arhdr_offset
+= archive_file_size
;
20516 /* Stop looping with "negative" archive_file_size. */
20517 if (arch
.next_arhdr_offset
< archive_file_size
)
20518 arch
.next_arhdr_offset
= -1ul;
20521 free (qualified_name
);
20525 if (nested_arch
.file
!= NULL
)
20526 fclose (nested_arch
.file
);
20527 release_archive (&nested_arch
);
20528 release_archive (&arch
);
20534 process_file (char * file_name
)
20536 Filedata
* filedata
= NULL
;
20537 struct stat statbuf
;
20538 char armag
[SARMAG
];
20539 bfd_boolean ret
= TRUE
;
20541 if (stat (file_name
, &statbuf
) < 0)
20543 if (errno
== ENOENT
)
20544 error (_("'%s': No such file\n"), file_name
);
20546 error (_("Could not locate '%s'. System error message: %s\n"),
20547 file_name
, strerror (errno
));
20551 if (! S_ISREG (statbuf
.st_mode
))
20553 error (_("'%s' is not an ordinary file\n"), file_name
);
20557 filedata
= calloc (1, sizeof * filedata
);
20558 if (filedata
== NULL
)
20560 error (_("Out of memory allocating file data structure\n"));
20564 filedata
->file_name
= file_name
;
20565 filedata
->handle
= fopen (file_name
, "rb");
20566 if (filedata
->handle
== NULL
)
20568 error (_("Input file '%s' is not readable.\n"), file_name
);
20573 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20575 error (_("%s: Failed to read file's magic number\n"), file_name
);
20576 fclose (filedata
->handle
);
20581 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20583 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20585 if (! process_archive (filedata
, FALSE
))
20588 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20590 if ( ! process_archive (filedata
, TRUE
))
20595 if (do_archive_index
)
20596 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20599 rewind (filedata
->handle
);
20600 archive_file_size
= archive_file_offset
= 0;
20602 if (! process_object (filedata
))
20606 fclose (filedata
->handle
);
20607 free (filedata
->section_headers
);
20608 free (filedata
->program_headers
);
20609 free (filedata
->string_table
);
20610 free (filedata
->dump_sects
);
20613 free (ba_cache
.strtab
);
20614 ba_cache
.strtab
= NULL
;
20615 free (ba_cache
.symtab
);
20616 ba_cache
.symtab
= NULL
;
20617 ba_cache
.filedata
= NULL
;
20622 #ifdef SUPPORT_DISASSEMBLY
20623 /* Needed by the i386 disassembler. For extra credit, someone could
20624 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20628 print_address (unsigned int addr
, FILE * outfile
)
20630 fprintf (outfile
,"0x%8.8x", addr
);
20633 /* Needed by the i386 disassembler. */
20636 db_task_printsym (unsigned int addr
)
20638 print_address (addr
, stderr
);
20643 main (int argc
, char ** argv
)
20647 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20648 setlocale (LC_MESSAGES
, "");
20650 #if defined (HAVE_SETLOCALE)
20651 setlocale (LC_CTYPE
, "");
20653 bindtextdomain (PACKAGE
, LOCALEDIR
);
20654 textdomain (PACKAGE
);
20656 expandargv (&argc
, &argv
);
20658 cmdline
.file_name
= "<cmdline>";
20659 parse_args (& cmdline
, argc
, argv
);
20661 if (optind
< (argc
- 1))
20663 else if (optind
>= argc
)
20665 warn (_("Nothing to do.\n"));
20670 while (optind
< argc
)
20671 if (! process_file (argv
[optind
++]))
20674 if (cmdline
.dump_sects
!= NULL
)
20675 free (cmdline
.dump_sects
);
20677 free (dump_ctf_symtab_name
);
20678 free (dump_ctf_strtab_name
);
20679 free (dump_ctf_parent_name
);
20681 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;