1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
3 Copyright (C) 2019-2020 Advanced Micro Devices, Inc. All rights reserved.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
53 /* Define BFD64 here, even if our default architecture is 32 bit ELF
54 as this will allow us to read in and parse 64bit and 32bit ELF files.
55 Only do this if we believe that the compiler can support a 64 bit
56 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
96 #include "elf/amdgcn.h"
100 #include "elf/bfin.h"
101 #include "elf/cr16.h"
102 #include "elf/cris.h"
104 #include "elf/csky.h"
105 #include "elf/d10v.h"
106 #include "elf/d30v.h"
109 #include "elf/epiphany.h"
110 #include "elf/fr30.h"
112 #include "elf/ft32.h"
114 #include "elf/hppa.h"
115 #include "elf/i386.h"
116 #include "elf/i370.h"
117 #include "elf/i860.h"
118 #include "elf/i960.h"
119 #include "elf/ia64.h"
120 #include "elf/ip2k.h"
121 #include "elf/lm32.h"
122 #include "elf/iq2000.h"
123 #include "elf/m32c.h"
124 #include "elf/m32r.h"
125 #include "elf/m68k.h"
126 #include "elf/m68hc11.h"
127 #include "elf/s12z.h"
128 #include "elf/mcore.h"
130 #include "elf/metag.h"
131 #include "elf/microblaze.h"
132 #include "elf/mips.h"
133 #include "elf/mmix.h"
134 #include "elf/mn10200.h"
135 #include "elf/mn10300.h"
136 #include "elf/moxie.h"
138 #include "elf/msp430.h"
139 #include "elf/nds32.h"
141 #include "elf/nios2.h"
142 #include "elf/or1k.h"
145 #include "elf/ppc64.h"
147 #include "elf/riscv.h"
148 #include "elf/rl78.h"
150 #include "elf/s390.h"
151 #include "elf/score.h"
153 #include "elf/sparc.h"
155 #include "elf/tic6x.h"
156 #include "elf/tilegx.h"
157 #include "elf/tilepro.h"
158 #include "elf/v850.h"
160 #include "elf/visium.h"
161 #include "elf/wasm32.h"
162 #include "elf/x86-64.h"
163 #include "elf/xc16x.h"
164 #include "elf/xgate.h"
165 #include "elf/xstormy16.h"
166 #include "elf/xtensa.h"
170 #include "libiberty.h"
171 #include "safe-ctype.h"
172 #include "filenames.h"
175 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
178 typedef struct elf_section_list
180 Elf_Internal_Shdr
* hdr
;
181 struct elf_section_list
* next
;
184 /* Flag bits indicating particular types of dump. */
185 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
186 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
187 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
188 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
189 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
190 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
192 typedef unsigned char dump_type
;
194 /* A linked list of the section names for which dumps were requested. */
195 struct dump_list_entry
199 struct dump_list_entry
* next
;
202 typedef struct filedata
204 const char * file_name
;
206 bfd_size_type file_size
;
207 Elf_Internal_Ehdr file_header
;
208 Elf_Internal_Shdr
* section_headers
;
209 Elf_Internal_Phdr
* program_headers
;
211 unsigned long string_table_length
;
212 /* A dynamic array of flags indicating for which sections a dump of
213 some kind has been requested. It is reset on a per-object file
214 basis and then initialised from the cmdline_dump_sects array,
215 the results of interpreting the -w switch, and the
216 dump_sects_byname list. */
217 dump_type
* dump_sects
;
218 unsigned int num_dump_sects
;
221 char * program_name
= "readelf";
223 static unsigned long archive_file_offset
;
224 static unsigned long archive_file_size
;
225 static unsigned long dynamic_addr
;
226 static bfd_size_type dynamic_size
;
227 static size_t dynamic_nent
;
228 static char * dynamic_strings
;
229 static unsigned long dynamic_strings_length
;
230 static unsigned long num_dynamic_syms
;
231 static Elf_Internal_Sym
* dynamic_symbols
;
232 static Elf_Internal_Syminfo
* dynamic_syminfo
;
233 static unsigned long dynamic_syminfo_offset
;
234 static unsigned int dynamic_syminfo_nent
;
235 static char program_interpreter
[PATH_MAX
];
236 static bfd_vma dynamic_info
[DT_ENCODING
];
237 static bfd_vma dynamic_info_DT_GNU_HASH
;
238 static bfd_vma dynamic_info_DT_MIPS_XHASH
;
239 static bfd_vma version_info
[16];
240 static Elf_Internal_Dyn
* dynamic_section
;
241 static elf_section_list
* symtab_shndx_list
;
242 static bfd_boolean show_name
= FALSE
;
243 static bfd_boolean do_dynamic
= FALSE
;
244 static bfd_boolean do_syms
= FALSE
;
245 static bfd_boolean do_dyn_syms
= FALSE
;
246 static bfd_boolean do_reloc
= FALSE
;
247 static bfd_boolean do_sections
= FALSE
;
248 static bfd_boolean do_section_groups
= FALSE
;
249 static bfd_boolean do_section_details
= FALSE
;
250 static bfd_boolean do_segments
= FALSE
;
251 static bfd_boolean do_unwind
= FALSE
;
252 static bfd_boolean do_using_dynamic
= FALSE
;
253 static bfd_boolean do_header
= FALSE
;
254 static bfd_boolean do_dump
= FALSE
;
255 static bfd_boolean do_version
= FALSE
;
256 static bfd_boolean do_histogram
= FALSE
;
257 static bfd_boolean do_debugging
= FALSE
;
258 static bfd_boolean do_ctf
= FALSE
;
259 static bfd_boolean do_arch
= FALSE
;
260 static bfd_boolean do_notes
= FALSE
;
261 static bfd_boolean do_archive_index
= FALSE
;
262 static bfd_boolean is_32bit_elf
= FALSE
;
263 static bfd_boolean decompress_dumps
= FALSE
;
265 static char *dump_ctf_parent_name
;
266 static char *dump_ctf_symtab_name
;
267 static char *dump_ctf_strtab_name
;
271 struct group_list
* next
;
272 unsigned int section_index
;
277 struct group_list
* root
;
278 unsigned int group_index
;
281 static size_t group_count
;
282 static struct group
* section_groups
;
283 static struct group
** section_headers_groups
;
285 /* A dynamic array of flags indicating for which sections a dump
286 has been requested via command line switches. */
287 static Filedata cmdline
;
289 static struct dump_list_entry
* dump_sects_byname
;
291 /* How to print a vma value. */
292 typedef enum print_mode
304 /* Versioned symbol info. */
305 enum versioned_symbol_info
312 static const char * get_symbol_version_string
313 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
314 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
318 #define SECTION_NAME(X) \
319 ((X) == NULL ? _("<none>") \
320 : filedata->string_table == NULL ? _("<no-strings>") \
321 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
322 : filedata->string_table + (X)->sh_name))
324 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
326 #define GET_ELF_SYMBOLS(file, section, sym_count) \
327 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
328 : get_64bit_elf_symbols (file, section, sym_count))
330 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
331 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
332 already been called and verified that the string exists. */
333 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
335 #define REMOVE_ARCH_BITS(ADDR) \
338 if (filedata->file_header.e_machine == EM_ARM) \
343 /* Get the correct GNU hash section name. */
344 #define GNU_HASH_SECTION_NAME \
345 dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
347 /* Print a BFD_VMA to an internal buffer, for use in error messages.
348 BFD_FMA_FMT can't be used in translated strings. */
351 bfd_vmatoa (char *fmtch
, bfd_vma value
)
353 /* bfd_vmatoa is used more then once in a printf call for output.
354 Cycle through an array of buffers. */
355 static int buf_pos
= 0;
356 static struct bfd_vmatoa_buf
363 ret
= buf
[buf_pos
++].place
;
364 buf_pos
%= ARRAY_SIZE (buf
);
366 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
367 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
371 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
372 OFFSET + the offset of the current archive member, if we are examining an
373 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
374 allocate a buffer using malloc and fill that. In either case return the
375 pointer to the start of the retrieved data or NULL if something went wrong.
376 If something does go wrong and REASON is not NULL then emit an error
377 message using REASON as part of the context. */
380 get_data (void * var
,
382 unsigned long offset
,
388 bfd_size_type amt
= size
* nmemb
;
390 if (size
== 0 || nmemb
== 0)
393 /* If the size_t type is smaller than the bfd_size_type, eg because
394 you are building a 32-bit tool on a 64-bit host, then make sure
395 that when the sizes are cast to (size_t) no information is lost. */
396 if ((size_t) size
!= size
397 || (size_t) nmemb
!= nmemb
398 || (size_t) amt
!= amt
)
401 error (_("Size truncation prevents reading %s"
402 " elements of size %s for %s\n"),
403 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
407 /* Check for size overflow. */
408 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
411 error (_("Size overflow prevents reading %s"
412 " elements of size %s for %s\n"),
413 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
417 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
418 attempting to allocate memory when the read is bound to fail. */
419 if (archive_file_offset
> filedata
->file_size
420 || offset
> filedata
->file_size
- archive_file_offset
421 || amt
> filedata
->file_size
- archive_file_offset
- offset
)
424 error (_("Reading %s bytes extends past end of file for %s\n"),
425 bfd_vmatoa ("u", amt
), reason
);
429 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
432 error (_("Unable to seek to 0x%lx for %s\n"),
433 archive_file_offset
+ offset
, reason
);
440 /* + 1 so that we can '\0' terminate invalid string table sections. */
441 mvar
= malloc ((size_t) amt
+ 1);
446 error (_("Out of memory allocating %s bytes for %s\n"),
447 bfd_vmatoa ("u", amt
), reason
);
451 ((char *) mvar
)[amt
] = '\0';
454 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
457 error (_("Unable to read in %s bytes of %s\n"),
458 bfd_vmatoa ("u", amt
), reason
);
467 /* Print a VMA value in the MODE specified.
468 Returns the number of characters displayed. */
471 print_vma (bfd_vma vma
, print_mode mode
)
483 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
490 return printf ("%5" BFD_VMA_FMT
"d", vma
);
496 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
499 return printf ("%" BFD_VMA_FMT
"d", vma
);
502 return printf ("%" BFD_VMA_FMT
"u", vma
);
505 /* FIXME: Report unrecognised mode ? */
510 /* Display a symbol on stdout. Handles the display of control characters and
511 multibye characters (assuming the host environment supports them).
513 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
515 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
516 padding as necessary.
518 Returns the number of emitted characters. */
521 print_symbol (signed int width
, const char *symbol
)
523 bfd_boolean extra_padding
= FALSE
;
524 signed int num_printed
= 0;
525 #ifdef HAVE_MBSTATE_T
528 unsigned int width_remaining
;
532 /* Keep the width positive. This helps the code below. */
534 extra_padding
= TRUE
;
540 /* Set the remaining width to a very large value.
541 This simplifies the code below. */
542 width_remaining
= INT_MAX
;
544 width_remaining
= width
;
546 #ifdef HAVE_MBSTATE_T
547 /* Initialise the multibyte conversion state. */
548 memset (& state
, 0, sizeof (state
));
551 while (width_remaining
)
554 const char c
= *symbol
++;
559 /* Do not print control characters directly as they can affect terminal
560 settings. Such characters usually appear in the names generated
561 by the assembler for local labels. */
564 if (width_remaining
< 2)
567 printf ("^%c", c
+ 0x40);
568 width_remaining
-= 2;
571 else if (ISPRINT (c
))
579 #ifdef HAVE_MBSTATE_T
582 /* Let printf do the hard work of displaying multibyte characters. */
583 printf ("%.1s", symbol
- 1);
587 #ifdef HAVE_MBSTATE_T
588 /* Try to find out how many bytes made up the character that was
589 just printed. Advance the symbol pointer past the bytes that
591 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
595 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
600 if (extra_padding
&& num_printed
< width
)
602 /* Fill in the remaining spaces. */
603 printf ("%-*s", width
- num_printed
, " ");
610 /* Returns a pointer to a static buffer containing a printable version of
611 the given section's name. Like print_symbol, except that it does not try
612 to print multibyte characters, it just interprets them as hex values. */
615 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
617 #define MAX_PRINT_SEC_NAME_LEN 128
618 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
619 const char * name
= SECTION_NAME (sec
);
620 char * buf
= sec_name_buf
;
622 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
624 while ((c
= * name
++) != 0)
635 else if (ISPRINT (c
))
642 static char hex
[17] = "0123456789ABCDEF";
647 * buf
++ = hex
[(c
& 0xf0) >> 4];
648 * buf
++ = hex
[c
& 0x0f];
662 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
664 if (ndx
>= filedata
->file_header
.e_shnum
)
665 return _("<corrupt>");
667 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
670 /* Return a pointer to section NAME, or NULL if no such section exists. */
672 static Elf_Internal_Shdr
*
673 find_section (Filedata
* filedata
, const char * name
)
677 if (filedata
->section_headers
== NULL
)
680 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
681 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
682 return filedata
->section_headers
+ i
;
687 /* Return a pointer to a section containing ADDR, or NULL if no such
690 static Elf_Internal_Shdr
*
691 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
695 if (filedata
->section_headers
== NULL
)
698 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
700 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
702 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
709 static Elf_Internal_Shdr
*
710 find_section_by_type (Filedata
* filedata
, unsigned int type
)
714 if (filedata
->section_headers
== NULL
)
717 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
719 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
721 if (sec
->sh_type
== type
)
728 /* Return a pointer to section NAME, or NULL if no such section exists,
729 restricted to the list of sections given in SET. */
731 static Elf_Internal_Shdr
*
732 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
736 if (filedata
->section_headers
== NULL
)
741 while ((i
= *set
++) > 0)
743 /* See PR 21156 for a reproducer. */
744 if (i
>= filedata
->file_header
.e_shnum
)
745 continue; /* FIXME: Should we issue an error message ? */
747 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
748 return filedata
->section_headers
+ i
;
752 return find_section (filedata
, name
);
755 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
756 This OS has so many departures from the ELF standard that we test it at
759 static inline bfd_boolean
760 is_ia64_vms (Filedata
* filedata
)
762 return filedata
->file_header
.e_machine
== EM_IA_64
763 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
766 /* Guess the relocation size commonly used by the specific machines. */
769 guess_is_rela (unsigned int e_machine
)
773 /* Targets that use REL relocations. */
790 /* Targets that use RELA relocations. */
794 case EM_ADAPTEVA_EPIPHANY
:
796 case EM_ALTERA_NIOS2
:
799 case EM_ARC_COMPACT2
:
820 case EM_LATTICEMICO32
:
829 case EM_CYGNUS_MN10200
:
831 case EM_CYGNUS_MN10300
:
867 case EM_MICROBLAZE_OLD
:
889 warn (_("Don't know about relocations on this machine architecture\n"));
894 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
895 Returns TRUE upon success, FALSE otherwise. If successful then a
896 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
897 and the number of relocs loaded is placed in *NRELASP. It is the caller's
898 responsibility to free the allocated buffer. */
901 slurp_rela_relocs (Filedata
* filedata
,
902 unsigned long rel_offset
,
903 unsigned long rel_size
,
904 Elf_Internal_Rela
** relasp
,
905 unsigned long * nrelasp
)
907 Elf_Internal_Rela
* relas
;
913 Elf32_External_Rela
* erelas
;
915 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
916 rel_size
, _("32-bit relocation data"));
920 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
922 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
923 sizeof (Elf_Internal_Rela
));
928 error (_("out of memory parsing relocs\n"));
932 for (i
= 0; i
< nrelas
; i
++)
934 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
935 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
936 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
943 Elf64_External_Rela
* erelas
;
945 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
946 rel_size
, _("64-bit relocation data"));
950 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
952 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
953 sizeof (Elf_Internal_Rela
));
958 error (_("out of memory parsing relocs\n"));
962 for (i
= 0; i
< nrelas
; i
++)
964 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
965 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
966 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
968 /* The #ifdef BFD64 below is to prevent a compile time
969 warning. We know that if we do not have a 64 bit data
970 type that we will never execute this code anyway. */
972 if (filedata
->file_header
.e_machine
== EM_MIPS
973 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
975 /* In little-endian objects, r_info isn't really a
976 64-bit little-endian value: it has a 32-bit
977 little-endian symbol index followed by four
978 individual byte fields. Reorder INFO
980 bfd_vma inf
= relas
[i
].r_info
;
981 inf
= (((inf
& 0xffffffff) << 32)
982 | ((inf
>> 56) & 0xff)
983 | ((inf
>> 40) & 0xff00)
984 | ((inf
>> 24) & 0xff0000)
985 | ((inf
>> 8) & 0xff000000));
986 relas
[i
].r_info
= inf
;
999 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1000 Returns TRUE upon success, FALSE otherwise. If successful then a
1001 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1002 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1003 responsibility to free the allocated buffer. */
1006 slurp_rel_relocs (Filedata
* filedata
,
1007 unsigned long rel_offset
,
1008 unsigned long rel_size
,
1009 Elf_Internal_Rela
** relsp
,
1010 unsigned long * nrelsp
)
1012 Elf_Internal_Rela
* rels
;
1018 Elf32_External_Rel
* erels
;
1020 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1021 rel_size
, _("32-bit relocation data"));
1025 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1027 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1032 error (_("out of memory parsing relocs\n"));
1036 for (i
= 0; i
< nrels
; i
++)
1038 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1039 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1040 rels
[i
].r_addend
= 0;
1047 Elf64_External_Rel
* erels
;
1049 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1050 rel_size
, _("64-bit relocation data"));
1054 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1056 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1061 error (_("out of memory parsing relocs\n"));
1065 for (i
= 0; i
< nrels
; i
++)
1067 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1068 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1069 rels
[i
].r_addend
= 0;
1071 /* The #ifdef BFD64 below is to prevent a compile time
1072 warning. We know that if we do not have a 64 bit data
1073 type that we will never execute this code anyway. */
1075 if (filedata
->file_header
.e_machine
== EM_MIPS
1076 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1078 /* In little-endian objects, r_info isn't really a
1079 64-bit little-endian value: it has a 32-bit
1080 little-endian symbol index followed by four
1081 individual byte fields. Reorder INFO
1083 bfd_vma inf
= rels
[i
].r_info
;
1084 inf
= (((inf
& 0xffffffff) << 32)
1085 | ((inf
>> 56) & 0xff)
1086 | ((inf
>> 40) & 0xff00)
1087 | ((inf
>> 24) & 0xff0000)
1088 | ((inf
>> 8) & 0xff000000));
1089 rels
[i
].r_info
= inf
;
1102 /* Returns the reloc type extracted from the reloc info field. */
1105 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1108 return ELF32_R_TYPE (reloc_info
);
1110 switch (filedata
->file_header
.e_machine
)
1113 /* Note: We assume that reloc_info has already been adjusted for us. */
1114 return ELF64_MIPS_R_TYPE (reloc_info
);
1117 return ELF64_R_TYPE_ID (reloc_info
);
1120 return ELF64_R_TYPE (reloc_info
);
1124 /* Return the symbol index extracted from the reloc info field. */
1127 get_reloc_symindex (bfd_vma reloc_info
)
1129 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1132 static inline bfd_boolean
1133 uses_msp430x_relocs (Filedata
* filedata
)
1136 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1137 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1138 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1139 /* TI compiler uses ELFOSABI_NONE. */
1140 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1143 /* Display the contents of the relocation data found at the specified
1147 dump_relocations (Filedata
* filedata
,
1148 unsigned long rel_offset
,
1149 unsigned long rel_size
,
1150 Elf_Internal_Sym
* symtab
,
1151 unsigned long nsyms
,
1153 unsigned long strtablen
,
1155 bfd_boolean is_dynsym
)
1158 Elf_Internal_Rela
* rels
;
1159 bfd_boolean res
= TRUE
;
1161 if (is_rela
== UNKNOWN
)
1162 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1166 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1171 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1180 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1182 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1187 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1189 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1197 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1199 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1204 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1206 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1210 for (i
= 0; i
< rel_size
; i
++)
1215 bfd_vma symtab_index
;
1218 offset
= rels
[i
].r_offset
;
1219 inf
= rels
[i
].r_info
;
1221 type
= get_reloc_type (filedata
, inf
);
1222 symtab_index
= get_reloc_symindex (inf
);
1226 printf ("%8.8lx %8.8lx ",
1227 (unsigned long) offset
& 0xffffffff,
1228 (unsigned long) inf
& 0xffffffff);
1232 #if BFD_HOST_64BIT_LONG
1234 ? "%16.16lx %16.16lx "
1235 : "%12.12lx %12.12lx ",
1237 #elif BFD_HOST_64BIT_LONG_LONG
1240 ? "%16.16llx %16.16llx "
1241 : "%12.12llx %12.12llx ",
1245 ? "%16.16I64x %16.16I64x "
1246 : "%12.12I64x %12.12I64x ",
1251 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1252 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1253 _bfd_int64_high (offset
),
1254 _bfd_int64_low (offset
),
1255 _bfd_int64_high (inf
),
1256 _bfd_int64_low (inf
));
1260 switch (filedata
->file_header
.e_machine
)
1267 rtype
= elf_aarch64_reloc_type (type
);
1271 case EM_CYGNUS_M32R
:
1272 rtype
= elf_m32r_reloc_type (type
);
1277 rtype
= elf_i386_reloc_type (type
);
1282 rtype
= elf_m68hc11_reloc_type (type
);
1286 rtype
= elf_s12z_reloc_type (type
);
1290 rtype
= elf_m68k_reloc_type (type
);
1294 rtype
= elf_i960_reloc_type (type
);
1299 rtype
= elf_avr_reloc_type (type
);
1302 case EM_OLD_SPARCV9
:
1303 case EM_SPARC32PLUS
:
1306 rtype
= elf_sparc_reloc_type (type
);
1310 rtype
= elf_spu_reloc_type (type
);
1314 rtype
= v800_reloc_type (type
);
1317 case EM_CYGNUS_V850
:
1318 rtype
= v850_reloc_type (type
);
1322 case EM_CYGNUS_D10V
:
1323 rtype
= elf_d10v_reloc_type (type
);
1327 case EM_CYGNUS_D30V
:
1328 rtype
= elf_d30v_reloc_type (type
);
1332 rtype
= elf_dlx_reloc_type (type
);
1336 rtype
= elf_sh_reloc_type (type
);
1340 case EM_CYGNUS_MN10300
:
1341 rtype
= elf_mn10300_reloc_type (type
);
1345 case EM_CYGNUS_MN10200
:
1346 rtype
= elf_mn10200_reloc_type (type
);
1350 case EM_CYGNUS_FR30
:
1351 rtype
= elf_fr30_reloc_type (type
);
1355 rtype
= elf_frv_reloc_type (type
);
1359 rtype
= elf_csky_reloc_type (type
);
1363 rtype
= elf_ft32_reloc_type (type
);
1367 rtype
= elf_mcore_reloc_type (type
);
1371 rtype
= elf_mmix_reloc_type (type
);
1375 rtype
= elf_moxie_reloc_type (type
);
1379 if (uses_msp430x_relocs (filedata
))
1381 rtype
= elf_msp430x_reloc_type (type
);
1386 rtype
= elf_msp430_reloc_type (type
);
1390 rtype
= elf_nds32_reloc_type (type
);
1394 rtype
= elf_ppc_reloc_type (type
);
1398 rtype
= elf_ppc64_reloc_type (type
);
1402 case EM_MIPS_RS3_LE
:
1403 rtype
= elf_mips_reloc_type (type
);
1407 rtype
= elf_riscv_reloc_type (type
);
1411 rtype
= elf_alpha_reloc_type (type
);
1415 rtype
= elf_arm_reloc_type (type
);
1419 case EM_ARC_COMPACT
:
1420 case EM_ARC_COMPACT2
:
1421 rtype
= elf_arc_reloc_type (type
);
1425 rtype
= elf_hppa_reloc_type (type
);
1431 rtype
= elf_h8_reloc_type (type
);
1435 rtype
= elf_or1k_reloc_type (type
);
1440 rtype
= elf_pj_reloc_type (type
);
1443 rtype
= elf_ia64_reloc_type (type
);
1447 rtype
= elf_cris_reloc_type (type
);
1451 rtype
= elf_i860_reloc_type (type
);
1457 rtype
= elf_x86_64_reloc_type (type
);
1461 rtype
= i370_reloc_type (type
);
1466 rtype
= elf_s390_reloc_type (type
);
1470 rtype
= elf_score_reloc_type (type
);
1474 rtype
= elf_xstormy16_reloc_type (type
);
1478 rtype
= elf_crx_reloc_type (type
);
1482 rtype
= elf_vax_reloc_type (type
);
1486 rtype
= elf_visium_reloc_type (type
);
1490 rtype
= elf_bpf_reloc_type (type
);
1493 case EM_ADAPTEVA_EPIPHANY
:
1494 rtype
= elf_epiphany_reloc_type (type
);
1499 rtype
= elf_ip2k_reloc_type (type
);
1503 rtype
= elf_iq2000_reloc_type (type
);
1508 rtype
= elf_xtensa_reloc_type (type
);
1511 case EM_LATTICEMICO32
:
1512 rtype
= elf_lm32_reloc_type (type
);
1517 rtype
= elf_m32c_reloc_type (type
);
1521 rtype
= elf_mt_reloc_type (type
);
1525 rtype
= elf_bfin_reloc_type (type
);
1529 rtype
= elf_mep_reloc_type (type
);
1533 rtype
= elf_cr16_reloc_type (type
);
1537 case EM_MICROBLAZE_OLD
:
1538 rtype
= elf_microblaze_reloc_type (type
);
1542 rtype
= elf_rl78_reloc_type (type
);
1546 rtype
= elf_rx_reloc_type (type
);
1550 rtype
= elf_metag_reloc_type (type
);
1555 rtype
= elf_xc16x_reloc_type (type
);
1559 rtype
= elf_tic6x_reloc_type (type
);
1563 rtype
= elf_tilegx_reloc_type (type
);
1567 rtype
= elf_tilepro_reloc_type (type
);
1570 case EM_WEBASSEMBLY
:
1571 rtype
= elf_wasm32_reloc_type (type
);
1575 rtype
= elf_xgate_reloc_type (type
);
1578 case EM_ALTERA_NIOS2
:
1579 rtype
= elf_nios2_reloc_type (type
);
1583 rtype
= elf_pru_reloc_type (type
);
1587 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1588 rtype
= elf_nfp3200_reloc_type (type
);
1590 rtype
= elf_nfp_reloc_type (type
);
1594 rtype
= elf_z80_reloc_type (type
);
1598 rtype
= elf_amdgcn_reloc_type (type
);
1603 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1605 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1607 if (filedata
->file_header
.e_machine
== EM_ALPHA
1609 && streq (rtype
, "R_ALPHA_LITUSE")
1612 switch (rels
[i
].r_addend
)
1614 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1615 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1616 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1617 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1618 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1619 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1620 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1621 default: rtype
= NULL
;
1625 printf (" (%s)", rtype
);
1629 printf (_("<unknown addend: %lx>"),
1630 (unsigned long) rels
[i
].r_addend
);
1634 else if (symtab_index
)
1636 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1638 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1643 Elf_Internal_Sym
* psym
;
1644 const char * version_string
;
1645 enum versioned_symbol_info sym_info
;
1646 unsigned short vna_other
;
1648 psym
= symtab
+ symtab_index
;
1651 = get_symbol_version_string (filedata
, is_dynsym
,
1660 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1664 unsigned int width
= is_32bit_elf
? 8 : 14;
1666 /* Relocations against GNU_IFUNC symbols do not use the value
1667 of the symbol as the address to relocate against. Instead
1668 they invoke the function named by the symbol and use its
1669 result as the address for relocation.
1671 To indicate this to the user, do not display the value of
1672 the symbol in the "Symbols's Value" field. Instead show
1673 its name followed by () as a hint that the symbol is
1677 || psym
->st_name
== 0
1678 || psym
->st_name
>= strtablen
)
1681 name
= strtab
+ psym
->st_name
;
1683 len
= print_symbol (width
, name
);
1685 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1687 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1691 print_vma (psym
->st_value
, LONG_HEX
);
1693 printf (is_32bit_elf
? " " : " ");
1696 if (psym
->st_name
== 0)
1698 const char * sec_name
= "<null>";
1701 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1703 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1704 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1705 else if (psym
->st_shndx
== SHN_ABS
)
1707 else if (psym
->st_shndx
== SHN_COMMON
)
1708 sec_name
= "COMMON";
1709 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1710 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1711 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1712 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1713 sec_name
= "SCOMMON";
1714 else if (filedata
->file_header
.e_machine
== EM_MIPS
1715 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1716 sec_name
= "SUNDEF";
1717 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1718 || filedata
->file_header
.e_machine
== EM_L1OM
1719 || filedata
->file_header
.e_machine
== EM_K1OM
)
1720 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1721 sec_name
= "LARGE_COMMON";
1722 else if (filedata
->file_header
.e_machine
== EM_IA_64
1723 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1724 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1725 sec_name
= "ANSI_COM";
1726 else if (is_ia64_vms (filedata
)
1727 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1728 sec_name
= "VMS_SYMVEC";
1731 sprintf (name_buf
, "<section 0x%x>",
1732 (unsigned int) psym
->st_shndx
);
1733 sec_name
= name_buf
;
1736 print_symbol (22, sec_name
);
1738 else if (strtab
== NULL
)
1739 printf (_("<string table index: %3ld>"), psym
->st_name
);
1740 else if (psym
->st_name
>= strtablen
)
1742 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1747 print_symbol (22, strtab
+ psym
->st_name
);
1749 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1755 bfd_vma off
= rels
[i
].r_addend
;
1757 if ((bfd_signed_vma
) off
< 0)
1758 printf (" - %" BFD_VMA_FMT
"x", - off
);
1760 printf (" + %" BFD_VMA_FMT
"x", off
);
1766 bfd_vma off
= rels
[i
].r_addend
;
1768 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1769 if ((bfd_signed_vma
) off
< 0)
1770 printf ("-%" BFD_VMA_FMT
"x", - off
);
1772 printf ("%" BFD_VMA_FMT
"x", off
);
1775 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1777 && streq (rtype
, "R_SPARC_OLO10"))
1778 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1783 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1785 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1786 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1787 const char * rtype2
= elf_mips_reloc_type (type2
);
1788 const char * rtype3
= elf_mips_reloc_type (type3
);
1790 printf (" Type2: ");
1793 printf (_("unrecognized: %-7lx"),
1794 (unsigned long) type2
& 0xffffffff);
1796 printf ("%-17.17s", rtype2
);
1798 printf ("\n Type3: ");
1801 printf (_("unrecognized: %-7lx"),
1802 (unsigned long) type3
& 0xffffffff);
1804 printf ("%-17.17s", rtype3
);
1817 get_aarch64_dynamic_type (unsigned long type
)
1821 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1822 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1823 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1830 get_mips_dynamic_type (unsigned long type
)
1834 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1835 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1836 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1837 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1838 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1839 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1840 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1841 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1842 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1843 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1844 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1845 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1846 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1847 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1848 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1849 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1850 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1851 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1852 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1853 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1854 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1855 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1856 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1857 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1858 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1859 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1860 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1861 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1862 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1863 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1864 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1865 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1866 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1867 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1868 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1869 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1870 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1871 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1872 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1873 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1874 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1875 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1876 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1877 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1878 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1879 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1880 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1887 get_sparc64_dynamic_type (unsigned long type
)
1891 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1898 get_ppc_dynamic_type (unsigned long type
)
1902 case DT_PPC_GOT
: return "PPC_GOT";
1903 case DT_PPC_OPT
: return "PPC_OPT";
1910 get_ppc64_dynamic_type (unsigned long type
)
1914 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1915 case DT_PPC64_OPD
: return "PPC64_OPD";
1916 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1917 case DT_PPC64_OPT
: return "PPC64_OPT";
1924 get_parisc_dynamic_type (unsigned long type
)
1928 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1929 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1930 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1931 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1932 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1933 case DT_HP_PREINIT
: return "HP_PREINIT";
1934 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1935 case DT_HP_NEEDED
: return "HP_NEEDED";
1936 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1937 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1938 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1939 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1940 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1941 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1942 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1943 case DT_HP_FILTERED
: return "HP_FILTERED";
1944 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1945 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1946 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1947 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1948 case DT_PLT
: return "PLT";
1949 case DT_PLT_SIZE
: return "PLT_SIZE";
1950 case DT_DLT
: return "DLT";
1951 case DT_DLT_SIZE
: return "DLT_SIZE";
1958 get_ia64_dynamic_type (unsigned long type
)
1962 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1963 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1964 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1965 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1966 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1967 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1968 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1969 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1970 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1971 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1972 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1973 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1974 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1975 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1976 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1977 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1978 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1979 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1980 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1981 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1982 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1983 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1984 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1985 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1986 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1987 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1988 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1989 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1990 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1991 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1992 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1999 get_solaris_section_type (unsigned long type
)
2003 case 0x6fffffee: return "SUNW_ancillary";
2004 case 0x6fffffef: return "SUNW_capchain";
2005 case 0x6ffffff0: return "SUNW_capinfo";
2006 case 0x6ffffff1: return "SUNW_symsort";
2007 case 0x6ffffff2: return "SUNW_tlssort";
2008 case 0x6ffffff3: return "SUNW_LDYNSYM";
2009 case 0x6ffffff4: return "SUNW_dof";
2010 case 0x6ffffff5: return "SUNW_cap";
2011 case 0x6ffffff6: return "SUNW_SIGNATURE";
2012 case 0x6ffffff7: return "SUNW_ANNOTATE";
2013 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2014 case 0x6ffffff9: return "SUNW_DEBUG";
2015 case 0x6ffffffa: return "SUNW_move";
2016 case 0x6ffffffb: return "SUNW_COMDAT";
2017 case 0x6ffffffc: return "SUNW_syminfo";
2018 case 0x6ffffffd: return "SUNW_verdef";
2019 case 0x6ffffffe: return "SUNW_verneed";
2020 case 0x6fffffff: return "SUNW_versym";
2021 case 0x70000000: return "SPARC_GOTDATA";
2022 default: return NULL
;
2027 get_alpha_dynamic_type (unsigned long type
)
2031 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2032 default: return NULL
;
2037 get_score_dynamic_type (unsigned long type
)
2041 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2042 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2043 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2044 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2045 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2046 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2047 default: return NULL
;
2052 get_tic6x_dynamic_type (unsigned long type
)
2056 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2057 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2058 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2059 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2060 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2061 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2062 default: return NULL
;
2067 get_nios2_dynamic_type (unsigned long type
)
2071 case DT_NIOS2_GP
: return "NIOS2_GP";
2072 default: return NULL
;
2077 get_solaris_dynamic_type (unsigned long type
)
2081 case 0x6000000d: return "SUNW_AUXILIARY";
2082 case 0x6000000e: return "SUNW_RTLDINF";
2083 case 0x6000000f: return "SUNW_FILTER";
2084 case 0x60000010: return "SUNW_CAP";
2085 case 0x60000011: return "SUNW_SYMTAB";
2086 case 0x60000012: return "SUNW_SYMSZ";
2087 case 0x60000013: return "SUNW_SORTENT";
2088 case 0x60000014: return "SUNW_SYMSORT";
2089 case 0x60000015: return "SUNW_SYMSORTSZ";
2090 case 0x60000016: return "SUNW_TLSSORT";
2091 case 0x60000017: return "SUNW_TLSSORTSZ";
2092 case 0x60000018: return "SUNW_CAPINFO";
2093 case 0x60000019: return "SUNW_STRPAD";
2094 case 0x6000001a: return "SUNW_CAPCHAIN";
2095 case 0x6000001b: return "SUNW_LDMACH";
2096 case 0x6000001d: return "SUNW_CAPCHAINENT";
2097 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2098 case 0x60000021: return "SUNW_PARENT";
2099 case 0x60000023: return "SUNW_ASLR";
2100 case 0x60000025: return "SUNW_RELAX";
2101 case 0x60000029: return "SUNW_NXHEAP";
2102 case 0x6000002b: return "SUNW_NXSTACK";
2104 case 0x70000001: return "SPARC_REGISTER";
2105 case 0x7ffffffd: return "AUXILIARY";
2106 case 0x7ffffffe: return "USED";
2107 case 0x7fffffff: return "FILTER";
2109 default: return NULL
;
2114 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2116 static char buff
[64];
2120 case DT_NULL
: return "NULL";
2121 case DT_NEEDED
: return "NEEDED";
2122 case DT_PLTRELSZ
: return "PLTRELSZ";
2123 case DT_PLTGOT
: return "PLTGOT";
2124 case DT_HASH
: return "HASH";
2125 case DT_STRTAB
: return "STRTAB";
2126 case DT_SYMTAB
: return "SYMTAB";
2127 case DT_RELA
: return "RELA";
2128 case DT_RELASZ
: return "RELASZ";
2129 case DT_RELAENT
: return "RELAENT";
2130 case DT_STRSZ
: return "STRSZ";
2131 case DT_SYMENT
: return "SYMENT";
2132 case DT_INIT
: return "INIT";
2133 case DT_FINI
: return "FINI";
2134 case DT_SONAME
: return "SONAME";
2135 case DT_RPATH
: return "RPATH";
2136 case DT_SYMBOLIC
: return "SYMBOLIC";
2137 case DT_REL
: return "REL";
2138 case DT_RELSZ
: return "RELSZ";
2139 case DT_RELENT
: return "RELENT";
2140 case DT_PLTREL
: return "PLTREL";
2141 case DT_DEBUG
: return "DEBUG";
2142 case DT_TEXTREL
: return "TEXTREL";
2143 case DT_JMPREL
: return "JMPREL";
2144 case DT_BIND_NOW
: return "BIND_NOW";
2145 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2146 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2147 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2148 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2149 case DT_RUNPATH
: return "RUNPATH";
2150 case DT_FLAGS
: return "FLAGS";
2152 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2153 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2154 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2156 case DT_CHECKSUM
: return "CHECKSUM";
2157 case DT_PLTPADSZ
: return "PLTPADSZ";
2158 case DT_MOVEENT
: return "MOVEENT";
2159 case DT_MOVESZ
: return "MOVESZ";
2160 case DT_FEATURE
: return "FEATURE";
2161 case DT_POSFLAG_1
: return "POSFLAG_1";
2162 case DT_SYMINSZ
: return "SYMINSZ";
2163 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2165 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2166 case DT_CONFIG
: return "CONFIG";
2167 case DT_DEPAUDIT
: return "DEPAUDIT";
2168 case DT_AUDIT
: return "AUDIT";
2169 case DT_PLTPAD
: return "PLTPAD";
2170 case DT_MOVETAB
: return "MOVETAB";
2171 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2173 case DT_VERSYM
: return "VERSYM";
2175 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2176 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2177 case DT_RELACOUNT
: return "RELACOUNT";
2178 case DT_RELCOUNT
: return "RELCOUNT";
2179 case DT_FLAGS_1
: return "FLAGS_1";
2180 case DT_VERDEF
: return "VERDEF";
2181 case DT_VERDEFNUM
: return "VERDEFNUM";
2182 case DT_VERNEED
: return "VERNEED";
2183 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2185 case DT_AUXILIARY
: return "AUXILIARY";
2186 case DT_USED
: return "USED";
2187 case DT_FILTER
: return "FILTER";
2189 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2190 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2191 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2192 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2193 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2194 case DT_GNU_HASH
: return "GNU_HASH";
2197 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2199 const char * result
;
2201 switch (filedata
->file_header
.e_machine
)
2204 result
= get_aarch64_dynamic_type (type
);
2207 case EM_MIPS_RS3_LE
:
2208 result
= get_mips_dynamic_type (type
);
2211 result
= get_sparc64_dynamic_type (type
);
2214 result
= get_ppc_dynamic_type (type
);
2217 result
= get_ppc64_dynamic_type (type
);
2220 result
= get_ia64_dynamic_type (type
);
2223 result
= get_alpha_dynamic_type (type
);
2226 result
= get_score_dynamic_type (type
);
2229 result
= get_tic6x_dynamic_type (type
);
2231 case EM_ALTERA_NIOS2
:
2232 result
= get_nios2_dynamic_type (type
);
2235 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2236 result
= get_solaris_dynamic_type (type
);
2245 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2247 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2248 || (filedata
->file_header
.e_machine
== EM_PARISC
2249 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2251 const char * result
;
2253 switch (filedata
->file_header
.e_machine
)
2256 result
= get_parisc_dynamic_type (type
);
2259 result
= get_ia64_dynamic_type (type
);
2262 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2263 result
= get_solaris_dynamic_type (type
);
2272 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2276 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2283 get_file_type (unsigned e_type
)
2285 static char buff
[32];
2289 case ET_NONE
: return _("NONE (None)");
2290 case ET_REL
: return _("REL (Relocatable file)");
2291 case ET_EXEC
: return _("EXEC (Executable file)");
2292 case ET_DYN
: return _("DYN (Shared object file)");
2293 case ET_CORE
: return _("CORE (Core file)");
2296 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2297 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2298 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2299 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2301 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2307 get_machine_name (unsigned e_machine
)
2309 static char buff
[64]; /* XXX */
2313 /* Please keep this switch table sorted by increasing EM_ value. */
2315 case EM_NONE
: return _("None");
2316 case EM_M32
: return "WE32100";
2317 case EM_SPARC
: return "Sparc";
2318 case EM_386
: return "Intel 80386";
2319 case EM_68K
: return "MC68000";
2320 case EM_88K
: return "MC88000";
2321 case EM_IAMCU
: return "Intel MCU";
2322 case EM_860
: return "Intel 80860";
2323 case EM_MIPS
: return "MIPS R3000";
2324 case EM_S370
: return "IBM System/370";
2326 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2327 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2328 case EM_PARISC
: return "HPPA";
2329 case EM_VPP550
: return "Fujitsu VPP500";
2330 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2331 case EM_960
: return "Intel 80960";
2332 case EM_PPC
: return "PowerPC";
2334 case EM_PPC64
: return "PowerPC64";
2336 case EM_S390
: return "IBM S/390";
2337 case EM_SPU
: return "SPU";
2339 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2340 case EM_FR20
: return "Fujitsu FR20";
2341 case EM_RH32
: return "TRW RH32";
2342 case EM_MCORE
: return "MCORE";
2344 case EM_ARM
: return "ARM";
2345 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2346 case EM_SH
: return "Renesas / SuperH SH";
2347 case EM_SPARCV9
: return "Sparc v9";
2348 case EM_TRICORE
: return "Siemens Tricore";
2349 case EM_ARC
: return "ARC";
2350 case EM_H8_300
: return "Renesas H8/300";
2351 case EM_H8_300H
: return "Renesas H8/300H";
2352 case EM_H8S
: return "Renesas H8S";
2353 case EM_H8_500
: return "Renesas H8/500";
2355 case EM_IA_64
: return "Intel IA-64";
2356 case EM_MIPS_X
: return "Stanford MIPS-X";
2357 case EM_COLDFIRE
: return "Motorola Coldfire";
2358 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2359 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2360 case EM_PCP
: return "Siemens PCP";
2361 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2362 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2363 case EM_STARCORE
: return "Motorola Star*Core processor";
2364 case EM_ME16
: return "Toyota ME16 processor";
2366 case EM_ST100
: return "STMicroelectronics ST100 processor";
2367 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2368 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2369 case EM_PDSP
: return "Sony DSP processor";
2370 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2371 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2372 case EM_FX66
: return "Siemens FX66 microcontroller";
2373 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2374 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2375 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2377 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2378 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2379 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2380 case EM_SVX
: return "Silicon Graphics SVx";
2381 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2382 case EM_VAX
: return "Digital VAX";
2383 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2384 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2385 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2386 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2388 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2389 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2390 case EM_PRISM
: return "Vitesse Prism";
2392 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2393 case EM_CYGNUS_FR30
:
2394 case EM_FR30
: return "Fujitsu FR30";
2395 case EM_CYGNUS_D10V
:
2396 case EM_D10V
: return "d10v";
2397 case EM_CYGNUS_D30V
:
2398 case EM_D30V
: return "d30v";
2399 case EM_CYGNUS_V850
:
2400 case EM_V850
: return "Renesas V850";
2401 case EM_CYGNUS_M32R
:
2402 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2403 case EM_CYGNUS_MN10300
:
2404 case EM_MN10300
: return "mn10300";
2406 case EM_CYGNUS_MN10200
:
2407 case EM_MN10200
: return "mn10200";
2408 case EM_PJ
: return "picoJava";
2409 case EM_OR1K
: return "OpenRISC 1000";
2410 case EM_ARC_COMPACT
: return "ARCompact";
2412 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2413 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2414 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2415 case EM_NS32K
: return "National Semiconductor 32000 series";
2416 case EM_TPC
: return "Tenor Network TPC processor";
2417 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2419 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2421 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2422 case EM_MAX
: return "MAX Processor";
2423 case EM_CR
: return "National Semiconductor CompactRISC";
2424 case EM_F2MC16
: return "Fujitsu F2MC16";
2425 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2426 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2427 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2428 case EM_SEP
: return "Sharp embedded microprocessor";
2429 case EM_ARCA
: return "Arca RISC microprocessor";
2431 case EM_UNICORE
: return "Unicore";
2432 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2433 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2434 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2435 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2436 case EM_XGATE
: return "Motorola XGATE embedded processor";
2438 case EM_XC16X
: return "Infineon Technologies xc16x";
2439 case EM_M16C
: return "Renesas M16C series microprocessors";
2440 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2441 case EM_CE
: return "Freescale Communication Engine RISC core";
2443 case EM_M32C
: return "Renesas M32c";
2445 case EM_TSK3000
: return "Altium TSK3000 core";
2446 case EM_RS08
: return "Freescale RS08 embedded processor";
2447 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2448 case EM_SCORE
: return "SUNPLUS S+Core";
2449 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2450 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2451 case EM_LATTICEMICO32
: return "Lattice Mico32";
2452 case EM_SE_C17
: return "Seiko Epson C17 family";
2454 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2455 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2456 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2457 case EM_TI_PRU
: return "TI PRU I/O processor";
2459 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2460 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2461 case EM_R32C
: return "Renesas R32C series microprocessors";
2462 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2463 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2464 case EM_8051
: return "Intel 8051 and variants";
2465 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2466 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2467 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2468 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2470 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2471 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2472 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2473 case EM_RX
: return "Renesas RX";
2474 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2475 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2476 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2479 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2480 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2481 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2483 case EM_L1OM
: return "Intel L1OM";
2484 case EM_K1OM
: return "Intel K1OM";
2485 case EM_INTEL182
: return "Intel (reserved)";
2486 case EM_AARCH64
: return "AArch64";
2487 case EM_ARM184
: return "ARM (reserved)";
2488 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2489 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2490 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2491 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2493 case EM_CUDA
: return "NVIDIA CUDA architecture";
2494 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2495 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2496 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2497 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2498 case EM_ARC_COMPACT2
: return "ARCv2";
2499 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2500 case EM_RL78
: return "Renesas RL78";
2501 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2502 case EM_78K0R
: return "Renesas 78K0R";
2504 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2505 case EM_BA1
: return "Beyond BA1 CPU architecture";
2506 case EM_BA2
: return "Beyond BA2 CPU architecture";
2507 case EM_XCORE
: return "XMOS xCORE processor family";
2508 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2510 case EM_KM32
: return "KM211 KM32 32-bit processor";
2511 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2512 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2513 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2514 case EM_KVARC
: return "KM211 KVARC processor";
2515 case EM_CDP
: return "Paneve CDP architecture family";
2516 case EM_COGE
: return "Cognitive Smart Memory Processor";
2517 case EM_COOL
: return "Bluechip Systems CoolEngine";
2518 case EM_NORC
: return "Nanoradio Optimized RISC";
2519 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2521 case EM_Z80
: return "Zilog Z80";
2522 case EM_VISIUM
: return "CDS VISIUMcore processor";
2523 case EM_FT32
: return "FTDI Chip FT32";
2524 case EM_MOXIE
: return "Moxie";
2525 case EM_AMDGPU
: return "AMD GPU";
2526 case EM_RISCV
: return "RISC-V";
2527 case EM_LANAI
: return "Lanai 32-bit processor";
2528 case EM_BPF
: return "Linux BPF";
2529 case EM_NFP
: return "Netronome Flow Processor";
2531 /* Large numbers... */
2532 case EM_MT
: return "Morpho Techologies MT processor";
2533 case EM_ALPHA
: return "Alpha";
2534 case EM_WEBASSEMBLY
: return "Web Assembly";
2535 case EM_DLX
: return "OpenDLX";
2536 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2537 case EM_IQ2000
: return "Vitesse IQ2000";
2539 case EM_NIOS32
: return "Altera Nios";
2540 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2541 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2542 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2543 case EM_S12Z
: return "Freescale S12Z";
2544 case EM_CSKY
: return "C-SKY";
2547 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2553 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2555 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2556 other compilers don't a specific architecture type in the e_flags, and
2557 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2558 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2561 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2562 but also sets a specific architecture type in the e_flags field.
2564 However, when decoding the flags we don't worry if we see an
2565 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2566 ARCEM architecture type. */
2568 switch (e_flags
& EF_ARC_MACH_MSK
)
2570 /* We only expect these to occur for EM_ARC_COMPACT2. */
2571 case EF_ARC_CPU_ARCV2EM
:
2572 strcat (buf
, ", ARC EM");
2574 case EF_ARC_CPU_ARCV2HS
:
2575 strcat (buf
, ", ARC HS");
2578 /* We only expect these to occur for EM_ARC_COMPACT. */
2579 case E_ARC_MACH_ARC600
:
2580 strcat (buf
, ", ARC600");
2582 case E_ARC_MACH_ARC601
:
2583 strcat (buf
, ", ARC601");
2585 case E_ARC_MACH_ARC700
:
2586 strcat (buf
, ", ARC700");
2589 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2590 new ELF with new architecture being read by an old version of
2591 readelf, or (c) An ELF built with non-GNU compiler that does not
2592 set the architecture in the e_flags. */
2594 if (e_machine
== EM_ARC_COMPACT
)
2595 strcat (buf
, ", Unknown ARCompact");
2597 strcat (buf
, ", Unknown ARC");
2601 switch (e_flags
& EF_ARC_OSABI_MSK
)
2603 case E_ARC_OSABI_ORIG
:
2604 strcat (buf
, ", (ABI:legacy)");
2606 case E_ARC_OSABI_V2
:
2607 strcat (buf
, ", (ABI:v2)");
2609 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2610 case E_ARC_OSABI_V3
:
2611 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2613 case E_ARC_OSABI_V4
:
2614 strcat (buf
, ", v4 ABI");
2617 strcat (buf
, ", unrecognised ARC OSABI flag");
2623 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2626 bfd_boolean unknown
= FALSE
;
2628 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2629 e_flags
&= ~ EF_ARM_EABIMASK
;
2631 /* Handle "generic" ARM flags. */
2632 if (e_flags
& EF_ARM_RELEXEC
)
2634 strcat (buf
, ", relocatable executable");
2635 e_flags
&= ~ EF_ARM_RELEXEC
;
2638 if (e_flags
& EF_ARM_PIC
)
2640 strcat (buf
, ", position independent");
2641 e_flags
&= ~ EF_ARM_PIC
;
2644 /* Now handle EABI specific flags. */
2648 strcat (buf
, ", <unrecognized EABI>");
2653 case EF_ARM_EABI_VER1
:
2654 strcat (buf
, ", Version1 EABI");
2659 /* Process flags one bit at a time. */
2660 flag
= e_flags
& - e_flags
;
2665 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2666 strcat (buf
, ", sorted symbol tables");
2676 case EF_ARM_EABI_VER2
:
2677 strcat (buf
, ", Version2 EABI");
2682 /* Process flags one bit at a time. */
2683 flag
= e_flags
& - e_flags
;
2688 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2689 strcat (buf
, ", sorted symbol tables");
2692 case EF_ARM_DYNSYMSUSESEGIDX
:
2693 strcat (buf
, ", dynamic symbols use segment index");
2696 case EF_ARM_MAPSYMSFIRST
:
2697 strcat (buf
, ", mapping symbols precede others");
2707 case EF_ARM_EABI_VER3
:
2708 strcat (buf
, ", Version3 EABI");
2711 case EF_ARM_EABI_VER4
:
2712 strcat (buf
, ", Version4 EABI");
2717 /* Process flags one bit at a time. */
2718 flag
= e_flags
& - e_flags
;
2724 strcat (buf
, ", BE8");
2728 strcat (buf
, ", LE8");
2738 case EF_ARM_EABI_VER5
:
2739 strcat (buf
, ", Version5 EABI");
2744 /* Process flags one bit at a time. */
2745 flag
= e_flags
& - e_flags
;
2751 strcat (buf
, ", BE8");
2755 strcat (buf
, ", LE8");
2758 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2759 strcat (buf
, ", soft-float ABI");
2762 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2763 strcat (buf
, ", hard-float ABI");
2773 case EF_ARM_EABI_UNKNOWN
:
2774 strcat (buf
, ", GNU EABI");
2779 /* Process flags one bit at a time. */
2780 flag
= e_flags
& - e_flags
;
2785 case EF_ARM_INTERWORK
:
2786 strcat (buf
, ", interworking enabled");
2789 case EF_ARM_APCS_26
:
2790 strcat (buf
, ", uses APCS/26");
2793 case EF_ARM_APCS_FLOAT
:
2794 strcat (buf
, ", uses APCS/float");
2798 strcat (buf
, ", position independent");
2802 strcat (buf
, ", 8 bit structure alignment");
2805 case EF_ARM_NEW_ABI
:
2806 strcat (buf
, ", uses new ABI");
2809 case EF_ARM_OLD_ABI
:
2810 strcat (buf
, ", uses old ABI");
2813 case EF_ARM_SOFT_FLOAT
:
2814 strcat (buf
, ", software FP");
2817 case EF_ARM_VFP_FLOAT
:
2818 strcat (buf
, ", VFP");
2821 case EF_ARM_MAVERICK_FLOAT
:
2822 strcat (buf
, ", Maverick FP");
2833 strcat (buf
,_(", <unknown>"));
2837 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2839 --size
; /* Leave space for null terminator. */
2841 switch (e_flags
& EF_AVR_MACH
)
2843 case E_AVR_MACH_AVR1
:
2844 strncat (buf
, ", avr:1", size
);
2846 case E_AVR_MACH_AVR2
:
2847 strncat (buf
, ", avr:2", size
);
2849 case E_AVR_MACH_AVR25
:
2850 strncat (buf
, ", avr:25", size
);
2852 case E_AVR_MACH_AVR3
:
2853 strncat (buf
, ", avr:3", size
);
2855 case E_AVR_MACH_AVR31
:
2856 strncat (buf
, ", avr:31", size
);
2858 case E_AVR_MACH_AVR35
:
2859 strncat (buf
, ", avr:35", size
);
2861 case E_AVR_MACH_AVR4
:
2862 strncat (buf
, ", avr:4", size
);
2864 case E_AVR_MACH_AVR5
:
2865 strncat (buf
, ", avr:5", size
);
2867 case E_AVR_MACH_AVR51
:
2868 strncat (buf
, ", avr:51", size
);
2870 case E_AVR_MACH_AVR6
:
2871 strncat (buf
, ", avr:6", size
);
2873 case E_AVR_MACH_AVRTINY
:
2874 strncat (buf
, ", avr:100", size
);
2876 case E_AVR_MACH_XMEGA1
:
2877 strncat (buf
, ", avr:101", size
);
2879 case E_AVR_MACH_XMEGA2
:
2880 strncat (buf
, ", avr:102", size
);
2882 case E_AVR_MACH_XMEGA3
:
2883 strncat (buf
, ", avr:103", size
);
2885 case E_AVR_MACH_XMEGA4
:
2886 strncat (buf
, ", avr:104", size
);
2888 case E_AVR_MACH_XMEGA5
:
2889 strncat (buf
, ", avr:105", size
);
2891 case E_AVR_MACH_XMEGA6
:
2892 strncat (buf
, ", avr:106", size
);
2894 case E_AVR_MACH_XMEGA7
:
2895 strncat (buf
, ", avr:107", size
);
2898 strncat (buf
, ", avr:<unknown>", size
);
2902 size
-= strlen (buf
);
2903 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2904 strncat (buf
, ", link-relax", size
);
2908 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2914 bfd_boolean has_fpu
= FALSE
;
2917 static const char *ABI_STRINGS
[] =
2919 "ABI v0", /* use r5 as return register; only used in N1213HC */
2920 "ABI v1", /* use r0 as return register */
2921 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2922 "ABI v2fp", /* for FPU */
2926 static const char *VER_STRINGS
[] =
2928 "Andes ELF V1.3 or older",
2932 static const char *ARCH_STRINGS
[] =
2941 abi
= EF_NDS_ABI
& e_flags
;
2942 arch
= EF_NDS_ARCH
& e_flags
;
2943 config
= EF_NDS_INST
& e_flags
;
2944 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2946 memset (buf
, 0, size
);
2953 case E_NDS_ABI_V2FP
:
2954 case E_NDS_ABI_AABI
:
2955 case E_NDS_ABI_V2FP_PLUS
:
2956 /* In case there are holes in the array. */
2957 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2961 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2967 case E_NDS32_ELF_VER_1_2
:
2968 case E_NDS32_ELF_VER_1_3
:
2969 case E_NDS32_ELF_VER_1_4
:
2970 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2974 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2978 if (E_NDS_ABI_V0
== abi
)
2980 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2981 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2982 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2983 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2989 case E_NDS_ARCH_STAR_V1_0
:
2990 case E_NDS_ARCH_STAR_V2_0
:
2991 case E_NDS_ARCH_STAR_V3_0
:
2992 case E_NDS_ARCH_STAR_V3_M
:
2993 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2997 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2998 /* ARCH version determines how the e_flags are interpreted.
2999 If it is unknown, we cannot proceed. */
3003 /* Newer ABI; Now handle architecture specific flags. */
3004 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3006 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3007 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3009 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3010 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3012 if (config
& E_NDS32_HAS_DIV_INST
)
3013 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3015 if (config
& E_NDS32_HAS_16BIT_INST
)
3016 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3020 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3022 if (version
<= E_NDS32_ELF_VER_1_3
)
3023 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3025 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3028 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3029 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3031 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3032 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3034 if (config
& E_NDS32_HAS_16BIT_INST
)
3036 if (version
<= E_NDS32_ELF_VER_1_3
)
3037 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3039 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3043 if (config
& E_NDS32_HAS_EXT_INST
)
3044 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3046 if (config
& E_NDS32_HAS_EXT2_INST
)
3047 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3049 if (config
& E_NDS32_HAS_FPU_INST
)
3052 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3055 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3058 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3061 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3064 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3069 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3071 case E_NDS32_FPU_REG_8SP_4DP
:
3072 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3074 case E_NDS32_FPU_REG_16SP_8DP
:
3075 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3077 case E_NDS32_FPU_REG_32SP_16DP
:
3078 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3080 case E_NDS32_FPU_REG_32SP_32DP
:
3081 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3086 if (config
& E_NDS32_HAS_AUDIO_INST
)
3087 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3089 if (config
& E_NDS32_HAS_STRING_INST
)
3090 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3092 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3093 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3095 if (config
& E_NDS32_HAS_VIDEO_INST
)
3097 if (version
<= E_NDS32_ELF_VER_1_3
)
3098 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3100 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3103 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3104 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3106 if (config
& E_NDS32_HAS_L2C_INST
)
3107 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3111 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3113 static char buf
[1024];
3124 case EM_ARC_COMPACT2
:
3125 case EM_ARC_COMPACT
:
3126 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3130 decode_ARM_machine_flags (e_flags
, buf
);
3134 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3138 if (e_flags
& EF_BFIN_PIC
)
3139 strcat (buf
, ", PIC");
3141 if (e_flags
& EF_BFIN_FDPIC
)
3142 strcat (buf
, ", FDPIC");
3144 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3145 strcat (buf
, ", code in L1");
3147 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3148 strcat (buf
, ", data in L1");
3153 switch (e_flags
& EF_FRV_CPU_MASK
)
3155 case EF_FRV_CPU_GENERIC
:
3159 strcat (buf
, ", fr???");
3162 case EF_FRV_CPU_FR300
:
3163 strcat (buf
, ", fr300");
3166 case EF_FRV_CPU_FR400
:
3167 strcat (buf
, ", fr400");
3169 case EF_FRV_CPU_FR405
:
3170 strcat (buf
, ", fr405");
3173 case EF_FRV_CPU_FR450
:
3174 strcat (buf
, ", fr450");
3177 case EF_FRV_CPU_FR500
:
3178 strcat (buf
, ", fr500");
3180 case EF_FRV_CPU_FR550
:
3181 strcat (buf
, ", fr550");
3184 case EF_FRV_CPU_SIMPLE
:
3185 strcat (buf
, ", simple");
3187 case EF_FRV_CPU_TOMCAT
:
3188 strcat (buf
, ", tomcat");
3194 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3195 strcat (buf
, ", m68000");
3196 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3197 strcat (buf
, ", cpu32");
3198 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3199 strcat (buf
, ", fido_a");
3202 char const * isa
= _("unknown");
3203 char const * mac
= _("unknown mac");
3204 char const * additional
= NULL
;
3206 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3208 case EF_M68K_CF_ISA_A_NODIV
:
3210 additional
= ", nodiv";
3212 case EF_M68K_CF_ISA_A
:
3215 case EF_M68K_CF_ISA_A_PLUS
:
3218 case EF_M68K_CF_ISA_B_NOUSP
:
3220 additional
= ", nousp";
3222 case EF_M68K_CF_ISA_B
:
3225 case EF_M68K_CF_ISA_C
:
3228 case EF_M68K_CF_ISA_C_NODIV
:
3230 additional
= ", nodiv";
3233 strcat (buf
, ", cf, isa ");
3236 strcat (buf
, additional
);
3237 if (e_flags
& EF_M68K_CF_FLOAT
)
3238 strcat (buf
, ", float");
3239 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3244 case EF_M68K_CF_MAC
:
3247 case EF_M68K_CF_EMAC
:
3250 case EF_M68K_CF_EMAC_B
:
3263 switch (e_flags
& EF_AMDGPU_MACH
)
3265 case EF_AMDGPU_MACH_AMDGCN_GFX801
: strcat (buf
, ", gfx801"); break;
3266 case EF_AMDGPU_MACH_AMDGCN_GFX802
: strcat (buf
, ", gfx802"); break;
3267 case EF_AMDGPU_MACH_AMDGCN_GFX803
: strcat (buf
, ", gfx803"); break;
3268 case EF_AMDGPU_MACH_AMDGCN_GFX810
: strcat (buf
, ", gfx810"); break;
3269 case EF_AMDGPU_MACH_AMDGCN_GFX900
: strcat (buf
, ", gfx900"); break;
3270 case EF_AMDGPU_MACH_AMDGCN_GFX902
: strcat (buf
, ", gfx902"); break;
3271 case EF_AMDGPU_MACH_AMDGCN_GFX904
: strcat (buf
, ", gfx904"); break;
3272 case EF_AMDGPU_MACH_AMDGCN_GFX906
: strcat (buf
, ", gfx906"); break;
3273 case EF_AMDGPU_MACH_AMDGCN_GFX908
: strcat (buf
, ", gfx908"); break;
3274 case EF_AMDGPU_MACH_AMDGCN_GFX909
: strcat (buf
, ", gfx909"); break;
3275 default: strcat (buf
, _(", <unknown AMDGPU gpu type>")); break;
3278 if (e_flags
& ~ EF_AMDGPU_MACH
)
3279 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3280 e_flags
& ~ EF_AMDGPU_MACH
);
3284 switch (e_flags
& EF_MEP_CPU_MASK
)
3286 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3287 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3288 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3289 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3290 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3291 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3292 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3295 switch (e_flags
& EF_MEP_COP_MASK
)
3297 case EF_MEP_COP_NONE
: break;
3298 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3299 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3300 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3301 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3302 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3305 if (e_flags
& EF_MEP_LIBRARY
)
3306 strcat (buf
, ", Built for Library");
3308 if (e_flags
& EF_MEP_INDEX_MASK
)
3309 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3310 e_flags
& EF_MEP_INDEX_MASK
);
3312 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3313 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3314 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3318 if (e_flags
& EF_PPC_EMB
)
3319 strcat (buf
, ", emb");
3321 if (e_flags
& EF_PPC_RELOCATABLE
)
3322 strcat (buf
, _(", relocatable"));
3324 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3325 strcat (buf
, _(", relocatable-lib"));
3329 if (e_flags
& EF_PPC64_ABI
)
3331 char abi
[] = ", abiv0";
3333 abi
[6] += e_flags
& EF_PPC64_ABI
;
3339 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3340 strcat (buf
, ", RH850 ABI");
3342 if (e_flags
& EF_V800_850E3
)
3343 strcat (buf
, ", V3 architecture");
3345 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3346 strcat (buf
, ", FPU not used");
3348 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3349 strcat (buf
, ", regmode: COMMON");
3351 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3352 strcat (buf
, ", r4 not used");
3354 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3355 strcat (buf
, ", r30 not used");
3357 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3358 strcat (buf
, ", r5 not used");
3360 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3361 strcat (buf
, ", r2 not used");
3363 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3365 switch (e_flags
& - e_flags
)
3367 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3368 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3369 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3370 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3371 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3372 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3373 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3374 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3375 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3376 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3377 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3378 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3385 case EM_CYGNUS_V850
:
3386 switch (e_flags
& EF_V850_ARCH
)
3388 case E_V850E3V5_ARCH
:
3389 strcat (buf
, ", v850e3v5");
3391 case E_V850E2V3_ARCH
:
3392 strcat (buf
, ", v850e2v3");
3395 strcat (buf
, ", v850e2");
3398 strcat (buf
, ", v850e1");
3401 strcat (buf
, ", v850e");
3404 strcat (buf
, ", v850");
3407 strcat (buf
, _(", unknown v850 architecture variant"));
3413 case EM_CYGNUS_M32R
:
3414 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3415 strcat (buf
, ", m32r");
3419 case EM_MIPS_RS3_LE
:
3420 if (e_flags
& EF_MIPS_NOREORDER
)
3421 strcat (buf
, ", noreorder");
3423 if (e_flags
& EF_MIPS_PIC
)
3424 strcat (buf
, ", pic");
3426 if (e_flags
& EF_MIPS_CPIC
)
3427 strcat (buf
, ", cpic");
3429 if (e_flags
& EF_MIPS_UCODE
)
3430 strcat (buf
, ", ugen_reserved");
3432 if (e_flags
& EF_MIPS_ABI2
)
3433 strcat (buf
, ", abi2");
3435 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3436 strcat (buf
, ", odk first");
3438 if (e_flags
& EF_MIPS_32BITMODE
)
3439 strcat (buf
, ", 32bitmode");
3441 if (e_flags
& EF_MIPS_NAN2008
)
3442 strcat (buf
, ", nan2008");
3444 if (e_flags
& EF_MIPS_FP64
)
3445 strcat (buf
, ", fp64");
3447 switch ((e_flags
& EF_MIPS_MACH
))
3449 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3450 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3451 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3452 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3453 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3454 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3455 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3456 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3457 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3458 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3459 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3460 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3461 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3462 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3463 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3464 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3465 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3466 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3467 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3468 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3469 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3471 /* We simply ignore the field in this case to avoid confusion:
3472 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3475 default: strcat (buf
, _(", unknown CPU")); break;
3478 switch ((e_flags
& EF_MIPS_ABI
))
3480 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3481 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3482 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3483 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3485 /* We simply ignore the field in this case to avoid confusion:
3486 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3487 This means it is likely to be an o32 file, but not for
3490 default: strcat (buf
, _(", unknown ABI")); break;
3493 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3494 strcat (buf
, ", mdmx");
3496 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3497 strcat (buf
, ", mips16");
3499 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3500 strcat (buf
, ", micromips");
3502 switch ((e_flags
& EF_MIPS_ARCH
))
3504 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3505 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3506 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3507 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3508 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3509 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3510 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3511 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3512 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3513 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3514 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3515 default: strcat (buf
, _(", unknown ISA")); break;
3520 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3524 switch (EF_NFP_MACH (e_flags
))
3526 case E_NFP_MACH_3200
:
3527 strcat (buf
, ", NFP-32xx");
3529 case E_NFP_MACH_6000
:
3530 strcat (buf
, ", NFP-6xxx");
3536 if (e_flags
& EF_RISCV_RVC
)
3537 strcat (buf
, ", RVC");
3539 if (e_flags
& EF_RISCV_RVE
)
3540 strcat (buf
, ", RVE");
3542 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3544 case EF_RISCV_FLOAT_ABI_SOFT
:
3545 strcat (buf
, ", soft-float ABI");
3548 case EF_RISCV_FLOAT_ABI_SINGLE
:
3549 strcat (buf
, ", single-float ABI");
3552 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3553 strcat (buf
, ", double-float ABI");
3556 case EF_RISCV_FLOAT_ABI_QUAD
:
3557 strcat (buf
, ", quad-float ABI");
3563 switch ((e_flags
& EF_SH_MACH_MASK
))
3565 case EF_SH1
: strcat (buf
, ", sh1"); break;
3566 case EF_SH2
: strcat (buf
, ", sh2"); break;
3567 case EF_SH3
: strcat (buf
, ", sh3"); break;
3568 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3569 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3570 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3571 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3572 case EF_SH4
: strcat (buf
, ", sh4"); break;
3573 case EF_SH5
: strcat (buf
, ", sh5"); break;
3574 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3575 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3576 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3577 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3578 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3579 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3580 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3581 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3582 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3583 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3584 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3585 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3586 default: strcat (buf
, _(", unknown ISA")); break;
3589 if (e_flags
& EF_SH_PIC
)
3590 strcat (buf
, ", pic");
3592 if (e_flags
& EF_SH_FDPIC
)
3593 strcat (buf
, ", fdpic");
3597 if (e_flags
& EF_OR1K_NODELAY
)
3598 strcat (buf
, ", no delay");
3602 if (e_flags
& EF_SPARC_32PLUS
)
3603 strcat (buf
, ", v8+");
3605 if (e_flags
& EF_SPARC_SUN_US1
)
3606 strcat (buf
, ", ultrasparcI");
3608 if (e_flags
& EF_SPARC_SUN_US3
)
3609 strcat (buf
, ", ultrasparcIII");
3611 if (e_flags
& EF_SPARC_HAL_R1
)
3612 strcat (buf
, ", halr1");
3614 if (e_flags
& EF_SPARC_LEDATA
)
3615 strcat (buf
, ", ledata");
3617 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3618 strcat (buf
, ", tso");
3620 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3621 strcat (buf
, ", pso");
3623 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3624 strcat (buf
, ", rmo");
3628 switch (e_flags
& EF_PARISC_ARCH
)
3630 case EFA_PARISC_1_0
:
3631 strcpy (buf
, ", PA-RISC 1.0");
3633 case EFA_PARISC_1_1
:
3634 strcpy (buf
, ", PA-RISC 1.1");
3636 case EFA_PARISC_2_0
:
3637 strcpy (buf
, ", PA-RISC 2.0");
3642 if (e_flags
& EF_PARISC_TRAPNIL
)
3643 strcat (buf
, ", trapnil");
3644 if (e_flags
& EF_PARISC_EXT
)
3645 strcat (buf
, ", ext");
3646 if (e_flags
& EF_PARISC_LSB
)
3647 strcat (buf
, ", lsb");
3648 if (e_flags
& EF_PARISC_WIDE
)
3649 strcat (buf
, ", wide");
3650 if (e_flags
& EF_PARISC_NO_KABP
)
3651 strcat (buf
, ", no kabp");
3652 if (e_flags
& EF_PARISC_LAZYSWAP
)
3653 strcat (buf
, ", lazyswap");
3658 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3659 strcat (buf
, ", new calling convention");
3661 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3662 strcat (buf
, ", gnu calling convention");
3666 if ((e_flags
& EF_IA_64_ABI64
))
3667 strcat (buf
, ", 64-bit");
3669 strcat (buf
, ", 32-bit");
3670 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3671 strcat (buf
, ", reduced fp model");
3672 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3673 strcat (buf
, ", no function descriptors, constant gp");
3674 else if ((e_flags
& EF_IA_64_CONS_GP
))
3675 strcat (buf
, ", constant gp");
3676 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3677 strcat (buf
, ", absolute");
3678 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3680 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3681 strcat (buf
, ", vms_linkages");
3682 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3684 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3686 case EF_IA_64_VMS_COMCOD_WARNING
:
3687 strcat (buf
, ", warning");
3689 case EF_IA_64_VMS_COMCOD_ERROR
:
3690 strcat (buf
, ", error");
3692 case EF_IA_64_VMS_COMCOD_ABORT
:
3693 strcat (buf
, ", abort");
3696 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3697 e_flags
& EF_IA_64_VMS_COMCOD
);
3698 strcat (buf
, ", <unknown>");
3704 if ((e_flags
& EF_VAX_NONPIC
))
3705 strcat (buf
, ", non-PIC");
3706 if ((e_flags
& EF_VAX_DFLOAT
))
3707 strcat (buf
, ", D-Float");
3708 if ((e_flags
& EF_VAX_GFLOAT
))
3709 strcat (buf
, ", G-Float");
3713 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3714 strcat (buf
, ", mcm");
3715 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3716 strcat (buf
, ", mcm24");
3717 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3718 strcat (buf
, ", gr6");
3722 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3724 case E_FLAG_RL78_ANY_CPU
: break;
3725 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3726 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3727 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3729 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3730 strcat (buf
, ", 64-bit doubles");
3734 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3735 strcat (buf
, ", 64-bit doubles");
3736 if (e_flags
& E_FLAG_RX_DSP
)
3737 strcat (buf
, ", dsp");
3738 if (e_flags
& E_FLAG_RX_PID
)
3739 strcat (buf
, ", pid");
3740 if (e_flags
& E_FLAG_RX_ABI
)
3741 strcat (buf
, ", RX ABI");
3742 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3743 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3744 ? ", uses String instructions" : ", bans String instructions");
3745 if (e_flags
& E_FLAG_RX_V2
)
3746 strcat (buf
, ", V2");
3747 if (e_flags
& E_FLAG_RX_V3
)
3748 strcat (buf
, ", V3");
3752 if (e_flags
& EF_S390_HIGH_GPRS
)
3753 strcat (buf
, ", highgprs");
3757 if ((e_flags
& EF_C6000_REL
))
3758 strcat (buf
, ", relocatable module");
3762 strcat (buf
, _(": architecture variant: "));
3763 switch (e_flags
& EF_MSP430_MACH
)
3765 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3766 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3767 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3768 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3769 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3770 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3771 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3772 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3773 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3774 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3775 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3776 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3777 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3778 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3779 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3781 strcat (buf
, _(": unknown")); break;
3784 if (e_flags
& ~ EF_MSP430_MACH
)
3785 strcat (buf
, _(": unknown extra flag bits also present"));
3789 switch (e_flags
& EF_Z80_MACH_MSK
)
3791 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3792 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3793 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3794 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3795 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3796 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3798 strcat (buf
, _(", unknown")); break;
3808 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3810 static char buff
[32];
3814 case ELFOSABI_NONE
: return "UNIX - System V";
3815 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3816 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3817 case ELFOSABI_GNU
: return "UNIX - GNU";
3818 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3819 case ELFOSABI_AIX
: return "UNIX - AIX";
3820 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3821 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3822 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3823 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3824 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3825 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3826 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3827 case ELFOSABI_AROS
: return "AROS";
3828 case ELFOSABI_FENIXOS
: return "FenixOS";
3829 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3830 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3833 switch (filedata
->file_header
.e_machine
)
3838 case ELFOSABI_AMDGPU_HSA
: return "AMD HSA Runtime";
3847 case ELFOSABI_ARM
: return "ARM";
3848 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3859 case ELFOSABI_STANDALONE
: return _("Standalone App");
3868 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3869 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3878 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3884 get_aarch64_segment_type (unsigned long type
)
3888 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3889 default: return NULL
;
3894 get_arm_segment_type (unsigned long type
)
3898 case PT_ARM_EXIDX
: return "EXIDX";
3899 default: return NULL
;
3904 get_s390_segment_type (unsigned long type
)
3908 case PT_S390_PGSTE
: return "S390_PGSTE";
3909 default: return NULL
;
3914 get_mips_segment_type (unsigned long type
)
3918 case PT_MIPS_REGINFO
: return "REGINFO";
3919 case PT_MIPS_RTPROC
: return "RTPROC";
3920 case PT_MIPS_OPTIONS
: return "OPTIONS";
3921 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3922 default: return NULL
;
3927 get_parisc_segment_type (unsigned long type
)
3931 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3932 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3933 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3934 default: return NULL
;
3939 get_ia64_segment_type (unsigned long type
)
3943 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3944 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3945 default: return NULL
;
3950 get_tic6x_segment_type (unsigned long type
)
3954 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3955 default: return NULL
;
3960 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3962 if (e_machine
== EM_PARISC
)
3965 case PT_HP_TLS
: return "HP_TLS";
3966 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3967 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3968 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3969 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3970 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3971 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3972 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3973 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3974 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3975 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3976 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3977 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3978 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3979 case PT_HP_STACK
: return "HP_STACK";
3980 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3981 default: return NULL
;
3984 if (e_machine
== EM_IA_64
)
3987 case PT_HP_TLS
: return "HP_TLS";
3988 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3989 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3990 case PT_IA_64_HP_STACK
: return "HP_STACK";
3991 default: return NULL
;
3998 get_solaris_segment_type (unsigned long type
)
4002 case 0x6464e550: return "PT_SUNW_UNWIND";
4003 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4004 case 0x6ffffff7: return "PT_LOSUNW";
4005 case 0x6ffffffa: return "PT_SUNWBSS";
4006 case 0x6ffffffb: return "PT_SUNWSTACK";
4007 case 0x6ffffffc: return "PT_SUNWDTRACE";
4008 case 0x6ffffffd: return "PT_SUNWCAP";
4009 case 0x6fffffff: return "PT_HISUNW";
4010 default: return NULL
;
4015 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4017 static char buff
[32];
4021 case PT_NULL
: return "NULL";
4022 case PT_LOAD
: return "LOAD";
4023 case PT_DYNAMIC
: return "DYNAMIC";
4024 case PT_INTERP
: return "INTERP";
4025 case PT_NOTE
: return "NOTE";
4026 case PT_SHLIB
: return "SHLIB";
4027 case PT_PHDR
: return "PHDR";
4028 case PT_TLS
: return "TLS";
4029 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4030 case PT_GNU_STACK
: return "GNU_STACK";
4031 case PT_GNU_RELRO
: return "GNU_RELRO";
4032 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4035 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4037 const char * result
;
4039 switch (filedata
->file_header
.e_machine
)
4042 result
= get_aarch64_segment_type (p_type
);
4045 result
= get_arm_segment_type (p_type
);
4048 case EM_MIPS_RS3_LE
:
4049 result
= get_mips_segment_type (p_type
);
4052 result
= get_parisc_segment_type (p_type
);
4055 result
= get_ia64_segment_type (p_type
);
4058 result
= get_tic6x_segment_type (p_type
);
4062 result
= get_s390_segment_type (p_type
);
4072 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4074 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4076 const char * result
= NULL
;
4078 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4081 case ELFOSABI_FREEBSD
:
4082 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4084 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4089 result
= get_hpux_segment_type (p_type
,
4090 filedata
->file_header
.e_machine
);
4092 case ELFOSABI_SOLARIS
:
4093 result
= get_solaris_segment_type (p_type
);
4101 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4104 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4111 get_arc_section_type_name (unsigned int sh_type
)
4115 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4123 get_mips_section_type_name (unsigned int sh_type
)
4127 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4128 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4129 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4130 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4131 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4132 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4133 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4134 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4135 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4136 case SHT_MIPS_RELD
: return "MIPS_RELD";
4137 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4138 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4139 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4140 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4141 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4142 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4143 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4144 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4145 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4146 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4147 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4148 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4149 case SHT_MIPS_LINE
: return "MIPS_LINE";
4150 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4151 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4152 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4153 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4154 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4155 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4156 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4157 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4158 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4159 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4160 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4161 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4162 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4163 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4164 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4165 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4166 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4167 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4175 get_parisc_section_type_name (unsigned int sh_type
)
4179 case SHT_PARISC_EXT
: return "PARISC_EXT";
4180 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4181 case SHT_PARISC_DOC
: return "PARISC_DOC";
4182 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4183 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4184 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4185 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4186 default: return NULL
;
4191 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4193 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4194 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4195 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4199 case SHT_IA_64_EXT
: return "IA_64_EXT";
4200 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4201 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4202 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4203 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4204 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4205 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4206 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4207 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4208 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4216 get_x86_64_section_type_name (unsigned int sh_type
)
4220 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4221 default: return NULL
;
4226 get_aarch64_section_type_name (unsigned int sh_type
)
4230 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4231 default: return NULL
;
4236 get_arm_section_type_name (unsigned int sh_type
)
4240 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4241 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4242 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4243 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4244 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4245 default: return NULL
;
4250 get_tic6x_section_type_name (unsigned int sh_type
)
4254 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4255 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4256 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4257 case SHT_TI_ICODE
: return "TI_ICODE";
4258 case SHT_TI_XREF
: return "TI_XREF";
4259 case SHT_TI_HANDLER
: return "TI_HANDLER";
4260 case SHT_TI_INITINFO
: return "TI_INITINFO";
4261 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4262 default: return NULL
;
4267 get_msp430x_section_type_name (unsigned int sh_type
)
4271 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4272 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4273 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4274 default: return NULL
;
4279 get_nfp_section_type_name (unsigned int sh_type
)
4283 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4284 case SHT_NFP_INITREG
: return "NFP_INITREG";
4285 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4286 default: return NULL
;
4291 get_v850_section_type_name (unsigned int sh_type
)
4295 case SHT_V850_SCOMMON
: return "V850 Small Common";
4296 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4297 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4298 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4299 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4300 default: return NULL
;
4305 get_riscv_section_type_name (unsigned int sh_type
)
4309 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4310 default: return NULL
;
4315 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4317 static char buff
[32];
4318 const char * result
;
4322 case SHT_NULL
: return "NULL";
4323 case SHT_PROGBITS
: return "PROGBITS";
4324 case SHT_SYMTAB
: return "SYMTAB";
4325 case SHT_STRTAB
: return "STRTAB";
4326 case SHT_RELA
: return "RELA";
4327 case SHT_HASH
: return "HASH";
4328 case SHT_DYNAMIC
: return "DYNAMIC";
4329 case SHT_NOTE
: return "NOTE";
4330 case SHT_NOBITS
: return "NOBITS";
4331 case SHT_REL
: return "REL";
4332 case SHT_SHLIB
: return "SHLIB";
4333 case SHT_DYNSYM
: return "DYNSYM";
4334 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4335 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4336 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4337 case SHT_GNU_HASH
: return "GNU_HASH";
4338 case SHT_GROUP
: return "GROUP";
4339 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4340 case SHT_GNU_verdef
: return "VERDEF";
4341 case SHT_GNU_verneed
: return "VERNEED";
4342 case SHT_GNU_versym
: return "VERSYM";
4343 case 0x6ffffff0: return "VERSYM";
4344 case 0x6ffffffc: return "VERDEF";
4345 case 0x7ffffffd: return "AUXILIARY";
4346 case 0x7fffffff: return "FILTER";
4347 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4350 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4352 switch (filedata
->file_header
.e_machine
)
4355 case EM_ARC_COMPACT
:
4356 case EM_ARC_COMPACT2
:
4357 result
= get_arc_section_type_name (sh_type
);
4360 case EM_MIPS_RS3_LE
:
4361 result
= get_mips_section_type_name (sh_type
);
4364 result
= get_parisc_section_type_name (sh_type
);
4367 result
= get_ia64_section_type_name (filedata
, sh_type
);
4372 result
= get_x86_64_section_type_name (sh_type
);
4375 result
= get_aarch64_section_type_name (sh_type
);
4378 result
= get_arm_section_type_name (sh_type
);
4381 result
= get_tic6x_section_type_name (sh_type
);
4384 result
= get_msp430x_section_type_name (sh_type
);
4387 result
= get_nfp_section_type_name (sh_type
);
4391 case EM_CYGNUS_V850
:
4392 result
= get_v850_section_type_name (sh_type
);
4395 result
= get_riscv_section_type_name (sh_type
);
4405 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4407 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4409 switch (filedata
->file_header
.e_machine
)
4412 result
= get_ia64_section_type_name (filedata
, sh_type
);
4415 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4416 result
= get_solaris_section_type (sh_type
);
4421 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4422 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4423 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4424 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4436 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4438 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4440 switch (filedata
->file_header
.e_machine
)
4444 case EM_CYGNUS_V850
:
4445 result
= get_v850_section_type_name (sh_type
);
4455 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4458 /* This message is probably going to be displayed in a 15
4459 character wide field, so put the hex value first. */
4460 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4466 #define OPTION_DEBUG_DUMP 512
4467 #define OPTION_DYN_SYMS 513
4468 #define OPTION_DWARF_DEPTH 514
4469 #define OPTION_DWARF_START 515
4470 #define OPTION_DWARF_CHECK 516
4471 #define OPTION_CTF_DUMP 517
4472 #define OPTION_CTF_PARENT 518
4473 #define OPTION_CTF_SYMBOLS 519
4474 #define OPTION_CTF_STRINGS 520
4476 static struct option options
[] =
4478 {"all", no_argument
, 0, 'a'},
4479 {"file-header", no_argument
, 0, 'h'},
4480 {"program-headers", no_argument
, 0, 'l'},
4481 {"headers", no_argument
, 0, 'e'},
4482 {"histogram", no_argument
, 0, 'I'},
4483 {"segments", no_argument
, 0, 'l'},
4484 {"sections", no_argument
, 0, 'S'},
4485 {"section-headers", no_argument
, 0, 'S'},
4486 {"section-groups", no_argument
, 0, 'g'},
4487 {"section-details", no_argument
, 0, 't'},
4488 {"full-section-name",no_argument
, 0, 'N'},
4489 {"symbols", no_argument
, 0, 's'},
4490 {"syms", no_argument
, 0, 's'},
4491 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4492 {"relocs", no_argument
, 0, 'r'},
4493 {"notes", no_argument
, 0, 'n'},
4494 {"dynamic", no_argument
, 0, 'd'},
4495 {"arch-specific", no_argument
, 0, 'A'},
4496 {"version-info", no_argument
, 0, 'V'},
4497 {"use-dynamic", no_argument
, 0, 'D'},
4498 {"unwind", no_argument
, 0, 'u'},
4499 {"archive-index", no_argument
, 0, 'c'},
4500 {"hex-dump", required_argument
, 0, 'x'},
4501 {"relocated-dump", required_argument
, 0, 'R'},
4502 {"string-dump", required_argument
, 0, 'p'},
4503 {"decompress", no_argument
, 0, 'z'},
4504 #ifdef SUPPORT_DISASSEMBLY
4505 {"instruction-dump", required_argument
, 0, 'i'},
4507 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4509 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4510 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4511 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4513 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4515 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4516 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4517 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4519 {"version", no_argument
, 0, 'v'},
4520 {"wide", no_argument
, 0, 'W'},
4521 {"help", no_argument
, 0, 'H'},
4522 {0, no_argument
, 0, 0}
4526 usage (FILE * stream
)
4528 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4529 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4530 fprintf (stream
, _(" Options are:\n\
4531 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4532 -h --file-header Display the ELF file header\n\
4533 -l --program-headers Display the program headers\n\
4534 --segments An alias for --program-headers\n\
4535 -S --section-headers Display the sections' header\n\
4536 --sections An alias for --section-headers\n\
4537 -g --section-groups Display the section groups\n\
4538 -t --section-details Display the section details\n\
4539 -e --headers Equivalent to: -h -l -S\n\
4540 -s --syms Display the symbol table\n\
4541 --symbols An alias for --syms\n\
4542 --dyn-syms Display the dynamic symbol table\n\
4543 -n --notes Display the core notes (if present)\n\
4544 -r --relocs Display the relocations (if present)\n\
4545 -u --unwind Display the unwind info (if present)\n\
4546 -d --dynamic Display the dynamic section (if present)\n\
4547 -V --version-info Display the version sections (if present)\n\
4548 -A --arch-specific Display architecture specific information (if any)\n\
4549 -c --archive-index Display the symbol/file index in an archive\n\
4550 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4551 -x --hex-dump=<number|name>\n\
4552 Dump the contents of section <number|name> as bytes\n\
4553 -p --string-dump=<number|name>\n\
4554 Dump the contents of section <number|name> as strings\n\
4555 -R --relocated-dump=<number|name>\n\
4556 Dump the contents of section <number|name> as relocated bytes\n\
4557 -z --decompress Decompress section before dumping it\n\
4558 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4559 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4560 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4561 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4562 =addr,=cu_index,=links,=follow-links]\n\
4563 Display the contents of DWARF debug sections\n"));
4564 fprintf (stream
, _("\
4565 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4566 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4568 fprintf (stream
, _("\
4569 --ctf=<number|name> Display CTF info from section <number|name>\n\
4570 --ctf-parent=<number|name>\n\
4571 Use section <number|name> as the CTF parent\n\n\
4572 --ctf-symbols=<number|name>\n\
4573 Use section <number|name> as the CTF external symtab\n\n\
4574 --ctf-strings=<number|name>\n\
4575 Use section <number|name> as the CTF external strtab\n\n"));
4577 #ifdef SUPPORT_DISASSEMBLY
4578 fprintf (stream
, _("\
4579 -i --instruction-dump=<number|name>\n\
4580 Disassemble the contents of section <number|name>\n"));
4582 fprintf (stream
, _("\
4583 -I --histogram Display histogram of bucket list lengths\n\
4584 -W --wide Allow output width to exceed 80 characters\n\
4585 @<file> Read options from <file>\n\
4586 -H --help Display this information\n\
4587 -v --version Display the version number of readelf\n"));
4589 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4590 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4592 exit (stream
== stdout
? 0 : 1);
4595 /* Record the fact that the user wants the contents of section number
4596 SECTION to be displayed using the method(s) encoded as flags bits
4597 in TYPE. Note, TYPE can be zero if we are creating the array for
4601 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4603 if (section
>= filedata
->num_dump_sects
)
4605 dump_type
* new_dump_sects
;
4607 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4608 sizeof (* new_dump_sects
));
4610 if (new_dump_sects
== NULL
)
4611 error (_("Out of memory allocating dump request table.\n"));
4614 if (filedata
->dump_sects
)
4616 /* Copy current flag settings. */
4617 memcpy (new_dump_sects
, filedata
->dump_sects
,
4618 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4620 free (filedata
->dump_sects
);
4623 filedata
->dump_sects
= new_dump_sects
;
4624 filedata
->num_dump_sects
= section
+ 1;
4628 if (filedata
->dump_sects
)
4629 filedata
->dump_sects
[section
] |= type
;
4632 /* Request a dump by section name. */
4635 request_dump_byname (const char * section
, dump_type type
)
4637 struct dump_list_entry
* new_request
;
4639 new_request
= (struct dump_list_entry
*)
4640 malloc (sizeof (struct dump_list_entry
));
4642 error (_("Out of memory allocating dump request table.\n"));
4644 new_request
->name
= strdup (section
);
4645 if (!new_request
->name
)
4646 error (_("Out of memory allocating dump request table.\n"));
4648 new_request
->type
= type
;
4650 new_request
->next
= dump_sects_byname
;
4651 dump_sects_byname
= new_request
;
4655 request_dump (Filedata
* filedata
, dump_type type
)
4661 section
= strtoul (optarg
, & cp
, 0);
4663 if (! *cp
&& section
>= 0)
4664 request_dump_bynumber (filedata
, section
, type
);
4666 request_dump_byname (optarg
, type
);
4670 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4677 while ((c
= getopt_long
4678 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4696 do_section_groups
= TRUE
;
4699 do_histogram
= TRUE
;
4704 do_section_groups
= TRUE
;
4709 do_section_details
= TRUE
;
4720 do_using_dynamic
= TRUE
;
4744 do_histogram
= TRUE
;
4750 do_archive_index
= TRUE
;
4753 request_dump (filedata
, HEX_DUMP
);
4756 request_dump (filedata
, STRING_DUMP
);
4759 request_dump (filedata
, RELOC_DUMP
);
4762 decompress_dumps
= TRUE
;
4768 do_debugging
= TRUE
;
4769 dwarf_select_sections_all ();
4773 do_debugging
= FALSE
;
4774 dwarf_select_sections_by_letters (optarg
);
4777 case OPTION_DEBUG_DUMP
:
4780 do_debugging
= TRUE
;
4783 do_debugging
= FALSE
;
4784 dwarf_select_sections_by_names (optarg
);
4787 case OPTION_DWARF_DEPTH
:
4791 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4794 case OPTION_DWARF_START
:
4798 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4801 case OPTION_DWARF_CHECK
:
4804 case OPTION_CTF_DUMP
:
4806 request_dump (filedata
, CTF_DUMP
);
4808 case OPTION_CTF_SYMBOLS
:
4809 dump_ctf_symtab_name
= strdup (optarg
);
4811 case OPTION_CTF_STRINGS
:
4812 dump_ctf_strtab_name
= strdup (optarg
);
4814 case OPTION_CTF_PARENT
:
4815 dump_ctf_parent_name
= strdup (optarg
);
4817 case OPTION_DYN_SYMS
:
4820 #ifdef SUPPORT_DISASSEMBLY
4822 request_dump (filedata
, DISASS_DUMP
);
4826 print_version (program_name
);
4835 /* xgettext:c-format */
4836 error (_("Invalid option '-%c'\n"), c
);
4843 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4844 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4845 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4846 && !do_section_groups
&& !do_archive_index
4852 get_elf_class (unsigned int elf_class
)
4854 static char buff
[32];
4858 case ELFCLASSNONE
: return _("none");
4859 case ELFCLASS32
: return "ELF32";
4860 case ELFCLASS64
: return "ELF64";
4862 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4868 get_data_encoding (unsigned int encoding
)
4870 static char buff
[32];
4874 case ELFDATANONE
: return _("none");
4875 case ELFDATA2LSB
: return _("2's complement, little endian");
4876 case ELFDATA2MSB
: return _("2's complement, big endian");
4878 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4883 /* Decode the data held in 'filedata->file_header'. */
4886 process_file_header (Filedata
* filedata
)
4888 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4890 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4891 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4892 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4893 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4896 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4900 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4906 printf (_("ELF Header:\n"));
4907 printf (_(" Magic: "));
4908 for (i
= 0; i
< EI_NIDENT
; i
++)
4909 printf ("%2.2x ", header
->e_ident
[i
]);
4911 printf (_(" Class: %s\n"),
4912 get_elf_class (header
->e_ident
[EI_CLASS
]));
4913 printf (_(" Data: %s\n"),
4914 get_data_encoding (header
->e_ident
[EI_DATA
]));
4915 printf (_(" Version: %d%s\n"),
4916 header
->e_ident
[EI_VERSION
],
4917 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4919 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4922 printf (_(" OS/ABI: %s\n"),
4923 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4924 printf (_(" ABI Version: %d\n"),
4925 header
->e_ident
[EI_ABIVERSION
]);
4926 printf (_(" Type: %s\n"),
4927 get_file_type (header
->e_type
));
4928 printf (_(" Machine: %s\n"),
4929 get_machine_name (header
->e_machine
));
4930 printf (_(" Version: 0x%lx\n"),
4933 printf (_(" Entry point address: "));
4934 print_vma (header
->e_entry
, PREFIX_HEX
);
4935 printf (_("\n Start of program headers: "));
4936 print_vma (header
->e_phoff
, DEC
);
4937 printf (_(" (bytes into file)\n Start of section headers: "));
4938 print_vma (header
->e_shoff
, DEC
);
4939 printf (_(" (bytes into file)\n"));
4941 printf (_(" Flags: 0x%lx%s\n"),
4943 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4944 printf (_(" Size of this header: %u (bytes)\n"),
4946 printf (_(" Size of program headers: %u (bytes)\n"),
4947 header
->e_phentsize
);
4948 printf (_(" Number of program headers: %u"),
4950 if (filedata
->section_headers
!= NULL
4951 && header
->e_phnum
== PN_XNUM
4952 && filedata
->section_headers
[0].sh_info
!= 0)
4954 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4955 printf (" (%u)", header
->e_phnum
);
4957 putc ('\n', stdout
);
4958 printf (_(" Size of section headers: %u (bytes)\n"),
4959 header
->e_shentsize
);
4960 printf (_(" Number of section headers: %u"),
4962 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4964 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4965 printf (" (%u)", header
->e_shnum
);
4967 putc ('\n', stdout
);
4968 printf (_(" Section header string table index: %u"),
4969 header
->e_shstrndx
);
4970 if (filedata
->section_headers
!= NULL
4971 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4973 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4974 printf (" (%u)", header
->e_shstrndx
);
4976 if (header
->e_shstrndx
!= SHN_UNDEF
4977 && header
->e_shstrndx
>= header
->e_shnum
)
4979 header
->e_shstrndx
= SHN_UNDEF
;
4980 printf (_(" <corrupt: out of range>"));
4982 putc ('\n', stdout
);
4985 if (filedata
->section_headers
!= NULL
)
4987 if (header
->e_phnum
== PN_XNUM
4988 && filedata
->section_headers
[0].sh_info
!= 0)
4989 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4990 if (header
->e_shnum
== SHN_UNDEF
)
4991 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4992 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4993 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4994 if (header
->e_shstrndx
>= header
->e_shnum
)
4995 header
->e_shstrndx
= SHN_UNDEF
;
4996 free (filedata
->section_headers
);
4997 filedata
->section_headers
= NULL
;
5003 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5004 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5007 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5009 Elf32_External_Phdr
* phdrs
;
5010 Elf32_External_Phdr
* external
;
5011 Elf_Internal_Phdr
* internal
;
5013 unsigned int size
= filedata
->file_header
.e_phentsize
;
5014 unsigned int num
= filedata
->file_header
.e_phnum
;
5016 /* PR binutils/17531: Cope with unexpected section header sizes. */
5017 if (size
== 0 || num
== 0)
5019 if (size
< sizeof * phdrs
)
5021 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5024 if (size
> sizeof * phdrs
)
5025 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5027 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5028 size
, num
, _("program headers"));
5032 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5033 i
< filedata
->file_header
.e_phnum
;
5034 i
++, internal
++, external
++)
5036 internal
->p_type
= BYTE_GET (external
->p_type
);
5037 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5038 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5039 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5040 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5041 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5042 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5043 internal
->p_align
= BYTE_GET (external
->p_align
);
5050 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5051 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5054 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5056 Elf64_External_Phdr
* phdrs
;
5057 Elf64_External_Phdr
* external
;
5058 Elf_Internal_Phdr
* internal
;
5060 unsigned int size
= filedata
->file_header
.e_phentsize
;
5061 unsigned int num
= filedata
->file_header
.e_phnum
;
5063 /* PR binutils/17531: Cope with unexpected section header sizes. */
5064 if (size
== 0 || num
== 0)
5066 if (size
< sizeof * phdrs
)
5068 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5071 if (size
> sizeof * phdrs
)
5072 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5074 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5075 size
, num
, _("program headers"));
5079 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5080 i
< filedata
->file_header
.e_phnum
;
5081 i
++, internal
++, external
++)
5083 internal
->p_type
= BYTE_GET (external
->p_type
);
5084 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5085 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5086 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5087 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5088 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5089 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5090 internal
->p_align
= BYTE_GET (external
->p_align
);
5097 /* Returns TRUE if the program headers were read into `program_headers'. */
5100 get_program_headers (Filedata
* filedata
)
5102 Elf_Internal_Phdr
* phdrs
;
5104 /* Check cache of prior read. */
5105 if (filedata
->program_headers
!= NULL
)
5108 /* Be kind to memory checkers by looking for
5109 e_phnum values which we know must be invalid. */
5110 if (filedata
->file_header
.e_phnum
5111 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5112 >= filedata
->file_size
)
5114 error (_("Too many program headers - %#x - the file is not that big\n"),
5115 filedata
->file_header
.e_phnum
);
5119 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5120 sizeof (Elf_Internal_Phdr
));
5123 error (_("Out of memory reading %u program headers\n"),
5124 filedata
->file_header
.e_phnum
);
5129 ? get_32bit_program_headers (filedata
, phdrs
)
5130 : get_64bit_program_headers (filedata
, phdrs
))
5132 filedata
->program_headers
= phdrs
;
5140 /* Returns TRUE if the program headers were loaded. */
5143 process_program_headers (Filedata
* filedata
)
5145 Elf_Internal_Phdr
* segment
;
5147 Elf_Internal_Phdr
* previous_load
= NULL
;
5152 if (filedata
->file_header
.e_phnum
== 0)
5154 /* PR binutils/12467. */
5155 if (filedata
->file_header
.e_phoff
!= 0)
5157 warn (_("possibly corrupt ELF header - it has a non-zero program"
5158 " header offset, but no program headers\n"));
5161 else if (do_segments
)
5162 printf (_("\nThere are no program headers in this file.\n"));
5166 if (do_segments
&& !do_header
)
5168 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5169 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5170 printf (ngettext ("There is %d program header, starting at offset %s\n",
5171 "There are %d program headers, starting at offset %s\n",
5172 filedata
->file_header
.e_phnum
),
5173 filedata
->file_header
.e_phnum
,
5174 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5177 if (! get_program_headers (filedata
))
5182 if (filedata
->file_header
.e_phnum
> 1)
5183 printf (_("\nProgram Headers:\n"));
5185 printf (_("\nProgram Headers:\n"));
5189 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5192 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5196 (_(" Type Offset VirtAddr PhysAddr\n"));
5198 (_(" FileSiz MemSiz Flags Align\n"));
5202 for (i
= 0, segment
= filedata
->program_headers
;
5203 i
< filedata
->file_header
.e_phnum
;
5208 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5212 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5213 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5214 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5215 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5216 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5218 (segment
->p_flags
& PF_R
? 'R' : ' '),
5219 (segment
->p_flags
& PF_W
? 'W' : ' '),
5220 (segment
->p_flags
& PF_X
? 'E' : ' '));
5221 printf ("%#lx", (unsigned long) segment
->p_align
);
5225 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5226 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5229 print_vma (segment
->p_offset
, FULL_HEX
);
5233 print_vma (segment
->p_vaddr
, FULL_HEX
);
5235 print_vma (segment
->p_paddr
, FULL_HEX
);
5238 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5239 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5242 print_vma (segment
->p_filesz
, FULL_HEX
);
5246 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5247 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5250 print_vma (segment
->p_memsz
, FULL_HEX
);
5254 (segment
->p_flags
& PF_R
? 'R' : ' '),
5255 (segment
->p_flags
& PF_W
? 'W' : ' '),
5256 (segment
->p_flags
& PF_X
? 'E' : ' '));
5258 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5259 printf ("%#lx", (unsigned long) segment
->p_align
);
5262 print_vma (segment
->p_align
, PREFIX_HEX
);
5267 print_vma (segment
->p_offset
, FULL_HEX
);
5269 print_vma (segment
->p_vaddr
, FULL_HEX
);
5271 print_vma (segment
->p_paddr
, FULL_HEX
);
5273 print_vma (segment
->p_filesz
, FULL_HEX
);
5275 print_vma (segment
->p_memsz
, FULL_HEX
);
5277 (segment
->p_flags
& PF_R
? 'R' : ' '),
5278 (segment
->p_flags
& PF_W
? 'W' : ' '),
5279 (segment
->p_flags
& PF_X
? 'E' : ' '));
5280 print_vma (segment
->p_align
, PREFIX_HEX
);
5283 putc ('\n', stdout
);
5286 switch (segment
->p_type
)
5289 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5290 required by the ELF standard, several programs, including the Linux
5291 kernel, make use of non-ordered segments. */
5293 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5294 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5296 if (segment
->p_memsz
< segment
->p_filesz
)
5297 error (_("the segment's file size is larger than its memory size\n"));
5298 previous_load
= segment
;
5302 /* PR 20815 - Verify that the program header is loaded into memory. */
5303 if (i
> 0 && previous_load
!= NULL
)
5304 error (_("the PHDR segment must occur before any LOAD segment\n"));
5305 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5309 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5311 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5312 if (load
->p_type
== PT_LOAD
5313 && load
->p_offset
<= segment
->p_offset
5314 && (load
->p_offset
+ load
->p_filesz
5315 >= segment
->p_offset
+ segment
->p_filesz
)
5316 && load
->p_vaddr
<= segment
->p_vaddr
5317 && (load
->p_vaddr
+ load
->p_filesz
5318 >= segment
->p_vaddr
+ segment
->p_filesz
))
5321 if (j
== filedata
->file_header
.e_phnum
)
5322 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5328 error (_("more than one dynamic segment\n"));
5330 /* By default, assume that the .dynamic section is the first
5331 section in the DYNAMIC segment. */
5332 dynamic_addr
= segment
->p_offset
;
5333 dynamic_size
= segment
->p_filesz
;
5335 /* Try to locate the .dynamic section. If there is
5336 a section header table, we can easily locate it. */
5337 if (filedata
->section_headers
!= NULL
)
5339 Elf_Internal_Shdr
* sec
;
5341 sec
= find_section (filedata
, ".dynamic");
5342 if (sec
== NULL
|| sec
->sh_size
== 0)
5344 /* A corresponding .dynamic section is expected, but on
5345 IA-64/OpenVMS it is OK for it to be missing. */
5346 if (!is_ia64_vms (filedata
))
5347 error (_("no .dynamic section in the dynamic segment\n"));
5351 if (sec
->sh_type
== SHT_NOBITS
)
5357 dynamic_addr
= sec
->sh_offset
;
5358 dynamic_size
= sec
->sh_size
;
5360 if (dynamic_addr
< segment
->p_offset
5361 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5362 warn (_("the .dynamic section is not contained"
5363 " within the dynamic segment\n"));
5364 else if (dynamic_addr
> segment
->p_offset
)
5365 warn (_("the .dynamic section is not the first section"
5366 " in the dynamic segment.\n"));
5369 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5370 segment. Check this after matching against the section headers
5371 so we don't warn on debuginfo file (which have NOBITS .dynamic
5373 if (dynamic_addr
> filedata
->file_size
5374 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5376 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5377 dynamic_addr
= dynamic_size
= 0;
5382 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5384 error (_("Unable to find program interpreter name\n"));
5388 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5390 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5391 error (_("Internal error: failed to create format string to display program interpreter\n"));
5393 program_interpreter
[0] = 0;
5394 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5395 error (_("Unable to read program interpreter name\n"));
5398 printf (_(" [Requesting program interpreter: %s]\n"),
5399 program_interpreter
);
5406 && filedata
->section_headers
!= NULL
5407 && filedata
->string_table
!= NULL
)
5409 printf (_("\n Section to Segment mapping:\n"));
5410 printf (_(" Segment Sections...\n"));
5412 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5415 Elf_Internal_Shdr
* section
;
5417 segment
= filedata
->program_headers
+ i
;
5418 section
= filedata
->section_headers
+ 1;
5420 printf (" %2.2d ", i
);
5422 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5424 if (!ELF_TBSS_SPECIAL (section
, segment
)
5425 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5426 printf ("%s ", printable_section_name (filedata
, section
));
5437 /* Find the file offset corresponding to VMA by using the program headers. */
5440 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5442 Elf_Internal_Phdr
* seg
;
5444 if (! get_program_headers (filedata
))
5446 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5450 for (seg
= filedata
->program_headers
;
5451 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5454 if (seg
->p_type
!= PT_LOAD
)
5457 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5458 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5459 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5462 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5463 (unsigned long) vma
);
5468 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5469 If PROBE is true, this is just a probe and we do not generate any error
5470 messages if the load fails. */
5473 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5475 Elf32_External_Shdr
* shdrs
;
5476 Elf_Internal_Shdr
* internal
;
5478 unsigned int size
= filedata
->file_header
.e_shentsize
;
5479 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5481 /* PR binutils/17531: Cope with unexpected section header sizes. */
5482 if (size
== 0 || num
== 0)
5484 if (size
< sizeof * shdrs
)
5487 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5490 if (!probe
&& size
> sizeof * shdrs
)
5491 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5493 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5495 probe
? NULL
: _("section headers"));
5499 free (filedata
->section_headers
);
5500 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5501 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5502 if (filedata
->section_headers
== NULL
)
5505 error (_("Out of memory reading %u section headers\n"), num
);
5510 for (i
= 0, internal
= filedata
->section_headers
;
5514 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5515 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5516 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5517 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5518 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5519 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5520 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5521 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5522 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5523 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5524 if (!probe
&& internal
->sh_link
> num
)
5525 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5526 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5527 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5534 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5537 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5539 Elf64_External_Shdr
* shdrs
;
5540 Elf_Internal_Shdr
* internal
;
5542 unsigned int size
= filedata
->file_header
.e_shentsize
;
5543 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5545 /* PR binutils/17531: Cope with unexpected section header sizes. */
5546 if (size
== 0 || num
== 0)
5549 if (size
< sizeof * shdrs
)
5552 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5556 if (! probe
&& size
> sizeof * shdrs
)
5557 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5559 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5560 filedata
->file_header
.e_shoff
,
5562 probe
? NULL
: _("section headers"));
5566 free (filedata
->section_headers
);
5567 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5568 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5569 if (filedata
->section_headers
== NULL
)
5572 error (_("Out of memory reading %u section headers\n"), num
);
5577 for (i
= 0, internal
= filedata
->section_headers
;
5581 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5582 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5583 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5584 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5585 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5586 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5587 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5588 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5589 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5590 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5591 if (!probe
&& internal
->sh_link
> num
)
5592 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5593 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5594 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5601 static Elf_Internal_Sym
*
5602 get_32bit_elf_symbols (Filedata
* filedata
,
5603 Elf_Internal_Shdr
* section
,
5604 unsigned long * num_syms_return
)
5606 unsigned long number
= 0;
5607 Elf32_External_Sym
* esyms
= NULL
;
5608 Elf_External_Sym_Shndx
* shndx
= NULL
;
5609 Elf_Internal_Sym
* isyms
= NULL
;
5610 Elf_Internal_Sym
* psym
;
5612 elf_section_list
* entry
;
5614 if (section
->sh_size
== 0)
5616 if (num_syms_return
!= NULL
)
5617 * num_syms_return
= 0;
5621 /* Run some sanity checks first. */
5622 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5624 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5625 printable_section_name (filedata
, section
),
5626 (unsigned long) section
->sh_entsize
);
5630 if (section
->sh_size
> filedata
->file_size
)
5632 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5633 printable_section_name (filedata
, section
),
5634 (unsigned long) section
->sh_size
);
5638 number
= section
->sh_size
/ section
->sh_entsize
;
5640 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5642 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5643 (unsigned long) section
->sh_size
,
5644 printable_section_name (filedata
, section
),
5645 (unsigned long) section
->sh_entsize
);
5649 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5650 section
->sh_size
, _("symbols"));
5655 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5657 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5662 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5666 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5667 entry
->hdr
->sh_offset
,
5668 1, entry
->hdr
->sh_size
,
5669 _("symbol table section indices"));
5673 /* PR17531: file: heap-buffer-overflow */
5674 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5676 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5677 printable_section_name (filedata
, entry
->hdr
),
5678 (unsigned long) entry
->hdr
->sh_size
,
5679 (unsigned long) section
->sh_size
);
5684 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5688 error (_("Out of memory reading %lu symbols\n"),
5689 (unsigned long) number
);
5693 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5695 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5696 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5697 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5698 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5699 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5701 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5702 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5703 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5704 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5705 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5712 if (num_syms_return
!= NULL
)
5713 * num_syms_return
= isyms
== NULL
? 0 : number
;
5718 static Elf_Internal_Sym
*
5719 get_64bit_elf_symbols (Filedata
* filedata
,
5720 Elf_Internal_Shdr
* section
,
5721 unsigned long * num_syms_return
)
5723 unsigned long number
= 0;
5724 Elf64_External_Sym
* esyms
= NULL
;
5725 Elf_External_Sym_Shndx
* shndx
= NULL
;
5726 Elf_Internal_Sym
* isyms
= NULL
;
5727 Elf_Internal_Sym
* psym
;
5729 elf_section_list
* entry
;
5731 if (section
->sh_size
== 0)
5733 if (num_syms_return
!= NULL
)
5734 * num_syms_return
= 0;
5738 /* Run some sanity checks first. */
5739 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5741 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5742 printable_section_name (filedata
, section
),
5743 (unsigned long) section
->sh_entsize
);
5747 if (section
->sh_size
> filedata
->file_size
)
5749 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5750 printable_section_name (filedata
, section
),
5751 (unsigned long) section
->sh_size
);
5755 number
= section
->sh_size
/ section
->sh_entsize
;
5757 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5759 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5760 (unsigned long) section
->sh_size
,
5761 printable_section_name (filedata
, section
),
5762 (unsigned long) section
->sh_entsize
);
5766 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5767 section
->sh_size
, _("symbols"));
5772 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5774 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5779 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5783 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5784 entry
->hdr
->sh_offset
,
5785 1, entry
->hdr
->sh_size
,
5786 _("symbol table section indices"));
5790 /* PR17531: file: heap-buffer-overflow */
5791 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5793 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5794 printable_section_name (filedata
, entry
->hdr
),
5795 (unsigned long) entry
->hdr
->sh_size
,
5796 (unsigned long) section
->sh_size
);
5801 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5805 error (_("Out of memory reading %lu symbols\n"),
5806 (unsigned long) number
);
5810 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5812 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5813 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5814 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5815 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5817 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5819 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5820 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5821 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5823 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5824 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5831 if (num_syms_return
!= NULL
)
5832 * num_syms_return
= isyms
== NULL
? 0 : number
;
5838 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5840 static char buff
[1024];
5842 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5844 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5845 bfd_vma os_flags
= 0;
5846 bfd_vma proc_flags
= 0;
5847 bfd_vma unknown_flags
= 0;
5855 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5856 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5857 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5858 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5859 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5860 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5861 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5862 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5863 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5864 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5865 /* IA-64 specific. */
5866 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5867 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5868 /* IA-64 OpenVMS specific. */
5869 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5870 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5871 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5872 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5873 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5874 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5876 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5877 /* SPARC specific. */
5878 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5879 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5881 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5882 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5883 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5885 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5887 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5890 if (do_section_details
)
5892 sprintf (buff
, "[%*.*lx]: ",
5893 field_size
, field_size
, (unsigned long) sh_flags
);
5894 p
+= field_size
+ 4;
5901 flag
= sh_flags
& - sh_flags
;
5904 if (do_section_details
)
5908 case SHF_WRITE
: sindex
= 0; break;
5909 case SHF_ALLOC
: sindex
= 1; break;
5910 case SHF_EXECINSTR
: sindex
= 2; break;
5911 case SHF_MERGE
: sindex
= 3; break;
5912 case SHF_STRINGS
: sindex
= 4; break;
5913 case SHF_INFO_LINK
: sindex
= 5; break;
5914 case SHF_LINK_ORDER
: sindex
= 6; break;
5915 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5916 case SHF_GROUP
: sindex
= 8; break;
5917 case SHF_TLS
: sindex
= 9; break;
5918 case SHF_EXCLUDE
: sindex
= 18; break;
5919 case SHF_COMPRESSED
: sindex
= 20; break;
5920 case SHF_GNU_MBIND
: sindex
= 24; break;
5924 switch (filedata
->file_header
.e_machine
)
5927 if (flag
== SHF_IA_64_SHORT
)
5929 else if (flag
== SHF_IA_64_NORECOV
)
5932 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5935 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5936 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5937 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5938 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5939 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5940 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5951 case EM_OLD_SPARCV9
:
5952 case EM_SPARC32PLUS
:
5955 if (flag
== SHF_ORDERED
)
5962 case SHF_ENTRYSECT
: sindex
= 21; break;
5963 case SHF_ARM_PURECODE
: sindex
= 22; break;
5964 case SHF_COMDEF
: sindex
= 23; break;
5969 if (flag
== SHF_PPC_VLE
)
5980 if (p
!= buff
+ field_size
+ 4)
5982 if (size
< (10 + 2))
5984 warn (_("Internal error: not enough buffer room for section flag info"));
5985 return _("<unknown>");
5992 size
-= flags
[sindex
].len
;
5993 p
= stpcpy (p
, flags
[sindex
].str
);
5995 else if (flag
& SHF_MASKOS
)
5997 else if (flag
& SHF_MASKPROC
)
6000 unknown_flags
|= flag
;
6006 case SHF_WRITE
: *p
= 'W'; break;
6007 case SHF_ALLOC
: *p
= 'A'; break;
6008 case SHF_EXECINSTR
: *p
= 'X'; break;
6009 case SHF_MERGE
: *p
= 'M'; break;
6010 case SHF_STRINGS
: *p
= 'S'; break;
6011 case SHF_INFO_LINK
: *p
= 'I'; break;
6012 case SHF_LINK_ORDER
: *p
= 'L'; break;
6013 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6014 case SHF_GROUP
: *p
= 'G'; break;
6015 case SHF_TLS
: *p
= 'T'; break;
6016 case SHF_EXCLUDE
: *p
= 'E'; break;
6017 case SHF_COMPRESSED
: *p
= 'C'; break;
6018 case SHF_GNU_MBIND
: *p
= 'D'; break;
6021 if ((filedata
->file_header
.e_machine
== EM_X86_64
6022 || filedata
->file_header
.e_machine
== EM_L1OM
6023 || filedata
->file_header
.e_machine
== EM_K1OM
)
6024 && flag
== SHF_X86_64_LARGE
)
6026 else if (filedata
->file_header
.e_machine
== EM_ARM
6027 && flag
== SHF_ARM_PURECODE
)
6029 else if (filedata
->file_header
.e_machine
== EM_PPC
6030 && flag
== SHF_PPC_VLE
)
6032 else if (flag
& SHF_MASKOS
)
6035 sh_flags
&= ~ SHF_MASKOS
;
6037 else if (flag
& SHF_MASKPROC
)
6040 sh_flags
&= ~ SHF_MASKPROC
;
6050 if (do_section_details
)
6054 size
-= 5 + field_size
;
6055 if (p
!= buff
+ field_size
+ 4)
6059 warn (_("Internal error: not enough buffer room for section flag info"));
6060 return _("<unknown>");
6066 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6067 (unsigned long) os_flags
);
6068 p
+= 5 + field_size
;
6072 size
-= 7 + field_size
;
6073 if (p
!= buff
+ field_size
+ 4)
6077 warn (_("Internal error: not enough buffer room for section flag info"));
6078 return _("<unknown>");
6084 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6085 (unsigned long) proc_flags
);
6086 p
+= 7 + field_size
;
6090 size
-= 10 + field_size
;
6091 if (p
!= buff
+ field_size
+ 4)
6095 warn (_("Internal error: not enough buffer room for section flag info"));
6096 return _("<unknown>");
6102 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6103 (unsigned long) unknown_flags
);
6104 p
+= 10 + field_size
;
6113 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6117 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6119 if (size
< sizeof (* echdr
))
6121 error (_("Compressed section is too small even for a compression header\n"));
6125 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6126 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6127 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6128 return sizeof (*echdr
);
6132 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6134 if (size
< sizeof (* echdr
))
6136 error (_("Compressed section is too small even for a compression header\n"));
6140 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6141 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6142 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6143 return sizeof (*echdr
);
6148 process_section_headers (Filedata
* filedata
)
6150 Elf_Internal_Shdr
* section
;
6153 filedata
->section_headers
= NULL
;
6155 if (filedata
->file_header
.e_shnum
== 0)
6157 /* PR binutils/12467. */
6158 if (filedata
->file_header
.e_shoff
!= 0)
6160 warn (_("possibly corrupt ELF file header - it has a non-zero"
6161 " section header offset, but no section headers\n"));
6164 else if (do_sections
)
6165 printf (_("\nThere are no sections in this file.\n"));
6170 if (do_sections
&& !do_header
)
6171 printf (ngettext ("There is %d section header, "
6172 "starting at offset 0x%lx:\n",
6173 "There are %d section headers, "
6174 "starting at offset 0x%lx:\n",
6175 filedata
->file_header
.e_shnum
),
6176 filedata
->file_header
.e_shnum
,
6177 (unsigned long) filedata
->file_header
.e_shoff
);
6181 if (! get_32bit_section_headers (filedata
, FALSE
))
6186 if (! get_64bit_section_headers (filedata
, FALSE
))
6190 /* Read in the string table, so that we have names to display. */
6191 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6192 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6194 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6196 if (section
->sh_size
!= 0)
6198 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6199 1, section
->sh_size
,
6202 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6206 /* Scan the sections for the dynamic symbol table
6207 and dynamic string table and debug sections. */
6208 dynamic_symbols
= NULL
;
6209 dynamic_strings
= NULL
;
6210 dynamic_syminfo
= NULL
;
6211 symtab_shndx_list
= NULL
;
6213 eh_addr_size
= is_32bit_elf
? 4 : 8;
6214 switch (filedata
->file_header
.e_machine
)
6217 case EM_MIPS_RS3_LE
:
6218 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6219 FDE addresses. However, the ABI also has a semi-official ILP32
6220 variant for which the normal FDE address size rules apply.
6222 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6223 section, where XX is the size of longs in bits. Unfortunately,
6224 earlier compilers provided no way of distinguishing ILP32 objects
6225 from LP64 objects, so if there's any doubt, we should assume that
6226 the official LP64 form is being used. */
6227 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6228 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6234 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6236 case E_H8_MACH_H8300
:
6237 case E_H8_MACH_H8300HN
:
6238 case E_H8_MACH_H8300SN
:
6239 case E_H8_MACH_H8300SXN
:
6242 case E_H8_MACH_H8300H
:
6243 case E_H8_MACH_H8300S
:
6244 case E_H8_MACH_H8300SX
:
6252 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6254 case EF_M32C_CPU_M16C
:
6261 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6264 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6265 if (section->sh_entsize != expected_entsize) \
6268 sprintf_vma (buf, section->sh_entsize); \
6269 /* Note: coded this way so that there is a single string for \
6271 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6272 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6273 (unsigned) expected_entsize); \
6274 section->sh_entsize = expected_entsize; \
6279 #define CHECK_ENTSIZE(section, i, type) \
6280 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6281 sizeof (Elf64_External_##type))
6283 for (i
= 0, section
= filedata
->section_headers
;
6284 i
< filedata
->file_header
.e_shnum
;
6287 char * name
= SECTION_NAME (section
);
6289 if (section
->sh_type
== SHT_DYNSYM
)
6291 if (dynamic_symbols
!= NULL
)
6293 error (_("File contains multiple dynamic symbol tables\n"));
6297 CHECK_ENTSIZE (section
, i
, Sym
);
6298 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6300 else if (section
->sh_type
== SHT_STRTAB
6301 && streq (name
, ".dynstr"))
6303 if (dynamic_strings
!= NULL
)
6305 error (_("File contains multiple dynamic string tables\n"));
6309 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6310 1, section
->sh_size
,
6311 _("dynamic strings"));
6312 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6314 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6316 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6318 entry
->hdr
= section
;
6319 entry
->next
= symtab_shndx_list
;
6320 symtab_shndx_list
= entry
;
6322 else if (section
->sh_type
== SHT_SYMTAB
)
6323 CHECK_ENTSIZE (section
, i
, Sym
);
6324 else if (section
->sh_type
== SHT_GROUP
)
6325 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6326 else if (section
->sh_type
== SHT_REL
)
6327 CHECK_ENTSIZE (section
, i
, Rel
);
6328 else if (section
->sh_type
== SHT_RELA
)
6329 CHECK_ENTSIZE (section
, i
, Rela
);
6330 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6331 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6332 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6333 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6334 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6335 && (const_strneq (name
, ".debug_")
6336 || const_strneq (name
, ".zdebug_")))
6339 name
+= sizeof (".zdebug_") - 1;
6341 name
+= sizeof (".debug_") - 1;
6344 || (do_debug_info
&& const_strneq (name
, "info"))
6345 || (do_debug_info
&& const_strneq (name
, "types"))
6346 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6347 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6348 || (do_debug_lines
&& const_strneq (name
, "line."))
6349 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6350 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6351 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6352 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6353 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6354 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6355 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6356 || (do_debug_frames
&& const_strneq (name
, "frame"))
6357 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6358 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6359 || (do_debug_str
&& const_strneq (name
, "str"))
6360 || (do_debug_loc
&& const_strneq (name
, "loc"))
6361 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6362 || (do_debug_addr
&& const_strneq (name
, "addr"))
6363 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6364 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6366 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6368 /* Linkonce section to be combined with .debug_info at link time. */
6369 else if ((do_debugging
|| do_debug_info
)
6370 && const_strneq (name
, ".gnu.linkonce.wi."))
6371 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6372 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6373 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6374 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6375 || streq (name
, ".debug_names")))
6376 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6377 /* Trace sections for Itanium VMS. */
6378 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6379 || do_trace_aranges
)
6380 && const_strneq (name
, ".trace_"))
6382 name
+= sizeof (".trace_") - 1;
6385 || (do_trace_info
&& streq (name
, "info"))
6386 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6387 || (do_trace_aranges
&& streq (name
, "aranges"))
6389 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6391 else if ((do_debugging
|| do_debug_links
)
6392 && (const_strneq (name
, ".gnu_debuglink")
6393 || const_strneq (name
, ".gnu_debugaltlink")))
6394 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6400 if (filedata
->file_header
.e_shnum
> 1)
6401 printf (_("\nSection Headers:\n"));
6403 printf (_("\nSection Header:\n"));
6407 if (do_section_details
)
6409 printf (_(" [Nr] Name\n"));
6410 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6414 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6418 if (do_section_details
)
6420 printf (_(" [Nr] Name\n"));
6421 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6425 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6429 if (do_section_details
)
6431 printf (_(" [Nr] Name\n"));
6432 printf (_(" Type Address Offset Link\n"));
6433 printf (_(" Size EntSize Info Align\n"));
6437 printf (_(" [Nr] Name Type Address Offset\n"));
6438 printf (_(" Size EntSize Flags Link Info Align\n"));
6442 if (do_section_details
)
6443 printf (_(" Flags\n"));
6445 for (i
= 0, section
= filedata
->section_headers
;
6446 i
< filedata
->file_header
.e_shnum
;
6449 /* Run some sanity checks on the section header. */
6451 /* Check the sh_link field. */
6452 switch (section
->sh_type
)
6456 if (section
->sh_link
== 0
6457 && (filedata
->file_header
.e_type
== ET_EXEC
6458 || filedata
->file_header
.e_type
== ET_DYN
))
6459 /* A dynamic relocation section where all entries use a
6460 zero symbol index need not specify a symtab section. */
6463 case SHT_SYMTAB_SHNDX
:
6467 case SHT_GNU_versym
:
6468 if (section
->sh_link
== 0
6469 || section
->sh_link
>= filedata
->file_header
.e_shnum
6470 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6471 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6472 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6473 i
, section
->sh_link
);
6479 case SHT_GNU_verneed
:
6480 case SHT_GNU_verdef
:
6481 case SHT_GNU_LIBLIST
:
6482 if (section
->sh_link
== 0
6483 || section
->sh_link
>= filedata
->file_header
.e_shnum
6484 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6485 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6486 i
, section
->sh_link
);
6489 case SHT_INIT_ARRAY
:
6490 case SHT_FINI_ARRAY
:
6491 case SHT_PREINIT_ARRAY
:
6492 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6493 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6494 i
, section
->sh_link
);
6498 /* FIXME: Add support for target specific section types. */
6499 #if 0 /* Currently we do not check other section types as there are too
6500 many special cases. Stab sections for example have a type
6501 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6503 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6504 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6505 i
, section
->sh_link
);
6510 /* Check the sh_info field. */
6511 switch (section
->sh_type
)
6515 if (section
->sh_info
== 0
6516 && (filedata
->file_header
.e_type
== ET_EXEC
6517 || filedata
->file_header
.e_type
== ET_DYN
))
6518 /* Dynamic relocations apply to segments, so they do not
6519 need to specify the section they relocate. */
6521 if (section
->sh_info
== 0
6522 || section
->sh_info
>= filedata
->file_header
.e_shnum
6523 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6524 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6525 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6526 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6527 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6528 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6529 /* FIXME: Are other section types valid ? */
6530 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6531 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6532 i
, section
->sh_info
);
6537 case SHT_SYMTAB_SHNDX
:
6538 case SHT_INIT_ARRAY
:
6539 case SHT_FINI_ARRAY
:
6540 case SHT_PREINIT_ARRAY
:
6541 if (section
->sh_info
!= 0)
6542 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6543 i
, section
->sh_info
);
6549 /* A symbol index - we assume that it is valid. */
6553 /* FIXME: Add support for target specific section types. */
6554 if (section
->sh_type
== SHT_NOBITS
)
6555 /* NOBITS section headers with non-zero sh_info fields can be
6556 created when a binary is stripped of everything but its debug
6557 information. The stripped sections have their headers
6558 preserved but their types set to SHT_NOBITS. So do not check
6559 this type of section. */
6561 else if (section
->sh_flags
& SHF_INFO_LINK
)
6563 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6564 warn (_("[%2u]: Expected link to another section in info field"), i
);
6566 else if (section
->sh_type
< SHT_LOOS
6567 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6568 && section
->sh_info
!= 0)
6569 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6570 i
, section
->sh_info
);
6574 /* Check the sh_size field. */
6575 if (section
->sh_size
> filedata
->file_size
6576 && section
->sh_type
!= SHT_NOBITS
6577 && section
->sh_type
!= SHT_NULL
6578 && section
->sh_type
< SHT_LOOS
)
6579 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6581 printf (" [%2u] ", i
);
6582 if (do_section_details
)
6583 printf ("%s\n ", printable_section_name (filedata
, section
));
6585 print_symbol (-17, SECTION_NAME (section
));
6587 printf (do_wide
? " %-15s " : " %-15.15s ",
6588 get_section_type_name (filedata
, section
->sh_type
));
6592 const char * link_too_big
= NULL
;
6594 print_vma (section
->sh_addr
, LONG_HEX
);
6596 printf ( " %6.6lx %6.6lx %2.2lx",
6597 (unsigned long) section
->sh_offset
,
6598 (unsigned long) section
->sh_size
,
6599 (unsigned long) section
->sh_entsize
);
6601 if (do_section_details
)
6602 fputs (" ", stdout
);
6604 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6606 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6609 /* The sh_link value is out of range. Normally this indicates
6610 an error but it can have special values in Solaris binaries. */
6611 switch (filedata
->file_header
.e_machine
)
6618 case EM_OLD_SPARCV9
:
6619 case EM_SPARC32PLUS
:
6622 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6623 link_too_big
= "BEFORE";
6624 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6625 link_too_big
= "AFTER";
6632 if (do_section_details
)
6634 if (link_too_big
!= NULL
&& * link_too_big
)
6635 printf ("<%s> ", link_too_big
);
6637 printf ("%2u ", section
->sh_link
);
6638 printf ("%3u %2lu\n", section
->sh_info
,
6639 (unsigned long) section
->sh_addralign
);
6642 printf ("%2u %3u %2lu\n",
6645 (unsigned long) section
->sh_addralign
);
6647 if (link_too_big
&& ! * link_too_big
)
6648 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6649 i
, section
->sh_link
);
6653 print_vma (section
->sh_addr
, LONG_HEX
);
6655 if ((long) section
->sh_offset
== section
->sh_offset
)
6656 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6660 print_vma (section
->sh_offset
, LONG_HEX
);
6663 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6664 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6668 print_vma (section
->sh_size
, LONG_HEX
);
6671 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6672 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6676 print_vma (section
->sh_entsize
, LONG_HEX
);
6679 if (do_section_details
)
6680 fputs (" ", stdout
);
6682 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6684 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6686 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6687 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6690 print_vma (section
->sh_addralign
, DEC
);
6694 else if (do_section_details
)
6697 print_vma (section
->sh_addr
, LONG_HEX
);
6698 if ((long) section
->sh_offset
== section
->sh_offset
)
6699 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6703 print_vma (section
->sh_offset
, LONG_HEX
);
6705 printf (" %u\n ", section
->sh_link
);
6706 print_vma (section
->sh_size
, LONG_HEX
);
6708 print_vma (section
->sh_entsize
, LONG_HEX
);
6710 printf (" %-16u %lu\n",
6712 (unsigned long) section
->sh_addralign
);
6717 print_vma (section
->sh_addr
, LONG_HEX
);
6718 if ((long) section
->sh_offset
== section
->sh_offset
)
6719 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6723 print_vma (section
->sh_offset
, LONG_HEX
);
6726 print_vma (section
->sh_size
, LONG_HEX
);
6728 print_vma (section
->sh_entsize
, LONG_HEX
);
6730 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6732 printf (" %2u %3u %lu\n",
6735 (unsigned long) section
->sh_addralign
);
6738 if (do_section_details
)
6740 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6741 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6743 /* Minimum section size is 12 bytes for 32-bit compression
6744 header + 12 bytes for compressed data header. */
6745 unsigned char buf
[24];
6747 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6748 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6749 sizeof (buf
), _("compression header")))
6751 Elf_Internal_Chdr chdr
;
6753 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6755 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6758 printf (_(" [<unknown>: 0x%x], "),
6760 print_vma (chdr
.ch_size
, LONG_HEX
);
6761 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6767 if (!do_section_details
)
6769 /* The ordering of the letters shown here matches the ordering of the
6770 corresponding SHF_xxx values, and hence the order in which these
6771 letters will be displayed to the user. */
6772 printf (_("Key to Flags:\n\
6773 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6774 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6775 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6776 if (filedata
->file_header
.e_machine
== EM_X86_64
6777 || filedata
->file_header
.e_machine
== EM_L1OM
6778 || filedata
->file_header
.e_machine
== EM_K1OM
)
6779 printf (_("l (large), "));
6780 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6781 printf (_("y (purecode), "));
6782 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6783 printf (_("v (VLE), "));
6784 printf ("p (processor specific)\n");
6791 get_group_flags (unsigned int flags
)
6793 static char buff
[128];
6797 else if (flags
== GRP_COMDAT
)
6800 snprintf (buff
, 14, _("[0x%x: "), flags
);
6802 flags
&= ~ GRP_COMDAT
;
6803 if (flags
& GRP_MASKOS
)
6805 strcat (buff
, "<OS specific>");
6806 flags
&= ~ GRP_MASKOS
;
6809 if (flags
& GRP_MASKPROC
)
6811 strcat (buff
, "<PROC specific>");
6812 flags
&= ~ GRP_MASKPROC
;
6816 strcat (buff
, "<unknown>");
6823 process_section_groups (Filedata
* filedata
)
6825 Elf_Internal_Shdr
* section
;
6827 struct group
* group
;
6828 Elf_Internal_Shdr
* symtab_sec
;
6829 Elf_Internal_Shdr
* strtab_sec
;
6830 Elf_Internal_Sym
* symtab
;
6831 unsigned long num_syms
;
6835 /* Don't process section groups unless needed. */
6836 if (!do_unwind
&& !do_section_groups
)
6839 if (filedata
->file_header
.e_shnum
== 0)
6841 if (do_section_groups
)
6842 printf (_("\nThere are no sections to group in this file.\n"));
6847 if (filedata
->section_headers
== NULL
)
6849 error (_("Section headers are not available!\n"));
6850 /* PR 13622: This can happen with a corrupt ELF header. */
6854 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6855 sizeof (struct group
*));
6857 if (section_headers_groups
== NULL
)
6859 error (_("Out of memory reading %u section group headers\n"),
6860 filedata
->file_header
.e_shnum
);
6864 /* Scan the sections for the group section. */
6866 for (i
= 0, section
= filedata
->section_headers
;
6867 i
< filedata
->file_header
.e_shnum
;
6869 if (section
->sh_type
== SHT_GROUP
)
6872 if (group_count
== 0)
6874 if (do_section_groups
)
6875 printf (_("\nThere are no section groups in this file.\n"));
6880 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6882 if (section_groups
== NULL
)
6884 error (_("Out of memory reading %lu groups\n"),
6885 (unsigned long) group_count
);
6895 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6896 i
< filedata
->file_header
.e_shnum
;
6899 if (section
->sh_type
== SHT_GROUP
)
6901 const char * name
= printable_section_name (filedata
, section
);
6902 const char * group_name
;
6903 unsigned char * start
;
6904 unsigned char * indices
;
6905 unsigned int entry
, j
, size
;
6906 Elf_Internal_Shdr
* sec
;
6907 Elf_Internal_Sym
* sym
;
6909 /* Get the symbol table. */
6910 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6911 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6914 error (_("Bad sh_link in group section `%s'\n"), name
);
6918 if (symtab_sec
!= sec
)
6923 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6928 error (_("Corrupt header in group section `%s'\n"), name
);
6932 if (section
->sh_info
>= num_syms
)
6934 error (_("Bad sh_info in group section `%s'\n"), name
);
6938 sym
= symtab
+ section
->sh_info
;
6940 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6942 if (sym
->st_shndx
== 0
6943 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6945 error (_("Bad sh_info in group section `%s'\n"), name
);
6949 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6958 /* Get the string table. */
6959 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6968 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6974 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6975 1, strtab_sec
->sh_size
,
6977 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6979 group_name
= sym
->st_name
< strtab_size
6980 ? strtab
+ sym
->st_name
: _("<corrupt>");
6983 /* PR 17531: file: loop. */
6984 if (section
->sh_entsize
> section
->sh_size
)
6986 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6987 printable_section_name (filedata
, section
),
6988 (unsigned long) section
->sh_entsize
,
6989 (unsigned long) section
->sh_size
);
6993 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6994 1, section
->sh_size
,
7000 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7001 entry
= byte_get (indices
, 4);
7004 if (do_section_groups
)
7006 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7007 get_group_flags (entry
), i
, name
, group_name
, size
);
7009 printf (_(" [Index] Name\n"));
7012 group
->group_index
= i
;
7014 for (j
= 0; j
< size
; j
++)
7016 struct group_list
* g
;
7018 entry
= byte_get (indices
, 4);
7021 if (entry
>= filedata
->file_header
.e_shnum
)
7023 static unsigned num_group_errors
= 0;
7025 if (num_group_errors
++ < 10)
7027 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7028 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7029 if (num_group_errors
== 10)
7030 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7035 if (section_headers_groups
[entry
] != NULL
)
7039 static unsigned num_errs
= 0;
7041 if (num_errs
++ < 10)
7043 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7045 section_headers_groups
[entry
]->group_index
);
7047 warn (_("Further error messages about already contained group sections suppressed\n"));
7053 /* Intel C/C++ compiler may put section 0 in a
7054 section group. We just warn it the first time
7055 and ignore it afterwards. */
7056 static bfd_boolean warned
= FALSE
;
7059 error (_("section 0 in group section [%5u]\n"),
7060 section_headers_groups
[entry
]->group_index
);
7066 section_headers_groups
[entry
] = group
;
7068 if (do_section_groups
)
7070 sec
= filedata
->section_headers
+ entry
;
7071 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7074 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7075 g
->section_index
= entry
;
7076 g
->next
= group
->root
;
7094 /* Data used to display dynamic fixups. */
7096 struct ia64_vms_dynfixup
7098 bfd_vma needed_ident
; /* Library ident number. */
7099 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7100 bfd_vma fixup_needed
; /* Index of the library. */
7101 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7102 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7105 /* Data used to display dynamic relocations. */
7107 struct ia64_vms_dynimgrela
7109 bfd_vma img_rela_cnt
; /* Number of relocations. */
7110 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7113 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7117 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7118 struct ia64_vms_dynfixup
* fixup
,
7119 const char * strtab
,
7120 unsigned int strtab_sz
)
7122 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7124 const char * lib_name
;
7126 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7127 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
7128 _("dynamic section image fixups"));
7132 if (fixup
->needed
< strtab_sz
)
7133 lib_name
= strtab
+ fixup
->needed
;
7136 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7137 (unsigned long) fixup
->needed
);
7140 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7141 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7143 (_("Seg Offset Type SymVec DataType\n"));
7145 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7150 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7151 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7152 type
= BYTE_GET (imfs
[i
].type
);
7153 rtype
= elf_ia64_reloc_type (type
);
7155 printf (" 0x%08x ", type
);
7157 printf (" %-32s ", rtype
);
7158 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7159 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7166 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7169 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7171 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7174 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7175 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7176 _("dynamic section image relocations"));
7180 printf (_("\nImage relocs\n"));
7182 (_("Seg Offset Type Addend Seg Sym Off\n"));
7184 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7189 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7190 printf ("%08" BFD_VMA_FMT
"x ",
7191 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7192 type
= BYTE_GET (imrs
[i
].type
);
7193 rtype
= elf_ia64_reloc_type (type
);
7195 printf ("0x%08x ", type
);
7197 printf ("%-31s ", rtype
);
7198 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7199 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7200 printf ("%08" BFD_VMA_FMT
"x\n",
7201 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7208 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7211 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7213 struct ia64_vms_dynfixup fixup
;
7214 struct ia64_vms_dynimgrela imgrela
;
7215 Elf_Internal_Dyn
*entry
;
7216 bfd_vma strtab_off
= 0;
7217 bfd_vma strtab_sz
= 0;
7218 char *strtab
= NULL
;
7219 bfd_boolean res
= TRUE
;
7221 memset (&fixup
, 0, sizeof (fixup
));
7222 memset (&imgrela
, 0, sizeof (imgrela
));
7224 /* Note: the order of the entries is specified by the OpenVMS specs. */
7225 for (entry
= dynamic_section
;
7226 entry
< dynamic_section
+ dynamic_nent
;
7229 switch (entry
->d_tag
)
7231 case DT_IA_64_VMS_STRTAB_OFFSET
:
7232 strtab_off
= entry
->d_un
.d_val
;
7235 strtab_sz
= entry
->d_un
.d_val
;
7237 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7238 1, strtab_sz
, _("dynamic string section"));
7241 case DT_IA_64_VMS_NEEDED_IDENT
:
7242 fixup
.needed_ident
= entry
->d_un
.d_val
;
7245 fixup
.needed
= entry
->d_un
.d_val
;
7247 case DT_IA_64_VMS_FIXUP_NEEDED
:
7248 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7250 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7251 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7253 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7254 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7255 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7258 case DT_IA_64_VMS_IMG_RELA_CNT
:
7259 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7261 case DT_IA_64_VMS_IMG_RELA_OFF
:
7262 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7263 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7285 dynamic_relocations
[] =
7287 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7288 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7289 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7292 /* Process the reloc section. */
7295 process_relocs (Filedata
* filedata
)
7297 unsigned long rel_size
;
7298 unsigned long rel_offset
;
7303 if (do_using_dynamic
)
7307 bfd_boolean has_dynamic_reloc
;
7310 has_dynamic_reloc
= FALSE
;
7312 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7314 is_rela
= dynamic_relocations
[i
].rela
;
7315 name
= dynamic_relocations
[i
].name
;
7316 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7317 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7320 has_dynamic_reloc
= TRUE
;
7322 if (is_rela
== UNKNOWN
)
7324 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7325 switch (dynamic_info
[DT_PLTREL
])
7339 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7340 name
, rel_offset
, rel_size
);
7342 dump_relocations (filedata
,
7343 offset_from_vma (filedata
, rel_offset
, rel_size
),
7345 dynamic_symbols
, num_dynamic_syms
,
7346 dynamic_strings
, dynamic_strings_length
,
7347 is_rela
, TRUE
/* is_dynamic */);
7351 if (is_ia64_vms (filedata
))
7352 if (process_ia64_vms_dynamic_relocs (filedata
))
7353 has_dynamic_reloc
= TRUE
;
7355 if (! has_dynamic_reloc
)
7356 printf (_("\nThere are no dynamic relocations in this file.\n"));
7360 Elf_Internal_Shdr
* section
;
7362 bfd_boolean found
= FALSE
;
7364 for (i
= 0, section
= filedata
->section_headers
;
7365 i
< filedata
->file_header
.e_shnum
;
7368 if ( section
->sh_type
!= SHT_RELA
7369 && section
->sh_type
!= SHT_REL
)
7372 rel_offset
= section
->sh_offset
;
7373 rel_size
= section
->sh_size
;
7377 Elf_Internal_Shdr
* strsec
;
7379 unsigned long num_rela
;
7381 printf (_("\nRelocation section "));
7383 if (filedata
->string_table
== NULL
)
7384 printf ("%d", section
->sh_name
);
7386 printf ("'%s'", printable_section_name (filedata
, section
));
7388 num_rela
= rel_size
/ section
->sh_entsize
;
7389 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7390 " at offset 0x%lx contains %lu entries:\n",
7392 rel_offset
, num_rela
);
7394 is_rela
= section
->sh_type
== SHT_RELA
;
7396 if (section
->sh_link
!= 0
7397 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7399 Elf_Internal_Shdr
* symsec
;
7400 Elf_Internal_Sym
* symtab
;
7401 unsigned long nsyms
;
7402 unsigned long strtablen
= 0;
7403 char * strtab
= NULL
;
7405 symsec
= filedata
->section_headers
+ section
->sh_link
;
7406 if (symsec
->sh_type
!= SHT_SYMTAB
7407 && symsec
->sh_type
!= SHT_DYNSYM
)
7410 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7415 if (symsec
->sh_link
!= 0
7416 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7418 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7420 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7423 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7426 dump_relocations (filedata
, rel_offset
, rel_size
,
7427 symtab
, nsyms
, strtab
, strtablen
,
7429 symsec
->sh_type
== SHT_DYNSYM
);
7435 dump_relocations (filedata
, rel_offset
, rel_size
,
7436 NULL
, 0, NULL
, 0, is_rela
,
7437 FALSE
/* is_dynamic */);
7445 /* Users sometimes forget the -D option, so try to be helpful. */
7446 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7448 if (dynamic_info
[dynamic_relocations
[i
].size
])
7450 printf (_("\nThere are no static relocations in this file."));
7451 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7456 if (i
== ARRAY_SIZE (dynamic_relocations
))
7457 printf (_("\nThere are no relocations in this file.\n"));
7464 /* An absolute address consists of a section and an offset. If the
7465 section is NULL, the offset itself is the address, otherwise, the
7466 address equals to LOAD_ADDRESS(section) + offset. */
7470 unsigned short section
;
7474 /* Find the nearest symbol at or below ADDR. Returns the symbol
7475 name, if found, and the offset from the symbol to ADDR. */
7478 find_symbol_for_address (Filedata
* filedata
,
7479 Elf_Internal_Sym
* symtab
,
7480 unsigned long nsyms
,
7481 const char * strtab
,
7482 unsigned long strtab_size
,
7483 struct absaddr addr
,
7484 const char ** symname
,
7487 bfd_vma dist
= 0x100000;
7488 Elf_Internal_Sym
* sym
;
7489 Elf_Internal_Sym
* beg
;
7490 Elf_Internal_Sym
* end
;
7491 Elf_Internal_Sym
* best
= NULL
;
7493 REMOVE_ARCH_BITS (addr
.offset
);
7495 end
= symtab
+ nsyms
;
7501 sym
= beg
+ (end
- beg
) / 2;
7503 value
= sym
->st_value
;
7504 REMOVE_ARCH_BITS (value
);
7506 if (sym
->st_name
!= 0
7507 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7508 && addr
.offset
>= value
7509 && addr
.offset
- value
< dist
)
7512 dist
= addr
.offset
- value
;
7517 if (addr
.offset
< value
)
7525 *symname
= (best
->st_name
>= strtab_size
7526 ? _("<corrupt>") : strtab
+ best
->st_name
);
7532 *offset
= addr
.offset
;
7535 static /* signed */ int
7536 symcmp (const void *p
, const void *q
)
7538 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7539 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7541 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7544 /* Process the unwind section. */
7546 #include "unwind-ia64.h"
7548 struct ia64_unw_table_entry
7550 struct absaddr start
;
7552 struct absaddr info
;
7555 struct ia64_unw_aux_info
7557 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7558 unsigned long table_len
; /* Length of unwind table. */
7559 unsigned char * info
; /* Unwind info. */
7560 unsigned long info_size
; /* Size of unwind info. */
7561 bfd_vma info_addr
; /* Starting address of unwind info. */
7562 bfd_vma seg_base
; /* Starting address of segment. */
7563 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7564 unsigned long nsyms
; /* Number of symbols. */
7565 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7566 unsigned long nfuns
; /* Number of entries in funtab. */
7567 char * strtab
; /* The string table. */
7568 unsigned long strtab_size
; /* Size of string table. */
7572 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7574 struct ia64_unw_table_entry
* tp
;
7575 unsigned long j
, nfuns
;
7577 bfd_boolean res
= TRUE
;
7579 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7580 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7581 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7582 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7584 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7586 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7590 const unsigned char * dp
;
7591 const unsigned char * head
;
7592 const unsigned char * end
;
7593 const char * procname
;
7595 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7596 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7598 fputs ("\n<", stdout
);
7602 fputs (procname
, stdout
);
7605 printf ("+%lx", (unsigned long) offset
);
7608 fputs (">: [", stdout
);
7609 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7610 fputc ('-', stdout
);
7611 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7612 printf ("], info at +0x%lx\n",
7613 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7615 /* PR 17531: file: 86232b32. */
7616 if (aux
->info
== NULL
)
7619 offset
= tp
->info
.offset
;
7620 if (tp
->info
.section
)
7622 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7624 warn (_("Invalid section %u in table entry %ld\n"),
7625 tp
->info
.section
, (long) (tp
- aux
->table
));
7629 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7631 offset
-= aux
->info_addr
;
7632 /* PR 17531: file: 0997b4d1. */
7633 if (offset
>= aux
->info_size
7634 || aux
->info_size
- offset
< 8)
7636 warn (_("Invalid offset %lx in table entry %ld\n"),
7637 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7642 head
= aux
->info
+ offset
;
7643 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7645 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7646 (unsigned) UNW_VER (stamp
),
7647 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7648 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7649 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7650 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7652 if (UNW_VER (stamp
) != 1)
7654 printf (_("\tUnknown version.\n"));
7659 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7660 /* PR 17531: file: 16ceda89. */
7661 if (end
> aux
->info
+ aux
->info_size
)
7662 end
= aux
->info
+ aux
->info_size
;
7663 for (dp
= head
+ 8; dp
< end
;)
7664 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7673 slurp_ia64_unwind_table (Filedata
* filedata
,
7674 struct ia64_unw_aux_info
* aux
,
7675 Elf_Internal_Shdr
* sec
)
7677 unsigned long size
, nrelas
, i
;
7678 Elf_Internal_Phdr
* seg
;
7679 struct ia64_unw_table_entry
* tep
;
7680 Elf_Internal_Shdr
* relsec
;
7681 Elf_Internal_Rela
* rela
;
7682 Elf_Internal_Rela
* rp
;
7683 unsigned char * table
;
7685 Elf_Internal_Sym
* sym
;
7686 const char * relname
;
7690 /* First, find the starting address of the segment that includes
7693 if (filedata
->file_header
.e_phnum
)
7695 if (! get_program_headers (filedata
))
7698 for (seg
= filedata
->program_headers
;
7699 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7702 if (seg
->p_type
!= PT_LOAD
)
7705 if (sec
->sh_addr
>= seg
->p_vaddr
7706 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7708 aux
->seg_base
= seg
->p_vaddr
;
7714 /* Second, build the unwind table from the contents of the unwind section: */
7715 size
= sec
->sh_size
;
7716 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7721 aux
->table_len
= size
/ (3 * eh_addr_size
);
7722 aux
->table
= (struct ia64_unw_table_entry
*)
7723 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7726 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7728 tep
->start
.section
= SHN_UNDEF
;
7729 tep
->end
.section
= SHN_UNDEF
;
7730 tep
->info
.section
= SHN_UNDEF
;
7731 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7732 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7733 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7734 tep
->start
.offset
+= aux
->seg_base
;
7735 tep
->end
.offset
+= aux
->seg_base
;
7736 tep
->info
.offset
+= aux
->seg_base
;
7740 /* Third, apply any relocations to the unwind table: */
7741 for (relsec
= filedata
->section_headers
;
7742 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7745 if (relsec
->sh_type
!= SHT_RELA
7746 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7747 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7750 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7759 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7761 unsigned int sym_ndx
;
7762 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7763 relname
= elf_ia64_reloc_type (r_type
);
7765 /* PR 17531: file: 9fa67536. */
7766 if (relname
== NULL
)
7768 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7772 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7774 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7778 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7780 /* PR 17531: file: 5bc8d9bf. */
7781 if (i
>= aux
->table_len
)
7783 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7787 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7788 if (sym_ndx
>= aux
->nsyms
)
7790 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7794 sym
= aux
->symtab
+ sym_ndx
;
7796 switch (rp
->r_offset
/ eh_addr_size
% 3)
7799 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7800 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7803 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7804 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7807 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7808 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7822 ia64_process_unwind (Filedata
* filedata
)
7824 Elf_Internal_Shdr
* sec
;
7825 Elf_Internal_Shdr
* unwsec
= NULL
;
7826 Elf_Internal_Shdr
* strsec
;
7827 unsigned long i
, unwcount
= 0, unwstart
= 0;
7828 struct ia64_unw_aux_info aux
;
7829 bfd_boolean res
= TRUE
;
7831 memset (& aux
, 0, sizeof (aux
));
7833 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7835 if (sec
->sh_type
== SHT_SYMTAB
7836 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7838 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7840 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7841 if (aux
.strtab
!= NULL
)
7843 error (_("Multiple auxillary string tables encountered\n"));
7847 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7850 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7852 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7857 printf (_("\nThere are no unwind sections in this file.\n"));
7859 while (unwcount
-- > 0)
7864 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7865 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7866 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7871 /* We have already counted the number of SHT_IA64_UNWIND
7872 sections so the loop above should never fail. */
7873 assert (unwsec
!= NULL
);
7876 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7878 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7880 /* We need to find which section group it is in. */
7881 struct group_list
* g
;
7883 if (section_headers_groups
== NULL
7884 || section_headers_groups
[i
] == NULL
)
7885 i
= filedata
->file_header
.e_shnum
;
7888 g
= section_headers_groups
[i
]->root
;
7890 for (; g
!= NULL
; g
= g
->next
)
7892 sec
= filedata
->section_headers
+ g
->section_index
;
7894 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7899 i
= filedata
->file_header
.e_shnum
;
7902 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7904 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7905 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7906 suffix
= SECTION_NAME (unwsec
) + len
;
7907 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7909 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7910 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7915 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7916 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7917 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7918 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7920 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7921 suffix
= SECTION_NAME (unwsec
) + len
;
7922 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7924 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7925 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7929 if (i
== filedata
->file_header
.e_shnum
)
7931 printf (_("\nCould not find unwind info section for "));
7933 if (filedata
->string_table
== NULL
)
7934 printf ("%d", unwsec
->sh_name
);
7936 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7940 aux
.info_addr
= sec
->sh_addr
;
7941 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7944 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7946 printf (_("\nUnwind section "));
7948 if (filedata
->string_table
== NULL
)
7949 printf ("%d", unwsec
->sh_name
);
7951 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7953 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7954 (unsigned long) unwsec
->sh_offset
,
7955 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7957 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7958 && aux
.table_len
> 0)
7959 dump_ia64_unwind (filedata
, & aux
);
7962 free ((char *) aux
.table
);
7964 free ((char *) aux
.info
);
7973 free ((char *) aux
.strtab
);
7978 struct hppa_unw_table_entry
7980 struct absaddr start
;
7982 unsigned int Cannot_unwind
:1; /* 0 */
7983 unsigned int Millicode
:1; /* 1 */
7984 unsigned int Millicode_save_sr0
:1; /* 2 */
7985 unsigned int Region_description
:2; /* 3..4 */
7986 unsigned int reserved1
:1; /* 5 */
7987 unsigned int Entry_SR
:1; /* 6 */
7988 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7989 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7990 unsigned int Args_stored
:1; /* 16 */
7991 unsigned int Variable_Frame
:1; /* 17 */
7992 unsigned int Separate_Package_Body
:1; /* 18 */
7993 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7994 unsigned int Stack_Overflow_Check
:1; /* 20 */
7995 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7996 unsigned int Ada_Region
:1; /* 22 */
7997 unsigned int cxx_info
:1; /* 23 */
7998 unsigned int cxx_try_catch
:1; /* 24 */
7999 unsigned int sched_entry_seq
:1; /* 25 */
8000 unsigned int reserved2
:1; /* 26 */
8001 unsigned int Save_SP
:1; /* 27 */
8002 unsigned int Save_RP
:1; /* 28 */
8003 unsigned int Save_MRP_in_frame
:1; /* 29 */
8004 unsigned int extn_ptr_defined
:1; /* 30 */
8005 unsigned int Cleanup_defined
:1; /* 31 */
8007 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8008 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8009 unsigned int Large_frame
:1; /* 2 */
8010 unsigned int Pseudo_SP_Set
:1; /* 3 */
8011 unsigned int reserved4
:1; /* 4 */
8012 unsigned int Total_frame_size
:27; /* 5..31 */
8015 struct hppa_unw_aux_info
8017 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8018 unsigned long table_len
; /* Length of unwind table. */
8019 bfd_vma seg_base
; /* Starting address of segment. */
8020 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8021 unsigned long nsyms
; /* Number of symbols. */
8022 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8023 unsigned long nfuns
; /* Number of entries in funtab. */
8024 char * strtab
; /* The string table. */
8025 unsigned long strtab_size
; /* Size of string table. */
8029 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8031 struct hppa_unw_table_entry
* tp
;
8032 unsigned long j
, nfuns
;
8033 bfd_boolean res
= TRUE
;
8035 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8036 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8037 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8038 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8040 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8042 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8045 const char * procname
;
8047 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8048 aux
->strtab_size
, tp
->start
, &procname
,
8051 fputs ("\n<", stdout
);
8055 fputs (procname
, stdout
);
8058 printf ("+%lx", (unsigned long) offset
);
8061 fputs (">: [", stdout
);
8062 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8063 fputc ('-', stdout
);
8064 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8067 #define PF(_m) if (tp->_m) printf (#_m " ");
8068 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8071 PF(Millicode_save_sr0
);
8072 /* PV(Region_description); */
8078 PF(Separate_Package_Body
);
8079 PF(Frame_Extension_Millicode
);
8080 PF(Stack_Overflow_Check
);
8081 PF(Two_Instruction_SP_Increment
);
8085 PF(sched_entry_seq
);
8088 PF(Save_MRP_in_frame
);
8089 PF(extn_ptr_defined
);
8090 PF(Cleanup_defined
);
8091 PF(MPE_XL_interrupt_marker
);
8092 PF(HP_UX_interrupt_marker
);
8095 PV(Total_frame_size
);
8108 slurp_hppa_unwind_table (Filedata
* filedata
,
8109 struct hppa_unw_aux_info
* aux
,
8110 Elf_Internal_Shdr
* sec
)
8112 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8113 Elf_Internal_Phdr
* seg
;
8114 struct hppa_unw_table_entry
* tep
;
8115 Elf_Internal_Shdr
* relsec
;
8116 Elf_Internal_Rela
* rela
;
8117 Elf_Internal_Rela
* rp
;
8118 unsigned char * table
;
8120 Elf_Internal_Sym
* sym
;
8121 const char * relname
;
8123 /* First, find the starting address of the segment that includes
8125 if (filedata
->file_header
.e_phnum
)
8127 if (! get_program_headers (filedata
))
8130 for (seg
= filedata
->program_headers
;
8131 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8134 if (seg
->p_type
!= PT_LOAD
)
8137 if (sec
->sh_addr
>= seg
->p_vaddr
8138 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8140 aux
->seg_base
= seg
->p_vaddr
;
8146 /* Second, build the unwind table from the contents of the unwind
8148 size
= sec
->sh_size
;
8149 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8155 nentries
= size
/ unw_ent_size
;
8156 size
= unw_ent_size
* nentries
;
8158 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8159 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8161 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8163 unsigned int tmp1
, tmp2
;
8165 tep
->start
.section
= SHN_UNDEF
;
8166 tep
->end
.section
= SHN_UNDEF
;
8168 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8169 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8170 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8171 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8173 tep
->start
.offset
+= aux
->seg_base
;
8174 tep
->end
.offset
+= aux
->seg_base
;
8176 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8177 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8178 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8179 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8180 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8181 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8182 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8183 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8184 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8185 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8186 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8187 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8188 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8189 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8190 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8191 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8192 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8193 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8194 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8195 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8196 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8197 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8198 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8199 tep
->Cleanup_defined
= tmp1
& 0x1;
8201 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8202 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8203 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8204 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8205 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8206 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8210 /* Third, apply any relocations to the unwind table. */
8211 for (relsec
= filedata
->section_headers
;
8212 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8215 if (relsec
->sh_type
!= SHT_RELA
8216 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8217 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8220 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8224 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8226 unsigned int sym_ndx
;
8227 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8228 relname
= elf_hppa_reloc_type (r_type
);
8230 if (relname
== NULL
)
8232 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8236 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8237 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8239 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8243 i
= rp
->r_offset
/ unw_ent_size
;
8244 if (i
>= aux
->table_len
)
8246 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8250 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8251 if (sym_ndx
>= aux
->nsyms
)
8253 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8257 sym
= aux
->symtab
+ sym_ndx
;
8259 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8262 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8263 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8266 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8267 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8277 aux
->table_len
= nentries
;
8283 hppa_process_unwind (Filedata
* filedata
)
8285 struct hppa_unw_aux_info aux
;
8286 Elf_Internal_Shdr
* unwsec
= NULL
;
8287 Elf_Internal_Shdr
* strsec
;
8288 Elf_Internal_Shdr
* sec
;
8290 bfd_boolean res
= TRUE
;
8292 if (filedata
->string_table
== NULL
)
8295 memset (& aux
, 0, sizeof (aux
));
8297 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8299 if (sec
->sh_type
== SHT_SYMTAB
8300 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8302 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8304 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8305 if (aux
.strtab
!= NULL
)
8307 error (_("Multiple auxillary string tables encountered\n"));
8311 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8314 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8316 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8321 printf (_("\nThere are no unwind sections in this file.\n"));
8323 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8325 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8327 unsigned long num_unwind
= sec
->sh_size
/ 16;
8329 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8330 "contains %lu entry:\n",
8331 "\nUnwind section '%s' at offset 0x%lx "
8332 "contains %lu entries:\n",
8334 printable_section_name (filedata
, sec
),
8335 (unsigned long) sec
->sh_offset
,
8338 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8341 if (res
&& aux
.table_len
> 0)
8343 if (! dump_hppa_unwind (filedata
, &aux
))
8348 free ((char *) aux
.table
);
8356 free ((char *) aux
.strtab
);
8363 unsigned char * data
; /* The unwind data. */
8364 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8365 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8366 unsigned long nrelas
; /* The number of relocations. */
8367 unsigned int rel_type
; /* REL or RELA ? */
8368 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8371 struct arm_unw_aux_info
8373 Filedata
* filedata
; /* The file containing the unwind sections. */
8374 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8375 unsigned long nsyms
; /* Number of symbols. */
8376 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8377 unsigned long nfuns
; /* Number of these symbols. */
8378 char * strtab
; /* The file's string table. */
8379 unsigned long strtab_size
; /* Size of string table. */
8383 arm_print_vma_and_name (Filedata
* filedata
,
8384 struct arm_unw_aux_info
* aux
,
8386 struct absaddr addr
)
8388 const char *procname
;
8391 if (addr
.section
== SHN_UNDEF
)
8394 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8395 aux
->strtab_size
, addr
, &procname
,
8398 print_vma (fn
, PREFIX_HEX
);
8402 fputs (" <", stdout
);
8403 fputs (procname
, stdout
);
8406 printf ("+0x%lx", (unsigned long) sym_offset
);
8407 fputc ('>', stdout
);
8414 arm_free_section (struct arm_section
*arm_sec
)
8416 if (arm_sec
->data
!= NULL
)
8417 free (arm_sec
->data
);
8419 if (arm_sec
->rela
!= NULL
)
8420 free (arm_sec
->rela
);
8423 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8424 cached section and install SEC instead.
8425 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8426 and return its valued in * WORDP, relocating if necessary.
8427 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8428 relocation's offset in ADDR.
8429 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8430 into the string table of the symbol associated with the reloc. If no
8431 reloc was applied store -1 there.
8432 5) Return TRUE upon success, FALSE otherwise. */
8435 get_unwind_section_word (Filedata
* filedata
,
8436 struct arm_unw_aux_info
* aux
,
8437 struct arm_section
* arm_sec
,
8438 Elf_Internal_Shdr
* sec
,
8439 bfd_vma word_offset
,
8440 unsigned int * wordp
,
8441 struct absaddr
* addr
,
8444 Elf_Internal_Rela
*rp
;
8445 Elf_Internal_Sym
*sym
;
8446 const char * relname
;
8448 bfd_boolean wrapped
;
8450 if (sec
== NULL
|| arm_sec
== NULL
)
8453 addr
->section
= SHN_UNDEF
;
8456 if (sym_name
!= NULL
)
8457 *sym_name
= (bfd_vma
) -1;
8459 /* If necessary, update the section cache. */
8460 if (sec
!= arm_sec
->sec
)
8462 Elf_Internal_Shdr
*relsec
;
8464 arm_free_section (arm_sec
);
8467 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8468 sec
->sh_size
, _("unwind data"));
8469 arm_sec
->rela
= NULL
;
8470 arm_sec
->nrelas
= 0;
8472 for (relsec
= filedata
->section_headers
;
8473 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8476 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8477 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8478 /* PR 15745: Check the section type as well. */
8479 || (relsec
->sh_type
!= SHT_REL
8480 && relsec
->sh_type
!= SHT_RELA
))
8483 arm_sec
->rel_type
= relsec
->sh_type
;
8484 if (relsec
->sh_type
== SHT_REL
)
8486 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8488 & arm_sec
->rela
, & arm_sec
->nrelas
))
8491 else /* relsec->sh_type == SHT_RELA */
8493 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8495 & arm_sec
->rela
, & arm_sec
->nrelas
))
8501 arm_sec
->next_rela
= arm_sec
->rela
;
8504 /* If there is no unwind data we can do nothing. */
8505 if (arm_sec
->data
== NULL
)
8508 /* If the offset is invalid then fail. */
8509 if (/* PR 21343 *//* PR 18879 */
8511 || word_offset
> (sec
->sh_size
- 4)
8512 || ((bfd_signed_vma
) word_offset
) < 0)
8515 /* Get the word at the required offset. */
8516 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8518 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8519 if (arm_sec
->rela
== NULL
)
8525 /* Look through the relocs to find the one that applies to the provided offset. */
8527 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8529 bfd_vma prelval
, offset
;
8531 if (rp
->r_offset
> word_offset
&& !wrapped
)
8536 if (rp
->r_offset
> word_offset
)
8539 if (rp
->r_offset
& 3)
8541 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8542 (unsigned long) rp
->r_offset
);
8546 if (rp
->r_offset
< word_offset
)
8549 /* PR 17531: file: 027-161405-0.004 */
8550 if (aux
->symtab
== NULL
)
8553 if (arm_sec
->rel_type
== SHT_REL
)
8555 offset
= word
& 0x7fffffff;
8556 if (offset
& 0x40000000)
8557 offset
|= ~ (bfd_vma
) 0x7fffffff;
8559 else if (arm_sec
->rel_type
== SHT_RELA
)
8560 offset
= rp
->r_addend
;
8563 error (_("Unknown section relocation type %d encountered\n"),
8568 /* PR 17531 file: 027-1241568-0.004. */
8569 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8571 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8572 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8576 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8577 offset
+= sym
->st_value
;
8578 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8580 /* Check that we are processing the expected reloc type. */
8581 if (filedata
->file_header
.e_machine
== EM_ARM
)
8583 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8584 if (relname
== NULL
)
8586 warn (_("Skipping unknown ARM relocation type: %d\n"),
8587 (int) ELF32_R_TYPE (rp
->r_info
));
8591 if (streq (relname
, "R_ARM_NONE"))
8594 if (! streq (relname
, "R_ARM_PREL31"))
8596 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8600 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8602 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8603 if (relname
== NULL
)
8605 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8606 (int) ELF32_R_TYPE (rp
->r_info
));
8610 if (streq (relname
, "R_C6000_NONE"))
8613 if (! streq (relname
, "R_C6000_PREL31"))
8615 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8623 /* This function currently only supports ARM and TI unwinders. */
8624 warn (_("Only TI and ARM unwinders are currently supported\n"));
8628 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8629 addr
->section
= sym
->st_shndx
;
8630 addr
->offset
= offset
;
8633 * sym_name
= sym
->st_name
;
8638 arm_sec
->next_rela
= rp
;
8643 static const char *tic6x_unwind_regnames
[16] =
8645 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8646 "A14", "A13", "A12", "A11", "A10",
8647 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8651 decode_tic6x_unwind_regmask (unsigned int mask
)
8655 for (i
= 12; mask
; mask
>>= 1, i
--)
8659 fputs (tic6x_unwind_regnames
[i
], stdout
);
8661 fputs (", ", stdout
);
8667 if (remaining == 0 && more_words) \
8670 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8671 data_offset, & word, & addr, NULL)) \
8677 #define GET_OP(OP) \
8682 (OP) = word >> 24; \
8687 printf (_("[Truncated opcode]\n")); \
8690 printf ("0x%02x ", OP)
8693 decode_arm_unwind_bytecode (Filedata
* filedata
,
8694 struct arm_unw_aux_info
* aux
,
8696 unsigned int remaining
,
8697 unsigned int more_words
,
8698 bfd_vma data_offset
,
8699 Elf_Internal_Shdr
* data_sec
,
8700 struct arm_section
* data_arm_sec
)
8702 struct absaddr addr
;
8703 bfd_boolean res
= TRUE
;
8705 /* Decode the unwinding instructions. */
8708 unsigned int op
, op2
;
8717 printf (" 0x%02x ", op
);
8719 if ((op
& 0xc0) == 0x00)
8721 int offset
= ((op
& 0x3f) << 2) + 4;
8723 printf (" vsp = vsp + %d", offset
);
8725 else if ((op
& 0xc0) == 0x40)
8727 int offset
= ((op
& 0x3f) << 2) + 4;
8729 printf (" vsp = vsp - %d", offset
);
8731 else if ((op
& 0xf0) == 0x80)
8734 if (op
== 0x80 && op2
== 0)
8735 printf (_("Refuse to unwind"));
8738 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8739 bfd_boolean first
= TRUE
;
8743 for (i
= 0; i
< 12; i
++)
8744 if (mask
& (1 << i
))
8750 printf ("r%d", 4 + i
);
8755 else if ((op
& 0xf0) == 0x90)
8757 if (op
== 0x9d || op
== 0x9f)
8758 printf (_(" [Reserved]"));
8760 printf (" vsp = r%d", op
& 0x0f);
8762 else if ((op
& 0xf0) == 0xa0)
8764 int end
= 4 + (op
& 0x07);
8765 bfd_boolean first
= TRUE
;
8769 for (i
= 4; i
<= end
; i
++)
8785 else if (op
== 0xb0)
8786 printf (_(" finish"));
8787 else if (op
== 0xb1)
8790 if (op2
== 0 || (op2
& 0xf0) != 0)
8791 printf (_("[Spare]"));
8794 unsigned int mask
= op2
& 0x0f;
8795 bfd_boolean first
= TRUE
;
8799 for (i
= 0; i
< 12; i
++)
8800 if (mask
& (1 << i
))
8811 else if (op
== 0xb2)
8813 unsigned char buf
[9];
8814 unsigned int i
, len
;
8815 unsigned long offset
;
8817 for (i
= 0; i
< sizeof (buf
); i
++)
8820 if ((buf
[i
] & 0x80) == 0)
8823 if (i
== sizeof (buf
))
8825 error (_("corrupt change to vsp"));
8830 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8831 assert (len
== i
+ 1);
8832 offset
= offset
* 4 + 0x204;
8833 printf ("vsp = vsp + %ld", offset
);
8836 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8838 unsigned int first
, last
;
8845 printf ("pop {D%d", first
);
8847 printf ("-D%d", first
+ last
);
8850 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8852 unsigned int count
= op
& 0x07;
8856 printf ("-D%d", 8 + count
);
8859 else if (op
>= 0xc0 && op
<= 0xc5)
8861 unsigned int count
= op
& 0x07;
8863 printf (" pop {wR10");
8865 printf ("-wR%d", 10 + count
);
8868 else if (op
== 0xc6)
8870 unsigned int first
, last
;
8875 printf ("pop {wR%d", first
);
8877 printf ("-wR%d", first
+ last
);
8880 else if (op
== 0xc7)
8883 if (op2
== 0 || (op2
& 0xf0) != 0)
8884 printf (_("[Spare]"));
8887 unsigned int mask
= op2
& 0x0f;
8888 bfd_boolean first
= TRUE
;
8892 for (i
= 0; i
< 4; i
++)
8893 if (mask
& (1 << i
))
8899 printf ("wCGR%d", i
);
8906 printf (_(" [unsupported opcode]"));
8917 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8918 struct arm_unw_aux_info
* aux
,
8920 unsigned int remaining
,
8921 unsigned int more_words
,
8922 bfd_vma data_offset
,
8923 Elf_Internal_Shdr
* data_sec
,
8924 struct arm_section
* data_arm_sec
)
8926 struct absaddr addr
;
8928 /* Decode the unwinding instructions. */
8931 unsigned int op
, op2
;
8940 printf (" 0x%02x ", op
);
8942 if ((op
& 0xc0) == 0x00)
8944 int offset
= ((op
& 0x3f) << 3) + 8;
8945 printf (" sp = sp + %d", offset
);
8947 else if ((op
& 0xc0) == 0x80)
8950 if (op
== 0x80 && op2
== 0)
8951 printf (_("Refuse to unwind"));
8954 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8956 printf ("pop compact {");
8960 decode_tic6x_unwind_regmask (mask
);
8964 else if ((op
& 0xf0) == 0xc0)
8972 unsigned int offset
;
8976 /* Scan entire instruction first so that GET_OP output is not
8977 interleaved with disassembly. */
8979 for (i
= 0; nregs
< (op
& 0xf); i
++)
8985 regpos
[nregs
].offset
= i
* 2;
8986 regpos
[nregs
].reg
= reg
;
8993 regpos
[nregs
].offset
= i
* 2 + 1;
8994 regpos
[nregs
].reg
= reg
;
8999 printf (_("pop frame {"));
9002 printf (_("*corrupt* - no registers specified"));
9007 for (i
= i
* 2; i
> 0; i
--)
9009 if (regpos
[reg
].offset
== i
- 1)
9011 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9018 fputs (name
, stdout
);
9026 else if (op
== 0xd0)
9027 printf (" MOV FP, SP");
9028 else if (op
== 0xd1)
9029 printf (" __c6xabi_pop_rts");
9030 else if (op
== 0xd2)
9032 unsigned char buf
[9];
9033 unsigned int i
, len
;
9034 unsigned long offset
;
9036 for (i
= 0; i
< sizeof (buf
); i
++)
9039 if ((buf
[i
] & 0x80) == 0)
9042 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9043 if (i
== sizeof (buf
))
9045 warn (_("Corrupt stack pointer adjustment detected\n"));
9049 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9050 assert (len
== i
+ 1);
9051 offset
= offset
* 8 + 0x408;
9052 printf (_("sp = sp + %ld"), offset
);
9054 else if ((op
& 0xf0) == 0xe0)
9056 if ((op
& 0x0f) == 7)
9059 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9063 printf (_(" [unsupported opcode]"));
9072 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9076 offset
= word
& 0x7fffffff;
9077 if (offset
& 0x40000000)
9078 offset
|= ~ (bfd_vma
) 0x7fffffff;
9080 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9083 return offset
+ where
;
9087 decode_arm_unwind (Filedata
* filedata
,
9088 struct arm_unw_aux_info
* aux
,
9090 unsigned int remaining
,
9091 bfd_vma data_offset
,
9092 Elf_Internal_Shdr
* data_sec
,
9093 struct arm_section
* data_arm_sec
)
9096 unsigned int more_words
= 0;
9097 struct absaddr addr
;
9098 bfd_vma sym_name
= (bfd_vma
) -1;
9099 bfd_boolean res
= TRUE
;
9103 /* Fetch the first word.
9104 Note - when decoding an object file the address extracted
9105 here will always be 0. So we also pass in the sym_name
9106 parameter so that we can find the symbol associated with
9107 the personality routine. */
9108 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9109 & word
, & addr
, & sym_name
))
9116 addr
.section
= SHN_UNDEF
;
9120 if ((word
& 0x80000000) == 0)
9122 /* Expand prel31 for personality routine. */
9124 const char *procname
;
9126 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9127 printf (_(" Personality routine: "));
9129 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9130 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9132 procname
= aux
->strtab
+ sym_name
;
9133 print_vma (fn
, PREFIX_HEX
);
9136 fputs (" <", stdout
);
9137 fputs (procname
, stdout
);
9138 fputc ('>', stdout
);
9142 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9143 fputc ('\n', stdout
);
9145 /* The GCC personality routines use the standard compact
9146 encoding, starting with one byte giving the number of
9148 if (procname
!= NULL
9149 && (const_strneq (procname
, "__gcc_personality_v0")
9150 || const_strneq (procname
, "__gxx_personality_v0")
9151 || const_strneq (procname
, "__gcj_personality_v0")
9152 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9159 printf (_(" [Truncated data]\n"));
9162 more_words
= word
>> 24;
9172 /* ARM EHABI Section 6.3:
9174 An exception-handling table entry for the compact model looks like:
9178 1 0 index Data for personalityRoutine[index] */
9180 if (filedata
->file_header
.e_machine
== EM_ARM
9181 && (word
& 0x70000000))
9183 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9187 per_index
= (word
>> 24) & 0x7f;
9188 printf (_(" Compact model index: %d\n"), per_index
);
9195 else if (per_index
< 3)
9197 more_words
= (word
>> 16) & 0xff;
9203 switch (filedata
->file_header
.e_machine
)
9208 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9209 data_offset
, data_sec
, data_arm_sec
))
9214 warn (_("Unknown ARM compact model index encountered\n"));
9215 printf (_(" [reserved]\n"));
9223 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9224 data_offset
, data_sec
, data_arm_sec
))
9227 else if (per_index
< 5)
9229 if (((word
>> 17) & 0x7f) == 0x7f)
9230 printf (_(" Restore stack from frame pointer\n"));
9232 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9233 printf (_(" Registers restored: "));
9235 printf (" (compact) ");
9236 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9238 printf (_(" Return register: %s\n"),
9239 tic6x_unwind_regnames
[word
& 0xf]);
9242 printf (_(" [reserved (%d)]\n"), per_index
);
9246 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9247 filedata
->file_header
.e_machine
);
9251 /* Decode the descriptors. Not implemented. */
9257 dump_arm_unwind (Filedata
* filedata
,
9258 struct arm_unw_aux_info
* aux
,
9259 Elf_Internal_Shdr
* exidx_sec
)
9261 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9262 unsigned int i
, exidx_len
;
9263 unsigned long j
, nfuns
;
9264 bfd_boolean res
= TRUE
;
9266 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9267 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9268 exidx_len
= exidx_sec
->sh_size
/ 8;
9270 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9271 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9272 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9273 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9275 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9277 for (i
= 0; i
< exidx_len
; i
++)
9279 unsigned int exidx_fn
, exidx_entry
;
9280 struct absaddr fn_addr
, entry_addr
;
9283 fputc ('\n', stdout
);
9285 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9286 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9287 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9288 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9291 arm_free_section (& exidx_arm_sec
);
9292 arm_free_section (& extab_arm_sec
);
9296 /* ARM EHABI, Section 5:
9297 An index table entry consists of 2 words.
9298 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9299 if (exidx_fn
& 0x80000000)
9301 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9305 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9307 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9308 fputs (": ", stdout
);
9310 if (exidx_entry
== 1)
9312 print_vma (exidx_entry
, PREFIX_HEX
);
9313 fputs (" [cantunwind]\n", stdout
);
9315 else if (exidx_entry
& 0x80000000)
9317 print_vma (exidx_entry
, PREFIX_HEX
);
9318 fputc ('\n', stdout
);
9319 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9323 bfd_vma table
, table_offset
= 0;
9324 Elf_Internal_Shdr
*table_sec
;
9326 fputs ("@", stdout
);
9327 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9328 print_vma (table
, PREFIX_HEX
);
9331 /* Locate the matching .ARM.extab. */
9332 if (entry_addr
.section
!= SHN_UNDEF
9333 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9335 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9336 table_offset
= entry_addr
.offset
;
9338 if (table_offset
> table_sec
->sh_size
9339 || ((bfd_signed_vma
) table_offset
) < 0)
9341 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9342 (unsigned long) table_offset
,
9343 printable_section_name (filedata
, table_sec
));
9350 table_sec
= find_section_by_address (filedata
, table
);
9351 if (table_sec
!= NULL
)
9352 table_offset
= table
- table_sec
->sh_addr
;
9355 if (table_sec
== NULL
)
9357 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9358 (unsigned long) table
);
9363 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9372 arm_free_section (&exidx_arm_sec
);
9373 arm_free_section (&extab_arm_sec
);
9378 /* Used for both ARM and C6X unwinding tables. */
9381 arm_process_unwind (Filedata
* filedata
)
9383 struct arm_unw_aux_info aux
;
9384 Elf_Internal_Shdr
*unwsec
= NULL
;
9385 Elf_Internal_Shdr
*strsec
;
9386 Elf_Internal_Shdr
*sec
;
9388 unsigned int sec_type
;
9389 bfd_boolean res
= TRUE
;
9391 switch (filedata
->file_header
.e_machine
)
9394 sec_type
= SHT_ARM_EXIDX
;
9398 sec_type
= SHT_C6000_UNWIND
;
9402 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9403 filedata
->file_header
.e_machine
);
9407 if (filedata
->string_table
== NULL
)
9410 memset (& aux
, 0, sizeof (aux
));
9411 aux
.filedata
= filedata
;
9413 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9415 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9417 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9419 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9421 /* PR binutils/17531 file: 011-12666-0.004. */
9422 if (aux
.strtab
!= NULL
)
9424 error (_("Multiple string tables found in file.\n"));
9428 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9429 1, strsec
->sh_size
, _("string table"));
9430 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9432 else if (sec
->sh_type
== sec_type
)
9437 printf (_("\nThere are no unwind sections in this file.\n"));
9439 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9441 if (sec
->sh_type
== sec_type
)
9443 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9444 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9445 "contains %lu entry:\n",
9446 "\nUnwind section '%s' at offset 0x%lx "
9447 "contains %lu entries:\n",
9449 printable_section_name (filedata
, sec
),
9450 (unsigned long) sec
->sh_offset
,
9453 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9461 free ((char *) aux
.strtab
);
9467 process_unwind (Filedata
* filedata
)
9469 struct unwind_handler
9471 unsigned int machtype
;
9472 bfd_boolean (* handler
)(Filedata
*);
9475 { EM_ARM
, arm_process_unwind
},
9476 { EM_IA_64
, ia64_process_unwind
},
9477 { EM_PARISC
, hppa_process_unwind
},
9478 { EM_TI_C6000
, arm_process_unwind
},
9486 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9487 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9488 return handlers
[i
].handler (filedata
);
9490 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9491 get_machine_name (filedata
->file_header
.e_machine
));
9496 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9498 switch (entry
->d_tag
)
9500 case DT_AARCH64_BTI_PLT
:
9501 case DT_AARCH64_PAC_PLT
:
9504 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9511 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9513 switch (entry
->d_tag
)
9516 if (entry
->d_un
.d_val
== 0)
9520 static const char * opts
[] =
9522 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9523 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9524 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9525 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9529 bfd_boolean first
= TRUE
;
9531 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9532 if (entry
->d_un
.d_val
& (1 << cnt
))
9534 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9540 case DT_MIPS_IVERSION
:
9541 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9542 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9546 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9547 /* Note: coded this way so that there is a single string for translation. */
9548 printf (_("<corrupt: %s>"), buf
);
9552 case DT_MIPS_TIME_STAMP
:
9556 time_t atime
= entry
->d_un
.d_val
;
9558 tmp
= gmtime (&atime
);
9559 /* PR 17531: file: 6accc532. */
9561 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9563 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9564 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9565 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9566 printf (_("Time Stamp: %s"), timebuf
);
9570 case DT_MIPS_RLD_VERSION
:
9571 case DT_MIPS_LOCAL_GOTNO
:
9572 case DT_MIPS_CONFLICTNO
:
9573 case DT_MIPS_LIBLISTNO
:
9574 case DT_MIPS_SYMTABNO
:
9575 case DT_MIPS_UNREFEXTNO
:
9576 case DT_MIPS_HIPAGENO
:
9577 case DT_MIPS_DELTA_CLASS_NO
:
9578 case DT_MIPS_DELTA_INSTANCE_NO
:
9579 case DT_MIPS_DELTA_RELOC_NO
:
9580 case DT_MIPS_DELTA_SYM_NO
:
9581 case DT_MIPS_DELTA_CLASSSYM_NO
:
9582 case DT_MIPS_COMPACT_SIZE
:
9583 print_vma (entry
->d_un
.d_val
, DEC
);
9587 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9588 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9589 /* Falls through. */
9592 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9598 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9600 switch (entry
->d_tag
)
9602 case DT_HP_DLD_FLAGS
:
9611 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9612 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9613 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9614 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9615 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9616 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9617 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9618 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9619 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9620 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9621 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9622 { DT_HP_GST
, "HP_GST" },
9623 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9624 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9625 { DT_HP_NODELETE
, "HP_NODELETE" },
9626 { DT_HP_GROUP
, "HP_GROUP" },
9627 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9629 bfd_boolean first
= TRUE
;
9631 bfd_vma val
= entry
->d_un
.d_val
;
9633 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9634 if (val
& flags
[cnt
].bit
)
9638 fputs (flags
[cnt
].str
, stdout
);
9640 val
^= flags
[cnt
].bit
;
9643 if (val
!= 0 || first
)
9647 print_vma (val
, HEX
);
9653 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9661 /* VMS vs Unix time offset and factor. */
9663 #define VMS_EPOCH_OFFSET 35067168000000000LL
9664 #define VMS_GRANULARITY_FACTOR 10000000
9666 /* Display a VMS time in a human readable format. */
9669 print_vms_time (bfd_int64_t vmstime
)
9674 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9675 tm
= gmtime (&unxtime
);
9676 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9677 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9678 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9683 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9685 switch (entry
->d_tag
)
9687 case DT_IA_64_PLT_RESERVE
:
9688 /* First 3 slots reserved. */
9689 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9691 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9694 case DT_IA_64_VMS_LINKTIME
:
9696 print_vms_time (entry
->d_un
.d_val
);
9700 case DT_IA_64_VMS_LNKFLAGS
:
9701 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9702 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9703 printf (" CALL_DEBUG");
9704 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9705 printf (" NOP0BUFS");
9706 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9707 printf (" P0IMAGE");
9708 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9709 printf (" MKTHREADS");
9710 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9711 printf (" UPCALLS");
9712 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9714 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9715 printf (" INITIALIZE");
9716 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9718 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9719 printf (" EXE_INIT");
9720 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9721 printf (" TBK_IN_IMG");
9722 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9723 printf (" DBG_IN_IMG");
9724 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9725 printf (" TBK_IN_DSF");
9726 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9727 printf (" DBG_IN_DSF");
9728 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9729 printf (" SIGNATURES");
9730 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9731 printf (" REL_SEG_OFF");
9735 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9742 get_32bit_dynamic_section (Filedata
* filedata
)
9744 Elf32_External_Dyn
* edyn
;
9745 Elf32_External_Dyn
* ext
;
9746 Elf_Internal_Dyn
* entry
;
9748 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9749 dynamic_size
, _("dynamic section"));
9753 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9754 might not have the luxury of section headers. Look for the DT_NULL
9755 terminator to determine the number of entries. */
9756 for (ext
= edyn
, dynamic_nent
= 0;
9757 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9761 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9765 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9767 if (dynamic_section
== NULL
)
9769 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9770 (unsigned long) dynamic_nent
);
9775 for (ext
= edyn
, entry
= dynamic_section
;
9776 entry
< dynamic_section
+ dynamic_nent
;
9779 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9780 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9789 get_64bit_dynamic_section (Filedata
* filedata
)
9791 Elf64_External_Dyn
* edyn
;
9792 Elf64_External_Dyn
* ext
;
9793 Elf_Internal_Dyn
* entry
;
9795 /* Read in the data. */
9796 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9797 dynamic_size
, _("dynamic section"));
9801 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9802 might not have the luxury of section headers. Look for the DT_NULL
9803 terminator to determine the number of entries. */
9804 for (ext
= edyn
, dynamic_nent
= 0;
9805 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9806 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9810 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9814 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9816 if (dynamic_section
== NULL
)
9818 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9819 (unsigned long) dynamic_nent
);
9824 /* Convert from external to internal formats. */
9825 for (ext
= edyn
, entry
= dynamic_section
;
9826 entry
< dynamic_section
+ dynamic_nent
;
9829 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9830 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9839 print_dynamic_flags (bfd_vma flags
)
9841 bfd_boolean first
= TRUE
;
9847 flag
= flags
& - flags
;
9857 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9858 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9859 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9860 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9861 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9862 default: fputs (_("unknown"), stdout
); break;
9868 /* Parse and display the contents of the dynamic section. */
9871 process_dynamic_section (Filedata
* filedata
)
9873 Elf_Internal_Dyn
* entry
;
9875 if (dynamic_size
== 0)
9878 printf (_("\nThere is no dynamic section in this file.\n"));
9885 if (! get_32bit_dynamic_section (filedata
))
9890 if (! get_64bit_dynamic_section (filedata
))
9894 /* Find the appropriate symbol table. */
9895 if (dynamic_symbols
== NULL
)
9897 for (entry
= dynamic_section
;
9898 entry
< dynamic_section
+ dynamic_nent
;
9901 Elf_Internal_Shdr section
;
9903 if (entry
->d_tag
!= DT_SYMTAB
)
9906 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9908 /* Since we do not know how big the symbol table is,
9909 we default to reading in the entire file (!) and
9910 processing that. This is overkill, I know, but it
9912 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9913 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9915 /* See PR 21379 for a reproducer. */
9916 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9920 if (archive_file_offset
!= 0)
9921 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9923 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9926 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9928 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9929 section
.sh_name
= filedata
->string_table_length
;
9931 if (dynamic_symbols
!= NULL
)
9933 error (_("Multiple dynamic symbol table sections found\n"));
9934 free (dynamic_symbols
);
9936 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9937 if (num_dynamic_syms
< 1)
9939 error (_("Unable to determine the number of symbols to load\n"));
9945 /* Similarly find a string table. */
9946 if (dynamic_strings
== NULL
)
9948 for (entry
= dynamic_section
;
9949 entry
< dynamic_section
+ dynamic_nent
;
9952 unsigned long offset
;
9955 if (entry
->d_tag
!= DT_STRTAB
)
9958 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9960 /* Since we do not know how big the string table is,
9961 we default to reading in the entire file (!) and
9962 processing that. This is overkill, I know, but it
9965 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9967 if (archive_file_offset
!= 0)
9968 str_tab_len
= archive_file_size
- offset
;
9970 str_tab_len
= filedata
->file_size
- offset
;
9972 if (str_tab_len
< 1)
9975 (_("Unable to determine the length of the dynamic string table\n"));
9979 if (dynamic_strings
!= NULL
)
9981 error (_("Multiple dynamic string tables found\n"));
9982 free (dynamic_strings
);
9985 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9987 _("dynamic string table"));
9988 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9992 /* And find the syminfo section if available. */
9993 if (dynamic_syminfo
== NULL
)
9995 unsigned long syminsz
= 0;
9997 for (entry
= dynamic_section
;
9998 entry
< dynamic_section
+ dynamic_nent
;
10001 if (entry
->d_tag
== DT_SYMINENT
)
10003 /* Note: these braces are necessary to avoid a syntax
10004 error from the SunOS4 C compiler. */
10005 /* PR binutils/17531: A corrupt file can trigger this test.
10006 So do not use an assert, instead generate an error message. */
10007 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10008 error (_("Bad value (%d) for SYMINENT entry\n"),
10009 (int) entry
->d_un
.d_val
);
10011 else if (entry
->d_tag
== DT_SYMINSZ
)
10012 syminsz
= entry
->d_un
.d_val
;
10013 else if (entry
->d_tag
== DT_SYMINFO
)
10014 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
10018 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10020 Elf_External_Syminfo
* extsyminfo
;
10021 Elf_External_Syminfo
* extsym
;
10022 Elf_Internal_Syminfo
* syminfo
;
10024 /* There is a syminfo section. Read the data. */
10025 extsyminfo
= (Elf_External_Syminfo
*)
10026 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
10027 _("symbol information"));
10031 if (dynamic_syminfo
!= NULL
)
10033 error (_("Multiple dynamic symbol information sections found\n"));
10034 free (dynamic_syminfo
);
10036 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10037 if (dynamic_syminfo
== NULL
)
10039 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10040 (unsigned long) syminsz
);
10044 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10045 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10046 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10047 ++syminfo
, ++extsym
)
10049 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10050 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10057 if (do_dynamic
&& dynamic_addr
)
10058 printf (ngettext ("\nDynamic section at offset 0x%lx "
10059 "contains %lu entry:\n",
10060 "\nDynamic section at offset 0x%lx "
10061 "contains %lu entries:\n",
10063 dynamic_addr
, (unsigned long) dynamic_nent
);
10065 printf (_(" Tag Type Name/Value\n"));
10067 for (entry
= dynamic_section
;
10068 entry
< dynamic_section
+ dynamic_nent
;
10073 const char * dtype
;
10076 print_vma (entry
->d_tag
, FULL_HEX
);
10077 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10078 printf (" (%s)%*s", dtype
,
10079 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10082 switch (entry
->d_tag
)
10086 print_dynamic_flags (entry
->d_un
.d_val
);
10096 switch (entry
->d_tag
)
10099 printf (_("Auxiliary library"));
10103 printf (_("Filter library"));
10107 printf (_("Configuration file"));
10111 printf (_("Dependency audit library"));
10115 printf (_("Audit library"));
10119 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10120 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10124 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10133 printf (_("Flags:"));
10135 if (entry
->d_un
.d_val
== 0)
10136 printf (_(" None\n"));
10139 unsigned long int val
= entry
->d_un
.d_val
;
10141 if (val
& DTF_1_PARINIT
)
10143 printf (" PARINIT");
10144 val
^= DTF_1_PARINIT
;
10146 if (val
& DTF_1_CONFEXP
)
10148 printf (" CONFEXP");
10149 val
^= DTF_1_CONFEXP
;
10152 printf (" %lx", val
);
10161 printf (_("Flags:"));
10163 if (entry
->d_un
.d_val
== 0)
10164 printf (_(" None\n"));
10167 unsigned long int val
= entry
->d_un
.d_val
;
10169 if (val
& DF_P1_LAZYLOAD
)
10171 printf (" LAZYLOAD");
10172 val
^= DF_P1_LAZYLOAD
;
10174 if (val
& DF_P1_GROUPPERM
)
10176 printf (" GROUPPERM");
10177 val
^= DF_P1_GROUPPERM
;
10180 printf (" %lx", val
);
10189 printf (_("Flags:"));
10190 if (entry
->d_un
.d_val
== 0)
10191 printf (_(" None\n"));
10194 unsigned long int val
= entry
->d_un
.d_val
;
10196 if (val
& DF_1_NOW
)
10201 if (val
& DF_1_GLOBAL
)
10203 printf (" GLOBAL");
10204 val
^= DF_1_GLOBAL
;
10206 if (val
& DF_1_GROUP
)
10211 if (val
& DF_1_NODELETE
)
10213 printf (" NODELETE");
10214 val
^= DF_1_NODELETE
;
10216 if (val
& DF_1_LOADFLTR
)
10218 printf (" LOADFLTR");
10219 val
^= DF_1_LOADFLTR
;
10221 if (val
& DF_1_INITFIRST
)
10223 printf (" INITFIRST");
10224 val
^= DF_1_INITFIRST
;
10226 if (val
& DF_1_NOOPEN
)
10228 printf (" NOOPEN");
10229 val
^= DF_1_NOOPEN
;
10231 if (val
& DF_1_ORIGIN
)
10233 printf (" ORIGIN");
10234 val
^= DF_1_ORIGIN
;
10236 if (val
& DF_1_DIRECT
)
10238 printf (" DIRECT");
10239 val
^= DF_1_DIRECT
;
10241 if (val
& DF_1_TRANS
)
10246 if (val
& DF_1_INTERPOSE
)
10248 printf (" INTERPOSE");
10249 val
^= DF_1_INTERPOSE
;
10251 if (val
& DF_1_NODEFLIB
)
10253 printf (" NODEFLIB");
10254 val
^= DF_1_NODEFLIB
;
10256 if (val
& DF_1_NODUMP
)
10258 printf (" NODUMP");
10259 val
^= DF_1_NODUMP
;
10261 if (val
& DF_1_CONFALT
)
10263 printf (" CONFALT");
10264 val
^= DF_1_CONFALT
;
10266 if (val
& DF_1_ENDFILTEE
)
10268 printf (" ENDFILTEE");
10269 val
^= DF_1_ENDFILTEE
;
10271 if (val
& DF_1_DISPRELDNE
)
10273 printf (" DISPRELDNE");
10274 val
^= DF_1_DISPRELDNE
;
10276 if (val
& DF_1_DISPRELPND
)
10278 printf (" DISPRELPND");
10279 val
^= DF_1_DISPRELPND
;
10281 if (val
& DF_1_NODIRECT
)
10283 printf (" NODIRECT");
10284 val
^= DF_1_NODIRECT
;
10286 if (val
& DF_1_IGNMULDEF
)
10288 printf (" IGNMULDEF");
10289 val
^= DF_1_IGNMULDEF
;
10291 if (val
& DF_1_NOKSYMS
)
10293 printf (" NOKSYMS");
10294 val
^= DF_1_NOKSYMS
;
10296 if (val
& DF_1_NOHDR
)
10301 if (val
& DF_1_EDITED
)
10303 printf (" EDITED");
10304 val
^= DF_1_EDITED
;
10306 if (val
& DF_1_NORELOC
)
10308 printf (" NORELOC");
10309 val
^= DF_1_NORELOC
;
10311 if (val
& DF_1_SYMINTPOSE
)
10313 printf (" SYMINTPOSE");
10314 val
^= DF_1_SYMINTPOSE
;
10316 if (val
& DF_1_GLOBAUDIT
)
10318 printf (" GLOBAUDIT");
10319 val
^= DF_1_GLOBAUDIT
;
10321 if (val
& DF_1_SINGLETON
)
10323 printf (" SINGLETON");
10324 val
^= DF_1_SINGLETON
;
10326 if (val
& DF_1_STUB
)
10331 if (val
& DF_1_PIE
)
10336 if (val
& DF_1_KMOD
)
10341 if (val
& DF_1_WEAKFILTER
)
10343 printf (" WEAKFILTER");
10344 val
^= DF_1_WEAKFILTER
;
10346 if (val
& DF_1_NOCOMMON
)
10348 printf (" NOCOMMON");
10349 val
^= DF_1_NOCOMMON
;
10352 printf (" %lx", val
);
10359 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10361 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10381 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10387 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10388 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10394 switch (entry
->d_tag
)
10397 printf (_("Shared library: [%s]"), name
);
10399 if (streq (name
, program_interpreter
))
10400 printf (_(" program interpreter"));
10404 printf (_("Library soname: [%s]"), name
);
10408 printf (_("Library rpath: [%s]"), name
);
10412 printf (_("Library runpath: [%s]"), name
);
10416 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10421 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10434 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10435 /* Fall through. */
10439 case DT_INIT_ARRAYSZ
:
10440 case DT_FINI_ARRAYSZ
:
10441 case DT_GNU_CONFLICTSZ
:
10442 case DT_GNU_LIBLISTSZ
:
10445 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10446 printf (_(" (bytes)\n"));
10451 case DT_VERNEEDNUM
:
10456 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10465 case DT_INIT_ARRAY
:
10466 case DT_FINI_ARRAY
:
10469 if (entry
->d_tag
== DT_USED
10470 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10472 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10476 printf (_("Not needed object: [%s]\n"), name
);
10481 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10487 /* The value of this entry is ignored. */
10492 case DT_GNU_PRELINKED
:
10496 time_t atime
= entry
->d_un
.d_val
;
10498 tmp
= gmtime (&atime
);
10499 /* PR 17533 file: 041-1244816-0.004. */
10501 printf (_("<corrupt time val: %lx"),
10502 (unsigned long) atime
);
10504 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10505 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10506 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10512 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10515 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10521 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10522 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10527 switch (filedata
->file_header
.e_machine
)
10530 dynamic_section_aarch64_val (entry
);
10533 case EM_MIPS_RS3_LE
:
10534 dynamic_section_mips_val (entry
);
10537 dynamic_section_parisc_val (entry
);
10540 dynamic_section_ia64_val (entry
);
10543 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10555 get_ver_flags (unsigned int flags
)
10557 static char buff
[128];
10564 if (flags
& VER_FLG_BASE
)
10565 strcat (buff
, "BASE");
10567 if (flags
& VER_FLG_WEAK
)
10569 if (flags
& VER_FLG_BASE
)
10570 strcat (buff
, " | ");
10572 strcat (buff
, "WEAK");
10575 if (flags
& VER_FLG_INFO
)
10577 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10578 strcat (buff
, " | ");
10580 strcat (buff
, "INFO");
10583 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10585 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10586 strcat (buff
, " | ");
10588 strcat (buff
, _("<unknown>"));
10594 /* Display the contents of the version sections. */
10597 process_version_sections (Filedata
* filedata
)
10599 Elf_Internal_Shdr
* section
;
10601 bfd_boolean found
= FALSE
;
10606 for (i
= 0, section
= filedata
->section_headers
;
10607 i
< filedata
->file_header
.e_shnum
;
10610 switch (section
->sh_type
)
10612 case SHT_GNU_verdef
:
10614 Elf_External_Verdef
* edefs
;
10621 printf (ngettext ("\nVersion definition section '%s' "
10622 "contains %u entry:\n",
10623 "\nVersion definition section '%s' "
10624 "contains %u entries:\n",
10626 printable_section_name (filedata
, section
),
10629 printf (_(" Addr: 0x"));
10630 printf_vma (section
->sh_addr
);
10631 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10632 (unsigned long) section
->sh_offset
, section
->sh_link
,
10633 printable_section_name_from_index (filedata
, section
->sh_link
));
10635 edefs
= (Elf_External_Verdef
*)
10636 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10637 _("version definition section"));
10640 endbuf
= (char *) edefs
+ section
->sh_size
;
10642 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10645 Elf_External_Verdef
* edef
;
10646 Elf_Internal_Verdef ent
;
10647 Elf_External_Verdaux
* eaux
;
10648 Elf_Internal_Verdaux aux
;
10649 unsigned long isum
;
10652 vstart
= ((char *) edefs
) + idx
;
10653 if (vstart
+ sizeof (*edef
) > endbuf
)
10656 edef
= (Elf_External_Verdef
*) vstart
;
10658 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10659 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10660 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10661 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10662 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10663 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10664 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10666 printf (_(" %#06lx: Rev: %d Flags: %s"),
10667 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10669 printf (_(" Index: %d Cnt: %d "),
10670 ent
.vd_ndx
, ent
.vd_cnt
);
10672 /* Check for overflow. */
10673 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10676 vstart
+= ent
.vd_aux
;
10678 if (vstart
+ sizeof (*eaux
) > endbuf
)
10680 eaux
= (Elf_External_Verdaux
*) vstart
;
10682 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10683 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10685 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10686 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10688 printf (_("Name index: %ld\n"), aux
.vda_name
);
10690 isum
= idx
+ ent
.vd_aux
;
10692 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10694 if (aux
.vda_next
< sizeof (*eaux
)
10695 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10697 warn (_("Invalid vda_next field of %lx\n"),
10702 /* Check for overflow. */
10703 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10706 isum
+= aux
.vda_next
;
10707 vstart
+= aux
.vda_next
;
10709 if (vstart
+ sizeof (*eaux
) > endbuf
)
10711 eaux
= (Elf_External_Verdaux
*) vstart
;
10713 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10714 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10716 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10717 printf (_(" %#06lx: Parent %d: %s\n"),
10718 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10720 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10721 isum
, j
, aux
.vda_name
);
10724 if (j
< ent
.vd_cnt
)
10725 printf (_(" Version def aux past end of section\n"));
10728 file: id:000001,src:000172+005151,op:splice,rep:2. */
10729 if (ent
.vd_next
< sizeof (*edef
)
10730 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10732 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10733 cnt
= section
->sh_info
;
10736 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10739 idx
+= ent
.vd_next
;
10742 if (cnt
< section
->sh_info
)
10743 printf (_(" Version definition past end of section\n"));
10749 case SHT_GNU_verneed
:
10751 Elf_External_Verneed
* eneed
;
10758 printf (ngettext ("\nVersion needs section '%s' "
10759 "contains %u entry:\n",
10760 "\nVersion needs section '%s' "
10761 "contains %u entries:\n",
10763 printable_section_name (filedata
, section
), section
->sh_info
);
10765 printf (_(" Addr: 0x"));
10766 printf_vma (section
->sh_addr
);
10767 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10768 (unsigned long) section
->sh_offset
, section
->sh_link
,
10769 printable_section_name_from_index (filedata
, section
->sh_link
));
10771 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10772 section
->sh_offset
, 1,
10774 _("Version Needs section"));
10777 endbuf
= (char *) eneed
+ section
->sh_size
;
10779 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10781 Elf_External_Verneed
* entry
;
10782 Elf_Internal_Verneed ent
;
10783 unsigned long isum
;
10787 vstart
= ((char *) eneed
) + idx
;
10788 if (vstart
+ sizeof (*entry
) > endbuf
)
10791 entry
= (Elf_External_Verneed
*) vstart
;
10793 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10794 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10795 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10796 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10797 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10799 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10801 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10802 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10804 printf (_(" File: %lx"), ent
.vn_file
);
10806 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10808 /* Check for overflow. */
10809 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10811 vstart
+= ent
.vn_aux
;
10813 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10815 Elf_External_Vernaux
* eaux
;
10816 Elf_Internal_Vernaux aux
;
10818 if (vstart
+ sizeof (*eaux
) > endbuf
)
10820 eaux
= (Elf_External_Vernaux
*) vstart
;
10822 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10823 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10824 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10825 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10826 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10828 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10829 printf (_(" %#06lx: Name: %s"),
10830 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10832 printf (_(" %#06lx: Name index: %lx"),
10833 isum
, aux
.vna_name
);
10835 printf (_(" Flags: %s Version: %d\n"),
10836 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10838 if (aux
.vna_next
< sizeof (*eaux
)
10839 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10841 warn (_("Invalid vna_next field of %lx\n"),
10846 /* Check for overflow. */
10847 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10849 isum
+= aux
.vna_next
;
10850 vstart
+= aux
.vna_next
;
10853 if (j
< ent
.vn_cnt
)
10854 warn (_("Missing Version Needs auxillary information\n"));
10856 if (ent
.vn_next
< sizeof (*entry
)
10857 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10859 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10860 cnt
= section
->sh_info
;
10863 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10865 idx
+= ent
.vn_next
;
10868 if (cnt
< section
->sh_info
)
10869 warn (_("Missing Version Needs information\n"));
10875 case SHT_GNU_versym
:
10877 Elf_Internal_Shdr
* link_section
;
10880 unsigned char * edata
;
10881 unsigned short * data
;
10883 Elf_Internal_Sym
* symbols
;
10884 Elf_Internal_Shdr
* string_sec
;
10885 unsigned long num_syms
;
10888 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10891 link_section
= filedata
->section_headers
+ section
->sh_link
;
10892 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10894 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10899 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10900 if (symbols
== NULL
)
10903 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10905 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10906 string_sec
->sh_size
,
10907 _("version string table"));
10914 printf (ngettext ("\nVersion symbols section '%s' "
10915 "contains %lu entry:\n",
10916 "\nVersion symbols section '%s' "
10917 "contains %lu entries:\n",
10919 printable_section_name (filedata
, section
), (unsigned long) total
);
10921 printf (_(" Addr: 0x"));
10922 printf_vma (section
->sh_addr
);
10923 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10924 (unsigned long) section
->sh_offset
, section
->sh_link
,
10925 printable_section_name (filedata
, link_section
));
10927 off
= offset_from_vma (filedata
,
10928 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10929 total
* sizeof (short));
10930 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10932 _("version symbol data"));
10940 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10942 for (cnt
= total
; cnt
--;)
10943 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10948 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10952 char *invalid
= _("*invalid*");
10954 printf (" %03x:", cnt
);
10956 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10957 switch (data
[cnt
+ j
])
10960 fputs (_(" 0 (*local*) "), stdout
);
10964 fputs (_(" 1 (*global*) "), stdout
);
10968 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10969 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10971 /* If this index value is greater than the size of the symbols
10972 array, break to avoid an out-of-bounds read. */
10973 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10975 warn (_("invalid index into symbol array\n"));
10980 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10982 Elf_Internal_Verneed ivn
;
10983 unsigned long offset
;
10985 offset
= offset_from_vma
10986 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10987 sizeof (Elf_External_Verneed
));
10991 Elf_Internal_Vernaux ivna
;
10992 Elf_External_Verneed evn
;
10993 Elf_External_Vernaux evna
;
10994 unsigned long a_off
;
10996 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10997 _("version need")) == NULL
)
11000 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11001 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11003 a_off
= offset
+ ivn
.vn_aux
;
11007 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11008 1, _("version need aux (2)")) == NULL
)
11011 ivna
.vna_other
= 0;
11015 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11016 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11019 a_off
+= ivna
.vna_next
;
11021 while (ivna
.vna_other
!= data
[cnt
+ j
]
11022 && ivna
.vna_next
!= 0);
11024 if (ivna
.vna_other
== data
[cnt
+ j
])
11026 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11028 if (ivna
.vna_name
>= string_sec
->sh_size
)
11031 name
= strtab
+ ivna
.vna_name
;
11035 offset
+= ivn
.vn_next
;
11037 while (ivn
.vn_next
);
11040 if (data
[cnt
+ j
] != 0x8001
11041 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11043 Elf_Internal_Verdef ivd
;
11044 Elf_External_Verdef evd
;
11045 unsigned long offset
;
11047 offset
= offset_from_vma
11048 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11053 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11054 _("version def")) == NULL
)
11057 /* PR 17531: file: 046-1082287-0.004. */
11058 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11063 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11064 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11067 offset
+= ivd
.vd_next
;
11069 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11070 && ivd
.vd_next
!= 0);
11072 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11074 Elf_External_Verdaux evda
;
11075 Elf_Internal_Verdaux ivda
;
11077 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11079 if (get_data (&evda
, filedata
,
11080 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11082 _("version def aux")) == NULL
)
11085 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11087 if (ivda
.vda_name
>= string_sec
->sh_size
)
11089 else if (name
!= NULL
&& name
!= invalid
)
11090 name
= _("*both*");
11092 name
= strtab
+ ivda
.vda_name
;
11096 nn
+= printf ("(%s%-*s",
11098 12 - (int) strlen (name
),
11102 printf ("%*c", 18 - nn
, ' ');
11120 printf (_("\nNo version information found in this file.\n"));
11125 static const char *
11126 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11128 static char buff
[32];
11132 case STB_LOCAL
: return "LOCAL";
11133 case STB_GLOBAL
: return "GLOBAL";
11134 case STB_WEAK
: return "WEAK";
11136 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11137 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11139 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11141 if (binding
== STB_GNU_UNIQUE
11142 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11144 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11147 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11152 static const char *
11153 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11155 static char buff
[32];
11159 case STT_NOTYPE
: return "NOTYPE";
11160 case STT_OBJECT
: return "OBJECT";
11161 case STT_FUNC
: return "FUNC";
11162 case STT_SECTION
: return "SECTION";
11163 case STT_FILE
: return "FILE";
11164 case STT_COMMON
: return "COMMON";
11165 case STT_TLS
: return "TLS";
11166 case STT_RELC
: return "RELC";
11167 case STT_SRELC
: return "SRELC";
11169 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11171 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11172 return "THUMB_FUNC";
11174 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11177 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11178 return "PARISC_MILLI";
11180 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11182 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11184 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11186 if (type
== STT_HP_OPAQUE
)
11187 return "HP_OPAQUE";
11188 if (type
== STT_HP_STUB
)
11192 if (type
== STT_GNU_IFUNC
11193 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11194 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11197 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11200 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11205 static const char *
11206 get_symbol_visibility (unsigned int visibility
)
11208 switch (visibility
)
11210 case STV_DEFAULT
: return "DEFAULT";
11211 case STV_INTERNAL
: return "INTERNAL";
11212 case STV_HIDDEN
: return "HIDDEN";
11213 case STV_PROTECTED
: return "PROTECTED";
11215 error (_("Unrecognized visibility value: %u"), visibility
);
11216 return _("<unknown>");
11220 static const char *
11221 get_alpha_symbol_other (unsigned int other
)
11225 case STO_ALPHA_NOPV
: return "NOPV";
11226 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11228 error (_("Unrecognized alpah specific other value: %u"), other
);
11229 return _("<unknown>");
11233 static const char *
11234 get_solaris_symbol_visibility (unsigned int visibility
)
11236 switch (visibility
)
11238 case 4: return "EXPORTED";
11239 case 5: return "SINGLETON";
11240 case 6: return "ELIMINATE";
11241 default: return get_symbol_visibility (visibility
);
11245 static const char *
11246 get_aarch64_symbol_other (unsigned int other
)
11248 static char buf
[32];
11250 if (other
& STO_AARCH64_VARIANT_PCS
)
11252 other
&= ~STO_AARCH64_VARIANT_PCS
;
11254 return "VARIANT_PCS";
11255 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11261 static const char *
11262 get_mips_symbol_other (unsigned int other
)
11266 case STO_OPTIONAL
: return "OPTIONAL";
11267 case STO_MIPS_PLT
: return "MIPS PLT";
11268 case STO_MIPS_PIC
: return "MIPS PIC";
11269 case STO_MICROMIPS
: return "MICROMIPS";
11270 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11271 case STO_MIPS16
: return "MIPS16";
11272 default: return NULL
;
11276 static const char *
11277 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11279 if (is_ia64_vms (filedata
))
11281 static char res
[32];
11285 /* Function types is for images and .STB files only. */
11286 switch (filedata
->file_header
.e_type
)
11290 switch (VMS_ST_FUNC_TYPE (other
))
11292 case VMS_SFT_CODE_ADDR
:
11293 strcat (res
, " CA");
11295 case VMS_SFT_SYMV_IDX
:
11296 strcat (res
, " VEC");
11299 strcat (res
, " FD");
11301 case VMS_SFT_RESERVE
:
11302 strcat (res
, " RSV");
11305 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11306 VMS_ST_FUNC_TYPE (other
));
11307 strcat (res
, " <unknown>");
11314 switch (VMS_ST_LINKAGE (other
))
11316 case VMS_STL_IGNORE
:
11317 strcat (res
, " IGN");
11319 case VMS_STL_RESERVE
:
11320 strcat (res
, " RSV");
11323 strcat (res
, " STD");
11326 strcat (res
, " LNK");
11329 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11330 VMS_ST_LINKAGE (other
));
11331 strcat (res
, " <unknown>");
11343 static const char *
11344 get_ppc64_symbol_other (unsigned int other
)
11346 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11349 other
>>= STO_PPC64_LOCAL_BIT
;
11352 static char buf
[32];
11354 other
= ppc64_decode_local_entry (other
);
11355 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11361 static const char *
11362 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11364 const char * result
= NULL
;
11365 static char buff
[32];
11370 switch (filedata
->file_header
.e_machine
)
11373 result
= get_alpha_symbol_other (other
);
11376 result
= get_aarch64_symbol_other (other
);
11379 result
= get_mips_symbol_other (other
);
11382 result
= get_ia64_symbol_other (filedata
, other
);
11385 result
= get_ppc64_symbol_other (other
);
11395 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11399 static const char *
11400 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11402 static char buff
[32];
11406 case SHN_UNDEF
: return "UND";
11407 case SHN_ABS
: return "ABS";
11408 case SHN_COMMON
: return "COM";
11410 if (type
== SHN_IA_64_ANSI_COMMON
11411 && filedata
->file_header
.e_machine
== EM_IA_64
11412 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11414 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11415 || filedata
->file_header
.e_machine
== EM_L1OM
11416 || filedata
->file_header
.e_machine
== EM_K1OM
)
11417 && type
== SHN_X86_64_LCOMMON
)
11418 return "LARGE_COM";
11419 else if ((type
== SHN_MIPS_SCOMMON
11420 && filedata
->file_header
.e_machine
== EM_MIPS
)
11421 || (type
== SHN_TIC6X_SCOMMON
11422 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11424 else if (type
== SHN_MIPS_SUNDEFINED
11425 && filedata
->file_header
.e_machine
== EM_MIPS
)
11427 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11428 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11429 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11430 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11431 else if (type
>= SHN_LORESERVE
)
11432 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11433 else if (type
>= filedata
->file_header
.e_shnum
)
11434 sprintf (buff
, _("bad section index[%3d]"), type
);
11436 sprintf (buff
, "%3d", type
);
11444 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11446 unsigned char * e_data
;
11449 /* If the size_t type is smaller than the bfd_size_type, eg because
11450 you are building a 32-bit tool on a 64-bit host, then make sure
11451 that when (number) is cast to (size_t) no information is lost. */
11452 if (sizeof (size_t) < sizeof (bfd_size_type
)
11453 && (bfd_size_type
) ((size_t) number
) != number
)
11455 error (_("Size truncation prevents reading %s elements of size %u\n"),
11456 bfd_vmatoa ("u", number
), ent_size
);
11460 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11461 attempting to allocate memory when the read is bound to fail. */
11462 if (ent_size
* number
> filedata
->file_size
)
11464 error (_("Invalid number of dynamic entries: %s\n"),
11465 bfd_vmatoa ("u", number
));
11469 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11470 if (e_data
== NULL
)
11472 error (_("Out of memory reading %s dynamic entries\n"),
11473 bfd_vmatoa ("u", number
));
11477 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11479 error (_("Unable to read in %s bytes of dynamic data\n"),
11480 bfd_vmatoa ("u", number
* ent_size
));
11485 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11486 if (i_data
== NULL
)
11488 error (_("Out of memory allocating space for %s dynamic entries\n"),
11489 bfd_vmatoa ("u", number
));
11495 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11503 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11505 Elf_Internal_Sym
* psym
;
11508 n
= print_vma (si
, DEC_5
);
11510 fputs (&" "[n
], stdout
);
11511 printf (" %3lu: ", hn
);
11513 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11515 printf (_("<No info available for dynamic symbol number %lu>\n"),
11516 (unsigned long) si
);
11520 psym
= dynamic_symbols
+ si
;
11521 print_vma (psym
->st_value
, LONG_HEX
);
11523 print_vma (psym
->st_size
, DEC_5
);
11525 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11526 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11528 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11529 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11532 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11534 printf (" %-7s", get_symbol_visibility (vis
));
11535 /* Check to see if any other bits in the st_other field are set.
11536 Note - displaying this information disrupts the layout of the
11537 table being generated, but for the moment this case is very
11539 if (psym
->st_other
^ vis
)
11540 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11543 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11544 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11545 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11547 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11551 static const char *
11552 get_symbol_version_string (Filedata
* filedata
,
11553 bfd_boolean is_dynsym
,
11554 const char * strtab
,
11555 unsigned long int strtab_size
,
11557 Elf_Internal_Sym
* psym
,
11558 enum versioned_symbol_info
* sym_info
,
11559 unsigned short * vna_other
)
11561 unsigned char data
[2];
11562 unsigned short vers_data
;
11563 unsigned long offset
;
11564 unsigned short max_vd_ndx
;
11567 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11570 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11571 sizeof data
+ si
* sizeof (vers_data
));
11573 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11574 sizeof (data
), 1, _("version data")) == NULL
)
11577 vers_data
= byte_get (data
, 2);
11579 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11582 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11585 /* Usually we'd only see verdef for defined symbols, and verneed for
11586 undefined symbols. However, symbols defined by the linker in
11587 .dynbss for variables copied from a shared library in order to
11588 avoid text relocations are defined yet have verneed. We could
11589 use a heuristic to detect the special case, for example, check
11590 for verneed first on symbols defined in SHT_NOBITS sections, but
11591 it is simpler and more reliable to just look for both verdef and
11592 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11594 if (psym
->st_shndx
!= SHN_UNDEF
11595 && vers_data
!= 0x8001
11596 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11598 Elf_Internal_Verdef ivd
;
11599 Elf_Internal_Verdaux ivda
;
11600 Elf_External_Verdaux evda
;
11603 off
= offset_from_vma (filedata
,
11604 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11605 sizeof (Elf_External_Verdef
));
11609 Elf_External_Verdef evd
;
11611 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11612 _("version def")) == NULL
)
11621 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11622 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11623 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11624 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11627 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11628 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11630 off
+= ivd
.vd_next
;
11632 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11634 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11636 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11639 off
-= ivd
.vd_next
;
11642 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11643 _("version def aux")) != NULL
)
11645 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11647 if (psym
->st_name
!= ivda
.vda_name
)
11648 return (ivda
.vda_name
< strtab_size
11649 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11654 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11656 Elf_External_Verneed evn
;
11657 Elf_Internal_Verneed ivn
;
11658 Elf_Internal_Vernaux ivna
;
11660 offset
= offset_from_vma (filedata
,
11661 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11665 unsigned long vna_off
;
11667 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11668 _("version need")) == NULL
)
11671 ivna
.vna_other
= 0;
11676 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11677 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11679 vna_off
= offset
+ ivn
.vn_aux
;
11683 Elf_External_Vernaux evna
;
11685 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11686 _("version need aux (3)")) == NULL
)
11689 ivna
.vna_other
= 0;
11694 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11695 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11696 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11699 vna_off
+= ivna
.vna_next
;
11701 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11703 if (ivna
.vna_other
== vers_data
)
11706 offset
+= ivn
.vn_next
;
11708 while (ivn
.vn_next
!= 0);
11710 if (ivna
.vna_other
== vers_data
)
11712 *sym_info
= symbol_undefined
;
11713 *vna_other
= ivna
.vna_other
;
11714 return (ivna
.vna_name
< strtab_size
11715 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11717 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11718 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11719 return _("<corrupt>");
11724 /* Dump the symbol table. */
11726 process_symbol_table (Filedata
* filedata
)
11728 Elf_Internal_Shdr
* section
;
11729 bfd_size_type nbuckets
= 0;
11730 bfd_size_type nchains
= 0;
11731 bfd_vma
* buckets
= NULL
;
11732 bfd_vma
* chains
= NULL
;
11733 bfd_vma ngnubuckets
= 0;
11734 bfd_vma
* gnubuckets
= NULL
;
11735 bfd_vma
* gnuchains
= NULL
;
11736 bfd_vma
* mipsxlat
= NULL
;
11737 bfd_vma gnusymidx
= 0;
11738 bfd_size_type ngnuchains
= 0;
11740 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11743 if (dynamic_info
[DT_HASH
]
11745 || (do_using_dynamic
11747 && dynamic_strings
!= NULL
)))
11749 unsigned char nb
[8];
11750 unsigned char nc
[8];
11751 unsigned int hash_ent_size
= 4;
11753 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11754 || filedata
->file_header
.e_machine
== EM_S390
11755 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11756 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11759 if (fseek (filedata
->handle
,
11760 (archive_file_offset
11761 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11762 sizeof nb
+ sizeof nc
)),
11765 error (_("Unable to seek to start of dynamic information\n"));
11769 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11771 error (_("Failed to read in number of buckets\n"));
11775 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11777 error (_("Failed to read in number of chains\n"));
11781 nbuckets
= byte_get (nb
, hash_ent_size
);
11782 nchains
= byte_get (nc
, hash_ent_size
);
11784 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11785 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11788 if (buckets
== NULL
|| chains
== NULL
)
11790 if (do_using_dynamic
)
11801 if (dynamic_info_DT_GNU_HASH
11803 || (do_using_dynamic
11805 && dynamic_strings
!= NULL
)))
11807 unsigned char nb
[16];
11808 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11809 bfd_vma buckets_vma
;
11811 if (fseek (filedata
->handle
,
11812 (archive_file_offset
11813 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11817 error (_("Unable to seek to start of dynamic information\n"));
11821 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11823 error (_("Failed to read in number of buckets\n"));
11827 ngnubuckets
= byte_get (nb
, 4);
11828 gnusymidx
= byte_get (nb
+ 4, 4);
11829 bitmaskwords
= byte_get (nb
+ 8, 4);
11830 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11832 buckets_vma
+= bitmaskwords
* 4;
11834 buckets_vma
+= bitmaskwords
* 8;
11836 if (fseek (filedata
->handle
,
11837 (archive_file_offset
11838 + offset_from_vma (filedata
, buckets_vma
, 4)),
11841 error (_("Unable to seek to start of dynamic information\n"));
11845 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11847 if (gnubuckets
== NULL
)
11850 for (i
= 0; i
< ngnubuckets
; i
++)
11851 if (gnubuckets
[i
] != 0)
11853 if (gnubuckets
[i
] < gnusymidx
)
11856 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11857 maxchain
= gnubuckets
[i
];
11860 if (maxchain
== 0xffffffff)
11863 maxchain
-= gnusymidx
;
11865 if (fseek (filedata
->handle
,
11866 (archive_file_offset
11867 + offset_from_vma (filedata
, buckets_vma
11868 + 4 * (ngnubuckets
+ maxchain
), 4)),
11871 error (_("Unable to seek to start of dynamic information\n"));
11877 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11879 error (_("Failed to determine last chain length\n"));
11883 if (maxchain
+ 1 == 0)
11888 while ((byte_get (nb
, 4) & 1) == 0);
11890 if (fseek (filedata
->handle
,
11891 (archive_file_offset
11892 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11895 error (_("Unable to seek to start of dynamic information\n"));
11899 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11900 ngnuchains
= maxchain
;
11902 if (gnuchains
== NULL
)
11905 if (dynamic_info_DT_MIPS_XHASH
)
11907 if (fseek (filedata
->handle
,
11908 (archive_file_offset
11909 + offset_from_vma (filedata
, (buckets_vma
11914 error (_("Unable to seek to start of dynamic information\n"));
11918 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11922 if (dynamic_info_DT_MIPS_XHASH
&& mipsxlat
== NULL
)
11927 if (gnuchains
== NULL
)
11932 if (do_using_dynamic
)
11937 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11939 && do_using_dynamic
11940 && dynamic_strings
!= NULL
11941 && dynamic_symbols
!= NULL
)
11945 if (dynamic_info
[DT_HASH
])
11950 printf (_("\nSymbol table for image:\n"));
11952 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11954 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11956 visited
= xcmalloc (nchains
, 1);
11957 memset (visited
, 0, nchains
);
11958 for (hn
= 0; hn
< nbuckets
; hn
++)
11960 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11962 print_dynamic_symbol (filedata
, si
, hn
);
11963 if (si
>= nchains
|| visited
[si
])
11965 error (_("histogram chain is corrupt\n"));
11974 if (dynamic_info_DT_GNU_HASH
)
11976 printf (_("\nSymbol table of `%s' for image:\n"),
11977 GNU_HASH_SECTION_NAME
);
11979 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11981 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11983 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11984 if (gnubuckets
[hn
] != 0)
11986 bfd_vma si
= gnubuckets
[hn
];
11987 bfd_vma off
= si
- gnusymidx
;
11991 if (dynamic_info_DT_MIPS_XHASH
)
11992 print_dynamic_symbol (filedata
, mipsxlat
[off
], hn
);
11994 print_dynamic_symbol (filedata
, si
, hn
);
11997 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
12001 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12002 && filedata
->section_headers
!= NULL
)
12006 for (i
= 0, section
= filedata
->section_headers
;
12007 i
< filedata
->file_header
.e_shnum
;
12011 char * strtab
= NULL
;
12012 unsigned long int strtab_size
= 0;
12013 Elf_Internal_Sym
* symtab
;
12014 Elf_Internal_Sym
* psym
;
12015 unsigned long num_syms
;
12017 if ((section
->sh_type
!= SHT_SYMTAB
12018 && section
->sh_type
!= SHT_DYNSYM
)
12020 && section
->sh_type
== SHT_SYMTAB
))
12023 if (section
->sh_entsize
== 0)
12025 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12026 printable_section_name (filedata
, section
));
12030 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12031 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12032 "\nSymbol table '%s' contains %lu entries:\n",
12034 printable_section_name (filedata
, section
),
12038 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12040 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12042 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12043 if (symtab
== NULL
)
12046 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12048 strtab
= filedata
->string_table
;
12049 strtab_size
= filedata
->string_table_length
;
12051 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12053 Elf_Internal_Shdr
* string_sec
;
12055 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12057 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12058 1, string_sec
->sh_size
,
12059 _("string table"));
12060 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12063 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
12065 const char *version_string
;
12066 enum versioned_symbol_info sym_info
;
12067 unsigned short vna_other
;
12069 printf ("%6d: ", si
);
12070 print_vma (psym
->st_value
, LONG_HEX
);
12072 print_vma (psym
->st_size
, DEC_5
);
12073 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12074 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12075 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12076 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12079 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12081 printf (" %-7s", get_symbol_visibility (vis
));
12082 /* Check to see if any other bits in the st_other field are set.
12083 Note - displaying this information disrupts the layout of the
12084 table being generated, but for the moment this case is very rare. */
12085 if (psym
->st_other
^ vis
)
12086 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12088 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12089 print_symbol (25, psym
->st_name
< strtab_size
12090 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12093 = get_symbol_version_string (filedata
,
12094 section
->sh_type
== SHT_DYNSYM
,
12095 strtab
, strtab_size
, si
,
12096 psym
, &sym_info
, &vna_other
);
12097 if (version_string
)
12099 if (sym_info
== symbol_undefined
)
12100 printf ("@%s (%d)", version_string
, vna_other
);
12102 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12108 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12109 && si
>= section
->sh_info
12110 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12111 && filedata
->file_header
.e_machine
!= EM_MIPS
12112 /* Solaris binaries have been found to violate this requirement as
12113 well. Not sure if this is a bug or an ABI requirement. */
12114 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12115 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12116 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12120 if (strtab
!= filedata
->string_table
)
12126 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12128 if (do_histogram
&& buckets
!= NULL
)
12130 unsigned long * lengths
;
12131 unsigned long * counts
;
12134 unsigned long maxlength
= 0;
12135 unsigned long nzero_counts
= 0;
12136 unsigned long nsyms
= 0;
12139 printf (ngettext ("\nHistogram for bucket list length "
12140 "(total of %lu bucket):\n",
12141 "\nHistogram for bucket list length "
12142 "(total of %lu buckets):\n",
12143 (unsigned long) nbuckets
),
12144 (unsigned long) nbuckets
);
12146 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12147 if (lengths
== NULL
)
12149 error (_("Out of memory allocating space for histogram buckets\n"));
12152 visited
= xcmalloc (nchains
, 1);
12153 memset (visited
, 0, nchains
);
12155 printf (_(" Length Number %% of total Coverage\n"));
12156 for (hn
= 0; hn
< nbuckets
; ++hn
)
12158 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12161 if (maxlength
< ++lengths
[hn
])
12163 if (si
>= nchains
|| visited
[si
])
12165 error (_("histogram chain is corrupt\n"));
12173 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12174 if (counts
== NULL
)
12177 error (_("Out of memory allocating space for histogram counts\n"));
12181 for (hn
= 0; hn
< nbuckets
; ++hn
)
12182 ++counts
[lengths
[hn
]];
12187 printf (" 0 %-10lu (%5.1f%%)\n",
12188 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12189 for (i
= 1; i
<= maxlength
; ++i
)
12191 nzero_counts
+= counts
[i
] * i
;
12192 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12193 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12194 (nzero_counts
* 100.0) / nsyms
);
12202 if (buckets
!= NULL
)
12208 if (do_histogram
&& gnubuckets
!= NULL
)
12210 unsigned long * lengths
;
12211 unsigned long * counts
;
12213 unsigned long maxlength
= 0;
12214 unsigned long nzero_counts
= 0;
12215 unsigned long nsyms
= 0;
12217 printf (ngettext ("\nHistogram for `%s' bucket list length "
12218 "(total of %lu bucket):\n",
12219 "\nHistogram for `%s' bucket list length "
12220 "(total of %lu buckets):\n",
12221 (unsigned long) ngnubuckets
),
12222 GNU_HASH_SECTION_NAME
,
12223 (unsigned long) ngnubuckets
);
12225 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12226 if (lengths
== NULL
)
12228 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12232 printf (_(" Length Number %% of total Coverage\n"));
12234 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12235 if (gnubuckets
[hn
] != 0)
12237 bfd_vma off
, length
= 1;
12239 for (off
= gnubuckets
[hn
] - gnusymidx
;
12240 /* PR 17531 file: 010-77222-0.004. */
12241 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12244 lengths
[hn
] = length
;
12245 if (length
> maxlength
)
12246 maxlength
= length
;
12250 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12251 if (counts
== NULL
)
12254 error (_("Out of memory allocating space for gnu histogram counts\n"));
12258 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12259 ++counts
[lengths
[hn
]];
12261 if (ngnubuckets
> 0)
12264 printf (" 0 %-10lu (%5.1f%%)\n",
12265 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12266 for (j
= 1; j
<= maxlength
; ++j
)
12268 nzero_counts
+= counts
[j
] * j
;
12269 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12270 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12271 (nzero_counts
* 100.0) / nsyms
);
12286 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12290 if (dynamic_syminfo
== NULL
12292 /* No syminfo, this is ok. */
12295 /* There better should be a dynamic symbol section. */
12296 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12300 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12301 "contains %d entry:\n",
12302 "\nDynamic info segment at offset 0x%lx "
12303 "contains %d entries:\n",
12304 dynamic_syminfo_nent
),
12305 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12307 printf (_(" Num: Name BoundTo Flags\n"));
12308 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12310 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12312 printf ("%4d: ", i
);
12313 if (i
>= num_dynamic_syms
)
12314 printf (_("<corrupt index>"));
12315 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12316 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12318 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12321 switch (dynamic_syminfo
[i
].si_boundto
)
12323 case SYMINFO_BT_SELF
:
12324 fputs ("SELF ", stdout
);
12326 case SYMINFO_BT_PARENT
:
12327 fputs ("PARENT ", stdout
);
12330 if (dynamic_syminfo
[i
].si_boundto
> 0
12331 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12332 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12334 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12338 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12342 if (flags
& SYMINFO_FLG_DIRECT
)
12343 printf (" DIRECT");
12344 if (flags
& SYMINFO_FLG_PASSTHRU
)
12345 printf (" PASSTHRU");
12346 if (flags
& SYMINFO_FLG_COPY
)
12348 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12349 printf (" LAZYLOAD");
12357 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12358 is contained by the region START .. END. The types of ADDR, START
12359 and END should all be the same. Note both ADDR + NELEM and END
12360 point to just beyond the end of the regions that are being tested. */
12361 #define IN_RANGE(START,END,ADDR,NELEM) \
12362 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12364 /* Check to see if the given reloc needs to be handled in a target specific
12365 manner. If so then process the reloc and return TRUE otherwise return
12368 If called with reloc == NULL, then this is a signal that reloc processing
12369 for the current section has finished, and any saved state should be
12373 target_specific_reloc_handling (Filedata
* filedata
,
12374 Elf_Internal_Rela
* reloc
,
12375 unsigned char * start
,
12376 unsigned char * end
,
12377 Elf_Internal_Sym
* symtab
,
12378 unsigned long num_syms
)
12380 unsigned int reloc_type
= 0;
12381 unsigned long sym_index
= 0;
12385 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12386 sym_index
= get_reloc_symindex (reloc
->r_info
);
12389 switch (filedata
->file_header
.e_machine
)
12392 case EM_MSP430_OLD
:
12394 static Elf_Internal_Sym
* saved_sym
= NULL
;
12402 switch (reloc_type
)
12404 case 10: /* R_MSP430_SYM_DIFF */
12405 if (uses_msp430x_relocs (filedata
))
12407 /* Fall through. */
12408 case 21: /* R_MSP430X_SYM_DIFF */
12410 if (sym_index
>= num_syms
)
12411 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12414 saved_sym
= symtab
+ sym_index
;
12417 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12418 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12419 goto handle_sym_diff
;
12421 case 5: /* R_MSP430_16_BYTE */
12422 case 9: /* R_MSP430_8 */
12423 if (uses_msp430x_relocs (filedata
))
12425 goto handle_sym_diff
;
12427 case 2: /* R_MSP430_ABS16 */
12428 case 15: /* R_MSP430X_ABS16 */
12429 if (! uses_msp430x_relocs (filedata
))
12431 goto handle_sym_diff
;
12434 if (saved_sym
!= NULL
)
12436 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12439 if (sym_index
>= num_syms
)
12440 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12444 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12445 - saved_sym
->st_value
);
12447 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12448 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12451 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12452 (long) reloc
->r_offset
);
12461 if (saved_sym
!= NULL
)
12462 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12469 case EM_CYGNUS_MN10300
:
12471 static Elf_Internal_Sym
* saved_sym
= NULL
;
12479 switch (reloc_type
)
12481 case 34: /* R_MN10300_ALIGN */
12483 case 33: /* R_MN10300_SYM_DIFF */
12484 if (sym_index
>= num_syms
)
12485 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12488 saved_sym
= symtab
+ sym_index
;
12491 case 1: /* R_MN10300_32 */
12492 case 2: /* R_MN10300_16 */
12493 if (saved_sym
!= NULL
)
12495 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12498 if (sym_index
>= num_syms
)
12499 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12503 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12504 - saved_sym
->st_value
);
12506 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12507 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12509 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12510 (long) reloc
->r_offset
);
12518 if (saved_sym
!= NULL
)
12519 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12527 static bfd_vma saved_sym1
= 0;
12528 static bfd_vma saved_sym2
= 0;
12529 static bfd_vma value
;
12533 saved_sym1
= saved_sym2
= 0;
12537 switch (reloc_type
)
12539 case 0x80: /* R_RL78_SYM. */
12540 saved_sym1
= saved_sym2
;
12541 if (sym_index
>= num_syms
)
12542 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12546 saved_sym2
= symtab
[sym_index
].st_value
;
12547 saved_sym2
+= reloc
->r_addend
;
12551 case 0x83: /* R_RL78_OPsub. */
12552 value
= saved_sym1
- saved_sym2
;
12553 saved_sym2
= saved_sym1
= 0;
12557 case 0x41: /* R_RL78_ABS32. */
12558 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12559 byte_put (start
+ reloc
->r_offset
, value
, 4);
12561 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12562 (long) reloc
->r_offset
);
12566 case 0x43: /* R_RL78_ABS16. */
12567 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12568 byte_put (start
+ reloc
->r_offset
, value
, 2);
12570 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12571 (long) reloc
->r_offset
);
12585 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12586 DWARF debug sections. This is a target specific test. Note - we do not
12587 go through the whole including-target-headers-multiple-times route, (as
12588 we have already done with <elf/h8.h>) because this would become very
12589 messy and even then this function would have to contain target specific
12590 information (the names of the relocs instead of their numeric values).
12591 FIXME: This is not the correct way to solve this problem. The proper way
12592 is to have target specific reloc sizing and typing functions created by
12593 the reloc-macros.h header, in the same way that it already creates the
12594 reloc naming functions. */
12597 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12599 /* Please keep this table alpha-sorted for ease of visual lookup. */
12600 switch (filedata
->file_header
.e_machine
)
12604 return reloc_type
== 1; /* R_386_32. */
12606 return reloc_type
== 1; /* R_68K_32. */
12608 return reloc_type
== 1; /* R_860_32. */
12610 return reloc_type
== 2; /* R_960_32. */
12612 return (reloc_type
== 258
12613 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12615 return reloc_type
== 11; /* R_BPF_DATA_32 */
12616 case EM_ADAPTEVA_EPIPHANY
:
12617 return reloc_type
== 3;
12619 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12621 return reloc_type
== 1; /* R_ARC_32. */
12622 case EM_ARC_COMPACT
:
12623 case EM_ARC_COMPACT2
:
12624 return reloc_type
== 4; /* R_ARC_32. */
12626 return reloc_type
== 2; /* R_ARM_ABS32 */
12629 return reloc_type
== 1;
12631 return reloc_type
== 0x12; /* R_byte4_data. */
12633 return reloc_type
== 3; /* R_CRIS_32. */
12635 return reloc_type
== 3; /* R_CR16_NUM32. */
12637 return reloc_type
== 15; /* R_CRX_NUM32. */
12639 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12640 case EM_CYGNUS_FRV
:
12641 return reloc_type
== 1;
12642 case EM_CYGNUS_D10V
:
12644 return reloc_type
== 6; /* R_D10V_32. */
12645 case EM_CYGNUS_D30V
:
12647 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12649 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12650 case EM_CYGNUS_FR30
:
12652 return reloc_type
== 3; /* R_FR30_32. */
12654 return reloc_type
== 1; /* R_FT32_32. */
12658 return reloc_type
== 1; /* R_H8_DIR32. */
12660 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12661 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12662 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12663 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12666 return reloc_type
== 2; /* R_IP2K_32. */
12668 return reloc_type
== 2; /* R_IQ2000_32. */
12669 case EM_LATTICEMICO32
:
12670 return reloc_type
== 3; /* R_LM32_32. */
12673 return reloc_type
== 3; /* R_M32C_32. */
12675 return reloc_type
== 34; /* R_M32R_32_RELA. */
12678 return reloc_type
== 6; /* R_M68HC11_32. */
12680 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12681 reloc_type
== 6; /* R_S12Z_CW32. */
12683 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12684 case EM_CYGNUS_MEP
:
12685 return reloc_type
== 4; /* R_MEP_32. */
12687 return reloc_type
== 2; /* R_METAG_ADDR32. */
12688 case EM_MICROBLAZE
:
12689 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12691 return reloc_type
== 2; /* R_MIPS_32. */
12693 return reloc_type
== 4; /* R_MMIX_32. */
12694 case EM_CYGNUS_MN10200
:
12696 return reloc_type
== 1; /* R_MN10200_32. */
12697 case EM_CYGNUS_MN10300
:
12699 return reloc_type
== 1; /* R_MN10300_32. */
12701 return reloc_type
== 1; /* R_MOXIE_32. */
12702 case EM_MSP430_OLD
:
12704 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12706 return reloc_type
== 2; /* R_MT_32. */
12708 return reloc_type
== 20; /* R_NDS32_RELA. */
12709 case EM_ALTERA_NIOS2
:
12710 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12712 return reloc_type
== 1; /* R_NIOS_32. */
12714 return reloc_type
== 1; /* R_OR1K_32. */
12716 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12717 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12718 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12721 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12723 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12725 return reloc_type
== 1; /* R_PPC_ADDR32. */
12727 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12729 return reloc_type
== 1; /* R_RISCV_32. */
12731 return reloc_type
== 1; /* R_RL78_DIR32. */
12733 return reloc_type
== 1; /* R_RX_DIR32. */
12735 return reloc_type
== 1; /* R_I370_ADDR31. */
12738 return reloc_type
== 4; /* R_S390_32. */
12740 return reloc_type
== 8; /* R_SCORE_ABS32. */
12742 return reloc_type
== 1; /* R_SH_DIR32. */
12743 case EM_SPARC32PLUS
:
12746 return reloc_type
== 3 /* R_SPARC_32. */
12747 || reloc_type
== 23; /* R_SPARC_UA32. */
12749 return reloc_type
== 6; /* R_SPU_ADDR32 */
12751 return reloc_type
== 1; /* R_C6000_ABS32. */
12753 return reloc_type
== 2; /* R_TILEGX_32. */
12755 return reloc_type
== 1; /* R_TILEPRO_32. */
12756 case EM_CYGNUS_V850
:
12758 return reloc_type
== 6; /* R_V850_ABS32. */
12760 return reloc_type
== 0x33; /* R_V810_WORD. */
12762 return reloc_type
== 1; /* R_VAX_32. */
12764 return reloc_type
== 3; /* R_VISIUM_32. */
12765 case EM_WEBASSEMBLY
:
12766 return reloc_type
== 1; /* R_WASM32_32. */
12770 return reloc_type
== 10; /* R_X86_64_32. */
12773 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12775 return reloc_type
== 4; /* R_XGATE_32. */
12777 return reloc_type
== 1; /* R_XSTROMY16_32. */
12778 case EM_XTENSA_OLD
:
12780 return reloc_type
== 1; /* R_XTENSA_32. */
12782 return reloc_type
== 6; /* R_Z80_32. */
12785 static unsigned int prev_warn
= 0;
12787 /* Avoid repeating the same warning multiple times. */
12788 if (prev_warn
!= filedata
->file_header
.e_machine
)
12789 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12790 filedata
->file_header
.e_machine
);
12791 prev_warn
= filedata
->file_header
.e_machine
;
12797 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12798 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12801 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12803 switch (filedata
->file_header
.e_machine
)
12804 /* Please keep this table alpha-sorted for ease of visual lookup. */
12808 return reloc_type
== 2; /* R_386_PC32. */
12810 return reloc_type
== 4; /* R_68K_PC32. */
12812 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12813 case EM_ADAPTEVA_EPIPHANY
:
12814 return reloc_type
== 6;
12816 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12817 case EM_ARC_COMPACT
:
12818 case EM_ARC_COMPACT2
:
12819 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12821 return reloc_type
== 3; /* R_ARM_REL32 */
12824 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12825 case EM_MICROBLAZE
:
12826 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12828 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12830 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12832 return reloc_type
== 26; /* R_PPC_REL32. */
12834 return reloc_type
== 26; /* R_PPC64_REL32. */
12836 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12839 return reloc_type
== 5; /* R_390_PC32. */
12841 return reloc_type
== 2; /* R_SH_REL32. */
12842 case EM_SPARC32PLUS
:
12845 return reloc_type
== 6; /* R_SPARC_DISP32. */
12847 return reloc_type
== 13; /* R_SPU_REL32. */
12849 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12851 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12853 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12857 return reloc_type
== 2; /* R_X86_64_PC32. */
12859 return reloc_type
== 4; /* R_VAX_PCREL32. */
12860 case EM_XTENSA_OLD
:
12862 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12864 /* Do not abort or issue an error message here. Not all targets use
12865 pc-relative 32-bit relocs in their DWARF debug information and we
12866 have already tested for target coverage in is_32bit_abs_reloc. A
12867 more helpful warning message will be generated by apply_relocations
12868 anyway, so just return. */
12873 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12874 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12877 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12879 switch (filedata
->file_header
.e_machine
)
12882 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12884 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12886 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12887 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12889 return reloc_type
== 80; /* R_PARISC_DIR64. */
12891 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12893 return reloc_type
== 2; /* R_RISCV_64. */
12894 case EM_SPARC32PLUS
:
12897 return reloc_type
== 32 /* R_SPARC_64. */
12898 || reloc_type
== 54; /* R_SPARC_UA64. */
12902 return reloc_type
== 1; /* R_X86_64_64. */
12905 return reloc_type
== 22; /* R_S390_64. */
12907 return reloc_type
== 1; /* R_TILEGX_64. */
12909 return reloc_type
== 18; /* R_MIPS_64. */
12915 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12916 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12919 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12921 switch (filedata
->file_header
.e_machine
)
12924 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12926 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12928 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12929 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12931 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12933 return reloc_type
== 44; /* R_PPC64_REL64. */
12934 case EM_SPARC32PLUS
:
12937 return reloc_type
== 46; /* R_SPARC_DISP64. */
12941 return reloc_type
== 24; /* R_X86_64_PC64. */
12944 return reloc_type
== 23; /* R_S390_PC64. */
12946 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12952 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12953 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12956 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12958 switch (filedata
->file_header
.e_machine
)
12960 case EM_CYGNUS_MN10200
:
12962 return reloc_type
== 4; /* R_MN10200_24. */
12964 return reloc_type
== 5; /* R_FT32_20. */
12966 return reloc_type
== 5; /* R_Z80_24. */
12972 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12973 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12976 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12978 /* Please keep this table alpha-sorted for ease of visual lookup. */
12979 switch (filedata
->file_header
.e_machine
)
12982 case EM_ARC_COMPACT
:
12983 case EM_ARC_COMPACT2
:
12984 return reloc_type
== 2; /* R_ARC_16. */
12985 case EM_ADAPTEVA_EPIPHANY
:
12986 return reloc_type
== 5;
12989 return reloc_type
== 4; /* R_AVR_16. */
12990 case EM_CYGNUS_D10V
:
12992 return reloc_type
== 3; /* R_D10V_16. */
12994 return reloc_type
== 2; /* R_FT32_16. */
12998 return reloc_type
== R_H8_DIR16
;
13001 return reloc_type
== 1; /* R_IP2K_16. */
13004 return reloc_type
== 1; /* R_M32C_16 */
13005 case EM_CYGNUS_MN10200
:
13007 return reloc_type
== 2; /* R_MN10200_16. */
13008 case EM_CYGNUS_MN10300
:
13010 return reloc_type
== 2; /* R_MN10300_16. */
13012 if (uses_msp430x_relocs (filedata
))
13013 return reloc_type
== 2; /* R_MSP430_ABS16. */
13014 /* Fall through. */
13015 case EM_MSP430_OLD
:
13016 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13018 return reloc_type
== 19; /* R_NDS32_RELA. */
13019 case EM_ALTERA_NIOS2
:
13020 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13022 return reloc_type
== 9; /* R_NIOS_16. */
13024 return reloc_type
== 2; /* R_OR1K_16. */
13026 return reloc_type
== 55; /* R_RISCV_SET16. */
13028 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13030 return reloc_type
== 2; /* R_C6000_ABS16. */
13032 return reloc_type
== 2; /* R_VISIUM_16. */
13035 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13037 return reloc_type
== 3; /* R_XGATE_16. */
13039 return reloc_type
== 4; /* R_Z80_16. */
13045 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13046 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13049 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13051 switch (filedata
->file_header
.e_machine
)
13054 return reloc_type
== 54; /* R_RISCV_SET8. */
13056 return reloc_type
== 1; /* R_Z80_8. */
13062 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13063 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13066 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13068 switch (filedata
->file_header
.e_machine
)
13071 return reloc_type
== 53; /* R_RISCV_SET6. */
13077 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13078 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13081 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13083 /* Please keep this table alpha-sorted for ease of visual lookup. */
13084 switch (filedata
->file_header
.e_machine
)
13087 return reloc_type
== 35; /* R_RISCV_ADD32. */
13093 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13094 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13097 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13099 /* Please keep this table alpha-sorted for ease of visual lookup. */
13100 switch (filedata
->file_header
.e_machine
)
13103 return reloc_type
== 39; /* R_RISCV_SUB32. */
13109 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13110 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13113 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13115 /* Please keep this table alpha-sorted for ease of visual lookup. */
13116 switch (filedata
->file_header
.e_machine
)
13119 return reloc_type
== 36; /* R_RISCV_ADD64. */
13125 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13126 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13129 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13131 /* Please keep this table alpha-sorted for ease of visual lookup. */
13132 switch (filedata
->file_header
.e_machine
)
13135 return reloc_type
== 40; /* R_RISCV_SUB64. */
13141 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13142 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13145 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13147 /* Please keep this table alpha-sorted for ease of visual lookup. */
13148 switch (filedata
->file_header
.e_machine
)
13151 return reloc_type
== 34; /* R_RISCV_ADD16. */
13157 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13158 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13161 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13163 /* Please keep this table alpha-sorted for ease of visual lookup. */
13164 switch (filedata
->file_header
.e_machine
)
13167 return reloc_type
== 38; /* R_RISCV_SUB16. */
13173 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13174 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13177 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13179 /* Please keep this table alpha-sorted for ease of visual lookup. */
13180 switch (filedata
->file_header
.e_machine
)
13183 return reloc_type
== 33; /* R_RISCV_ADD8. */
13189 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13190 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13193 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13195 /* Please keep this table alpha-sorted for ease of visual lookup. */
13196 switch (filedata
->file_header
.e_machine
)
13199 return reloc_type
== 37; /* R_RISCV_SUB8. */
13205 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13206 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13209 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13211 switch (filedata
->file_header
.e_machine
)
13214 return reloc_type
== 52; /* R_RISCV_SUB6. */
13220 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13221 relocation entries (possibly formerly used for SHT_GROUP sections). */
13224 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13226 switch (filedata
->file_header
.e_machine
)
13228 case EM_386
: /* R_386_NONE. */
13229 case EM_68K
: /* R_68K_NONE. */
13230 case EM_ADAPTEVA_EPIPHANY
:
13231 case EM_ALPHA
: /* R_ALPHA_NONE. */
13232 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13233 case EM_ARC
: /* R_ARC_NONE. */
13234 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13235 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13236 case EM_ARM
: /* R_ARM_NONE. */
13237 case EM_C166
: /* R_XC16X_NONE. */
13238 case EM_CRIS
: /* R_CRIS_NONE. */
13239 case EM_FT32
: /* R_FT32_NONE. */
13240 case EM_IA_64
: /* R_IA64_NONE. */
13241 case EM_K1OM
: /* R_X86_64_NONE. */
13242 case EM_L1OM
: /* R_X86_64_NONE. */
13243 case EM_M32R
: /* R_M32R_NONE. */
13244 case EM_MIPS
: /* R_MIPS_NONE. */
13245 case EM_MN10300
: /* R_MN10300_NONE. */
13246 case EM_MOXIE
: /* R_MOXIE_NONE. */
13247 case EM_NIOS32
: /* R_NIOS_NONE. */
13248 case EM_OR1K
: /* R_OR1K_NONE. */
13249 case EM_PARISC
: /* R_PARISC_NONE. */
13250 case EM_PPC64
: /* R_PPC64_NONE. */
13251 case EM_PPC
: /* R_PPC_NONE. */
13252 case EM_RISCV
: /* R_RISCV_NONE. */
13253 case EM_S390
: /* R_390_NONE. */
13255 case EM_SH
: /* R_SH_NONE. */
13256 case EM_SPARC32PLUS
:
13257 case EM_SPARC
: /* R_SPARC_NONE. */
13259 case EM_TILEGX
: /* R_TILEGX_NONE. */
13260 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13261 case EM_TI_C6000
:/* R_C6000_NONE. */
13262 case EM_X86_64
: /* R_X86_64_NONE. */
13264 case EM_Z80
: /* R_Z80_NONE. */
13265 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13266 return reloc_type
== 0;
13269 return reloc_type
== 0 || reloc_type
== 256;
13272 return (reloc_type
== 0 /* R_AVR_NONE. */
13273 || reloc_type
== 30 /* R_AVR_DIFF8. */
13274 || reloc_type
== 31 /* R_AVR_DIFF16. */
13275 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13277 return reloc_type
== 3; /* R_METAG_NONE. */
13279 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13280 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13281 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13282 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13283 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13285 return (reloc_type
== 0 /* R_PRU_NONE. */
13286 || reloc_type
== 65 /* R_PRU_DIFF8. */
13287 || reloc_type
== 66 /* R_PRU_DIFF16. */
13288 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13289 case EM_XTENSA_OLD
:
13291 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13292 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13293 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13294 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13299 /* Returns TRUE if there is a relocation against
13300 section NAME at OFFSET bytes. */
13303 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13305 Elf_Internal_Rela
* relocs
;
13306 Elf_Internal_Rela
* rp
;
13308 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13311 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13313 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13314 if (rp
->r_offset
== offset
)
13320 /* Apply relocations to a section.
13321 Returns TRUE upon success, FALSE otherwise.
13322 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13323 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13324 will be set to the number of relocs loaded.
13326 Note: So far support has been added only for those relocations
13327 which can be found in debug sections. FIXME: Add support for
13328 more relocations ? */
13331 apply_relocations (Filedata
* filedata
,
13332 const Elf_Internal_Shdr
* section
,
13333 unsigned char * start
,
13334 bfd_size_type size
,
13335 void ** relocs_return
,
13336 unsigned long * num_relocs_return
)
13338 Elf_Internal_Shdr
* relsec
;
13339 unsigned char * end
= start
+ size
;
13341 if (relocs_return
!= NULL
)
13343 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13344 * num_relocs_return
= 0;
13347 if (filedata
->file_header
.e_type
!= ET_REL
)
13348 /* No relocs to apply. */
13351 /* Find the reloc section associated with the section. */
13352 for (relsec
= filedata
->section_headers
;
13353 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13356 bfd_boolean is_rela
;
13357 unsigned long num_relocs
;
13358 Elf_Internal_Rela
* relocs
;
13359 Elf_Internal_Rela
* rp
;
13360 Elf_Internal_Shdr
* symsec
;
13361 Elf_Internal_Sym
* symtab
;
13362 unsigned long num_syms
;
13363 Elf_Internal_Sym
* sym
;
13365 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13366 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13367 || filedata
->section_headers
+ relsec
->sh_info
!= section
13368 || relsec
->sh_size
== 0
13369 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13372 is_rela
= relsec
->sh_type
== SHT_RELA
;
13376 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13377 relsec
->sh_size
, & relocs
, & num_relocs
))
13382 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13383 relsec
->sh_size
, & relocs
, & num_relocs
))
13387 /* SH uses RELA but uses in place value instead of the addend field. */
13388 if (filedata
->file_header
.e_machine
== EM_SH
)
13391 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13392 if (symsec
->sh_type
!= SHT_SYMTAB
13393 && symsec
->sh_type
!= SHT_DYNSYM
)
13395 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13397 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13400 unsigned int reloc_type
;
13401 unsigned int reloc_size
;
13402 bfd_boolean reloc_inplace
= FALSE
;
13403 bfd_boolean reloc_subtract
= FALSE
;
13404 unsigned char * rloc
;
13405 unsigned long sym_index
;
13407 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13409 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13411 else if (is_none_reloc (filedata
, reloc_type
))
13413 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13414 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13416 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13417 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13419 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13421 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13423 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13424 || is_6bit_abs_reloc (filedata
, reloc_type
))
13426 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13428 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13431 reloc_inplace
= TRUE
;
13433 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13435 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13438 reloc_inplace
= TRUE
;
13440 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13442 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13445 reloc_inplace
= TRUE
;
13447 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13449 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13452 reloc_inplace
= TRUE
;
13454 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13458 reloc_inplace
= TRUE
;
13462 static unsigned int prev_reloc
= 0;
13464 if (reloc_type
!= prev_reloc
)
13465 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13466 reloc_type
, printable_section_name (filedata
, section
));
13467 prev_reloc
= reloc_type
;
13471 rloc
= start
+ rp
->r_offset
;
13472 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13474 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13475 (unsigned long) rp
->r_offset
,
13476 printable_section_name (filedata
, section
));
13480 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13481 if (sym_index
>= num_syms
)
13483 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13484 sym_index
, printable_section_name (filedata
, section
));
13487 sym
= symtab
+ sym_index
;
13489 /* If the reloc has a symbol associated with it,
13490 make sure that it is of an appropriate type.
13492 Relocations against symbols without type can happen.
13493 Gcc -feliminate-dwarf2-dups may generate symbols
13494 without type for debug info.
13496 Icc generates relocations against function symbols
13497 instead of local labels.
13499 Relocations against object symbols can happen, eg when
13500 referencing a global array. For an example of this see
13501 the _clz.o binary in libgcc.a. */
13503 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13504 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13506 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13507 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13508 printable_section_name (filedata
, relsec
),
13509 (long int)(rp
- relocs
));
13515 addend
+= rp
->r_addend
;
13516 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13517 partial_inplace. */
13519 || (filedata
->file_header
.e_machine
== EM_XTENSA
13520 && reloc_type
== 1)
13521 || ((filedata
->file_header
.e_machine
== EM_PJ
13522 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13523 && reloc_type
== 1)
13524 || ((filedata
->file_header
.e_machine
== EM_D30V
13525 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13526 && reloc_type
== 12)
13529 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13530 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13532 addend
+= byte_get (rloc
, reloc_size
);
13535 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13536 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13538 /* On HPPA, all pc-relative relocations are biased by 8. */
13539 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13541 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13544 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13545 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13547 if (reloc_subtract
)
13548 addend
-= sym
->st_value
;
13550 addend
+= sym
->st_value
;
13551 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13552 byte_put (rloc
, addend
, reloc_size
);
13554 else if (reloc_subtract
)
13555 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13557 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13561 /* Let the target specific reloc processing code know that
13562 we have finished with these relocs. */
13563 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13567 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13568 * num_relocs_return
= num_relocs
;
13579 #ifdef SUPPORT_DISASSEMBLY
13581 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13583 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13585 /* FIXME: XXX -- to be done --- XXX */
13591 /* Reads in the contents of SECTION from FILE, returning a pointer
13592 to a malloc'ed buffer or NULL if something went wrong. */
13595 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13597 bfd_size_type num_bytes
= section
->sh_size
;
13599 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13601 printf (_("Section '%s' has no data to dump.\n"),
13602 printable_section_name (filedata
, section
));
13606 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13607 _("section contents"));
13610 /* Uncompresses a section that was compressed using zlib, in place. */
13613 uncompress_section_contents (unsigned char ** buffer
,
13614 dwarf_size_type uncompressed_size
,
13615 dwarf_size_type
* size
)
13617 dwarf_size_type compressed_size
= *size
;
13618 unsigned char * compressed_buffer
= *buffer
;
13619 unsigned char * uncompressed_buffer
;
13623 /* It is possible the section consists of several compressed
13624 buffers concatenated together, so we uncompress in a loop. */
13625 /* PR 18313: The state field in the z_stream structure is supposed
13626 to be invisible to the user (ie us), but some compilers will
13627 still complain about it being used without initialisation. So
13628 we first zero the entire z_stream structure and then set the fields
13630 memset (& strm
, 0, sizeof strm
);
13631 strm
.avail_in
= compressed_size
;
13632 strm
.next_in
= (Bytef
*) compressed_buffer
;
13633 strm
.avail_out
= uncompressed_size
;
13634 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13636 rc
= inflateInit (& strm
);
13637 while (strm
.avail_in
> 0)
13641 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13642 + (uncompressed_size
- strm
.avail_out
));
13643 rc
= inflate (&strm
, Z_FINISH
);
13644 if (rc
!= Z_STREAM_END
)
13646 rc
= inflateReset (& strm
);
13648 rc
= inflateEnd (& strm
);
13650 || strm
.avail_out
!= 0)
13653 *buffer
= uncompressed_buffer
;
13654 *size
= uncompressed_size
;
13658 free (uncompressed_buffer
);
13659 /* Indicate decompression failure. */
13665 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13667 Elf_Internal_Shdr
* relsec
;
13668 bfd_size_type num_bytes
;
13669 unsigned char * data
;
13670 unsigned char * end
;
13671 unsigned char * real_start
;
13672 unsigned char * start
;
13673 bfd_boolean some_strings_shown
;
13675 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13677 /* PR 21820: Do not fail if the section was empty. */
13678 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13680 num_bytes
= section
->sh_size
;
13682 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13684 if (decompress_dumps
)
13686 dwarf_size_type new_size
= num_bytes
;
13687 dwarf_size_type uncompressed_size
= 0;
13689 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13691 Elf_Internal_Chdr chdr
;
13692 unsigned int compression_header_size
13693 = get_compression_header (& chdr
, (unsigned char *) start
,
13696 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13698 warn (_("section '%s' has unsupported compress type: %d\n"),
13699 printable_section_name (filedata
, section
), chdr
.ch_type
);
13702 uncompressed_size
= chdr
.ch_size
;
13703 start
+= compression_header_size
;
13704 new_size
-= compression_header_size
;
13706 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13708 /* Read the zlib header. In this case, it should be "ZLIB"
13709 followed by the uncompressed section size, 8 bytes in
13710 big-endian order. */
13711 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13712 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13713 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13714 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13715 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13716 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13717 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13718 uncompressed_size
+= start
[11];
13723 if (uncompressed_size
)
13725 if (uncompress_section_contents (& start
,
13726 uncompressed_size
, & new_size
))
13727 num_bytes
= new_size
;
13730 error (_("Unable to decompress section %s\n"),
13731 printable_section_name (filedata
, section
));
13736 start
= real_start
;
13739 /* If the section being dumped has relocations against it the user might
13740 be expecting these relocations to have been applied. Check for this
13741 case and issue a warning message in order to avoid confusion.
13742 FIXME: Maybe we ought to have an option that dumps a section with
13743 relocs applied ? */
13744 for (relsec
= filedata
->section_headers
;
13745 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13748 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13749 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13750 || filedata
->section_headers
+ relsec
->sh_info
!= section
13751 || relsec
->sh_size
== 0
13752 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13755 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13760 end
= start
+ num_bytes
;
13761 some_strings_shown
= FALSE
;
13765 while (!ISPRINT (* data
))
13766 if (++ data
>= end
)
13771 size_t maxlen
= end
- data
;
13774 /* PR 11128: Use two separate invocations in order to work
13775 around bugs in the Solaris 8 implementation of printf. */
13776 printf (" [%6tx] ", data
- start
);
13778 printf (" [%6Ix] ", (size_t) (data
- start
));
13782 print_symbol ((int) maxlen
, (const char *) data
);
13784 data
+= strnlen ((const char *) data
, maxlen
);
13788 printf (_("<corrupt>\n"));
13791 some_strings_shown
= TRUE
;
13795 if (! some_strings_shown
)
13796 printf (_(" No strings found in this section."));
13805 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13806 Filedata
* filedata
,
13807 bfd_boolean relocate
)
13809 Elf_Internal_Shdr
* relsec
;
13810 bfd_size_type bytes
;
13811 bfd_size_type section_size
;
13813 unsigned char * data
;
13814 unsigned char * real_start
;
13815 unsigned char * start
;
13817 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13819 /* PR 21820: Do not fail if the section was empty. */
13820 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13822 section_size
= section
->sh_size
;
13824 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13826 if (decompress_dumps
)
13828 dwarf_size_type new_size
= section_size
;
13829 dwarf_size_type uncompressed_size
= 0;
13831 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13833 Elf_Internal_Chdr chdr
;
13834 unsigned int compression_header_size
13835 = get_compression_header (& chdr
, start
, section_size
);
13837 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13839 warn (_("section '%s' has unsupported compress type: %d\n"),
13840 printable_section_name (filedata
, section
), chdr
.ch_type
);
13843 uncompressed_size
= chdr
.ch_size
;
13844 start
+= compression_header_size
;
13845 new_size
-= compression_header_size
;
13847 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13849 /* Read the zlib header. In this case, it should be "ZLIB"
13850 followed by the uncompressed section size, 8 bytes in
13851 big-endian order. */
13852 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13853 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13854 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13855 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13856 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13857 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13858 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13859 uncompressed_size
+= start
[11];
13864 if (uncompressed_size
)
13866 if (uncompress_section_contents (& start
, uncompressed_size
,
13869 section_size
= new_size
;
13873 error (_("Unable to decompress section %s\n"),
13874 printable_section_name (filedata
, section
));
13875 /* FIXME: Print the section anyway ? */
13880 start
= real_start
;
13885 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13890 /* If the section being dumped has relocations against it the user might
13891 be expecting these relocations to have been applied. Check for this
13892 case and issue a warning message in order to avoid confusion.
13893 FIXME: Maybe we ought to have an option that dumps a section with
13894 relocs applied ? */
13895 for (relsec
= filedata
->section_headers
;
13896 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13899 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13900 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13901 || filedata
->section_headers
+ relsec
->sh_info
!= section
13902 || relsec
->sh_size
== 0
13903 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13906 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13911 addr
= section
->sh_addr
;
13912 bytes
= section_size
;
13921 lbytes
= (bytes
> 16 ? 16 : bytes
);
13923 printf (" 0x%8.8lx ", (unsigned long) addr
);
13925 for (j
= 0; j
< 16; j
++)
13928 printf ("%2.2x", data
[j
]);
13936 for (j
= 0; j
< lbytes
; j
++)
13939 if (k
>= ' ' && k
< 0x7f)
13958 static ctf_sect_t
*
13959 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
13961 buf
->cts_name
= SECTION_NAME (shdr
);
13962 buf
->cts_size
= shdr
->sh_size
;
13963 buf
->cts_entsize
= shdr
->sh_entsize
;
13968 /* Formatting callback function passed to ctf_dump. Returns either the pointer
13969 it is passed, or a pointer to newly-allocated storage, in which case
13970 dump_ctf() will free it when it no longer needs it. */
13972 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
13973 char *s
, void *arg
)
13975 const char *blanks
= arg
;
13978 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
13984 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13986 Elf_Internal_Shdr
* parent_sec
= NULL
;
13987 Elf_Internal_Shdr
* symtab_sec
= NULL
;
13988 Elf_Internal_Shdr
* strtab_sec
= NULL
;
13989 void * data
= NULL
;
13990 void * symdata
= NULL
;
13991 void * strdata
= NULL
;
13992 void * parentdata
= NULL
;
13993 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
13994 ctf_sect_t
* symsectp
= NULL
;
13995 ctf_sect_t
* strsectp
= NULL
;
13996 ctf_file_t
* ctf
= NULL
;
13997 ctf_file_t
* parent
= NULL
;
13999 const char *things
[] = {"Header", "Labels", "Data objects",
14000 "Function objects", "Variables", "Types", "Strings",
14002 const char **thing
;
14004 bfd_boolean ret
= FALSE
;
14007 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14008 data
= get_section_contents (section
, filedata
);
14009 ctfsect
.cts_data
= data
;
14011 if (!dump_ctf_symtab_name
)
14012 dump_ctf_symtab_name
= strdup (".symtab");
14014 if (!dump_ctf_strtab_name
)
14015 dump_ctf_strtab_name
= strdup (".strtab");
14017 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14019 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14021 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14024 if ((symdata
= (void *) get_data (NULL
, filedata
,
14025 symtab_sec
->sh_offset
, 1,
14026 symtab_sec
->sh_size
,
14027 _("symbols"))) == NULL
)
14029 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14030 symsect
.cts_data
= symdata
;
14032 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14034 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14036 error (_("No string table section named %s\n"),
14037 dump_ctf_strtab_name
);
14040 if ((strdata
= (void *) get_data (NULL
, filedata
,
14041 strtab_sec
->sh_offset
, 1,
14042 strtab_sec
->sh_size
,
14043 _("strings"))) == NULL
)
14045 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14046 strsect
.cts_data
= strdata
;
14048 if (dump_ctf_parent_name
)
14050 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14052 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14055 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14056 parent_sec
->sh_offset
, 1,
14057 parent_sec
->sh_size
,
14058 _("CTF parent"))) == NULL
)
14060 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14061 parentsect
.cts_data
= parentdata
;
14064 /* Load the CTF file and dump it. */
14066 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14068 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14074 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14076 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14080 ctf_import (ctf
, parent
);
14085 printf (_("\nDump of CTF section '%s':\n"),
14086 printable_section_name (filedata
, section
));
14088 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14090 ctf_dump_state_t
*s
= NULL
;
14093 printf ("\n %s:\n", *thing
);
14094 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14095 (void *) " ")) != NULL
)
14097 printf ("%s\n", item
);
14101 if (ctf_errno (ctf
))
14103 error (_("Iteration failed: %s, %s\n"), *thing
,
14104 ctf_errmsg (ctf_errno (ctf
)));
14110 ctf_file_close (ctf
);
14111 ctf_file_close (parent
);
14120 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14121 const Elf_Internal_Shdr
* sec
,
14124 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14126 Filedata
* filedata
= (Filedata
*) data
;
14128 if (section
->start
!= NULL
)
14130 /* If it is already loaded, do nothing. */
14131 if (streq (section
->filename
, filedata
->file_name
))
14133 free (section
->start
);
14136 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14137 section
->address
= sec
->sh_addr
;
14138 section
->user_data
= NULL
;
14139 section
->filename
= filedata
->file_name
;
14140 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14142 sec
->sh_size
, buf
);
14143 if (section
->start
== NULL
)
14147 unsigned char *start
= section
->start
;
14148 dwarf_size_type size
= sec
->sh_size
;
14149 dwarf_size_type uncompressed_size
= 0;
14151 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14153 Elf_Internal_Chdr chdr
;
14154 unsigned int compression_header_size
;
14156 if (size
< (is_32bit_elf
14157 ? sizeof (Elf32_External_Chdr
)
14158 : sizeof (Elf64_External_Chdr
)))
14160 warn (_("compressed section %s is too small to contain a compression header"),
14165 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14167 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14169 warn (_("section '%s' has unsupported compress type: %d\n"),
14170 section
->name
, chdr
.ch_type
);
14173 uncompressed_size
= chdr
.ch_size
;
14174 start
+= compression_header_size
;
14175 size
-= compression_header_size
;
14177 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14179 /* Read the zlib header. In this case, it should be "ZLIB"
14180 followed by the uncompressed section size, 8 bytes in
14181 big-endian order. */
14182 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14183 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14184 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14185 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14186 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14187 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14188 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14189 uncompressed_size
+= start
[11];
14194 if (uncompressed_size
)
14196 if (uncompress_section_contents (&start
, uncompressed_size
,
14199 /* Free the compressed buffer, update the section buffer
14200 and the section size if uncompress is successful. */
14201 free (section
->start
);
14202 section
->start
= start
;
14206 error (_("Unable to decompress section %s\n"),
14207 printable_section_name (filedata
, sec
));
14212 section
->size
= size
;
14215 if (section
->start
== NULL
)
14218 if (debug_displays
[debug
].relocate
)
14220 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14221 & section
->reloc_info
, & section
->num_relocs
))
14226 section
->reloc_info
= NULL
;
14227 section
->num_relocs
= 0;
14233 #if HAVE_LIBDEBUGINFOD
14234 /* Return a hex string representation of the build-id. */
14236 get_build_id (void * data
)
14238 Filedata
* filedata
= (Filedata
*)data
;
14239 Elf_Internal_Shdr
* shdr
;
14242 /* Iterate through notes to find note.gnu.build-id. */
14243 for (i
= 0, shdr
= filedata
->section_headers
;
14244 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14247 if (shdr
->sh_type
!= SHT_NOTE
)
14252 size_t data_remaining
;
14254 Elf_External_Note
* enote
;
14255 Elf_Internal_Note inote
;
14257 bfd_vma offset
= shdr
->sh_offset
;
14258 bfd_vma align
= shdr
->sh_addralign
;
14259 bfd_vma length
= shdr
->sh_size
;
14261 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14267 else if (align
!= 4 && align
!= 8)
14270 end
= (char *) enote
+ length
;
14271 data_remaining
= end
- (char *) enote
;
14273 if (!is_ia64_vms (filedata
))
14275 min_notesz
= offsetof (Elf_External_Note
, name
);
14276 if (data_remaining
< min_notesz
)
14278 warn (ngettext ("debuginfod: Corrupt note: only %ld byte remains, "
14279 "not enough for a full note\n",
14280 "Corrupt note: only %ld bytes remain, "
14281 "not enough for a full note\n",
14283 (long) data_remaining
);
14286 data_remaining
-= min_notesz
;
14288 inote
.type
= BYTE_GET (enote
->type
);
14289 inote
.namesz
= BYTE_GET (enote
->namesz
);
14290 inote
.namedata
= enote
->name
;
14291 inote
.descsz
= BYTE_GET (enote
->descsz
);
14292 inote
.descdata
= ((char *) enote
14293 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14294 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14295 next
= ((char *) enote
14296 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14300 Elf64_External_VMS_Note
*vms_enote
;
14302 /* PR binutils/15191
14303 Make sure that there is enough data to read. */
14304 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14305 if (data_remaining
< min_notesz
)
14307 warn (ngettext ("debuginfod: Corrupt note: only %ld byte remains, "
14308 "not enough for a full note\n",
14309 "Corrupt note: only %ld bytes remain, "
14310 "not enough for a full note\n",
14312 (long) data_remaining
);
14315 data_remaining
-= min_notesz
;
14317 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14318 inote
.type
= BYTE_GET (vms_enote
->type
);
14319 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14320 inote
.namedata
= vms_enote
->name
;
14321 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14322 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14323 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14324 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14327 /* Skip malformed notes. */
14328 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14329 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14330 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14331 || ((size_t) (next
- inote
.descdata
)
14332 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14334 warn (_("debuginfod: note with invalid namesz and/or descsz found\n"));
14335 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
14336 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
14340 /* Check if this is the build-id note. If so then convert the build-id
14341 bytes to a hex string. */
14342 if (inote
.namesz
> 0
14343 && const_strneq (inote
.namedata
, "GNU")
14344 && inote
.type
== NT_GNU_BUILD_ID
)
14349 build_id
= malloc (inote
.descsz
* 2 + 1);
14350 if (build_id
== NULL
)
14353 for (j
= 0; j
< inote
.descsz
; ++j
)
14354 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14355 build_id
[inote
.descsz
* 2] = '\0';
14357 return (unsigned char *)build_id
;
14363 #endif /* HAVE_LIBDEBUGINFOD */
14365 /* If this is not NULL, load_debug_section will only look for sections
14366 within the list of sections given here. */
14367 static unsigned int * section_subset
= NULL
;
14370 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14372 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14373 Elf_Internal_Shdr
* sec
;
14374 Filedata
* filedata
= (Filedata
*) data
;
14376 /* Without section headers we cannot find any sections. */
14377 if (filedata
->section_headers
== NULL
)
14380 if (filedata
->string_table
== NULL
14381 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14382 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14384 Elf_Internal_Shdr
* strs
;
14386 /* Read in the string table, so that we have section names to scan. */
14387 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14389 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14391 filedata
->string_table
14392 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14393 1, strs
->sh_size
, _("string table"));
14395 filedata
->string_table_length
14396 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14400 /* Locate the debug section. */
14401 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14403 section
->name
= section
->uncompressed_name
;
14406 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14408 section
->name
= section
->compressed_name
;
14413 /* If we're loading from a subset of sections, and we've loaded
14414 a section matching this name before, it's likely that it's a
14416 if (section_subset
!= NULL
)
14417 free_debug_section (debug
);
14419 return load_specific_debug_section (debug
, sec
, data
);
14423 free_debug_section (enum dwarf_section_display_enum debug
)
14425 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14427 if (section
->start
== NULL
)
14430 free ((char *) section
->start
);
14431 section
->start
= NULL
;
14432 section
->address
= 0;
14437 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14439 char * name
= SECTION_NAME (section
);
14440 const char * print_name
= printable_section_name (filedata
, section
);
14441 bfd_size_type length
;
14442 bfd_boolean result
= TRUE
;
14445 length
= section
->sh_size
;
14448 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14451 if (section
->sh_type
== SHT_NOBITS
)
14453 /* There is no point in dumping the contents of a debugging section
14454 which has the NOBITS type - the bits in the file will be random.
14455 This can happen when a file containing a .eh_frame section is
14456 stripped with the --only-keep-debug command line option. */
14457 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14462 if (const_strneq (name
, ".gnu.linkonce.wi."))
14463 name
= ".debug_info";
14465 /* See if we know how to display the contents of this section. */
14466 for (i
= 0; i
< max
; i
++)
14468 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14469 struct dwarf_section_display
* display
= debug_displays
+ i
;
14470 struct dwarf_section
* sec
= & display
->section
;
14472 if (streq (sec
->uncompressed_name
, name
)
14473 || (id
== line
&& const_strneq (name
, ".debug_line."))
14474 || streq (sec
->compressed_name
, name
))
14476 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14479 free_debug_section (id
);
14481 if (i
== line
&& const_strneq (name
, ".debug_line."))
14483 else if (streq (sec
->uncompressed_name
, name
))
14484 sec
->name
= sec
->uncompressed_name
;
14486 sec
->name
= sec
->compressed_name
;
14488 if (load_specific_debug_section (id
, section
, filedata
))
14490 /* If this debug section is part of a CU/TU set in a .dwp file,
14491 restrict load_debug_section to the sections in that set. */
14492 section_subset
= find_cu_tu_set (filedata
, shndx
);
14494 result
&= display
->display (sec
, filedata
);
14496 section_subset
= NULL
;
14498 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14499 free_debug_section (id
);
14507 printf (_("Unrecognized debug section: %s\n"), print_name
);
14514 /* Set DUMP_SECTS for all sections where dumps were requested
14515 based on section name. */
14518 initialise_dumps_byname (Filedata
* filedata
)
14520 struct dump_list_entry
* cur
;
14522 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14525 bfd_boolean any
= FALSE
;
14527 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14528 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14530 request_dump_bynumber (filedata
, i
, cur
->type
);
14535 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14541 process_section_contents (Filedata
* filedata
)
14543 Elf_Internal_Shdr
* section
;
14545 bfd_boolean res
= TRUE
;
14550 initialise_dumps_byname (filedata
);
14552 for (i
= 0, section
= filedata
->section_headers
;
14553 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14556 dump_type dump
= filedata
->dump_sects
[i
];
14558 #ifdef SUPPORT_DISASSEMBLY
14559 if (dump
& DISASS_DUMP
)
14561 if (! disassemble_section (section
, filedata
))
14565 if (dump
& HEX_DUMP
)
14567 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14571 if (dump
& RELOC_DUMP
)
14573 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14577 if (dump
& STRING_DUMP
)
14579 if (! dump_section_as_strings (section
, filedata
))
14583 if (dump
& DEBUG_DUMP
)
14585 if (! display_debug_section (i
, section
, filedata
))
14589 if (dump
& CTF_DUMP
)
14591 if (! dump_section_as_ctf (section
, filedata
))
14596 /* Check to see if the user requested a
14597 dump of a section that does not exist. */
14598 while (i
< filedata
->num_dump_sects
)
14600 if (filedata
->dump_sects
[i
])
14602 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14612 process_mips_fpe_exception (int mask
)
14616 bfd_boolean first
= TRUE
;
14618 if (mask
& OEX_FPU_INEX
)
14619 fputs ("INEX", stdout
), first
= FALSE
;
14620 if (mask
& OEX_FPU_UFLO
)
14621 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14622 if (mask
& OEX_FPU_OFLO
)
14623 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14624 if (mask
& OEX_FPU_DIV0
)
14625 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14626 if (mask
& OEX_FPU_INVAL
)
14627 printf ("%sINVAL", first
? "" : "|");
14630 fputs ("0", stdout
);
14633 /* Display's the value of TAG at location P. If TAG is
14634 greater than 0 it is assumed to be an unknown tag, and
14635 a message is printed to this effect. Otherwise it is
14636 assumed that a message has already been printed.
14638 If the bottom bit of TAG is set it assumed to have a
14639 string value, otherwise it is assumed to have an integer
14642 Returns an updated P pointing to the first unread byte
14643 beyond the end of TAG's value.
14645 Reads at or beyond END will not be made. */
14647 static unsigned char *
14648 display_tag_value (signed int tag
,
14650 const unsigned char * const end
)
14655 printf (" Tag_unknown_%d: ", tag
);
14659 warn (_("<corrupt tag>\n"));
14663 /* PR 17531 file: 027-19978-0.004. */
14664 size_t maxlen
= (end
- p
) - 1;
14669 print_symbol ((int) maxlen
, (const char *) p
);
14670 p
+= strnlen ((char *) p
, maxlen
) + 1;
14674 printf (_("<corrupt string tag>"));
14675 p
= (unsigned char *) end
;
14681 READ_ULEB (val
, p
, end
);
14682 printf ("%ld (0x%lx)\n", val
, val
);
14689 /* ARC ABI attributes section. */
14691 static unsigned char *
14692 display_arc_attribute (unsigned char * p
,
14693 const unsigned char * const end
)
14698 READ_ULEB (tag
, p
, end
);
14702 case Tag_ARC_PCS_config
:
14703 READ_ULEB (val
, p
, end
);
14704 printf (" Tag_ARC_PCS_config: ");
14708 printf (_("Absent/Non standard\n"));
14711 printf (_("Bare metal/mwdt\n"));
14714 printf (_("Bare metal/newlib\n"));
14717 printf (_("Linux/uclibc\n"));
14720 printf (_("Linux/glibc\n"));
14723 printf (_("Unknown\n"));
14728 case Tag_ARC_CPU_base
:
14729 READ_ULEB (val
, p
, end
);
14730 printf (" Tag_ARC_CPU_base: ");
14735 printf (_("Absent\n"));
14737 case TAG_CPU_ARC6xx
:
14738 printf ("ARC6xx\n");
14740 case TAG_CPU_ARC7xx
:
14741 printf ("ARC7xx\n");
14743 case TAG_CPU_ARCEM
:
14744 printf ("ARCEM\n");
14746 case TAG_CPU_ARCHS
:
14747 printf ("ARCHS\n");
14752 case Tag_ARC_CPU_variation
:
14753 READ_ULEB (val
, p
, end
);
14754 printf (" Tag_ARC_CPU_variation: ");
14758 if (val
> 0 && val
< 16)
14759 printf ("Core%d\n", val
);
14761 printf ("Unknown\n");
14765 printf (_("Absent\n"));
14770 case Tag_ARC_CPU_name
:
14771 printf (" Tag_ARC_CPU_name: ");
14772 p
= display_tag_value (-1, p
, end
);
14775 case Tag_ARC_ABI_rf16
:
14776 READ_ULEB (val
, p
, end
);
14777 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14780 case Tag_ARC_ABI_osver
:
14781 READ_ULEB (val
, p
, end
);
14782 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14785 case Tag_ARC_ABI_pic
:
14786 case Tag_ARC_ABI_sda
:
14787 READ_ULEB (val
, p
, end
);
14788 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14789 : " Tag_ARC_ABI_pic: ");
14793 printf (_("Absent\n"));
14802 printf (_("Unknown\n"));
14807 case Tag_ARC_ABI_tls
:
14808 READ_ULEB (val
, p
, end
);
14809 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14812 case Tag_ARC_ABI_enumsize
:
14813 READ_ULEB (val
, p
, end
);
14814 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14818 case Tag_ARC_ABI_exceptions
:
14819 READ_ULEB (val
, p
, end
);
14820 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14824 case Tag_ARC_ABI_double_size
:
14825 READ_ULEB (val
, p
, end
);
14826 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14829 case Tag_ARC_ISA_config
:
14830 printf (" Tag_ARC_ISA_config: ");
14831 p
= display_tag_value (-1, p
, end
);
14834 case Tag_ARC_ISA_apex
:
14835 printf (" Tag_ARC_ISA_apex: ");
14836 p
= display_tag_value (-1, p
, end
);
14839 case Tag_ARC_ISA_mpy_option
:
14840 READ_ULEB (val
, p
, end
);
14841 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14844 case Tag_ARC_ATR_version
:
14845 READ_ULEB (val
, p
, end
);
14846 printf (" Tag_ARC_ATR_version: %d\n", val
);
14850 return display_tag_value (tag
& 1, p
, end
);
14856 /* ARM EABI attributes section. */
14861 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14863 const char ** table
;
14864 } arm_attr_public_tag
;
14866 static const char * arm_attr_tag_CPU_arch
[] =
14867 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14868 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14869 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14870 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14871 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14872 {"No", "Thumb-1", "Thumb-2", "Yes"};
14873 static const char * arm_attr_tag_FP_arch
[] =
14874 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14875 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14876 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14877 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14878 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14879 "NEON for ARMv8.1"};
14880 static const char * arm_attr_tag_PCS_config
[] =
14881 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14882 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14883 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14884 {"V6", "SB", "TLS", "Unused"};
14885 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14886 {"Absolute", "PC-relative", "SB-relative", "None"};
14887 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14888 {"Absolute", "PC-relative", "None"};
14889 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14890 {"None", "direct", "GOT-indirect"};
14891 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14892 {"None", "??? 1", "2", "??? 3", "4"};
14893 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14894 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14895 {"Unused", "Needed", "Sign only"};
14896 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14897 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14898 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14899 {"Unused", "Finite", "RTABI", "IEEE 754"};
14900 static const char * arm_attr_tag_ABI_enum_size
[] =
14901 {"Unused", "small", "int", "forced to int"};
14902 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14903 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14904 static const char * arm_attr_tag_ABI_VFP_args
[] =
14905 {"AAPCS", "VFP registers", "custom", "compatible"};
14906 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14907 {"AAPCS", "WMMX registers", "custom"};
14908 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14909 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14910 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14911 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14912 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14913 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14914 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14915 static const char * arm_attr_tag_FP_HP_extension
[] =
14916 {"Not Allowed", "Allowed"};
14917 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14918 {"None", "IEEE 754", "Alternative Format"};
14919 static const char * arm_attr_tag_DSP_extension
[] =
14920 {"Follow architecture", "Allowed"};
14921 static const char * arm_attr_tag_MPextension_use
[] =
14922 {"Not Allowed", "Allowed"};
14923 static const char * arm_attr_tag_DIV_use
[] =
14924 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14925 "Allowed in v7-A with integer division extension"};
14926 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14927 static const char * arm_attr_tag_Virtualization_use
[] =
14928 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14929 "TrustZone and Virtualization Extensions"};
14930 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14931 {"Not Allowed", "Allowed"};
14933 static const char * arm_attr_tag_MVE_arch
[] =
14934 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14936 #define LOOKUP(id, name) \
14937 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14938 static arm_attr_public_tag arm_attr_public_tags
[] =
14940 {4, "CPU_raw_name", 1, NULL
},
14941 {5, "CPU_name", 1, NULL
},
14942 LOOKUP(6, CPU_arch
),
14943 {7, "CPU_arch_profile", 0, NULL
},
14944 LOOKUP(8, ARM_ISA_use
),
14945 LOOKUP(9, THUMB_ISA_use
),
14946 LOOKUP(10, FP_arch
),
14947 LOOKUP(11, WMMX_arch
),
14948 LOOKUP(12, Advanced_SIMD_arch
),
14949 LOOKUP(13, PCS_config
),
14950 LOOKUP(14, ABI_PCS_R9_use
),
14951 LOOKUP(15, ABI_PCS_RW_data
),
14952 LOOKUP(16, ABI_PCS_RO_data
),
14953 LOOKUP(17, ABI_PCS_GOT_use
),
14954 LOOKUP(18, ABI_PCS_wchar_t
),
14955 LOOKUP(19, ABI_FP_rounding
),
14956 LOOKUP(20, ABI_FP_denormal
),
14957 LOOKUP(21, ABI_FP_exceptions
),
14958 LOOKUP(22, ABI_FP_user_exceptions
),
14959 LOOKUP(23, ABI_FP_number_model
),
14960 {24, "ABI_align_needed", 0, NULL
},
14961 {25, "ABI_align_preserved", 0, NULL
},
14962 LOOKUP(26, ABI_enum_size
),
14963 LOOKUP(27, ABI_HardFP_use
),
14964 LOOKUP(28, ABI_VFP_args
),
14965 LOOKUP(29, ABI_WMMX_args
),
14966 LOOKUP(30, ABI_optimization_goals
),
14967 LOOKUP(31, ABI_FP_optimization_goals
),
14968 {32, "compatibility", 0, NULL
},
14969 LOOKUP(34, CPU_unaligned_access
),
14970 LOOKUP(36, FP_HP_extension
),
14971 LOOKUP(38, ABI_FP_16bit_format
),
14972 LOOKUP(42, MPextension_use
),
14973 LOOKUP(44, DIV_use
),
14974 LOOKUP(46, DSP_extension
),
14975 LOOKUP(48, MVE_arch
),
14976 {64, "nodefaults", 0, NULL
},
14977 {65, "also_compatible_with", 0, NULL
},
14978 LOOKUP(66, T2EE_use
),
14979 {67, "conformance", 1, NULL
},
14980 LOOKUP(68, Virtualization_use
),
14981 LOOKUP(70, MPextension_use_legacy
)
14985 static unsigned char *
14986 display_arm_attribute (unsigned char * p
,
14987 const unsigned char * const end
)
14991 arm_attr_public_tag
* attr
;
14995 READ_ULEB (tag
, p
, end
);
14997 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14999 if (arm_attr_public_tags
[i
].tag
== tag
)
15001 attr
= &arm_attr_public_tags
[i
];
15008 printf (" Tag_%s: ", attr
->name
);
15009 switch (attr
->type
)
15014 case 7: /* Tag_CPU_arch_profile. */
15015 READ_ULEB (val
, p
, end
);
15018 case 0: printf (_("None\n")); break;
15019 case 'A': printf (_("Application\n")); break;
15020 case 'R': printf (_("Realtime\n")); break;
15021 case 'M': printf (_("Microcontroller\n")); break;
15022 case 'S': printf (_("Application or Realtime\n")); break;
15023 default: printf ("??? (%d)\n", val
); break;
15027 case 24: /* Tag_align_needed. */
15028 READ_ULEB (val
, p
, end
);
15031 case 0: printf (_("None\n")); break;
15032 case 1: printf (_("8-byte\n")); break;
15033 case 2: printf (_("4-byte\n")); break;
15034 case 3: printf ("??? 3\n"); break;
15037 printf (_("8-byte and up to %d-byte extended\n"),
15040 printf ("??? (%d)\n", val
);
15045 case 25: /* Tag_align_preserved. */
15046 READ_ULEB (val
, p
, end
);
15049 case 0: printf (_("None\n")); break;
15050 case 1: printf (_("8-byte, except leaf SP\n")); break;
15051 case 2: printf (_("8-byte\n")); break;
15052 case 3: printf ("??? 3\n"); break;
15055 printf (_("8-byte and up to %d-byte extended\n"),
15058 printf ("??? (%d)\n", val
);
15063 case 32: /* Tag_compatibility. */
15065 READ_ULEB (val
, p
, end
);
15066 printf (_("flag = %d, vendor = "), val
);
15069 size_t maxlen
= (end
- p
) - 1;
15071 print_symbol ((int) maxlen
, (const char *) p
);
15072 p
+= strnlen ((char *) p
, maxlen
) + 1;
15076 printf (_("<corrupt>"));
15077 p
= (unsigned char *) end
;
15083 case 64: /* Tag_nodefaults. */
15084 /* PR 17531: file: 001-505008-0.01. */
15087 printf (_("True\n"));
15090 case 65: /* Tag_also_compatible_with. */
15091 READ_ULEB (val
, p
, end
);
15092 if (val
== 6 /* Tag_CPU_arch. */)
15094 READ_ULEB (val
, p
, end
);
15095 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15096 printf ("??? (%d)\n", val
);
15098 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15102 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15107 printf (_("<unknown: %d>\n"), tag
);
15113 return display_tag_value (-1, p
, end
);
15115 return display_tag_value (0, p
, end
);
15118 assert (attr
->type
& 0x80);
15119 READ_ULEB (val
, p
, end
);
15120 type
= attr
->type
& 0x7f;
15122 printf ("??? (%d)\n", val
);
15124 printf ("%s\n", attr
->table
[val
]);
15129 return display_tag_value (tag
, p
, end
);
15132 static unsigned char *
15133 display_gnu_attribute (unsigned char * p
,
15134 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15135 const unsigned char * const end
)
15140 READ_ULEB (tag
, p
, end
);
15142 /* Tag_compatibility is the only generic GNU attribute defined at
15146 READ_ULEB (val
, p
, end
);
15148 printf (_("flag = %d, vendor = "), val
);
15151 printf (_("<corrupt>\n"));
15152 warn (_("corrupt vendor attribute\n"));
15158 size_t maxlen
= (end
- p
) - 1;
15160 print_symbol ((int) maxlen
, (const char *) p
);
15161 p
+= strnlen ((char *) p
, maxlen
) + 1;
15165 printf (_("<corrupt>"));
15166 p
= (unsigned char *) end
;
15173 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15174 return display_proc_gnu_attribute (p
, tag
, end
);
15176 return display_tag_value (tag
, p
, end
);
15179 static unsigned char *
15180 display_power_gnu_attribute (unsigned char * p
,
15182 const unsigned char * const end
)
15186 if (tag
== Tag_GNU_Power_ABI_FP
)
15188 printf (" Tag_GNU_Power_ABI_FP: ");
15191 printf (_("<corrupt>\n"));
15194 READ_ULEB (val
, p
, end
);
15197 printf ("(%#x), ", val
);
15202 printf (_("unspecified hard/soft float, "));
15205 printf (_("hard float, "));
15208 printf (_("soft float, "));
15211 printf (_("single-precision hard float, "));
15218 printf (_("unspecified long double\n"));
15221 printf (_("128-bit IBM long double\n"));
15224 printf (_("64-bit long double\n"));
15227 printf (_("128-bit IEEE long double\n"));
15233 if (tag
== Tag_GNU_Power_ABI_Vector
)
15235 printf (" Tag_GNU_Power_ABI_Vector: ");
15238 printf (_("<corrupt>\n"));
15241 READ_ULEB (val
, p
, end
);
15244 printf ("(%#x), ", val
);
15249 printf (_("unspecified\n"));
15252 printf (_("generic\n"));
15255 printf ("AltiVec\n");
15264 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15266 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15269 printf (_("<corrupt>\n"));
15272 READ_ULEB (val
, p
, end
);
15275 printf ("(%#x), ", val
);
15280 printf (_("unspecified\n"));
15283 printf ("r3/r4\n");
15286 printf (_("memory\n"));
15295 return display_tag_value (tag
& 1, p
, end
);
15298 static unsigned char *
15299 display_s390_gnu_attribute (unsigned char * p
,
15301 const unsigned char * const end
)
15305 if (tag
== Tag_GNU_S390_ABI_Vector
)
15307 printf (" Tag_GNU_S390_ABI_Vector: ");
15308 READ_ULEB (val
, p
, end
);
15313 printf (_("any\n"));
15316 printf (_("software\n"));
15319 printf (_("hardware\n"));
15322 printf ("??? (%d)\n", val
);
15328 return display_tag_value (tag
& 1, p
, end
);
15332 display_sparc_hwcaps (unsigned int mask
)
15336 bfd_boolean first
= TRUE
;
15338 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15339 fputs ("mul32", stdout
), first
= FALSE
;
15340 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15341 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15342 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15343 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15344 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15345 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15346 if (mask
& ELF_SPARC_HWCAP_POPC
)
15347 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15348 if (mask
& ELF_SPARC_HWCAP_VIS
)
15349 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15350 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15351 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15352 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15353 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15354 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15355 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15356 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15357 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15358 if (mask
& ELF_SPARC_HWCAP_HPC
)
15359 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15360 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15361 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15362 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15363 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15364 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15365 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15366 if (mask
& ELF_SPARC_HWCAP_IMA
)
15367 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15368 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15369 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15372 fputc ('0', stdout
);
15373 fputc ('\n', stdout
);
15377 display_sparc_hwcaps2 (unsigned int mask
)
15381 bfd_boolean first
= TRUE
;
15383 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15384 fputs ("fjathplus", stdout
), first
= FALSE
;
15385 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15386 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15387 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15388 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15389 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15390 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15391 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15392 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15393 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15394 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15395 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15396 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15397 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15398 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15399 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15400 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15401 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15402 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15403 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15404 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15407 fputc ('0', stdout
);
15408 fputc ('\n', stdout
);
15411 static unsigned char *
15412 display_sparc_gnu_attribute (unsigned char * p
,
15414 const unsigned char * const end
)
15418 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15420 READ_ULEB (val
, p
, end
);
15421 printf (" Tag_GNU_Sparc_HWCAPS: ");
15422 display_sparc_hwcaps (val
);
15425 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15427 READ_ULEB (val
, p
, end
);
15428 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15429 display_sparc_hwcaps2 (val
);
15433 return display_tag_value (tag
, p
, end
);
15437 print_mips_fp_abi_value (unsigned int val
)
15441 case Val_GNU_MIPS_ABI_FP_ANY
:
15442 printf (_("Hard or soft float\n"));
15444 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15445 printf (_("Hard float (double precision)\n"));
15447 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15448 printf (_("Hard float (single precision)\n"));
15450 case Val_GNU_MIPS_ABI_FP_SOFT
:
15451 printf (_("Soft float\n"));
15453 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15454 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15456 case Val_GNU_MIPS_ABI_FP_XX
:
15457 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15459 case Val_GNU_MIPS_ABI_FP_64
:
15460 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15462 case Val_GNU_MIPS_ABI_FP_64A
:
15463 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15465 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15466 printf (_("NaN 2008 compatibility\n"));
15469 printf ("??? (%d)\n", val
);
15474 static unsigned char *
15475 display_mips_gnu_attribute (unsigned char * p
,
15477 const unsigned char * const end
)
15479 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15483 printf (" Tag_GNU_MIPS_ABI_FP: ");
15484 READ_ULEB (val
, p
, end
);
15485 print_mips_fp_abi_value (val
);
15489 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15493 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15494 READ_ULEB (val
, p
, end
);
15498 case Val_GNU_MIPS_ABI_MSA_ANY
:
15499 printf (_("Any MSA or not\n"));
15501 case Val_GNU_MIPS_ABI_MSA_128
:
15502 printf (_("128-bit MSA\n"));
15505 printf ("??? (%d)\n", val
);
15511 return display_tag_value (tag
& 1, p
, end
);
15514 static unsigned char *
15515 display_tic6x_attribute (unsigned char * p
,
15516 const unsigned char * const end
)
15521 READ_ULEB (tag
, p
, end
);
15526 printf (" Tag_ISA: ");
15527 READ_ULEB (val
, p
, end
);
15531 case C6XABI_Tag_ISA_none
:
15532 printf (_("None\n"));
15534 case C6XABI_Tag_ISA_C62X
:
15537 case C6XABI_Tag_ISA_C67X
:
15540 case C6XABI_Tag_ISA_C67XP
:
15541 printf ("C67x+\n");
15543 case C6XABI_Tag_ISA_C64X
:
15546 case C6XABI_Tag_ISA_C64XP
:
15547 printf ("C64x+\n");
15549 case C6XABI_Tag_ISA_C674X
:
15550 printf ("C674x\n");
15553 printf ("??? (%d)\n", val
);
15558 case Tag_ABI_wchar_t
:
15559 printf (" Tag_ABI_wchar_t: ");
15560 READ_ULEB (val
, p
, end
);
15564 printf (_("Not used\n"));
15567 printf (_("2 bytes\n"));
15570 printf (_("4 bytes\n"));
15573 printf ("??? (%d)\n", val
);
15578 case Tag_ABI_stack_align_needed
:
15579 printf (" Tag_ABI_stack_align_needed: ");
15580 READ_ULEB (val
, p
, end
);
15584 printf (_("8-byte\n"));
15587 printf (_("16-byte\n"));
15590 printf ("??? (%d)\n", val
);
15595 case Tag_ABI_stack_align_preserved
:
15596 READ_ULEB (val
, p
, end
);
15597 printf (" Tag_ABI_stack_align_preserved: ");
15601 printf (_("8-byte\n"));
15604 printf (_("16-byte\n"));
15607 printf ("??? (%d)\n", val
);
15613 READ_ULEB (val
, p
, end
);
15614 printf (" Tag_ABI_DSBT: ");
15618 printf (_("DSBT addressing not used\n"));
15621 printf (_("DSBT addressing used\n"));
15624 printf ("??? (%d)\n", val
);
15630 READ_ULEB (val
, p
, end
);
15631 printf (" Tag_ABI_PID: ");
15635 printf (_("Data addressing position-dependent\n"));
15638 printf (_("Data addressing position-independent, GOT near DP\n"));
15641 printf (_("Data addressing position-independent, GOT far from DP\n"));
15644 printf ("??? (%d)\n", val
);
15650 READ_ULEB (val
, p
, end
);
15651 printf (" Tag_ABI_PIC: ");
15655 printf (_("Code addressing position-dependent\n"));
15658 printf (_("Code addressing position-independent\n"));
15661 printf ("??? (%d)\n", val
);
15666 case Tag_ABI_array_object_alignment
:
15667 READ_ULEB (val
, p
, end
);
15668 printf (" Tag_ABI_array_object_alignment: ");
15672 printf (_("8-byte\n"));
15675 printf (_("4-byte\n"));
15678 printf (_("16-byte\n"));
15681 printf ("??? (%d)\n", val
);
15686 case Tag_ABI_array_object_align_expected
:
15687 READ_ULEB (val
, p
, end
);
15688 printf (" Tag_ABI_array_object_align_expected: ");
15692 printf (_("8-byte\n"));
15695 printf (_("4-byte\n"));
15698 printf (_("16-byte\n"));
15701 printf ("??? (%d)\n", val
);
15706 case Tag_ABI_compatibility
:
15708 READ_ULEB (val
, p
, end
);
15709 printf (" Tag_ABI_compatibility: ");
15710 printf (_("flag = %d, vendor = "), val
);
15713 size_t maxlen
= (end
- p
) - 1;
15715 print_symbol ((int) maxlen
, (const char *) p
);
15716 p
+= strnlen ((char *) p
, maxlen
) + 1;
15720 printf (_("<corrupt>"));
15721 p
= (unsigned char *) end
;
15727 case Tag_ABI_conformance
:
15729 printf (" Tag_ABI_conformance: \"");
15732 size_t maxlen
= (end
- p
) - 1;
15734 print_symbol ((int) maxlen
, (const char *) p
);
15735 p
+= strnlen ((char *) p
, maxlen
) + 1;
15739 printf (_("<corrupt>"));
15740 p
= (unsigned char *) end
;
15747 return display_tag_value (tag
, p
, end
);
15751 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15753 unsigned long addr
= 0;
15754 size_t bytes
= end
- p
;
15761 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15763 printf (" 0x%8.8lx ", addr
);
15765 for (j
= 0; j
< 16; j
++)
15768 printf ("%2.2x", p
[j
]);
15776 for (j
= 0; j
< lbytes
; j
++)
15779 if (k
>= ' ' && k
< 0x7f)
15795 static unsigned char *
15796 display_msp430x_attribute (unsigned char * p
,
15797 const unsigned char * const end
)
15802 READ_ULEB (tag
, p
, end
);
15806 case OFBA_MSPABI_Tag_ISA
:
15807 printf (" Tag_ISA: ");
15808 READ_ULEB (val
, p
, end
);
15811 case 0: printf (_("None\n")); break;
15812 case 1: printf (_("MSP430\n")); break;
15813 case 2: printf (_("MSP430X\n")); break;
15814 default: printf ("??? (%d)\n", val
); break;
15818 case OFBA_MSPABI_Tag_Code_Model
:
15819 printf (" Tag_Code_Model: ");
15820 READ_ULEB (val
, p
, end
);
15823 case 0: printf (_("None\n")); break;
15824 case 1: printf (_("Small\n")); break;
15825 case 2: printf (_("Large\n")); break;
15826 default: printf ("??? (%d)\n", val
); break;
15830 case OFBA_MSPABI_Tag_Data_Model
:
15831 printf (" Tag_Data_Model: ");
15832 READ_ULEB (val
, p
, end
);
15835 case 0: printf (_("None\n")); break;
15836 case 1: printf (_("Small\n")); break;
15837 case 2: printf (_("Large\n")); break;
15838 case 3: printf (_("Restricted Large\n")); break;
15839 default: printf ("??? (%d)\n", val
); break;
15844 printf (_(" <unknown tag %d>: "), tag
);
15851 size_t maxlen
= (end
- p
) - 1;
15853 print_symbol ((int) maxlen
, (const char *) p
);
15854 p
+= strnlen ((char *) p
, maxlen
) + 1;
15858 printf (_("<corrupt>"));
15859 p
= (unsigned char *) end
;
15865 READ_ULEB (val
, p
, end
);
15866 printf ("%d (0x%x)\n", val
, val
);
15875 static unsigned char *
15876 display_msp430_gnu_attribute (unsigned char * p
,
15878 const unsigned char * const end
)
15880 if (tag
== Tag_GNU_MSP430_Data_Region
)
15884 printf (" Tag_GNU_MSP430_Data_Region: ");
15885 READ_ULEB (val
, p
, end
);
15889 case Val_GNU_MSP430_Data_Region_Any
:
15890 printf (_("Any Region\n"));
15892 case Val_GNU_MSP430_Data_Region_Lower
:
15893 printf (_("Lower Region Only\n"));
15896 printf ("??? (%u)\n", val
);
15900 return display_tag_value (tag
& 1, p
, end
);
15903 struct riscv_attr_tag_t
{
15908 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15910 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15913 T(priv_spec_minor
),
15914 T(priv_spec_revision
),
15915 T(unaligned_access
),
15920 static unsigned char *
15921 display_riscv_attribute (unsigned char *p
,
15922 const unsigned char * const end
)
15926 struct riscv_attr_tag_t
*attr
= NULL
;
15929 READ_ULEB (tag
, p
, end
);
15931 /* Find the name of attribute. */
15932 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
15934 if (riscv_attr_tag
[i
].tag
== tag
)
15936 attr
= &riscv_attr_tag
[i
];
15942 printf (" %s: ", attr
->name
);
15944 return display_tag_value (tag
, p
, end
);
15948 case Tag_RISCV_priv_spec
:
15949 case Tag_RISCV_priv_spec_minor
:
15950 case Tag_RISCV_priv_spec_revision
:
15951 READ_ULEB (val
, p
, end
);
15952 printf (_("%u\n"), val
);
15954 case Tag_RISCV_unaligned_access
:
15955 READ_ULEB (val
, p
, end
);
15959 printf (_("No unaligned access\n"));
15962 printf (_("Unaligned access\n"));
15966 case Tag_RISCV_stack_align
:
15967 READ_ULEB (val
, p
, end
);
15968 printf (_("%u-bytes\n"), val
);
15970 case Tag_RISCV_arch
:
15971 p
= display_tag_value (-1, p
, end
);
15974 return display_tag_value (tag
, p
, end
);
15981 process_attributes (Filedata
* filedata
,
15982 const char * public_name
,
15983 unsigned int proc_type
,
15984 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15985 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15987 Elf_Internal_Shdr
* sect
;
15989 bfd_boolean res
= TRUE
;
15991 /* Find the section header so that we get the size. */
15992 for (i
= 0, sect
= filedata
->section_headers
;
15993 i
< filedata
->file_header
.e_shnum
;
15996 unsigned char * contents
;
15999 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16002 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16003 sect
->sh_size
, _("attributes"));
16004 if (contents
== NULL
)
16011 /* The first character is the version of the attributes.
16012 Currently only version 1, (aka 'A') is recognised here. */
16015 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16020 bfd_vma section_len
;
16022 section_len
= sect
->sh_size
- 1;
16025 while (section_len
> 0)
16028 unsigned int namelen
;
16029 bfd_boolean public_section
;
16030 bfd_boolean gnu_section
;
16032 if (section_len
<= 4)
16034 error (_("Tag section ends prematurely\n"));
16038 attr_len
= byte_get (p
, 4);
16041 if (attr_len
> section_len
)
16043 error (_("Bad attribute length (%u > %u)\n"),
16044 (unsigned) attr_len
, (unsigned) section_len
);
16045 attr_len
= section_len
;
16048 /* PR 17531: file: 001-101425-0.004 */
16049 else if (attr_len
< 5)
16051 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16056 section_len
-= attr_len
;
16059 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16060 if (namelen
== 0 || namelen
>= attr_len
)
16062 error (_("Corrupt attribute section name\n"));
16067 printf (_("Attribute Section: "));
16068 print_symbol (INT_MAX
, (const char *) p
);
16071 if (public_name
&& streq ((char *) p
, public_name
))
16072 public_section
= TRUE
;
16074 public_section
= FALSE
;
16076 if (streq ((char *) p
, "gnu"))
16077 gnu_section
= TRUE
;
16079 gnu_section
= FALSE
;
16082 attr_len
-= namelen
;
16084 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16089 unsigned char * end
;
16091 /* PR binutils/17531: Safe handling of corrupt files. */
16094 error (_("Unused bytes at end of section\n"));
16101 size
= byte_get (p
, 4);
16102 if (size
> attr_len
)
16104 error (_("Bad subsection length (%u > %u)\n"),
16105 (unsigned) size
, (unsigned) attr_len
);
16109 /* PR binutils/17531: Safe handling of corrupt files. */
16112 error (_("Bad subsection length (%u < 6)\n"),
16120 end
= p
+ size
- 1;
16121 assert (end
<= contents
+ sect
->sh_size
);
16127 printf (_("File Attributes\n"));
16130 printf (_("Section Attributes:"));
16133 printf (_("Symbol Attributes:"));
16134 /* Fall through. */
16138 READ_ULEB (val
, p
, end
);
16141 printf (" %d", val
);
16146 printf (_("Unknown tag: %d\n"), tag
);
16147 public_section
= FALSE
;
16151 if (public_section
&& display_pub_attribute
!= NULL
)
16154 p
= display_pub_attribute (p
, end
);
16157 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16160 p
= display_gnu_attribute (p
,
16161 display_proc_gnu_attribute
,
16167 printf (_(" Unknown attribute:\n"));
16168 display_raw_attribute (p
, end
);
16183 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16184 Print the Address, Access and Initial fields of an entry at VMA ADDR
16185 and return the VMA of the next entry, or -1 if there was a problem.
16186 Does not read from DATA_END or beyond. */
16189 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16190 unsigned char * data_end
)
16193 print_vma (addr
, LONG_HEX
);
16195 if (addr
< pltgot
+ 0xfff0)
16196 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16198 printf ("%10s", "");
16201 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16205 unsigned char * from
= data
+ addr
- pltgot
;
16207 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16209 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16210 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16211 return (bfd_vma
) -1;
16215 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16216 print_vma (entry
, LONG_HEX
);
16219 return addr
+ (is_32bit_elf
? 4 : 8);
16222 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16223 PLTGOT. Print the Address and Initial fields of an entry at VMA
16224 ADDR and return the VMA of the next entry. */
16227 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16230 print_vma (addr
, LONG_HEX
);
16233 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16238 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16239 print_vma (entry
, LONG_HEX
);
16241 return addr
+ (is_32bit_elf
? 4 : 8);
16245 print_mips_ases (unsigned int mask
)
16247 if (mask
& AFL_ASE_DSP
)
16248 fputs ("\n\tDSP ASE", stdout
);
16249 if (mask
& AFL_ASE_DSPR2
)
16250 fputs ("\n\tDSP R2 ASE", stdout
);
16251 if (mask
& AFL_ASE_DSPR3
)
16252 fputs ("\n\tDSP R3 ASE", stdout
);
16253 if (mask
& AFL_ASE_EVA
)
16254 fputs ("\n\tEnhanced VA Scheme", stdout
);
16255 if (mask
& AFL_ASE_MCU
)
16256 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16257 if (mask
& AFL_ASE_MDMX
)
16258 fputs ("\n\tMDMX ASE", stdout
);
16259 if (mask
& AFL_ASE_MIPS3D
)
16260 fputs ("\n\tMIPS-3D ASE", stdout
);
16261 if (mask
& AFL_ASE_MT
)
16262 fputs ("\n\tMT ASE", stdout
);
16263 if (mask
& AFL_ASE_SMARTMIPS
)
16264 fputs ("\n\tSmartMIPS ASE", stdout
);
16265 if (mask
& AFL_ASE_VIRT
)
16266 fputs ("\n\tVZ ASE", stdout
);
16267 if (mask
& AFL_ASE_MSA
)
16268 fputs ("\n\tMSA ASE", stdout
);
16269 if (mask
& AFL_ASE_MIPS16
)
16270 fputs ("\n\tMIPS16 ASE", stdout
);
16271 if (mask
& AFL_ASE_MICROMIPS
)
16272 fputs ("\n\tMICROMIPS ASE", stdout
);
16273 if (mask
& AFL_ASE_XPA
)
16274 fputs ("\n\tXPA ASE", stdout
);
16275 if (mask
& AFL_ASE_MIPS16E2
)
16276 fputs ("\n\tMIPS16e2 ASE", stdout
);
16277 if (mask
& AFL_ASE_CRC
)
16278 fputs ("\n\tCRC ASE", stdout
);
16279 if (mask
& AFL_ASE_GINV
)
16280 fputs ("\n\tGINV ASE", stdout
);
16281 if (mask
& AFL_ASE_LOONGSON_MMI
)
16282 fputs ("\n\tLoongson MMI ASE", stdout
);
16283 if (mask
& AFL_ASE_LOONGSON_CAM
)
16284 fputs ("\n\tLoongson CAM ASE", stdout
);
16285 if (mask
& AFL_ASE_LOONGSON_EXT
)
16286 fputs ("\n\tLoongson EXT ASE", stdout
);
16287 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16288 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16290 fprintf (stdout
, "\n\t%s", _("None"));
16291 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16292 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16296 print_mips_isa_ext (unsigned int isa_ext
)
16301 fputs (_("None"), stdout
);
16304 fputs ("RMI XLR", stdout
);
16306 case AFL_EXT_OCTEON3
:
16307 fputs ("Cavium Networks Octeon3", stdout
);
16309 case AFL_EXT_OCTEON2
:
16310 fputs ("Cavium Networks Octeon2", stdout
);
16312 case AFL_EXT_OCTEONP
:
16313 fputs ("Cavium Networks OcteonP", stdout
);
16315 case AFL_EXT_OCTEON
:
16316 fputs ("Cavium Networks Octeon", stdout
);
16319 fputs ("Toshiba R5900", stdout
);
16322 fputs ("MIPS R4650", stdout
);
16325 fputs ("LSI R4010", stdout
);
16328 fputs ("NEC VR4100", stdout
);
16331 fputs ("Toshiba R3900", stdout
);
16333 case AFL_EXT_10000
:
16334 fputs ("MIPS R10000", stdout
);
16337 fputs ("Broadcom SB-1", stdout
);
16340 fputs ("NEC VR4111/VR4181", stdout
);
16343 fputs ("NEC VR4120", stdout
);
16346 fputs ("NEC VR5400", stdout
);
16349 fputs ("NEC VR5500", stdout
);
16351 case AFL_EXT_LOONGSON_2E
:
16352 fputs ("ST Microelectronics Loongson 2E", stdout
);
16354 case AFL_EXT_LOONGSON_2F
:
16355 fputs ("ST Microelectronics Loongson 2F", stdout
);
16357 case AFL_EXT_INTERAPTIV_MR2
:
16358 fputs ("Imagination interAptiv MR2", stdout
);
16361 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16366 get_mips_reg_size (int reg_size
)
16368 return (reg_size
== AFL_REG_NONE
) ? 0
16369 : (reg_size
== AFL_REG_32
) ? 32
16370 : (reg_size
== AFL_REG_64
) ? 64
16371 : (reg_size
== AFL_REG_128
) ? 128
16376 process_mips_specific (Filedata
* filedata
)
16378 Elf_Internal_Dyn
* entry
;
16379 Elf_Internal_Shdr
*sect
= NULL
;
16380 size_t liblist_offset
= 0;
16381 size_t liblistno
= 0;
16382 size_t conflictsno
= 0;
16383 size_t options_offset
= 0;
16384 size_t conflicts_offset
= 0;
16385 size_t pltrelsz
= 0;
16387 bfd_vma pltgot
= 0;
16388 bfd_vma mips_pltgot
= 0;
16389 bfd_vma jmprel
= 0;
16390 bfd_vma local_gotno
= 0;
16391 bfd_vma gotsym
= 0;
16392 bfd_vma symtabno
= 0;
16393 bfd_boolean res
= TRUE
;
16395 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16396 display_mips_gnu_attribute
))
16399 sect
= find_section (filedata
, ".MIPS.abiflags");
16403 Elf_External_ABIFlags_v0
*abiflags_ext
;
16404 Elf_Internal_ABIFlags_v0 abiflags_in
;
16406 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16408 error (_("Corrupt MIPS ABI Flags section.\n"));
16413 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16414 sect
->sh_size
, _("MIPS ABI Flags section"));
16417 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16418 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16419 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16420 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16421 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16422 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16423 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16424 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16425 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16426 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16427 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16429 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16430 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16431 if (abiflags_in
.isa_rev
> 1)
16432 printf ("r%d", abiflags_in
.isa_rev
);
16433 printf ("\nGPR size: %d",
16434 get_mips_reg_size (abiflags_in
.gpr_size
));
16435 printf ("\nCPR1 size: %d",
16436 get_mips_reg_size (abiflags_in
.cpr1_size
));
16437 printf ("\nCPR2 size: %d",
16438 get_mips_reg_size (abiflags_in
.cpr2_size
));
16439 fputs ("\nFP ABI: ", stdout
);
16440 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16441 fputs ("ISA Extension: ", stdout
);
16442 print_mips_isa_ext (abiflags_in
.isa_ext
);
16443 fputs ("\nASEs:", stdout
);
16444 print_mips_ases (abiflags_in
.ases
);
16445 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16446 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16447 fputc ('\n', stdout
);
16448 free (abiflags_ext
);
16453 /* We have a lot of special sections. Thanks SGI! */
16454 if (dynamic_section
== NULL
)
16456 /* No dynamic information available. See if there is static GOT. */
16457 sect
= find_section (filedata
, ".got");
16460 unsigned char *data_end
;
16461 unsigned char *data
;
16465 pltgot
= sect
->sh_addr
;
16468 addr_size
= (is_32bit_elf
? 4 : 8);
16469 end
= pltgot
+ sect
->sh_size
;
16471 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16473 _("Global Offset Table data"));
16474 /* PR 12855: Null data is handled gracefully throughout. */
16475 data_end
= data
+ (end
- pltgot
);
16477 printf (_("\nStatic GOT:\n"));
16478 printf (_(" Canonical gp value: "));
16479 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16482 /* In a dynamic binary GOT[0] is reserved for the dynamic
16483 loader to store the lazy resolver pointer, however in
16484 a static binary it may well have been omitted and GOT
16485 reduced to a table of addresses.
16486 PR 21344: Check for the entry being fully available
16487 before fetching it. */
16489 && data
+ ent
- pltgot
+ addr_size
<= data_end
16490 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16492 printf (_(" Reserved entries:\n"));
16493 printf (_(" %*s %10s %*s\n"),
16494 addr_size
* 2, _("Address"), _("Access"),
16495 addr_size
* 2, _("Value"));
16496 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16498 if (ent
== (bfd_vma
) -1)
16499 goto sgot_print_fail
;
16501 /* Check for the MSB of GOT[1] being set, identifying a
16502 GNU object. This entry will be used by some runtime
16503 loaders, to store the module pointer. Otherwise this
16504 is an ordinary local entry.
16505 PR 21344: Check for the entry being fully available
16506 before fetching it. */
16508 && data
+ ent
- pltgot
+ addr_size
<= data_end
16509 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16510 >> (addr_size
* 8 - 1)) != 0)
16512 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16514 if (ent
== (bfd_vma
) -1)
16515 goto sgot_print_fail
;
16520 if (data
!= NULL
&& ent
< end
)
16522 printf (_(" Local entries:\n"));
16523 printf (" %*s %10s %*s\n",
16524 addr_size
* 2, _("Address"), _("Access"),
16525 addr_size
* 2, _("Value"));
16528 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16530 if (ent
== (bfd_vma
) -1)
16531 goto sgot_print_fail
;
16543 for (entry
= dynamic_section
;
16544 /* PR 17531 file: 012-50589-0.004. */
16545 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16547 switch (entry
->d_tag
)
16549 case DT_MIPS_LIBLIST
:
16551 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16552 liblistno
* sizeof (Elf32_External_Lib
));
16554 case DT_MIPS_LIBLISTNO
:
16555 liblistno
= entry
->d_un
.d_val
;
16557 case DT_MIPS_OPTIONS
:
16558 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16560 case DT_MIPS_CONFLICT
:
16562 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16563 conflictsno
* sizeof (Elf32_External_Conflict
));
16565 case DT_MIPS_CONFLICTNO
:
16566 conflictsno
= entry
->d_un
.d_val
;
16569 pltgot
= entry
->d_un
.d_ptr
;
16571 case DT_MIPS_LOCAL_GOTNO
:
16572 local_gotno
= entry
->d_un
.d_val
;
16574 case DT_MIPS_GOTSYM
:
16575 gotsym
= entry
->d_un
.d_val
;
16577 case DT_MIPS_SYMTABNO
:
16578 symtabno
= entry
->d_un
.d_val
;
16580 case DT_MIPS_PLTGOT
:
16581 mips_pltgot
= entry
->d_un
.d_ptr
;
16584 pltrel
= entry
->d_un
.d_val
;
16587 pltrelsz
= entry
->d_un
.d_val
;
16590 jmprel
= entry
->d_un
.d_ptr
;
16596 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16598 Elf32_External_Lib
* elib
;
16601 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16603 sizeof (Elf32_External_Lib
),
16604 _("liblist section data"));
16607 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16608 "\nSection '.liblist' contains %lu entries:\n",
16609 (unsigned long) liblistno
),
16610 (unsigned long) liblistno
);
16611 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16614 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16621 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16622 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16623 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16624 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16625 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16627 tmp
= gmtime (&atime
);
16628 snprintf (timebuf
, sizeof (timebuf
),
16629 "%04u-%02u-%02uT%02u:%02u:%02u",
16630 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16631 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16633 printf ("%3lu: ", (unsigned long) cnt
);
16634 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16635 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16637 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16638 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16639 liblist
.l_version
);
16641 if (liblist
.l_flags
== 0)
16645 static const struct
16652 { " EXACT_MATCH", LL_EXACT_MATCH
},
16653 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16654 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16655 { " EXPORTS", LL_EXPORTS
},
16656 { " DELAY_LOAD", LL_DELAY_LOAD
},
16657 { " DELTA", LL_DELTA
}
16659 int flags
= liblist
.l_flags
;
16662 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16663 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16665 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16666 flags
^= l_flags_vals
[fcnt
].bit
;
16669 printf (" %#x", (unsigned int) flags
);
16681 if (options_offset
!= 0)
16683 Elf_External_Options
* eopt
;
16686 sect
= filedata
->section_headers
;
16688 /* Find the section header so that we get the size. */
16689 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16690 /* PR 17533 file: 012-277276-0.004. */
16693 error (_("No MIPS_OPTIONS header found\n"));
16697 if (sect
->sh_size
< sizeof (* eopt
))
16699 error (_("The MIPS options section is too small.\n"));
16703 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16704 sect
->sh_size
, _("options"));
16707 Elf_Internal_Options
* iopt
;
16708 Elf_Internal_Options
* option
;
16709 Elf_Internal_Options
* iopt_end
;
16711 iopt
= (Elf_Internal_Options
*)
16712 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16715 error (_("Out of memory allocating space for MIPS options\n"));
16721 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16723 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16725 Elf_External_Options
* eoption
;
16727 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16729 option
->kind
= BYTE_GET (eoption
->kind
);
16730 option
->size
= BYTE_GET (eoption
->size
);
16731 option
->section
= BYTE_GET (eoption
->section
);
16732 option
->info
= BYTE_GET (eoption
->info
);
16734 /* PR 17531: file: ffa0fa3b. */
16735 if (option
->size
< sizeof (* eopt
)
16736 || offset
+ option
->size
> sect
->sh_size
)
16738 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16741 offset
+= option
->size
;
16747 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16748 "\nSection '%s' contains %d entries:\n",
16750 printable_section_name (filedata
, sect
), cnt
);
16759 switch (option
->kind
)
16762 /* This shouldn't happen. */
16763 printf (" NULL %d %lx", option
->section
, option
->info
);
16767 printf (" REGINFO ");
16768 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16770 Elf32_External_RegInfo
* ereg
;
16771 Elf32_RegInfo reginfo
;
16774 if (option
+ 2 > iopt_end
)
16776 printf (_("<corrupt>\n"));
16777 error (_("Truncated MIPS REGINFO option\n"));
16782 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16784 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16785 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16786 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16787 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16788 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16789 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16791 printf ("GPR %08lx GP 0x%lx\n",
16792 reginfo
.ri_gprmask
,
16793 (unsigned long) reginfo
.ri_gp_value
);
16794 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16795 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16796 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16801 Elf64_External_RegInfo
* ereg
;
16802 Elf64_Internal_RegInfo reginfo
;
16804 if (option
+ 2 > iopt_end
)
16806 printf (_("<corrupt>\n"));
16807 error (_("Truncated MIPS REGINFO option\n"));
16812 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16813 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16814 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16815 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16816 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16817 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16818 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16820 printf ("GPR %08lx GP 0x",
16821 reginfo
.ri_gprmask
);
16822 printf_vma (reginfo
.ri_gp_value
);
16825 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16826 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16827 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16832 case ODK_EXCEPTIONS
:
16833 fputs (" EXCEPTIONS fpe_min(", stdout
);
16834 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16835 fputs (") fpe_max(", stdout
);
16836 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16837 fputs (")", stdout
);
16839 if (option
->info
& OEX_PAGE0
)
16840 fputs (" PAGE0", stdout
);
16841 if (option
->info
& OEX_SMM
)
16842 fputs (" SMM", stdout
);
16843 if (option
->info
& OEX_FPDBUG
)
16844 fputs (" FPDBUG", stdout
);
16845 if (option
->info
& OEX_DISMISS
)
16846 fputs (" DISMISS", stdout
);
16850 fputs (" PAD ", stdout
);
16851 if (option
->info
& OPAD_PREFIX
)
16852 fputs (" PREFIX", stdout
);
16853 if (option
->info
& OPAD_POSTFIX
)
16854 fputs (" POSTFIX", stdout
);
16855 if (option
->info
& OPAD_SYMBOL
)
16856 fputs (" SYMBOL", stdout
);
16860 fputs (" HWPATCH ", stdout
);
16861 if (option
->info
& OHW_R4KEOP
)
16862 fputs (" R4KEOP", stdout
);
16863 if (option
->info
& OHW_R8KPFETCH
)
16864 fputs (" R8KPFETCH", stdout
);
16865 if (option
->info
& OHW_R5KEOP
)
16866 fputs (" R5KEOP", stdout
);
16867 if (option
->info
& OHW_R5KCVTL
)
16868 fputs (" R5KCVTL", stdout
);
16872 fputs (" FILL ", stdout
);
16873 /* XXX Print content of info word? */
16877 fputs (" TAGS ", stdout
);
16878 /* XXX Print content of info word? */
16882 fputs (" HWAND ", stdout
);
16883 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16884 fputs (" R4KEOP_CHECKED", stdout
);
16885 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16886 fputs (" R4KEOP_CLEAN", stdout
);
16890 fputs (" HWOR ", stdout
);
16891 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16892 fputs (" R4KEOP_CHECKED", stdout
);
16893 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16894 fputs (" R4KEOP_CLEAN", stdout
);
16898 printf (" GP_GROUP %#06lx self-contained %#06lx",
16899 option
->info
& OGP_GROUP
,
16900 (option
->info
& OGP_SELF
) >> 16);
16904 printf (" IDENT %#06lx self-contained %#06lx",
16905 option
->info
& OGP_GROUP
,
16906 (option
->info
& OGP_SELF
) >> 16);
16910 /* This shouldn't happen. */
16911 printf (" %3d ??? %d %lx",
16912 option
->kind
, option
->section
, option
->info
);
16916 len
= sizeof (* eopt
);
16917 while (len
< option
->size
)
16919 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16921 if (ISPRINT (datum
))
16922 printf ("%c", datum
);
16924 printf ("\\%03o", datum
);
16927 fputs ("\n", stdout
);
16929 offset
+= option
->size
;
16939 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16941 Elf32_Conflict
* iconf
;
16944 if (dynamic_symbols
== NULL
)
16946 error (_("conflict list found without a dynamic symbol table\n"));
16950 /* PR 21345 - print a slightly more helpful error message
16951 if we are sure that the cmalloc will fail. */
16952 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16954 error (_("Overlarge number of conflicts detected: %lx\n"),
16955 (long) conflictsno
);
16959 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16962 error (_("Out of memory allocating space for dynamic conflicts\n"));
16968 Elf32_External_Conflict
* econf32
;
16970 econf32
= (Elf32_External_Conflict
*)
16971 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16972 sizeof (* econf32
), _("conflict"));
16976 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16977 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16983 Elf64_External_Conflict
* econf64
;
16985 econf64
= (Elf64_External_Conflict
*)
16986 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16987 sizeof (* econf64
), _("conflict"));
16991 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16992 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16997 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16998 "\nSection '.conflict' contains %lu entries:\n",
16999 (unsigned long) conflictsno
),
17000 (unsigned long) conflictsno
);
17001 puts (_(" Num: Index Value Name"));
17003 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17005 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17007 if (iconf
[cnt
] >= num_dynamic_syms
)
17008 printf (_("<corrupt symbol index>"));
17011 Elf_Internal_Sym
* psym
;
17013 psym
= & dynamic_symbols
[iconf
[cnt
]];
17014 print_vma (psym
->st_value
, FULL_HEX
);
17016 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17017 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
17019 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17027 if (pltgot
!= 0 && local_gotno
!= 0)
17029 bfd_vma ent
, local_end
, global_end
;
17031 unsigned char * data
;
17032 unsigned char * data_end
;
17036 addr_size
= (is_32bit_elf
? 4 : 8);
17037 local_end
= pltgot
+ local_gotno
* addr_size
;
17039 /* PR binutils/17533 file: 012-111227-0.004 */
17040 if (symtabno
< gotsym
)
17042 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17043 (unsigned long) gotsym
, (unsigned long) symtabno
);
17047 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17048 /* PR 17531: file: 54c91a34. */
17049 if (global_end
< local_end
)
17051 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17055 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17056 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17057 global_end
- pltgot
, 1,
17058 _("Global Offset Table data"));
17059 /* PR 12855: Null data is handled gracefully throughout. */
17060 data_end
= data
+ (global_end
- pltgot
);
17062 printf (_("\nPrimary GOT:\n"));
17063 printf (_(" Canonical gp value: "));
17064 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17067 printf (_(" Reserved entries:\n"));
17068 printf (_(" %*s %10s %*s Purpose\n"),
17069 addr_size
* 2, _("Address"), _("Access"),
17070 addr_size
* 2, _("Initial"));
17071 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17072 printf (_(" Lazy resolver\n"));
17073 if (ent
== (bfd_vma
) -1)
17074 goto got_print_fail
;
17076 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17077 This entry will be used by some runtime loaders, to store the
17078 module pointer. Otherwise this is an ordinary local entry.
17079 PR 21344: Check for the entry being fully available before
17082 && data
+ ent
- pltgot
+ addr_size
<= data_end
17083 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17084 >> (addr_size
* 8 - 1)) != 0)
17086 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17087 printf (_(" Module pointer (GNU extension)\n"));
17088 if (ent
== (bfd_vma
) -1)
17089 goto got_print_fail
;
17093 if (data
!= NULL
&& ent
< local_end
)
17095 printf (_(" Local entries:\n"));
17096 printf (" %*s %10s %*s\n",
17097 addr_size
* 2, _("Address"), _("Access"),
17098 addr_size
* 2, _("Initial"));
17099 while (ent
< local_end
)
17101 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17103 if (ent
== (bfd_vma
) -1)
17104 goto got_print_fail
;
17109 if (data
!= NULL
&& gotsym
< symtabno
)
17113 printf (_(" Global entries:\n"));
17114 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17115 addr_size
* 2, _("Address"),
17117 addr_size
* 2, _("Initial"),
17118 addr_size
* 2, _("Sym.Val."),
17120 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17121 _("Ndx"), _("Name"));
17123 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17125 for (i
= gotsym
; i
< symtabno
; i
++)
17127 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17130 if (dynamic_symbols
== NULL
)
17131 printf (_("<no dynamic symbols>"));
17132 else if (i
< num_dynamic_syms
)
17134 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17136 print_vma (psym
->st_value
, LONG_HEX
);
17137 printf (" %-7s %3s ",
17138 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17139 get_symbol_index_type (filedata
, psym
->st_shndx
));
17141 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17142 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17144 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17147 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17148 (unsigned long) i
);
17151 if (ent
== (bfd_vma
) -1)
17162 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17165 size_t offset
, rel_offset
;
17166 unsigned long count
, i
;
17167 unsigned char * data
;
17168 int addr_size
, sym_width
;
17169 Elf_Internal_Rela
* rels
;
17171 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17172 if (pltrel
== DT_RELA
)
17174 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17179 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17184 addr_size
= (is_32bit_elf
? 4 : 8);
17185 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17187 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17188 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17189 1, _("Procedure Linkage Table data"));
17193 printf ("\nPLT GOT:\n\n");
17194 printf (_(" Reserved entries:\n"));
17195 printf (_(" %*s %*s Purpose\n"),
17196 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17197 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17198 printf (_(" PLT lazy resolver\n"));
17199 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17200 printf (_(" Module pointer\n"));
17203 printf (_(" Entries:\n"));
17204 printf (" %*s %*s %*s %-7s %3s %s\n",
17205 addr_size
* 2, _("Address"),
17206 addr_size
* 2, _("Initial"),
17207 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17208 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17209 for (i
= 0; i
< count
; i
++)
17211 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17213 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17216 if (idx
>= num_dynamic_syms
)
17217 printf (_("<corrupt symbol index: %lu>"), idx
);
17220 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17222 print_vma (psym
->st_value
, LONG_HEX
);
17223 printf (" %-7s %3s ",
17224 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17225 get_symbol_index_type (filedata
, psym
->st_shndx
));
17226 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17227 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17229 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17244 process_nds32_specific (Filedata
* filedata
)
17246 Elf_Internal_Shdr
*sect
= NULL
;
17248 sect
= find_section (filedata
, ".nds32_e_flags");
17251 unsigned int *flag
;
17253 printf ("\nNDS32 elf flags section:\n");
17254 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17255 sect
->sh_size
, _("NDS32 elf flags section"));
17260 switch ((*flag
) & 0x3)
17263 printf ("(VEC_SIZE):\tNo entry.\n");
17266 printf ("(VEC_SIZE):\t4 bytes\n");
17269 printf ("(VEC_SIZE):\t16 bytes\n");
17272 printf ("(VEC_SIZE):\treserved\n");
17281 process_gnu_liblist (Filedata
* filedata
)
17283 Elf_Internal_Shdr
* section
;
17284 Elf_Internal_Shdr
* string_sec
;
17285 Elf32_External_Lib
* elib
;
17287 size_t strtab_size
;
17289 unsigned long num_liblist
;
17291 bfd_boolean res
= TRUE
;
17296 for (i
= 0, section
= filedata
->section_headers
;
17297 i
< filedata
->file_header
.e_shnum
;
17300 switch (section
->sh_type
)
17302 case SHT_GNU_LIBLIST
:
17303 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17306 elib
= (Elf32_External_Lib
*)
17307 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17308 _("liblist section data"));
17316 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17317 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17318 string_sec
->sh_size
,
17319 _("liblist string table"));
17321 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17328 strtab_size
= string_sec
->sh_size
;
17330 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17331 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17332 "\nLibrary list section '%s' contains %lu entries:\n",
17334 printable_section_name (filedata
, section
),
17337 puts (_(" Library Time Stamp Checksum Version Flags"));
17339 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17347 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17348 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17349 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17350 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17351 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17353 tmp
= gmtime (&atime
);
17354 snprintf (timebuf
, sizeof (timebuf
),
17355 "%04u-%02u-%02uT%02u:%02u:%02u",
17356 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17357 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17359 printf ("%3lu: ", (unsigned long) cnt
);
17361 printf ("%-20s", liblist
.l_name
< strtab_size
17362 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17364 printf ("%-20.20s", liblist
.l_name
< strtab_size
17365 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17366 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17367 liblist
.l_version
, liblist
.l_flags
);
17378 static const char *
17379 get_note_type (Filedata
* filedata
, unsigned e_type
)
17381 static char buff
[64];
17383 if (filedata
->file_header
.e_type
== ET_CORE
)
17387 return _("NT_AUXV (auxiliary vector)");
17389 return _("NT_PRSTATUS (prstatus structure)");
17391 return _("NT_FPREGSET (floating point registers)");
17393 return _("NT_PRPSINFO (prpsinfo structure)");
17394 case NT_TASKSTRUCT
:
17395 return _("NT_TASKSTRUCT (task structure)");
17397 return _("NT_PRXFPREG (user_xfpregs structure)");
17399 return _("NT_PPC_VMX (ppc Altivec registers)");
17401 return _("NT_PPC_VSX (ppc VSX registers)");
17403 return _("NT_PPC_TAR (ppc TAR register)");
17405 return _("NT_PPC_PPR (ppc PPR register)");
17407 return _("NT_PPC_DSCR (ppc DSCR register)");
17409 return _("NT_PPC_EBB (ppc EBB registers)");
17411 return _("NT_PPC_PMU (ppc PMU registers)");
17412 case NT_PPC_TM_CGPR
:
17413 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17414 case NT_PPC_TM_CFPR
:
17415 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17416 case NT_PPC_TM_CVMX
:
17417 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17418 case NT_PPC_TM_CVSX
:
17419 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17420 case NT_PPC_TM_SPR
:
17421 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17422 case NT_PPC_TM_CTAR
:
17423 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17424 case NT_PPC_TM_CPPR
:
17425 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17426 case NT_PPC_TM_CDSCR
:
17427 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17429 return _("NT_386_TLS (x86 TLS information)");
17430 case NT_386_IOPERM
:
17431 return _("NT_386_IOPERM (x86 I/O permissions)");
17432 case NT_X86_XSTATE
:
17433 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17434 case NT_S390_HIGH_GPRS
:
17435 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17436 case NT_S390_TIMER
:
17437 return _("NT_S390_TIMER (s390 timer register)");
17438 case NT_S390_TODCMP
:
17439 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17440 case NT_S390_TODPREG
:
17441 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17443 return _("NT_S390_CTRS (s390 control registers)");
17444 case NT_S390_PREFIX
:
17445 return _("NT_S390_PREFIX (s390 prefix register)");
17446 case NT_S390_LAST_BREAK
:
17447 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17448 case NT_S390_SYSTEM_CALL
:
17449 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17451 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17452 case NT_S390_VXRS_LOW
:
17453 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17454 case NT_S390_VXRS_HIGH
:
17455 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17456 case NT_S390_GS_CB
:
17457 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17458 case NT_S390_GS_BC
:
17459 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17461 return _("NT_ARM_VFP (arm VFP registers)");
17463 return _("NT_ARM_TLS (AArch TLS registers)");
17464 case NT_ARM_HW_BREAK
:
17465 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17466 case NT_ARM_HW_WATCH
:
17467 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17469 return _("NT_PSTATUS (pstatus structure)");
17471 return _("NT_FPREGS (floating point registers)");
17473 return _("NT_PSINFO (psinfo structure)");
17475 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17477 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17478 case NT_WIN32PSTATUS
:
17479 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17481 return _("NT_SIGINFO (siginfo_t data)");
17483 return _("NT_FILE (mapped files)");
17491 return _("NT_VERSION (version)");
17493 return _("NT_ARCH (architecture)");
17494 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17496 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17502 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17507 print_core_note (Elf_Internal_Note
*pnote
)
17509 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17510 bfd_vma count
, page_size
;
17511 unsigned char *descdata
, *filenames
, *descend
;
17513 if (pnote
->type
!= NT_FILE
)
17523 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17524 /* Still "successful". */
17529 if (pnote
->descsz
< 2 * addr_size
)
17531 error (_(" Malformed note - too short for header\n"));
17535 descdata
= (unsigned char *) pnote
->descdata
;
17536 descend
= descdata
+ pnote
->descsz
;
17538 if (descdata
[pnote
->descsz
- 1] != '\0')
17540 error (_(" Malformed note - does not end with \\0\n"));
17544 count
= byte_get (descdata
, addr_size
);
17545 descdata
+= addr_size
;
17547 page_size
= byte_get (descdata
, addr_size
);
17548 descdata
+= addr_size
;
17550 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17551 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17553 error (_(" Malformed note - too short for supplied file count\n"));
17557 printf (_(" Page size: "));
17558 print_vma (page_size
, DEC
);
17561 printf (_(" %*s%*s%*s\n"),
17562 (int) (2 + 2 * addr_size
), _("Start"),
17563 (int) (4 + 2 * addr_size
), _("End"),
17564 (int) (4 + 2 * addr_size
), _("Page Offset"));
17565 filenames
= descdata
+ count
* 3 * addr_size
;
17566 while (count
-- > 0)
17568 bfd_vma start
, end
, file_ofs
;
17570 if (filenames
== descend
)
17572 error (_(" Malformed note - filenames end too early\n"));
17576 start
= byte_get (descdata
, addr_size
);
17577 descdata
+= addr_size
;
17578 end
= byte_get (descdata
, addr_size
);
17579 descdata
+= addr_size
;
17580 file_ofs
= byte_get (descdata
, addr_size
);
17581 descdata
+= addr_size
;
17584 print_vma (start
, FULL_HEX
);
17586 print_vma (end
, FULL_HEX
);
17588 print_vma (file_ofs
, FULL_HEX
);
17589 printf ("\n %s\n", filenames
);
17591 filenames
+= 1 + strlen ((char *) filenames
);
17597 static const char *
17598 get_gnu_elf_note_type (unsigned e_type
)
17600 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17603 case NT_GNU_ABI_TAG
:
17604 return _("NT_GNU_ABI_TAG (ABI version tag)");
17606 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17607 case NT_GNU_BUILD_ID
:
17608 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17609 case NT_GNU_GOLD_VERSION
:
17610 return _("NT_GNU_GOLD_VERSION (gold version)");
17611 case NT_GNU_PROPERTY_TYPE_0
:
17612 return _("NT_GNU_PROPERTY_TYPE_0");
17613 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17614 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17615 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17616 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17619 static char buff
[64];
17621 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17628 decode_x86_compat_isa (unsigned int bitmask
)
17632 unsigned int bit
= bitmask
& (- bitmask
);
17637 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17640 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17643 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17646 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17649 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17652 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17655 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17658 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17661 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17664 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17667 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17670 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17671 printf ("AVX512F");
17673 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17674 printf ("AVX512CD");
17676 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17677 printf ("AVX512ER");
17679 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17680 printf ("AVX512PF");
17682 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17683 printf ("AVX512VL");
17685 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17686 printf ("AVX512DQ");
17688 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17689 printf ("AVX512BW");
17692 printf (_("<unknown: %x>"), bit
);
17701 decode_x86_isa (unsigned int bitmask
)
17705 printf (_("<None>"));
17711 unsigned int bit
= bitmask
& (- bitmask
);
17716 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17719 case GNU_PROPERTY_X86_ISA_1_SSE
:
17722 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17725 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17728 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17731 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17734 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17737 case GNU_PROPERTY_X86_ISA_1_AVX
:
17740 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17743 case GNU_PROPERTY_X86_ISA_1_FMA
:
17746 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17747 printf ("AVX512F");
17749 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17750 printf ("AVX512CD");
17752 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17753 printf ("AVX512ER");
17755 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17756 printf ("AVX512PF");
17758 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17759 printf ("AVX512VL");
17761 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17762 printf ("AVX512DQ");
17764 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17765 printf ("AVX512BW");
17767 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17768 printf ("AVX512_4FMAPS");
17770 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17771 printf ("AVX512_4VNNIW");
17773 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17774 printf ("AVX512_BITALG");
17776 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17777 printf ("AVX512_IFMA");
17779 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17780 printf ("AVX512_VBMI");
17782 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17783 printf ("AVX512_VBMI2");
17785 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17786 printf ("AVX512_VNNI");
17788 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17789 printf ("AVX512_BF16");
17792 printf (_("<unknown: %x>"), bit
);
17800 static const char *
17801 get_amd_elf_note_type (unsigned e_type
)
17803 static char buff
[64];
17807 case NT_AMDGPU_HSA_CODE_OBJECT_VERSION
:
17808 return _("NT_AMDGPU_HSA_CODE_OBJECT_VERSION (code object version)");
17809 case NT_AMDGPU_HSA_HSAIL
:
17810 return _("NT_AMDGPU_HSA_HSAIL (hsail)");
17811 case NT_AMDGPU_HSA_ISA
:
17812 return _("NT_AMDGPU_HSA_ISA (ISA name)");
17813 case NT_AMDGPU_HSA_PRODUCER
:
17814 return _("NT_AMDGPU_HSA_PRODUCER (producer name)");
17815 case NT_AMDGPU_HSA_PRODUCER_OPTIONS
:
17816 return _("NT_AMDGPU_HSA_PRODUCER_OPTIONS (producer options");
17817 case NT_AMDGPU_HSA_EXTENSION
:
17818 return _("NT_AMDGPU_HSA_EXTENSION (extension)");
17819 case NT_AMDGPU_HSA_METADATA
:
17820 return _("NT_AMDGPU_HSA_METADATA (code object metadata)");
17821 case NT_AMDGPU_ISA
:
17822 return _("NT_AMDGPU_ISA");
17823 case NT_AMDGPU_PAL_METADATA
:
17824 return _("NT_AMDGPU_PAL_METADATA (code object metadata)");
17825 case NT_AMDGPU_METADATA
:
17826 return _("NT_AMDGPU_METADATA (code object metadata)");
17831 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17836 print_amd_note (Elf_Internal_Note
*pnote
)
17838 switch (pnote
->type
)
17840 case NT_AMDGPU_HSA_CODE_OBJECT_VERSION
:
17842 unsigned int major
, minor
;
17844 major
= byte_get ((unsigned char*) pnote
->descdata
, 4);
17845 minor
= byte_get ((unsigned char*) pnote
->descdata
+ 4, 4);
17847 printf (_(" Version: %d.%d\n"), major
, minor
);
17851 case NT_AMDGPU_HSA_ISA
:
17853 unsigned long i
, vendorsz
;
17854 unsigned int major
, minor
, stepping
;
17856 vendorsz
= byte_get ((unsigned char*) pnote
->descdata
, 2);
17857 major
= byte_get ((unsigned char*) pnote
->descdata
+ 4, 4);
17858 minor
= byte_get ((unsigned char*) pnote
->descdata
+ 8, 4);
17859 stepping
= byte_get ((unsigned char*) pnote
->descdata
+ 12, 4);
17861 printf (_(" Vendor: "));
17862 for (i
= 16; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17863 printf ("%c", pnote
->descdata
[i
]);
17864 printf (_(", Architecture: "));
17865 for (i
= 16 + vendorsz
; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17866 printf ("%c", pnote
->descdata
[i
]);
17868 printf (_(", Version: %d.%d.%d"), major
, minor
, stepping
);
17877 decode_x86_feature_1 (unsigned int bitmask
)
17881 printf (_("<None>"));
17887 unsigned int bit
= bitmask
& (- bitmask
);
17892 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17895 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17899 printf (_("<unknown: %x>"), bit
);
17908 decode_x86_feature_2 (unsigned int bitmask
)
17912 printf (_("<None>"));
17918 unsigned int bit
= bitmask
& (- bitmask
);
17923 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17926 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17929 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17932 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17935 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17938 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17941 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17944 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17947 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17948 printf ("XSAVEOPT");
17950 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17954 printf (_("<unknown: %x>"), bit
);
17963 decode_aarch64_feature_1_and (unsigned int bitmask
)
17967 unsigned int bit
= bitmask
& (- bitmask
);
17972 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17976 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17981 printf (_("<unknown: %x>"), bit
);
17990 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17992 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17993 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17994 unsigned int size
= is_32bit_elf
? 4 : 8;
17996 printf (_(" Properties: "));
17998 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18000 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18004 while (ptr
< ptr_end
)
18008 unsigned int datasz
;
18010 if ((size_t) (ptr_end
- ptr
) < 8)
18012 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18016 type
= byte_get (ptr
, 4);
18017 datasz
= byte_get (ptr
+ 4, 4);
18021 if (datasz
> (size_t) (ptr_end
- ptr
))
18023 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18028 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18030 if (filedata
->file_header
.e_machine
== EM_X86_64
18031 || filedata
->file_header
.e_machine
== EM_IAMCU
18032 || filedata
->file_header
.e_machine
== EM_386
)
18034 unsigned int bitmask
;
18037 bitmask
= byte_get (ptr
, 4);
18043 case GNU_PROPERTY_X86_ISA_1_USED
:
18045 printf (_("x86 ISA used: <corrupt length: %#x> "),
18049 printf ("x86 ISA used: ");
18050 decode_x86_isa (bitmask
);
18054 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18056 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18060 printf ("x86 ISA needed: ");
18061 decode_x86_isa (bitmask
);
18065 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18067 printf (_("x86 feature: <corrupt length: %#x> "),
18071 printf ("x86 feature: ");
18072 decode_x86_feature_1 (bitmask
);
18076 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18078 printf (_("x86 feature used: <corrupt length: %#x> "),
18082 printf ("x86 feature used: ");
18083 decode_x86_feature_2 (bitmask
);
18087 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18089 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18092 printf ("x86 feature needed: ");
18093 decode_x86_feature_2 (bitmask
);
18097 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18099 printf (_("x86 ISA used: <corrupt length: %#x> "),
18103 printf ("x86 ISA used: ");
18104 decode_x86_compat_isa (bitmask
);
18108 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18110 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18114 printf ("x86 ISA needed: ");
18115 decode_x86_compat_isa (bitmask
);
18123 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18125 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18127 printf ("AArch64 feature: ");
18129 printf (_("<corrupt length: %#x> "), datasz
);
18131 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18140 case GNU_PROPERTY_STACK_SIZE
:
18141 printf (_("stack size: "));
18142 if (datasz
!= size
)
18143 printf (_("<corrupt length: %#x> "), datasz
);
18145 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18148 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18149 printf ("no copy on protected ");
18151 printf (_("<corrupt length: %#x> "), datasz
);
18159 if (type
< GNU_PROPERTY_LOPROC
)
18160 printf (_("<unknown type %#x data: "), type
);
18161 else if (type
< GNU_PROPERTY_LOUSER
)
18162 printf (_("<procesor-specific type %#x data: "), type
);
18164 printf (_("<application-specific type %#x data: "), type
);
18165 for (j
= 0; j
< datasz
; ++j
)
18166 printf ("%02x ", ptr
[j
] & 0xff);
18170 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18171 if (ptr
== ptr_end
)
18184 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18186 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18187 switch (pnote
->type
)
18189 case NT_GNU_BUILD_ID
:
18193 printf (_(" Build ID: "));
18194 for (i
= 0; i
< pnote
->descsz
; ++i
)
18195 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18200 case NT_GNU_ABI_TAG
:
18202 unsigned long os
, major
, minor
, subminor
;
18203 const char *osname
;
18205 /* PR 17531: file: 030-599401-0.004. */
18206 if (pnote
->descsz
< 16)
18208 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18212 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18213 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18214 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18215 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18219 case GNU_ABI_TAG_LINUX
:
18222 case GNU_ABI_TAG_HURD
:
18225 case GNU_ABI_TAG_SOLARIS
:
18226 osname
= "Solaris";
18228 case GNU_ABI_TAG_FREEBSD
:
18229 osname
= "FreeBSD";
18231 case GNU_ABI_TAG_NETBSD
:
18234 case GNU_ABI_TAG_SYLLABLE
:
18235 osname
= "Syllable";
18237 case GNU_ABI_TAG_NACL
:
18241 osname
= "Unknown";
18245 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18246 major
, minor
, subminor
);
18250 case NT_GNU_GOLD_VERSION
:
18254 printf (_(" Version: "));
18255 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18256 printf ("%c", pnote
->descdata
[i
]);
18263 unsigned long num_entries
, mask
;
18265 /* Hardware capabilities information. Word 0 is the number of entries.
18266 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18267 is a series of entries, where each entry is a single byte followed
18268 by a nul terminated string. The byte gives the bit number to test
18269 if enabled in the bitmask. */
18270 printf (_(" Hardware Capabilities: "));
18271 if (pnote
->descsz
< 8)
18273 error (_("<corrupt GNU_HWCAP>\n"));
18276 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18277 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18278 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18279 /* FIXME: Add code to display the entries... */
18283 case NT_GNU_PROPERTY_TYPE_0
:
18284 print_gnu_property_note (filedata
, pnote
);
18288 /* Handle unrecognised types. An error message should have already been
18289 created by get_gnu_elf_note_type(), so all that we need to do is to
18290 display the data. */
18294 printf (_(" Description data: "));
18295 for (i
= 0; i
< pnote
->descsz
; ++i
)
18296 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18305 static const char *
18306 get_v850_elf_note_type (enum v850_notes n_type
)
18308 static char buff
[64];
18312 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18313 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18314 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18315 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18316 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18317 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18319 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18325 print_v850_note (Elf_Internal_Note
* pnote
)
18329 if (pnote
->descsz
!= 4)
18332 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18336 printf (_("not set\n"));
18340 switch (pnote
->type
)
18342 case V850_NOTE_ALIGNMENT
:
18345 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18346 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18350 case V850_NOTE_DATA_SIZE
:
18353 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18354 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18358 case V850_NOTE_FPU_INFO
:
18361 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18362 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18366 case V850_NOTE_MMU_INFO
:
18367 case V850_NOTE_CACHE_INFO
:
18368 case V850_NOTE_SIMD_INFO
:
18369 if (val
== EF_RH850_SIMD
)
18371 printf (_("yes\n"));
18377 /* An 'unknown note type' message will already have been displayed. */
18381 printf (_("unknown value: %x\n"), val
);
18386 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18388 unsigned int version
;
18390 switch (pnote
->type
)
18392 case NT_NETBSD_IDENT
:
18393 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18394 if ((version
/ 10000) % 100)
18395 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18396 version
, version
/ 100000000, (version
/ 1000000) % 100,
18397 (version
/ 10000) % 100 > 26 ? "Z" : "",
18398 'A' + (version
/ 10000) % 26);
18400 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18401 version
, version
/ 100000000, (version
/ 1000000) % 100,
18402 (version
/ 100) % 100);
18405 case NT_NETBSD_MARCH
:
18406 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18410 #ifdef NT_NETBSD_PAX
18411 case NT_NETBSD_PAX
:
18412 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18413 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18414 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18415 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18416 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18417 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18418 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18419 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18424 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
18430 static const char *
18431 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18435 case NT_FREEBSD_THRMISC
:
18436 return _("NT_THRMISC (thrmisc structure)");
18437 case NT_FREEBSD_PROCSTAT_PROC
:
18438 return _("NT_PROCSTAT_PROC (proc data)");
18439 case NT_FREEBSD_PROCSTAT_FILES
:
18440 return _("NT_PROCSTAT_FILES (files data)");
18441 case NT_FREEBSD_PROCSTAT_VMMAP
:
18442 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18443 case NT_FREEBSD_PROCSTAT_GROUPS
:
18444 return _("NT_PROCSTAT_GROUPS (groups data)");
18445 case NT_FREEBSD_PROCSTAT_UMASK
:
18446 return _("NT_PROCSTAT_UMASK (umask data)");
18447 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18448 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18449 case NT_FREEBSD_PROCSTAT_OSREL
:
18450 return _("NT_PROCSTAT_OSREL (osreldate data)");
18451 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18452 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18453 case NT_FREEBSD_PROCSTAT_AUXV
:
18454 return _("NT_PROCSTAT_AUXV (auxv data)");
18455 case NT_FREEBSD_PTLWPINFO
:
18456 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18458 return get_note_type (filedata
, e_type
);
18461 static const char *
18462 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18464 static char buff
[64];
18468 case NT_NETBSDCORE_PROCINFO
:
18469 /* NetBSD core "procinfo" structure. */
18470 return _("NetBSD procinfo structure");
18472 #ifdef NT_NETBSDCORE_AUXV
18473 case NT_NETBSDCORE_AUXV
:
18474 return _("NetBSD ELF auxiliary vector data");
18478 /* As of Jan 2002 there are no other machine-independent notes
18479 defined for NetBSD core files. If the note type is less
18480 than the start of the machine-dependent note types, we don't
18483 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18485 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18491 switch (filedata
->file_header
.e_machine
)
18493 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18494 and PT_GETFPREGS == mach+2. */
18499 case EM_SPARC32PLUS
:
18503 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18504 return _("PT_GETREGS (reg structure)");
18505 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18506 return _("PT_GETFPREGS (fpreg structure)");
18512 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18513 There's also old PT___GETREGS40 == mach + 1 for old reg
18514 structure which lacks GBR. */
18518 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18519 return _("PT___GETREGS40 (old reg structure)");
18520 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18521 return _("PT_GETREGS (reg structure)");
18522 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18523 return _("PT_GETFPREGS (fpreg structure)");
18529 /* On all other arch's, PT_GETREGS == mach+1 and
18530 PT_GETFPREGS == mach+3. */
18534 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18535 return _("PT_GETREGS (reg structure)");
18536 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18537 return _("PT_GETFPREGS (fpreg structure)");
18543 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18544 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18548 static const char *
18549 get_stapsdt_note_type (unsigned e_type
)
18551 static char buff
[64];
18556 return _("NT_STAPSDT (SystemTap probe descriptors)");
18562 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18567 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18569 size_t len
, maxlen
;
18570 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18571 char *data
= pnote
->descdata
;
18572 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18573 bfd_vma pc
, base_addr
, semaphore
;
18574 char *provider
, *probe
, *arg_fmt
;
18576 if (pnote
->descsz
< (addr_size
* 3))
18577 goto stapdt_note_too_small
;
18579 pc
= byte_get ((unsigned char *) data
, addr_size
);
18582 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18585 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18588 if (data
>= data_end
)
18589 goto stapdt_note_too_small
;
18590 maxlen
= data_end
- data
;
18591 len
= strnlen (data
, maxlen
);
18598 goto stapdt_note_too_small
;
18600 if (data
>= data_end
)
18601 goto stapdt_note_too_small
;
18602 maxlen
= data_end
- data
;
18603 len
= strnlen (data
, maxlen
);
18610 goto stapdt_note_too_small
;
18612 if (data
>= data_end
)
18613 goto stapdt_note_too_small
;
18614 maxlen
= data_end
- data
;
18615 len
= strnlen (data
, maxlen
);
18622 goto stapdt_note_too_small
;
18624 printf (_(" Provider: %s\n"), provider
);
18625 printf (_(" Name: %s\n"), probe
);
18626 printf (_(" Location: "));
18627 print_vma (pc
, FULL_HEX
);
18628 printf (_(", Base: "));
18629 print_vma (base_addr
, FULL_HEX
);
18630 printf (_(", Semaphore: "));
18631 print_vma (semaphore
, FULL_HEX
);
18633 printf (_(" Arguments: %s\n"), arg_fmt
);
18635 return data
== data_end
;
18637 stapdt_note_too_small
:
18638 printf (_(" <corrupt - note is too small>\n"));
18639 error (_("corrupt stapdt note - the data size is too small\n"));
18643 static const char *
18644 get_ia64_vms_note_type (unsigned e_type
)
18646 static char buff
[64];
18651 return _("NT_VMS_MHD (module header)");
18653 return _("NT_VMS_LNM (language name)");
18655 return _("NT_VMS_SRC (source files)");
18657 return "NT_VMS_TITLE";
18659 return _("NT_VMS_EIDC (consistency check)");
18660 case NT_VMS_FPMODE
:
18661 return _("NT_VMS_FPMODE (FP mode)");
18662 case NT_VMS_LINKTIME
:
18663 return "NT_VMS_LINKTIME";
18664 case NT_VMS_IMGNAM
:
18665 return _("NT_VMS_IMGNAM (image name)");
18667 return _("NT_VMS_IMGID (image id)");
18668 case NT_VMS_LINKID
:
18669 return _("NT_VMS_LINKID (link id)");
18670 case NT_VMS_IMGBID
:
18671 return _("NT_VMS_IMGBID (build id)");
18672 case NT_VMS_GSTNAM
:
18673 return _("NT_VMS_GSTNAM (sym table name)");
18674 case NT_VMS_ORIG_DYN
:
18675 return "NT_VMS_ORIG_DYN";
18676 case NT_VMS_PATCHTIME
:
18677 return "NT_VMS_PATCHTIME";
18679 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18685 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18687 int maxlen
= pnote
->descsz
;
18689 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18690 goto desc_size_fail
;
18692 switch (pnote
->type
)
18696 goto desc_size_fail
;
18698 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18700 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18701 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18702 if (l
+ 34 < maxlen
)
18704 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18705 if (l
+ 35 < maxlen
)
18706 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18708 printf (_(" Module version : <missing>\n"));
18712 printf (_(" Module name : <missing>\n"));
18713 printf (_(" Module version : <missing>\n"));
18718 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18722 case NT_VMS_FPMODE
:
18723 printf (_(" Floating Point mode: "));
18725 goto desc_size_fail
;
18726 /* FIXME: Generate an error if descsz > 8 ? */
18728 printf ("0x%016" BFD_VMA_FMT
"x\n",
18729 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18732 case NT_VMS_LINKTIME
:
18733 printf (_(" Link time: "));
18735 goto desc_size_fail
;
18736 /* FIXME: Generate an error if descsz > 8 ? */
18739 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18743 case NT_VMS_PATCHTIME
:
18744 printf (_(" Patch time: "));
18746 goto desc_size_fail
;
18747 /* FIXME: Generate an error if descsz > 8 ? */
18750 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18754 case NT_VMS_ORIG_DYN
:
18756 goto desc_size_fail
;
18758 printf (_(" Major id: %u, minor id: %u\n"),
18759 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18760 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18761 printf (_(" Last modified : "));
18763 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18764 printf (_("\n Link flags : "));
18765 printf ("0x%016" BFD_VMA_FMT
"x\n",
18766 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18767 printf (_(" Header flags: 0x%08x\n"),
18768 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18769 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18773 case NT_VMS_IMGNAM
:
18774 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18777 case NT_VMS_GSTNAM
:
18778 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18782 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18785 case NT_VMS_LINKID
:
18786 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18796 printf (_(" <corrupt - data size is too small>\n"));
18797 error (_("corrupt IA64 note: data size is too small\n"));
18801 /* Find the symbol associated with a build attribute that is attached
18802 to address OFFSET. If PNAME is non-NULL then store the name of
18803 the symbol (if found) in the provided pointer, Returns NULL if a
18804 symbol could not be found. */
18806 static Elf_Internal_Sym
*
18807 get_symbol_for_build_attribute (Filedata
* filedata
,
18808 unsigned long offset
,
18809 bfd_boolean is_open_attr
,
18810 const char ** pname
)
18812 static Filedata
* saved_filedata
= NULL
;
18813 static char * strtab
;
18814 static unsigned long strtablen
;
18815 static Elf_Internal_Sym
* symtab
;
18816 static unsigned long nsyms
;
18817 Elf_Internal_Sym
* saved_sym
= NULL
;
18818 Elf_Internal_Sym
* sym
;
18820 if (filedata
->section_headers
!= NULL
18821 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
18823 Elf_Internal_Shdr
* symsec
;
18825 /* Load the symbol and string sections. */
18826 for (symsec
= filedata
->section_headers
;
18827 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18830 if (symsec
->sh_type
== SHT_SYMTAB
)
18832 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
18834 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18836 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
18838 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18839 1, strtab_sec
->sh_size
,
18840 _("string table"));
18841 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
18845 saved_filedata
= filedata
;
18848 if (symtab
== NULL
|| strtab
== NULL
)
18851 /* Find a symbol whose value matches offset. */
18852 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
18853 if (sym
->st_value
== offset
)
18855 if (sym
->st_name
>= strtablen
)
18856 /* Huh ? This should not happen. */
18859 if (strtab
[sym
->st_name
] == 0)
18862 /* The AArch64 and ARM architectures define mapping symbols
18863 (eg $d, $x, $t) which we want to ignore. */
18864 if (strtab
[sym
->st_name
] == '$'
18865 && strtab
[sym
->st_name
+ 1] != 0
18866 && strtab
[sym
->st_name
+ 2] == 0)
18871 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18872 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18873 FUNC symbols entirely. */
18874 switch (ELF_ST_TYPE (sym
->st_info
))
18881 /* If the symbol has a size associated
18882 with it then we can stop searching. */
18883 sym
= symtab
+ nsyms
;
18888 /* Ignore function symbols. */
18895 switch (ELF_ST_BIND (sym
->st_info
))
18898 if (saved_sym
== NULL
18899 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18904 if (saved_sym
== NULL
)
18914 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18922 if (saved_sym
&& pname
)
18923 * pname
= strtab
+ saved_sym
->st_name
;
18928 /* Returns true iff addr1 and addr2 are in the same section. */
18931 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18933 Elf_Internal_Shdr
* a1
;
18934 Elf_Internal_Shdr
* a2
;
18936 a1
= find_section_by_address (filedata
, addr1
);
18937 a2
= find_section_by_address (filedata
, addr2
);
18939 return a1
== a2
&& a1
!= NULL
;
18943 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18944 Filedata
* filedata
)
18946 static unsigned long global_offset
= 0;
18947 static unsigned long global_end
= 0;
18948 static unsigned long func_offset
= 0;
18949 static unsigned long func_end
= 0;
18951 Elf_Internal_Sym
* sym
;
18953 unsigned long start
;
18955 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18957 switch (pnote
->descsz
)
18960 /* A zero-length description means that the range of
18961 the previous note of the same type should be used. */
18964 if (global_end
> global_offset
)
18965 printf (_(" Applies to region from %#lx to %#lx\n"),
18966 global_offset
, global_end
);
18968 printf (_(" Applies to region from %#lx\n"), global_offset
);
18972 if (func_end
> func_offset
)
18973 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18975 printf (_(" Applies to region from %#lx\n"), func_offset
);
18980 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18987 /* FIXME: We should check that version 3+ notes are being used here... */
18988 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18989 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18993 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18999 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19000 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19004 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19005 printf (_(" <invalid descsz>"));
19010 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19011 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19012 in order to avoid them being confused with the start address of the
19013 first function in the file... */
19014 if (sym
== NULL
&& is_open_attr
)
19015 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19018 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19019 end
= start
+ sym
->st_size
;
19023 /* FIXME: Need to properly allow for section alignment.
19024 16 is just the alignment used on x86_64. */
19026 && start
> BFD_ALIGN (global_end
, 16)
19027 /* Build notes are not guaranteed to be organised in order of
19028 increasing address, but we should find the all of the notes
19029 for one section in the same place. */
19030 && same_section (filedata
, start
, global_end
))
19031 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19032 global_end
+ 1, start
- 1);
19034 printf (_(" Applies to region from %#lx"), start
);
19035 global_offset
= start
;
19039 printf (_(" to %#lx"), end
);
19045 printf (_(" Applies to region from %#lx"), start
);
19046 func_offset
= start
;
19050 printf (_(" to %#lx"), end
);
19056 printf (_(" (%s)"), name
);
19063 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19065 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19066 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19067 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19069 char name_attribute
;
19070 const char * expected_types
;
19071 const char * name
= pnote
->namedata
;
19075 if (name
== NULL
|| pnote
->namesz
< 2)
19077 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19078 print_symbol (-20, _(" <corrupt name>"));
19087 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19088 if (name
[0] == 'G' && name
[1] == 'A')
19090 if (pnote
->namesz
< 4)
19092 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19093 print_symbol (-20, _(" <corrupt name>"));
19102 switch ((name_type
= * name
))
19104 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19105 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19106 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19107 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19108 printf ("%c", * name
);
19112 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19113 print_symbol (-20, _("<unknown name type>"));
19120 switch ((name_attribute
= * name
))
19122 case GNU_BUILD_ATTRIBUTE_VERSION
:
19123 text
= _("<version>");
19124 expected_types
= string_expected
;
19127 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19128 text
= _("<stack prot>");
19129 expected_types
= "!+*";
19132 case GNU_BUILD_ATTRIBUTE_RELRO
:
19133 text
= _("<relro>");
19134 expected_types
= bool_expected
;
19137 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19138 text
= _("<stack size>");
19139 expected_types
= number_expected
;
19142 case GNU_BUILD_ATTRIBUTE_TOOL
:
19143 text
= _("<tool>");
19144 expected_types
= string_expected
;
19147 case GNU_BUILD_ATTRIBUTE_ABI
:
19149 expected_types
= "$*";
19152 case GNU_BUILD_ATTRIBUTE_PIC
:
19154 expected_types
= number_expected
;
19157 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19158 text
= _("<short enum>");
19159 expected_types
= bool_expected
;
19163 if (ISPRINT (* name
))
19165 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19167 if (len
> left
&& ! do_wide
)
19169 printf ("%.*s:", len
, name
);
19175 static char tmpbuf
[128];
19177 error (_("unrecognised byte in name field: %d\n"), * name
);
19178 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19182 expected_types
= "*$!+";
19187 left
-= printf ("%s", text
);
19189 if (strchr (expected_types
, name_type
) == NULL
)
19190 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19192 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19194 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19195 (unsigned long) pnote
->namesz
,
19196 (long) (name
- pnote
->namedata
));
19200 if (left
< 1 && ! do_wide
)
19205 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19207 unsigned int bytes
;
19208 unsigned long long val
= 0;
19209 unsigned int shift
= 0;
19210 char * decoded
= NULL
;
19212 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19214 /* The -1 is because the name field is always 0 terminated, and we
19215 want to be able to ensure that the shift in the while loop below
19216 will not overflow. */
19219 if (bytes
> sizeof (val
))
19221 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19223 bytes
= sizeof (val
);
19225 /* We do not bother to warn if bytes == 0 as this can
19226 happen with some early versions of the gcc plugin. */
19230 unsigned long byte
= (* name
++) & 0xff;
19232 val
|= byte
<< shift
;
19236 switch (name_attribute
)
19238 case GNU_BUILD_ATTRIBUTE_PIC
:
19241 case 0: decoded
= "static"; break;
19242 case 1: decoded
= "pic"; break;
19243 case 2: decoded
= "PIC"; break;
19244 case 3: decoded
= "pie"; break;
19245 case 4: decoded
= "PIE"; break;
19249 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19252 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19253 case 0: decoded
= "off"; break;
19254 case 1: decoded
= "on"; break;
19255 case 2: decoded
= "all"; break;
19256 case 3: decoded
= "strong"; break;
19257 case 4: decoded
= "explicit"; break;
19265 if (decoded
!= NULL
)
19267 print_symbol (-left
, decoded
);
19278 left
-= printf ("0x%llx", val
);
19280 left
-= printf ("0x%-.*llx", left
, val
);
19284 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19285 left
-= print_symbol (- left
, name
);
19287 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19288 left
-= print_symbol (- left
, "true");
19290 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19291 left
-= print_symbol (- left
, "false");
19295 if (do_wide
&& left
> 0)
19296 printf ("%-*s", left
, " ");
19301 /* Note that by the ELF standard, the name field is already null byte
19302 terminated, and namesz includes the terminating null byte.
19303 I.E. the value of namesz for the name "FSF" is 4.
19305 If the value of namesz is zero, there is no name present. */
19308 process_note (Elf_Internal_Note
* pnote
,
19309 Filedata
* filedata
)
19311 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19314 if (pnote
->namesz
== 0)
19315 /* If there is no note name, then use the default set of
19316 note type strings. */
19317 nt
= get_note_type (filedata
, pnote
->type
);
19319 else if (const_strneq (pnote
->namedata
, "GNU"))
19320 /* GNU-specific object file notes. */
19321 nt
= get_gnu_elf_note_type (pnote
->type
);
19323 else if (const_strneq (pnote
->namedata
, "AMD")
19324 || const_strneq (pnote
->namedata
, "AMDGPU"))
19325 /* AMD-specific object file notes. */
19326 nt
= get_amd_elf_note_type (pnote
->type
);
19328 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19329 /* FreeBSD-specific core file notes. */
19330 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19332 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19333 /* NetBSD-specific core file notes. */
19334 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19336 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19337 /* NetBSD-specific core file notes. */
19338 return process_netbsd_elf_note (pnote
);
19340 else if (const_strneq (pnote
->namedata
, "PaX"))
19341 /* NetBSD-specific core file notes. */
19342 return process_netbsd_elf_note (pnote
);
19344 else if (strneq (pnote
->namedata
, "SPU/", 4))
19346 /* SPU-specific core file notes. */
19347 nt
= pnote
->namedata
+ 4;
19351 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19352 /* VMS/ia64-specific file notes. */
19353 nt
= get_ia64_vms_note_type (pnote
->type
);
19355 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19356 nt
= get_stapsdt_note_type (pnote
->type
);
19359 /* Don't recognize this note name; just use the default set of
19360 note type strings. */
19361 nt
= get_note_type (filedata
, pnote
->type
);
19365 if (((const_strneq (pnote
->namedata
, "GA")
19366 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19367 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19368 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19369 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19370 print_gnu_build_attribute_name (pnote
);
19372 print_symbol (-20, name
);
19375 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19377 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19379 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19380 return print_ia64_vms_note (pnote
);
19381 else if (const_strneq (pnote
->namedata
, "GNU"))
19382 return print_gnu_note (filedata
, pnote
);
19383 else if (const_strneq (pnote
->namedata
, "AMD")
19384 || const_strneq (pnote
->namedata
, "AMDGPU"))
19385 return print_amd_note (pnote
);
19386 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19387 return print_stapsdt_note (pnote
);
19388 else if (const_strneq (pnote
->namedata
, "CORE"))
19389 return print_core_note (pnote
);
19390 else if (((const_strneq (pnote
->namedata
, "GA")
19391 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19392 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19393 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19394 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19395 return print_gnu_build_attribute_description (pnote
, filedata
);
19401 printf (_(" description data: "));
19402 for (i
= 0; i
< pnote
->descsz
; i
++)
19403 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19415 process_notes_at (Filedata
* filedata
,
19416 Elf_Internal_Shdr
* section
,
19421 Elf_External_Note
* pnotes
;
19422 Elf_External_Note
* external
;
19424 bfd_boolean res
= TRUE
;
19431 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19434 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19439 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19442 if (pnotes
== NULL
)
19448 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19450 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19451 (unsigned long) offset
, (unsigned long) length
);
19453 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19454 specifies that notes should be aligned to 4 bytes in 32-bit
19455 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19456 we also support 4 byte alignment in 64-bit objects. If section
19457 alignment is less than 4, we treate alignment as 4 bytes. */
19460 else if (align
!= 4 && align
!= 8)
19462 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19467 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19469 end
= (char *) pnotes
+ length
;
19470 while ((char *) external
< end
)
19472 Elf_Internal_Note inote
;
19475 char * temp
= NULL
;
19476 size_t data_remaining
= end
- (char *) external
;
19478 if (!is_ia64_vms (filedata
))
19480 /* PR binutils/15191
19481 Make sure that there is enough data to read. */
19482 min_notesz
= offsetof (Elf_External_Note
, name
);
19483 if (data_remaining
< min_notesz
)
19485 warn (ngettext ("Corrupt note: only %ld byte remains, "
19486 "not enough for a full note\n",
19487 "Corrupt note: only %ld bytes remain, "
19488 "not enough for a full note\n",
19490 (long) data_remaining
);
19493 data_remaining
-= min_notesz
;
19495 inote
.type
= BYTE_GET (external
->type
);
19496 inote
.namesz
= BYTE_GET (external
->namesz
);
19497 inote
.namedata
= external
->name
;
19498 inote
.descsz
= BYTE_GET (external
->descsz
);
19499 inote
.descdata
= ((char *) external
19500 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19501 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19502 next
= ((char *) external
19503 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19507 Elf64_External_VMS_Note
*vms_external
;
19509 /* PR binutils/15191
19510 Make sure that there is enough data to read. */
19511 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19512 if (data_remaining
< min_notesz
)
19514 warn (ngettext ("Corrupt note: only %ld byte remains, "
19515 "not enough for a full note\n",
19516 "Corrupt note: only %ld bytes remain, "
19517 "not enough for a full note\n",
19519 (long) data_remaining
);
19522 data_remaining
-= min_notesz
;
19524 vms_external
= (Elf64_External_VMS_Note
*) external
;
19525 inote
.type
= BYTE_GET (vms_external
->type
);
19526 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19527 inote
.namedata
= vms_external
->name
;
19528 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19529 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19530 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19531 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19534 /* PR 17531: file: 3443835e. */
19535 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19536 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19537 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19538 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19539 || ((size_t) (next
- inote
.descdata
)
19540 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19542 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19543 (unsigned long) ((char *) external
- (char *) pnotes
));
19544 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19545 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19549 external
= (Elf_External_Note
*) next
;
19551 /* Verify that name is null terminated. It appears that at least
19552 one version of Linux (RedHat 6.0) generates corefiles that don't
19553 comply with the ELF spec by failing to include the null byte in
19555 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19557 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19559 temp
= (char *) malloc (inote
.namesz
+ 1);
19562 error (_("Out of memory allocating space for inote name\n"));
19567 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19568 inote
.namedata
= temp
;
19570 inote
.namedata
[inote
.namesz
] = 0;
19573 if (! process_note (& inote
, filedata
))
19589 process_corefile_note_segments (Filedata
* filedata
)
19591 Elf_Internal_Phdr
* segment
;
19593 bfd_boolean res
= TRUE
;
19595 if (! get_program_headers (filedata
))
19598 for (i
= 0, segment
= filedata
->program_headers
;
19599 i
< filedata
->file_header
.e_phnum
;
19602 if (segment
->p_type
== PT_NOTE
)
19603 if (! process_notes_at (filedata
, NULL
,
19604 (bfd_vma
) segment
->p_offset
,
19605 (bfd_vma
) segment
->p_filesz
,
19606 (bfd_vma
) segment
->p_align
))
19614 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19616 Elf_External_Note
* pnotes
;
19617 Elf_External_Note
* external
;
19619 bfd_boolean res
= TRUE
;
19624 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19626 if (pnotes
== NULL
)
19630 end
= (char*) pnotes
+ length
;
19632 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19633 (unsigned long) offset
, (unsigned long) length
);
19635 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19637 Elf_External_Note
* next
;
19638 Elf_Internal_Note inote
;
19640 inote
.type
= BYTE_GET (external
->type
);
19641 inote
.namesz
= BYTE_GET (external
->namesz
);
19642 inote
.namedata
= external
->name
;
19643 inote
.descsz
= BYTE_GET (external
->descsz
);
19644 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19645 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19647 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19649 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19650 inote
.descdata
= inote
.namedata
;
19654 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19656 if ( ((char *) next
> end
)
19657 || ((char *) next
< (char *) pnotes
))
19659 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19660 (unsigned long) ((char *) external
- (char *) pnotes
));
19661 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19662 inote
.type
, inote
.namesz
, inote
.descsz
);
19668 /* Prevent out-of-bounds indexing. */
19669 if ( inote
.namedata
+ inote
.namesz
> end
19670 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19672 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19673 (unsigned long) ((char *) external
- (char *) pnotes
));
19674 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19675 inote
.type
, inote
.namesz
, inote
.descsz
);
19679 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19681 if (! print_v850_note (& inote
))
19684 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19685 inote
.namesz
, inote
.descsz
);
19695 process_note_sections (Filedata
* filedata
)
19697 Elf_Internal_Shdr
* section
;
19699 unsigned int n
= 0;
19700 bfd_boolean res
= TRUE
;
19702 for (i
= 0, section
= filedata
->section_headers
;
19703 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19706 if (section
->sh_type
== SHT_NOTE
)
19708 if (! process_notes_at (filedata
, section
,
19709 (bfd_vma
) section
->sh_offset
,
19710 (bfd_vma
) section
->sh_size
,
19711 (bfd_vma
) section
->sh_addralign
))
19716 if (( filedata
->file_header
.e_machine
== EM_V800
19717 || filedata
->file_header
.e_machine
== EM_V850
19718 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19719 && section
->sh_type
== SHT_RENESAS_INFO
)
19721 if (! process_v850_notes (filedata
,
19722 (bfd_vma
) section
->sh_offset
,
19723 (bfd_vma
) section
->sh_size
))
19730 /* Try processing NOTE segments instead. */
19731 return process_corefile_note_segments (filedata
);
19737 process_notes (Filedata
* filedata
)
19739 /* If we have not been asked to display the notes then do nothing. */
19743 if (filedata
->file_header
.e_type
!= ET_CORE
)
19744 return process_note_sections (filedata
);
19746 /* No program headers means no NOTE segment. */
19747 if (filedata
->file_header
.e_phnum
> 0)
19748 return process_corefile_note_segments (filedata
);
19750 printf (_("No note segments present in the core file.\n"));
19754 static unsigned char *
19755 display_public_gnu_attributes (unsigned char * start
,
19756 const unsigned char * const end
)
19758 printf (_(" Unknown GNU attribute: %s\n"), start
);
19760 start
+= strnlen ((char *) start
, end
- start
);
19761 display_raw_attribute (start
, end
);
19763 return (unsigned char *) end
;
19766 static unsigned char *
19767 display_generic_attribute (unsigned char * start
,
19769 const unsigned char * const end
)
19772 return (unsigned char *) end
;
19774 return display_tag_value (tag
, start
, end
);
19778 process_arch_specific (Filedata
* filedata
)
19783 switch (filedata
->file_header
.e_machine
)
19786 case EM_ARC_COMPACT
:
19787 case EM_ARC_COMPACT2
:
19788 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19789 display_arc_attribute
,
19790 display_generic_attribute
);
19792 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19793 display_arm_attribute
,
19794 display_generic_attribute
);
19797 case EM_MIPS_RS3_LE
:
19798 return process_mips_specific (filedata
);
19801 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19802 display_msp430x_attribute
,
19803 display_msp430_gnu_attribute
);
19806 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19807 display_riscv_attribute
,
19808 display_generic_attribute
);
19811 return process_nds32_specific (filedata
);
19815 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19816 display_power_gnu_attribute
);
19820 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19821 display_s390_gnu_attribute
);
19824 case EM_SPARC32PLUS
:
19826 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19827 display_sparc_gnu_attribute
);
19830 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19831 display_tic6x_attribute
,
19832 display_generic_attribute
);
19835 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19836 display_public_gnu_attributes
,
19837 display_generic_attribute
);
19842 get_file_header (Filedata
* filedata
)
19844 /* Read in the identity array. */
19845 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19848 /* Determine how to read the rest of the header. */
19849 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19854 byte_get
= byte_get_little_endian
;
19855 byte_put
= byte_put_little_endian
;
19858 byte_get
= byte_get_big_endian
;
19859 byte_put
= byte_put_big_endian
;
19863 /* For now we only support 32 bit and 64 bit ELF files. */
19864 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19866 /* Read in the rest of the header. */
19869 Elf32_External_Ehdr ehdr32
;
19871 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19874 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19875 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19876 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19877 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19878 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19879 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19880 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19881 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19882 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19883 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19884 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19885 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19886 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19890 Elf64_External_Ehdr ehdr64
;
19892 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19893 we will not be able to cope with the 64bit data found in
19894 64 ELF files. Detect this now and abort before we start
19895 overwriting things. */
19896 if (sizeof (bfd_vma
) < 8)
19898 error (_("This instance of readelf has been built without support for a\n\
19899 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19903 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19906 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19907 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19908 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19909 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19910 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19911 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19912 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19913 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19914 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19915 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19916 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19917 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19918 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19921 if (filedata
->file_header
.e_shoff
)
19923 /* There may be some extensions in the first section header. Don't
19924 bomb if we can't read it. */
19926 get_32bit_section_headers (filedata
, TRUE
);
19928 get_64bit_section_headers (filedata
, TRUE
);
19935 close_file (Filedata
* filedata
)
19939 if (filedata
->handle
)
19940 fclose (filedata
->handle
);
19946 close_debug_file (void * data
)
19948 close_file ((Filedata
*) data
);
19952 open_file (const char * pathname
)
19954 struct stat statbuf
;
19955 Filedata
* filedata
= NULL
;
19957 if (stat (pathname
, & statbuf
) < 0
19958 || ! S_ISREG (statbuf
.st_mode
))
19961 filedata
= calloc (1, sizeof * filedata
);
19962 if (filedata
== NULL
)
19965 filedata
->handle
= fopen (pathname
, "rb");
19966 if (filedata
->handle
== NULL
)
19969 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19970 filedata
->file_name
= pathname
;
19972 if (! get_file_header (filedata
))
19975 if (filedata
->file_header
.e_shoff
)
19979 /* Read the section headers again, this time for real. */
19981 res
= get_32bit_section_headers (filedata
, FALSE
);
19983 res
= get_64bit_section_headers (filedata
, FALSE
);
19994 if (filedata
->handle
)
19995 fclose (filedata
->handle
);
20002 open_debug_file (const char * pathname
)
20004 return open_file (pathname
);
20007 /* Process one ELF object file according to the command line options.
20008 This file may actually be stored in an archive. The file is
20009 positioned at the start of the ELF object. Returns TRUE if no
20010 problems were encountered, FALSE otherwise. */
20013 process_object (Filedata
* filedata
)
20015 bfd_boolean have_separate_files
;
20017 bfd_boolean res
= TRUE
;
20019 if (! get_file_header (filedata
))
20021 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20025 /* Initialise per file variables. */
20026 for (i
= ARRAY_SIZE (version_info
); i
--;)
20027 version_info
[i
] = 0;
20029 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
20030 dynamic_info
[i
] = 0;
20031 dynamic_info_DT_GNU_HASH
= 0;
20032 dynamic_info_DT_MIPS_XHASH
= 0;
20034 /* Process the file. */
20036 printf (_("\nFile: %s\n"), filedata
->file_name
);
20038 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20039 Note we do this even if cmdline_dump_sects is empty because we
20040 must make sure that the dump_sets array is zeroed out before each
20041 object file is processed. */
20042 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
20043 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
20045 if (cmdline
.num_dump_sects
> 0)
20047 if (filedata
->num_dump_sects
== 0)
20048 /* A sneaky way of allocating the dump_sects array. */
20049 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
20051 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
20052 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
20053 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
20056 if (! process_file_header (filedata
))
20059 if (! process_section_headers (filedata
))
20061 /* Without loaded section headers we cannot process lots of things. */
20062 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20064 if (! do_using_dynamic
)
20065 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20068 if (! process_section_groups (filedata
))
20069 /* Without loaded section groups we cannot process unwind. */
20072 if (process_program_headers (filedata
))
20073 process_dynamic_section (filedata
);
20077 if (! process_relocs (filedata
))
20080 if (! process_unwind (filedata
))
20083 if (! process_symbol_table (filedata
))
20086 if (! process_syminfo (filedata
))
20089 if (! process_version_sections (filedata
))
20092 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20093 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20095 have_separate_files
= FALSE
;
20097 if (! process_section_contents (filedata
))
20100 if (have_separate_files
)
20104 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20106 if (! process_section_headers (d
->handle
))
20108 else if (! process_section_contents (d
->handle
))
20112 /* The file handles are closed by the call to free_debug_memory() below. */
20115 if (! process_notes (filedata
))
20118 if (! process_gnu_liblist (filedata
))
20121 if (! process_arch_specific (filedata
))
20124 free (filedata
->program_headers
);
20125 filedata
->program_headers
= NULL
;
20127 free (filedata
->section_headers
);
20128 filedata
->section_headers
= NULL
;
20130 free (filedata
->string_table
);
20131 filedata
->string_table
= NULL
;
20132 filedata
->string_table_length
= 0;
20134 if (dynamic_strings
)
20136 free (dynamic_strings
);
20137 dynamic_strings
= NULL
;
20138 dynamic_strings_length
= 0;
20141 if (dynamic_symbols
)
20143 free (dynamic_symbols
);
20144 dynamic_symbols
= NULL
;
20145 num_dynamic_syms
= 0;
20148 if (dynamic_syminfo
)
20150 free (dynamic_syminfo
);
20151 dynamic_syminfo
= NULL
;
20154 if (dynamic_section
)
20156 free (dynamic_section
);
20157 dynamic_section
= NULL
;
20160 if (section_headers_groups
)
20162 free (section_headers_groups
);
20163 section_headers_groups
= NULL
;
20166 if (section_groups
)
20168 struct group_list
* g
;
20169 struct group_list
* next
;
20171 for (i
= 0; i
< group_count
; i
++)
20173 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
20180 free (section_groups
);
20181 section_groups
= NULL
;
20184 free_debug_memory ();
20189 /* Process an ELF archive.
20190 On entry the file is positioned just after the ARMAG string.
20191 Returns TRUE upon success, FALSE otherwise. */
20194 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20196 struct archive_info arch
;
20197 struct archive_info nested_arch
;
20199 bfd_boolean ret
= TRUE
;
20203 /* The ARCH structure is used to hold information about this archive. */
20204 arch
.file_name
= NULL
;
20206 arch
.index_array
= NULL
;
20207 arch
.sym_table
= NULL
;
20208 arch
.longnames
= NULL
;
20210 /* The NESTED_ARCH structure is used as a single-item cache of information
20211 about a nested archive (when members of a thin archive reside within
20212 another regular archive file). */
20213 nested_arch
.file_name
= NULL
;
20214 nested_arch
.file
= NULL
;
20215 nested_arch
.index_array
= NULL
;
20216 nested_arch
.sym_table
= NULL
;
20217 nested_arch
.longnames
= NULL
;
20219 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20220 is_thin_archive
, do_archive_index
) != 0)
20226 if (do_archive_index
)
20228 if (arch
.sym_table
== NULL
)
20229 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
20232 unsigned long i
, l
;
20233 unsigned long current_pos
;
20235 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20236 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
20238 current_pos
= ftell (filedata
->handle
);
20240 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20242 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
20244 char * member_name
;
20246 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
20248 if (member_name
!= NULL
)
20250 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
20252 if (qualified_name
!= NULL
)
20254 printf (_("Contents of binary %s at offset "), qualified_name
);
20255 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20257 free (qualified_name
);
20262 if (l
>= arch
.sym_size
)
20264 error (_("%s: end of the symbol table reached before the end of the index\n"),
20265 filedata
->file_name
);
20269 /* PR 17531: file: 0b6630b2. */
20270 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20271 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20274 if (arch
.uses_64bit_indices
)
20279 if (l
< arch
.sym_size
)
20281 error (ngettext ("%s: %ld byte remains in the symbol table, "
20282 "but without corresponding entries in "
20283 "the index table\n",
20284 "%s: %ld bytes remain in the symbol table, "
20285 "but without corresponding entries in "
20286 "the index table\n",
20287 arch
.sym_size
- l
),
20288 filedata
->file_name
, arch
.sym_size
- l
);
20292 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20294 error (_("%s: failed to seek back to start of object files in the archive\n"),
20295 filedata
->file_name
);
20301 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20302 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20303 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20304 && !do_section_groups
&& !do_dyn_syms
)
20306 ret
= TRUE
; /* Archive index only. */
20315 char * qualified_name
;
20317 /* Read the next archive header. */
20318 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20320 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
20323 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20324 if (got
!= sizeof arch
.arhdr
)
20328 /* PR 24049 - we cannot use filedata->file_name as this will
20329 have already been freed. */
20330 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20335 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20337 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
20342 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20344 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20345 if (archive_file_size
& 01)
20346 ++archive_file_size
;
20348 name
= get_archive_member_name (&arch
, &nested_arch
);
20351 error (_("%s: bad archive file name\n"), arch
.file_name
);
20355 namelen
= strlen (name
);
20357 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20358 if (qualified_name
== NULL
)
20360 error (_("%s: bad archive file name\n"), arch
.file_name
);
20365 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20367 /* This is a proxy for an external member of a thin archive. */
20368 Filedata
* member_filedata
;
20369 char * member_file_name
= adjust_relative_path
20370 (filedata
->file_name
, name
, namelen
);
20372 if (member_file_name
== NULL
)
20378 member_filedata
= open_file (member_file_name
);
20379 if (member_filedata
== NULL
)
20381 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20382 free (member_file_name
);
20387 archive_file_offset
= arch
.nested_member_origin
;
20388 member_filedata
->file_name
= qualified_name
;
20390 if (! process_object (member_filedata
))
20393 close_file (member_filedata
);
20394 free (member_file_name
);
20396 else if (is_thin_archive
)
20398 Filedata thin_filedata
;
20400 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20402 /* PR 15140: Allow for corrupt thin archives. */
20403 if (nested_arch
.file
== NULL
)
20405 error (_("%s: contains corrupt thin archive: %s\n"),
20406 qualified_name
, name
);
20411 /* This is a proxy for a member of a nested archive. */
20412 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20414 /* The nested archive file will have been opened and setup by
20415 get_archive_member_name. */
20416 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20418 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
20423 thin_filedata
.handle
= nested_arch
.file
;
20424 thin_filedata
.file_name
= qualified_name
;
20426 if (! process_object (& thin_filedata
))
20431 archive_file_offset
= arch
.next_arhdr_offset
;
20432 arch
.next_arhdr_offset
+= archive_file_size
;
20434 filedata
->file_name
= qualified_name
;
20435 if (! process_object (filedata
))
20439 if (filedata
->dump_sects
!= NULL
)
20441 free (filedata
->dump_sects
);
20442 filedata
->dump_sects
= NULL
;
20443 filedata
->num_dump_sects
= 0;
20446 free (qualified_name
);
20450 if (nested_arch
.file
!= NULL
)
20451 fclose (nested_arch
.file
);
20452 release_archive (&nested_arch
);
20453 release_archive (&arch
);
20459 process_file (char * file_name
)
20461 Filedata
* filedata
= NULL
;
20462 struct stat statbuf
;
20463 char armag
[SARMAG
];
20464 bfd_boolean ret
= TRUE
;
20466 if (stat (file_name
, &statbuf
) < 0)
20468 if (errno
== ENOENT
)
20469 error (_("'%s': No such file\n"), file_name
);
20471 error (_("Could not locate '%s'. System error message: %s\n"),
20472 file_name
, strerror (errno
));
20476 if (! S_ISREG (statbuf
.st_mode
))
20478 error (_("'%s' is not an ordinary file\n"), file_name
);
20482 filedata
= calloc (1, sizeof * filedata
);
20483 if (filedata
== NULL
)
20485 error (_("Out of memory allocating file data structure\n"));
20489 filedata
->file_name
= file_name
;
20490 filedata
->handle
= fopen (file_name
, "rb");
20491 if (filedata
->handle
== NULL
)
20493 error (_("Input file '%s' is not readable.\n"), file_name
);
20498 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20500 error (_("%s: Failed to read file's magic number\n"), file_name
);
20501 fclose (filedata
->handle
);
20506 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20508 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20510 if (! process_archive (filedata
, FALSE
))
20513 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20515 if ( ! process_archive (filedata
, TRUE
))
20520 if (do_archive_index
)
20521 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20524 rewind (filedata
->handle
);
20525 archive_file_size
= archive_file_offset
= 0;
20527 if (! process_object (filedata
))
20531 fclose (filedata
->handle
);
20537 #ifdef SUPPORT_DISASSEMBLY
20538 /* Needed by the i386 disassembler. For extra credit, someone could
20539 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20543 print_address (unsigned int addr
, FILE * outfile
)
20545 fprintf (outfile
,"0x%8.8x", addr
);
20548 /* Needed by the i386 disassembler. */
20551 db_task_printsym (unsigned int addr
)
20553 print_address (addr
, stderr
);
20558 main (int argc
, char ** argv
)
20562 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20563 setlocale (LC_MESSAGES
, "");
20565 #if defined (HAVE_SETLOCALE)
20566 setlocale (LC_CTYPE
, "");
20568 bindtextdomain (PACKAGE
, LOCALEDIR
);
20569 textdomain (PACKAGE
);
20571 expandargv (&argc
, &argv
);
20573 cmdline
.file_name
= "<cmdline>";
20574 parse_args (& cmdline
, argc
, argv
);
20576 if (optind
< (argc
- 1))
20578 else if (optind
>= argc
)
20580 warn (_("Nothing to do.\n"));
20585 while (optind
< argc
)
20586 if (! process_file (argv
[optind
++]))
20589 if (cmdline
.dump_sects
!= NULL
)
20590 free (cmdline
.dump_sects
);
20592 free (dump_ctf_symtab_name
);
20593 free (dump_ctf_strtab_name
);
20594 free (dump_ctf_parent_name
);
20596 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;