1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/csky.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
107 #include "elf/epiphany.h"
108 #include "elf/fr30.h"
110 #include "elf/ft32.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/s12z.h"
126 #include "elf/mcore.h"
128 #include "elf/metag.h"
129 #include "elf/microblaze.h"
130 #include "elf/mips.h"
131 #include "elf/mmix.h"
132 #include "elf/mn10200.h"
133 #include "elf/mn10300.h"
134 #include "elf/moxie.h"
136 #include "elf/msp430.h"
137 #include "elf/nds32.h"
139 #include "elf/nios2.h"
140 #include "elf/or1k.h"
143 #include "elf/ppc64.h"
145 #include "elf/riscv.h"
146 #include "elf/rl78.h"
148 #include "elf/s390.h"
149 #include "elf/score.h"
151 #include "elf/sparc.h"
153 #include "elf/tic6x.h"
154 #include "elf/tilegx.h"
155 #include "elf/tilepro.h"
156 #include "elf/v850.h"
158 #include "elf/visium.h"
159 #include "elf/wasm32.h"
160 #include "elf/x86-64.h"
161 #include "elf/xc16x.h"
162 #include "elf/xgate.h"
163 #include "elf/xstormy16.h"
164 #include "elf/xtensa.h"
168 #include "libiberty.h"
169 #include "safe-ctype.h"
170 #include "filenames.h"
173 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
176 typedef struct elf_section_list
178 Elf_Internal_Shdr
* hdr
;
179 struct elf_section_list
* next
;
182 /* Flag bits indicating particular types of dump. */
183 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
184 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
187 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
190 typedef unsigned char dump_type
;
192 /* A linked list of the section names for which dumps were requested. */
193 struct dump_list_entry
197 struct dump_list_entry
* next
;
200 /* A dynamic array of flags indicating for which sections a dump
201 has been requested via command line switches. */
203 dump_type
* dump_sects
;
204 unsigned int num_dump_sects
;
207 static struct dump_data cmdline
;
209 static struct dump_list_entry
* dump_sects_byname
;
211 typedef struct filedata
213 const char * file_name
;
215 bfd_size_type file_size
;
216 Elf_Internal_Ehdr file_header
;
217 Elf_Internal_Shdr
* section_headers
;
218 Elf_Internal_Phdr
* program_headers
;
220 unsigned long string_table_length
;
221 /* A dynamic array of flags indicating for which sections a dump of
222 some kind has been requested. It is reset on a per-object file
223 basis and then initialised from the cmdline_dump_sects array,
224 the results of interpreting the -w switch, and the
225 dump_sects_byname list. */
226 struct dump_data dump
;
229 char * program_name
= "readelf";
231 static unsigned long archive_file_offset
;
232 static unsigned long archive_file_size
;
233 static unsigned long dynamic_addr
;
234 static bfd_size_type dynamic_size
;
235 static size_t dynamic_nent
;
236 static char * dynamic_strings
;
237 static unsigned long dynamic_strings_length
;
238 static unsigned long num_dynamic_syms
;
239 static bfd_size_type nbuckets
;
240 static bfd_size_type nchains
;
241 static bfd_vma
*buckets
;
242 static bfd_vma
*chains
;
243 static bfd_vma ngnubuckets
;
244 static bfd_vma
*gnubuckets
;
245 static bfd_vma
*gnuchains
;
246 static bfd_vma
*mipsxlat
;
247 static bfd_size_type ngnuchains
;
248 static bfd_vma gnusymidx
;
249 static Elf_Internal_Sym
* dynamic_symbols
;
250 static Elf_Internal_Syminfo
* dynamic_syminfo
;
251 static unsigned long dynamic_syminfo_offset
;
252 static unsigned int dynamic_syminfo_nent
;
253 static char program_interpreter
[PATH_MAX
];
254 static bfd_vma dynamic_info
[DT_ENCODING
];
255 static bfd_vma dynamic_info_DT_GNU_HASH
;
256 static bfd_vma dynamic_info_DT_MIPS_XHASH
;
257 static bfd_vma version_info
[16];
258 static Elf_Internal_Dyn
* dynamic_section
;
259 static elf_section_list
* symtab_shndx_list
;
260 static bfd_boolean show_name
= FALSE
;
261 static bfd_boolean do_dynamic
= FALSE
;
262 static bfd_boolean do_syms
= FALSE
;
263 static bfd_boolean do_dyn_syms
= FALSE
;
264 static bfd_boolean do_reloc
= FALSE
;
265 static bfd_boolean do_sections
= FALSE
;
266 static bfd_boolean do_section_groups
= FALSE
;
267 static bfd_boolean do_section_details
= FALSE
;
268 static bfd_boolean do_segments
= FALSE
;
269 static bfd_boolean do_unwind
= FALSE
;
270 static bfd_boolean do_using_dynamic
= FALSE
;
271 static bfd_boolean do_header
= FALSE
;
272 static bfd_boolean do_dump
= FALSE
;
273 static bfd_boolean do_version
= FALSE
;
274 static bfd_boolean do_histogram
= FALSE
;
275 static bfd_boolean do_debugging
= FALSE
;
276 static bfd_boolean do_ctf
= FALSE
;
277 static bfd_boolean do_arch
= FALSE
;
278 static bfd_boolean do_notes
= FALSE
;
279 static bfd_boolean do_archive_index
= FALSE
;
280 static bfd_boolean is_32bit_elf
= FALSE
;
281 static bfd_boolean decompress_dumps
= FALSE
;
283 static char *dump_ctf_parent_name
;
284 static char *dump_ctf_symtab_name
;
285 static char *dump_ctf_strtab_name
;
289 struct group_list
* next
;
290 unsigned int section_index
;
295 struct group_list
* root
;
296 unsigned int group_index
;
299 static size_t group_count
;
300 static struct group
* section_groups
;
301 static struct group
** section_headers_groups
;
303 /* How to print a vma value. */
304 typedef enum print_mode
316 /* Versioned symbol info. */
317 enum versioned_symbol_info
324 static const char * get_symbol_version_string
325 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
326 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
330 #define SECTION_NAME(X) \
331 ((X) == NULL ? _("<none>") \
332 : filedata->string_table == NULL ? _("<no-strings>") \
333 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
334 : filedata->string_table + (X)->sh_name))
336 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
338 #define GET_ELF_SYMBOLS(file, section, sym_count) \
339 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
340 : get_64bit_elf_symbols (file, section, sym_count))
342 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
343 (strtab != NULL && offset < strtab_size)
344 #define VALID_DYNAMIC_NAME(offset) \
345 VALID_SYMBOL_NAME (dynamic_strings, dynamic_strings_length, offset)
346 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
347 already been called and verified that the string exists. */
348 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
350 #define REMOVE_ARCH_BITS(ADDR) \
353 if (filedata->file_header.e_machine == EM_ARM) \
358 /* Get the correct GNU hash section name. */
359 #define GNU_HASH_SECTION_NAME \
360 dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
362 /* Print a BFD_VMA to an internal buffer, for use in error messages.
363 BFD_FMA_FMT can't be used in translated strings. */
366 bfd_vmatoa (char *fmtch
, bfd_vma value
)
368 /* bfd_vmatoa is used more then once in a printf call for output.
369 Cycle through an array of buffers. */
370 static int buf_pos
= 0;
371 static struct bfd_vmatoa_buf
378 ret
= buf
[buf_pos
++].place
;
379 buf_pos
%= ARRAY_SIZE (buf
);
381 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
382 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
386 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
387 OFFSET + the offset of the current archive member, if we are examining an
388 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
389 allocate a buffer using malloc and fill that. In either case return the
390 pointer to the start of the retrieved data or NULL if something went wrong.
391 If something does go wrong and REASON is not NULL then emit an error
392 message using REASON as part of the context. */
395 get_data (void * var
,
397 unsigned long offset
,
403 bfd_size_type amt
= size
* nmemb
;
405 if (size
== 0 || nmemb
== 0)
408 /* If the size_t type is smaller than the bfd_size_type, eg because
409 you are building a 32-bit tool on a 64-bit host, then make sure
410 that when the sizes are cast to (size_t) no information is lost. */
411 if ((size_t) size
!= size
412 || (size_t) nmemb
!= nmemb
413 || (size_t) amt
!= amt
)
416 error (_("Size truncation prevents reading %s"
417 " elements of size %s for %s\n"),
418 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
422 /* Check for size overflow. */
423 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
426 error (_("Size overflow prevents reading %s"
427 " elements of size %s for %s\n"),
428 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
432 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
433 attempting to allocate memory when the read is bound to fail. */
434 if (archive_file_offset
> filedata
->file_size
435 || offset
> filedata
->file_size
- archive_file_offset
436 || amt
> filedata
->file_size
- archive_file_offset
- offset
)
439 error (_("Reading %s bytes extends past end of file for %s\n"),
440 bfd_vmatoa ("u", amt
), reason
);
444 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
447 error (_("Unable to seek to 0x%lx for %s\n"),
448 archive_file_offset
+ offset
, reason
);
455 /* + 1 so that we can '\0' terminate invalid string table sections. */
456 mvar
= malloc ((size_t) amt
+ 1);
461 error (_("Out of memory allocating %s bytes for %s\n"),
462 bfd_vmatoa ("u", amt
), reason
);
466 ((char *) mvar
)[amt
] = '\0';
469 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
472 error (_("Unable to read in %s bytes of %s\n"),
473 bfd_vmatoa ("u", amt
), reason
);
482 /* Print a VMA value in the MODE specified.
483 Returns the number of characters displayed. */
486 print_vma (bfd_vma vma
, print_mode mode
)
498 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
505 return printf ("%5" BFD_VMA_FMT
"d", vma
);
511 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
514 return printf ("%" BFD_VMA_FMT
"d", vma
);
517 return printf ("%" BFD_VMA_FMT
"u", vma
);
520 /* FIXME: Report unrecognised mode ? */
525 /* Display a symbol on stdout. Handles the display of control characters and
526 multibye characters (assuming the host environment supports them).
528 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
530 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
531 padding as necessary.
533 Returns the number of emitted characters. */
536 print_symbol (signed int width
, const char *symbol
)
538 bfd_boolean extra_padding
= FALSE
;
539 signed int num_printed
= 0;
540 #ifdef HAVE_MBSTATE_T
543 unsigned int width_remaining
;
547 /* Keep the width positive. This helps the code below. */
549 extra_padding
= TRUE
;
555 /* Set the remaining width to a very large value.
556 This simplifies the code below. */
557 width_remaining
= INT_MAX
;
559 width_remaining
= width
;
561 #ifdef HAVE_MBSTATE_T
562 /* Initialise the multibyte conversion state. */
563 memset (& state
, 0, sizeof (state
));
566 while (width_remaining
)
569 const char c
= *symbol
++;
574 /* Do not print control characters directly as they can affect terminal
575 settings. Such characters usually appear in the names generated
576 by the assembler for local labels. */
579 if (width_remaining
< 2)
582 printf ("^%c", c
+ 0x40);
583 width_remaining
-= 2;
586 else if (ISPRINT (c
))
594 #ifdef HAVE_MBSTATE_T
597 /* Let printf do the hard work of displaying multibyte characters. */
598 printf ("%.1s", symbol
- 1);
602 #ifdef HAVE_MBSTATE_T
603 /* Try to find out how many bytes made up the character that was
604 just printed. Advance the symbol pointer past the bytes that
606 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
610 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
615 if (extra_padding
&& num_printed
< width
)
617 /* Fill in the remaining spaces. */
618 printf ("%-*s", width
- num_printed
, " ");
625 /* Returns a pointer to a static buffer containing a printable version of
626 the given section's name. Like print_symbol, except that it does not try
627 to print multibyte characters, it just interprets them as hex values. */
630 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
632 #define MAX_PRINT_SEC_NAME_LEN 128
633 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
634 const char * name
= SECTION_NAME (sec
);
635 char * buf
= sec_name_buf
;
637 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
639 while ((c
= * name
++) != 0)
650 else if (ISPRINT (c
))
657 static char hex
[17] = "0123456789ABCDEF";
662 * buf
++ = hex
[(c
& 0xf0) >> 4];
663 * buf
++ = hex
[c
& 0x0f];
677 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
679 if (ndx
>= filedata
->file_header
.e_shnum
)
680 return _("<corrupt>");
682 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
685 /* Return a pointer to section NAME, or NULL if no such section exists. */
687 static Elf_Internal_Shdr
*
688 find_section (Filedata
* filedata
, const char * name
)
692 if (filedata
->section_headers
== NULL
)
695 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
696 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
697 return filedata
->section_headers
+ i
;
702 /* Return a pointer to a section containing ADDR, or NULL if no such
705 static Elf_Internal_Shdr
*
706 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
710 if (filedata
->section_headers
== NULL
)
713 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
715 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
717 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
724 static Elf_Internal_Shdr
*
725 find_section_by_type (Filedata
* filedata
, unsigned int type
)
729 if (filedata
->section_headers
== NULL
)
732 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
734 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
736 if (sec
->sh_type
== type
)
743 /* Return a pointer to section NAME, or NULL if no such section exists,
744 restricted to the list of sections given in SET. */
746 static Elf_Internal_Shdr
*
747 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
751 if (filedata
->section_headers
== NULL
)
756 while ((i
= *set
++) > 0)
758 /* See PR 21156 for a reproducer. */
759 if (i
>= filedata
->file_header
.e_shnum
)
760 continue; /* FIXME: Should we issue an error message ? */
762 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
763 return filedata
->section_headers
+ i
;
767 return find_section (filedata
, name
);
770 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
771 This OS has so many departures from the ELF standard that we test it at
774 static inline bfd_boolean
775 is_ia64_vms (Filedata
* filedata
)
777 return filedata
->file_header
.e_machine
== EM_IA_64
778 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
781 /* Guess the relocation size commonly used by the specific machines. */
784 guess_is_rela (unsigned int e_machine
)
788 /* Targets that use REL relocations. */
805 /* Targets that use RELA relocations. */
809 case EM_ADAPTEVA_EPIPHANY
:
811 case EM_ALTERA_NIOS2
:
814 case EM_ARC_COMPACT2
:
835 case EM_LATTICEMICO32
:
844 case EM_CYGNUS_MN10200
:
846 case EM_CYGNUS_MN10300
:
882 case EM_MICROBLAZE_OLD
:
904 warn (_("Don't know about relocations on this machine architecture\n"));
909 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
910 Returns TRUE upon success, FALSE otherwise. If successful then a
911 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
912 and the number of relocs loaded is placed in *NRELASP. It is the caller's
913 responsibility to free the allocated buffer. */
916 slurp_rela_relocs (Filedata
* filedata
,
917 unsigned long rel_offset
,
918 unsigned long rel_size
,
919 Elf_Internal_Rela
** relasp
,
920 unsigned long * nrelasp
)
922 Elf_Internal_Rela
* relas
;
928 Elf32_External_Rela
* erelas
;
930 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
931 rel_size
, _("32-bit relocation data"));
935 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
937 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
938 sizeof (Elf_Internal_Rela
));
943 error (_("out of memory parsing relocs\n"));
947 for (i
= 0; i
< nrelas
; i
++)
949 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
950 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
951 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
958 Elf64_External_Rela
* erelas
;
960 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
961 rel_size
, _("64-bit relocation data"));
965 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
967 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
968 sizeof (Elf_Internal_Rela
));
973 error (_("out of memory parsing relocs\n"));
977 for (i
= 0; i
< nrelas
; i
++)
979 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
980 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
981 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
983 /* The #ifdef BFD64 below is to prevent a compile time
984 warning. We know that if we do not have a 64 bit data
985 type that we will never execute this code anyway. */
987 if (filedata
->file_header
.e_machine
== EM_MIPS
988 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
990 /* In little-endian objects, r_info isn't really a
991 64-bit little-endian value: it has a 32-bit
992 little-endian symbol index followed by four
993 individual byte fields. Reorder INFO
995 bfd_vma inf
= relas
[i
].r_info
;
996 inf
= (((inf
& 0xffffffff) << 32)
997 | ((inf
>> 56) & 0xff)
998 | ((inf
>> 40) & 0xff00)
999 | ((inf
>> 24) & 0xff0000)
1000 | ((inf
>> 8) & 0xff000000));
1001 relas
[i
].r_info
= inf
;
1014 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1015 Returns TRUE upon success, FALSE otherwise. If successful then a
1016 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1017 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1018 responsibility to free the allocated buffer. */
1021 slurp_rel_relocs (Filedata
* filedata
,
1022 unsigned long rel_offset
,
1023 unsigned long rel_size
,
1024 Elf_Internal_Rela
** relsp
,
1025 unsigned long * nrelsp
)
1027 Elf_Internal_Rela
* rels
;
1033 Elf32_External_Rel
* erels
;
1035 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1036 rel_size
, _("32-bit relocation data"));
1040 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1042 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1047 error (_("out of memory parsing relocs\n"));
1051 for (i
= 0; i
< nrels
; i
++)
1053 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1054 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1055 rels
[i
].r_addend
= 0;
1062 Elf64_External_Rel
* erels
;
1064 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1065 rel_size
, _("64-bit relocation data"));
1069 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1071 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1076 error (_("out of memory parsing relocs\n"));
1080 for (i
= 0; i
< nrels
; i
++)
1082 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1083 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1084 rels
[i
].r_addend
= 0;
1086 /* The #ifdef BFD64 below is to prevent a compile time
1087 warning. We know that if we do not have a 64 bit data
1088 type that we will never execute this code anyway. */
1090 if (filedata
->file_header
.e_machine
== EM_MIPS
1091 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1093 /* In little-endian objects, r_info isn't really a
1094 64-bit little-endian value: it has a 32-bit
1095 little-endian symbol index followed by four
1096 individual byte fields. Reorder INFO
1098 bfd_vma inf
= rels
[i
].r_info
;
1099 inf
= (((inf
& 0xffffffff) << 32)
1100 | ((inf
>> 56) & 0xff)
1101 | ((inf
>> 40) & 0xff00)
1102 | ((inf
>> 24) & 0xff0000)
1103 | ((inf
>> 8) & 0xff000000));
1104 rels
[i
].r_info
= inf
;
1117 /* Returns the reloc type extracted from the reloc info field. */
1120 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1123 return ELF32_R_TYPE (reloc_info
);
1125 switch (filedata
->file_header
.e_machine
)
1128 /* Note: We assume that reloc_info has already been adjusted for us. */
1129 return ELF64_MIPS_R_TYPE (reloc_info
);
1132 return ELF64_R_TYPE_ID (reloc_info
);
1135 return ELF64_R_TYPE (reloc_info
);
1139 /* Return the symbol index extracted from the reloc info field. */
1142 get_reloc_symindex (bfd_vma reloc_info
)
1144 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1147 static inline bfd_boolean
1148 uses_msp430x_relocs (Filedata
* filedata
)
1151 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1152 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1153 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1154 /* TI compiler uses ELFOSABI_NONE. */
1155 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1158 /* Display the contents of the relocation data found at the specified
1162 dump_relocations (Filedata
* filedata
,
1163 unsigned long rel_offset
,
1164 unsigned long rel_size
,
1165 Elf_Internal_Sym
* symtab
,
1166 unsigned long nsyms
,
1168 unsigned long strtablen
,
1170 bfd_boolean is_dynsym
)
1173 Elf_Internal_Rela
* rels
;
1174 bfd_boolean res
= TRUE
;
1176 if (is_rela
== UNKNOWN
)
1177 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1181 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1186 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1195 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1197 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1202 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1204 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1212 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1214 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1219 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1221 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1225 for (i
= 0; i
< rel_size
; i
++)
1230 bfd_vma symtab_index
;
1233 offset
= rels
[i
].r_offset
;
1234 inf
= rels
[i
].r_info
;
1236 type
= get_reloc_type (filedata
, inf
);
1237 symtab_index
= get_reloc_symindex (inf
);
1241 printf ("%8.8lx %8.8lx ",
1242 (unsigned long) offset
& 0xffffffff,
1243 (unsigned long) inf
& 0xffffffff);
1247 #if BFD_HOST_64BIT_LONG
1249 ? "%16.16lx %16.16lx "
1250 : "%12.12lx %12.12lx ",
1252 #elif BFD_HOST_64BIT_LONG_LONG
1255 ? "%16.16llx %16.16llx "
1256 : "%12.12llx %12.12llx ",
1260 ? "%16.16I64x %16.16I64x "
1261 : "%12.12I64x %12.12I64x ",
1266 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1267 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1268 _bfd_int64_high (offset
),
1269 _bfd_int64_low (offset
),
1270 _bfd_int64_high (inf
),
1271 _bfd_int64_low (inf
));
1275 switch (filedata
->file_header
.e_machine
)
1282 rtype
= elf_aarch64_reloc_type (type
);
1286 case EM_CYGNUS_M32R
:
1287 rtype
= elf_m32r_reloc_type (type
);
1292 rtype
= elf_i386_reloc_type (type
);
1297 rtype
= elf_m68hc11_reloc_type (type
);
1301 rtype
= elf_s12z_reloc_type (type
);
1305 rtype
= elf_m68k_reloc_type (type
);
1309 rtype
= elf_i960_reloc_type (type
);
1314 rtype
= elf_avr_reloc_type (type
);
1317 case EM_OLD_SPARCV9
:
1318 case EM_SPARC32PLUS
:
1321 rtype
= elf_sparc_reloc_type (type
);
1325 rtype
= elf_spu_reloc_type (type
);
1329 rtype
= v800_reloc_type (type
);
1332 case EM_CYGNUS_V850
:
1333 rtype
= v850_reloc_type (type
);
1337 case EM_CYGNUS_D10V
:
1338 rtype
= elf_d10v_reloc_type (type
);
1342 case EM_CYGNUS_D30V
:
1343 rtype
= elf_d30v_reloc_type (type
);
1347 rtype
= elf_dlx_reloc_type (type
);
1351 rtype
= elf_sh_reloc_type (type
);
1355 case EM_CYGNUS_MN10300
:
1356 rtype
= elf_mn10300_reloc_type (type
);
1360 case EM_CYGNUS_MN10200
:
1361 rtype
= elf_mn10200_reloc_type (type
);
1365 case EM_CYGNUS_FR30
:
1366 rtype
= elf_fr30_reloc_type (type
);
1370 rtype
= elf_frv_reloc_type (type
);
1374 rtype
= elf_csky_reloc_type (type
);
1378 rtype
= elf_ft32_reloc_type (type
);
1382 rtype
= elf_mcore_reloc_type (type
);
1386 rtype
= elf_mmix_reloc_type (type
);
1390 rtype
= elf_moxie_reloc_type (type
);
1394 if (uses_msp430x_relocs (filedata
))
1396 rtype
= elf_msp430x_reloc_type (type
);
1401 rtype
= elf_msp430_reloc_type (type
);
1405 rtype
= elf_nds32_reloc_type (type
);
1409 rtype
= elf_ppc_reloc_type (type
);
1413 rtype
= elf_ppc64_reloc_type (type
);
1417 case EM_MIPS_RS3_LE
:
1418 rtype
= elf_mips_reloc_type (type
);
1422 rtype
= elf_riscv_reloc_type (type
);
1426 rtype
= elf_alpha_reloc_type (type
);
1430 rtype
= elf_arm_reloc_type (type
);
1434 case EM_ARC_COMPACT
:
1435 case EM_ARC_COMPACT2
:
1436 rtype
= elf_arc_reloc_type (type
);
1440 rtype
= elf_hppa_reloc_type (type
);
1446 rtype
= elf_h8_reloc_type (type
);
1450 rtype
= elf_or1k_reloc_type (type
);
1455 rtype
= elf_pj_reloc_type (type
);
1458 rtype
= elf_ia64_reloc_type (type
);
1462 rtype
= elf_cris_reloc_type (type
);
1466 rtype
= elf_i860_reloc_type (type
);
1472 rtype
= elf_x86_64_reloc_type (type
);
1476 rtype
= i370_reloc_type (type
);
1481 rtype
= elf_s390_reloc_type (type
);
1485 rtype
= elf_score_reloc_type (type
);
1489 rtype
= elf_xstormy16_reloc_type (type
);
1493 rtype
= elf_crx_reloc_type (type
);
1497 rtype
= elf_vax_reloc_type (type
);
1501 rtype
= elf_visium_reloc_type (type
);
1505 rtype
= elf_bpf_reloc_type (type
);
1508 case EM_ADAPTEVA_EPIPHANY
:
1509 rtype
= elf_epiphany_reloc_type (type
);
1514 rtype
= elf_ip2k_reloc_type (type
);
1518 rtype
= elf_iq2000_reloc_type (type
);
1523 rtype
= elf_xtensa_reloc_type (type
);
1526 case EM_LATTICEMICO32
:
1527 rtype
= elf_lm32_reloc_type (type
);
1532 rtype
= elf_m32c_reloc_type (type
);
1536 rtype
= elf_mt_reloc_type (type
);
1540 rtype
= elf_bfin_reloc_type (type
);
1544 rtype
= elf_mep_reloc_type (type
);
1548 rtype
= elf_cr16_reloc_type (type
);
1552 case EM_MICROBLAZE_OLD
:
1553 rtype
= elf_microblaze_reloc_type (type
);
1557 rtype
= elf_rl78_reloc_type (type
);
1561 rtype
= elf_rx_reloc_type (type
);
1565 rtype
= elf_metag_reloc_type (type
);
1570 rtype
= elf_xc16x_reloc_type (type
);
1574 rtype
= elf_tic6x_reloc_type (type
);
1578 rtype
= elf_tilegx_reloc_type (type
);
1582 rtype
= elf_tilepro_reloc_type (type
);
1585 case EM_WEBASSEMBLY
:
1586 rtype
= elf_wasm32_reloc_type (type
);
1590 rtype
= elf_xgate_reloc_type (type
);
1593 case EM_ALTERA_NIOS2
:
1594 rtype
= elf_nios2_reloc_type (type
);
1598 rtype
= elf_pru_reloc_type (type
);
1602 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1603 rtype
= elf_nfp3200_reloc_type (type
);
1605 rtype
= elf_nfp_reloc_type (type
);
1609 rtype
= elf_z80_reloc_type (type
);
1614 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1616 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1618 if (filedata
->file_header
.e_machine
== EM_ALPHA
1620 && streq (rtype
, "R_ALPHA_LITUSE")
1623 switch (rels
[i
].r_addend
)
1625 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1626 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1627 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1628 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1629 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1630 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1631 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1632 default: rtype
= NULL
;
1636 printf (" (%s)", rtype
);
1640 printf (_("<unknown addend: %lx>"),
1641 (unsigned long) rels
[i
].r_addend
);
1645 else if (symtab_index
)
1647 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1649 error (_(" bad symbol index: %08lx in reloc\n"),
1650 (unsigned long) symtab_index
);
1655 Elf_Internal_Sym
* psym
;
1656 const char * version_string
;
1657 enum versioned_symbol_info sym_info
;
1658 unsigned short vna_other
;
1660 psym
= symtab
+ symtab_index
;
1663 = get_symbol_version_string (filedata
, is_dynsym
,
1672 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1676 unsigned int width
= is_32bit_elf
? 8 : 14;
1678 /* Relocations against GNU_IFUNC symbols do not use the value
1679 of the symbol as the address to relocate against. Instead
1680 they invoke the function named by the symbol and use its
1681 result as the address for relocation.
1683 To indicate this to the user, do not display the value of
1684 the symbol in the "Symbols's Value" field. Instead show
1685 its name followed by () as a hint that the symbol is
1689 || psym
->st_name
== 0
1690 || psym
->st_name
>= strtablen
)
1693 name
= strtab
+ psym
->st_name
;
1695 len
= print_symbol (width
, name
);
1697 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1699 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1703 print_vma (psym
->st_value
, LONG_HEX
);
1705 printf (is_32bit_elf
? " " : " ");
1708 if (psym
->st_name
== 0)
1710 const char * sec_name
= "<null>";
1713 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1715 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1716 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1717 else if (psym
->st_shndx
== SHN_ABS
)
1719 else if (psym
->st_shndx
== SHN_COMMON
)
1720 sec_name
= "COMMON";
1721 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1722 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1723 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1724 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1725 sec_name
= "SCOMMON";
1726 else if (filedata
->file_header
.e_machine
== EM_MIPS
1727 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1728 sec_name
= "SUNDEF";
1729 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1730 || filedata
->file_header
.e_machine
== EM_L1OM
1731 || filedata
->file_header
.e_machine
== EM_K1OM
)
1732 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1733 sec_name
= "LARGE_COMMON";
1734 else if (filedata
->file_header
.e_machine
== EM_IA_64
1735 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1736 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1737 sec_name
= "ANSI_COM";
1738 else if (is_ia64_vms (filedata
)
1739 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1740 sec_name
= "VMS_SYMVEC";
1743 sprintf (name_buf
, "<section 0x%x>",
1744 (unsigned int) psym
->st_shndx
);
1745 sec_name
= name_buf
;
1748 print_symbol (22, sec_name
);
1750 else if (strtab
== NULL
)
1751 printf (_("<string table index: %3ld>"), psym
->st_name
);
1752 else if (psym
->st_name
>= strtablen
)
1754 error (_("<corrupt string table index: %3ld>\n"),
1760 print_symbol (22, strtab
+ psym
->st_name
);
1762 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1768 bfd_vma off
= rels
[i
].r_addend
;
1770 if ((bfd_signed_vma
) off
< 0)
1771 printf (" - %" BFD_VMA_FMT
"x", - off
);
1773 printf (" + %" BFD_VMA_FMT
"x", off
);
1779 bfd_vma off
= rels
[i
].r_addend
;
1781 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1782 if ((bfd_signed_vma
) off
< 0)
1783 printf ("-%" BFD_VMA_FMT
"x", - off
);
1785 printf ("%" BFD_VMA_FMT
"x", off
);
1788 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1790 && streq (rtype
, "R_SPARC_OLO10"))
1791 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1796 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1798 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1799 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1800 const char * rtype2
= elf_mips_reloc_type (type2
);
1801 const char * rtype3
= elf_mips_reloc_type (type3
);
1803 printf (" Type2: ");
1806 printf (_("unrecognized: %-7lx"),
1807 (unsigned long) type2
& 0xffffffff);
1809 printf ("%-17.17s", rtype2
);
1811 printf ("\n Type3: ");
1814 printf (_("unrecognized: %-7lx"),
1815 (unsigned long) type3
& 0xffffffff);
1817 printf ("%-17.17s", rtype3
);
1830 get_aarch64_dynamic_type (unsigned long type
)
1834 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1835 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1836 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1843 get_mips_dynamic_type (unsigned long type
)
1847 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1848 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1849 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1850 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1851 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1852 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1853 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1854 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1855 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1856 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1857 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1858 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1859 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1860 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1861 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1862 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1863 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1864 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1865 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1866 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1867 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1868 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1869 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1870 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1871 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1872 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1873 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1874 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1875 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1876 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1877 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1878 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1879 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1880 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1881 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1882 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1883 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1884 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1885 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1886 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1887 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1888 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1889 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1890 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1891 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1892 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1893 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1900 get_sparc64_dynamic_type (unsigned long type
)
1904 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1911 get_ppc_dynamic_type (unsigned long type
)
1915 case DT_PPC_GOT
: return "PPC_GOT";
1916 case DT_PPC_OPT
: return "PPC_OPT";
1923 get_ppc64_dynamic_type (unsigned long type
)
1927 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1928 case DT_PPC64_OPD
: return "PPC64_OPD";
1929 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1930 case DT_PPC64_OPT
: return "PPC64_OPT";
1937 get_parisc_dynamic_type (unsigned long type
)
1941 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1942 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1943 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1944 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1945 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1946 case DT_HP_PREINIT
: return "HP_PREINIT";
1947 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1948 case DT_HP_NEEDED
: return "HP_NEEDED";
1949 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1950 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1951 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1952 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1953 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1954 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1955 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1956 case DT_HP_FILTERED
: return "HP_FILTERED";
1957 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1958 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1959 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1960 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1961 case DT_PLT
: return "PLT";
1962 case DT_PLT_SIZE
: return "PLT_SIZE";
1963 case DT_DLT
: return "DLT";
1964 case DT_DLT_SIZE
: return "DLT_SIZE";
1971 get_ia64_dynamic_type (unsigned long type
)
1975 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1976 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1977 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1978 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1979 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1980 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1981 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1982 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1983 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1984 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1985 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1986 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1987 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1988 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1989 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1990 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1991 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1992 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1993 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1994 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1995 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1996 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1997 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1998 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1999 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2000 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2001 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2002 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2003 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2004 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2005 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2012 get_solaris_section_type (unsigned long type
)
2016 case 0x6fffffee: return "SUNW_ancillary";
2017 case 0x6fffffef: return "SUNW_capchain";
2018 case 0x6ffffff0: return "SUNW_capinfo";
2019 case 0x6ffffff1: return "SUNW_symsort";
2020 case 0x6ffffff2: return "SUNW_tlssort";
2021 case 0x6ffffff3: return "SUNW_LDYNSYM";
2022 case 0x6ffffff4: return "SUNW_dof";
2023 case 0x6ffffff5: return "SUNW_cap";
2024 case 0x6ffffff6: return "SUNW_SIGNATURE";
2025 case 0x6ffffff7: return "SUNW_ANNOTATE";
2026 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2027 case 0x6ffffff9: return "SUNW_DEBUG";
2028 case 0x6ffffffa: return "SUNW_move";
2029 case 0x6ffffffb: return "SUNW_COMDAT";
2030 case 0x6ffffffc: return "SUNW_syminfo";
2031 case 0x6ffffffd: return "SUNW_verdef";
2032 case 0x6ffffffe: return "SUNW_verneed";
2033 case 0x6fffffff: return "SUNW_versym";
2034 case 0x70000000: return "SPARC_GOTDATA";
2035 default: return NULL
;
2040 get_alpha_dynamic_type (unsigned long type
)
2044 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2045 default: return NULL
;
2050 get_score_dynamic_type (unsigned long type
)
2054 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2055 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2056 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2057 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2058 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2059 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2060 default: return NULL
;
2065 get_tic6x_dynamic_type (unsigned long type
)
2069 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2070 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2071 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2072 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2073 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2074 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2075 default: return NULL
;
2080 get_nios2_dynamic_type (unsigned long type
)
2084 case DT_NIOS2_GP
: return "NIOS2_GP";
2085 default: return NULL
;
2090 get_solaris_dynamic_type (unsigned long type
)
2094 case 0x6000000d: return "SUNW_AUXILIARY";
2095 case 0x6000000e: return "SUNW_RTLDINF";
2096 case 0x6000000f: return "SUNW_FILTER";
2097 case 0x60000010: return "SUNW_CAP";
2098 case 0x60000011: return "SUNW_SYMTAB";
2099 case 0x60000012: return "SUNW_SYMSZ";
2100 case 0x60000013: return "SUNW_SORTENT";
2101 case 0x60000014: return "SUNW_SYMSORT";
2102 case 0x60000015: return "SUNW_SYMSORTSZ";
2103 case 0x60000016: return "SUNW_TLSSORT";
2104 case 0x60000017: return "SUNW_TLSSORTSZ";
2105 case 0x60000018: return "SUNW_CAPINFO";
2106 case 0x60000019: return "SUNW_STRPAD";
2107 case 0x6000001a: return "SUNW_CAPCHAIN";
2108 case 0x6000001b: return "SUNW_LDMACH";
2109 case 0x6000001d: return "SUNW_CAPCHAINENT";
2110 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2111 case 0x60000021: return "SUNW_PARENT";
2112 case 0x60000023: return "SUNW_ASLR";
2113 case 0x60000025: return "SUNW_RELAX";
2114 case 0x60000029: return "SUNW_NXHEAP";
2115 case 0x6000002b: return "SUNW_NXSTACK";
2117 case 0x70000001: return "SPARC_REGISTER";
2118 case 0x7ffffffd: return "AUXILIARY";
2119 case 0x7ffffffe: return "USED";
2120 case 0x7fffffff: return "FILTER";
2122 default: return NULL
;
2127 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2129 static char buff
[64];
2133 case DT_NULL
: return "NULL";
2134 case DT_NEEDED
: return "NEEDED";
2135 case DT_PLTRELSZ
: return "PLTRELSZ";
2136 case DT_PLTGOT
: return "PLTGOT";
2137 case DT_HASH
: return "HASH";
2138 case DT_STRTAB
: return "STRTAB";
2139 case DT_SYMTAB
: return "SYMTAB";
2140 case DT_RELA
: return "RELA";
2141 case DT_RELASZ
: return "RELASZ";
2142 case DT_RELAENT
: return "RELAENT";
2143 case DT_STRSZ
: return "STRSZ";
2144 case DT_SYMENT
: return "SYMENT";
2145 case DT_INIT
: return "INIT";
2146 case DT_FINI
: return "FINI";
2147 case DT_SONAME
: return "SONAME";
2148 case DT_RPATH
: return "RPATH";
2149 case DT_SYMBOLIC
: return "SYMBOLIC";
2150 case DT_REL
: return "REL";
2151 case DT_RELSZ
: return "RELSZ";
2152 case DT_RELENT
: return "RELENT";
2153 case DT_PLTREL
: return "PLTREL";
2154 case DT_DEBUG
: return "DEBUG";
2155 case DT_TEXTREL
: return "TEXTREL";
2156 case DT_JMPREL
: return "JMPREL";
2157 case DT_BIND_NOW
: return "BIND_NOW";
2158 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2159 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2160 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2161 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2162 case DT_RUNPATH
: return "RUNPATH";
2163 case DT_FLAGS
: return "FLAGS";
2165 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2166 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2167 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2169 case DT_CHECKSUM
: return "CHECKSUM";
2170 case DT_PLTPADSZ
: return "PLTPADSZ";
2171 case DT_MOVEENT
: return "MOVEENT";
2172 case DT_MOVESZ
: return "MOVESZ";
2173 case DT_FEATURE
: return "FEATURE";
2174 case DT_POSFLAG_1
: return "POSFLAG_1";
2175 case DT_SYMINSZ
: return "SYMINSZ";
2176 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2178 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2179 case DT_CONFIG
: return "CONFIG";
2180 case DT_DEPAUDIT
: return "DEPAUDIT";
2181 case DT_AUDIT
: return "AUDIT";
2182 case DT_PLTPAD
: return "PLTPAD";
2183 case DT_MOVETAB
: return "MOVETAB";
2184 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2186 case DT_VERSYM
: return "VERSYM";
2188 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2189 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2190 case DT_RELACOUNT
: return "RELACOUNT";
2191 case DT_RELCOUNT
: return "RELCOUNT";
2192 case DT_FLAGS_1
: return "FLAGS_1";
2193 case DT_VERDEF
: return "VERDEF";
2194 case DT_VERDEFNUM
: return "VERDEFNUM";
2195 case DT_VERNEED
: return "VERNEED";
2196 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2198 case DT_AUXILIARY
: return "AUXILIARY";
2199 case DT_USED
: return "USED";
2200 case DT_FILTER
: return "FILTER";
2202 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2203 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2204 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2205 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2206 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2207 case DT_GNU_HASH
: return "GNU_HASH";
2210 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2212 const char * result
;
2214 switch (filedata
->file_header
.e_machine
)
2217 result
= get_aarch64_dynamic_type (type
);
2220 case EM_MIPS_RS3_LE
:
2221 result
= get_mips_dynamic_type (type
);
2224 result
= get_sparc64_dynamic_type (type
);
2227 result
= get_ppc_dynamic_type (type
);
2230 result
= get_ppc64_dynamic_type (type
);
2233 result
= get_ia64_dynamic_type (type
);
2236 result
= get_alpha_dynamic_type (type
);
2239 result
= get_score_dynamic_type (type
);
2242 result
= get_tic6x_dynamic_type (type
);
2244 case EM_ALTERA_NIOS2
:
2245 result
= get_nios2_dynamic_type (type
);
2248 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2249 result
= get_solaris_dynamic_type (type
);
2258 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2260 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2261 || (filedata
->file_header
.e_machine
== EM_PARISC
2262 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2264 const char * result
;
2266 switch (filedata
->file_header
.e_machine
)
2269 result
= get_parisc_dynamic_type (type
);
2272 result
= get_ia64_dynamic_type (type
);
2275 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2276 result
= get_solaris_dynamic_type (type
);
2285 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2289 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2296 get_file_type (unsigned e_type
)
2298 static char buff
[64];
2302 case ET_NONE
: return _("NONE (None)");
2303 case ET_REL
: return _("REL (Relocatable file)");
2304 case ET_EXEC
: return _("EXEC (Executable file)");
2305 case ET_DYN
: return _("DYN (Shared object file)");
2306 case ET_CORE
: return _("CORE (Core file)");
2309 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2310 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2311 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2312 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2314 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2320 get_machine_name (unsigned e_machine
)
2322 static char buff
[64]; /* XXX */
2326 /* Please keep this switch table sorted by increasing EM_ value. */
2328 case EM_NONE
: return _("None");
2329 case EM_M32
: return "WE32100";
2330 case EM_SPARC
: return "Sparc";
2331 case EM_386
: return "Intel 80386";
2332 case EM_68K
: return "MC68000";
2333 case EM_88K
: return "MC88000";
2334 case EM_IAMCU
: return "Intel MCU";
2335 case EM_860
: return "Intel 80860";
2336 case EM_MIPS
: return "MIPS R3000";
2337 case EM_S370
: return "IBM System/370";
2339 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2340 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2341 case EM_PARISC
: return "HPPA";
2342 case EM_VPP550
: return "Fujitsu VPP500";
2343 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2344 case EM_960
: return "Intel 80960";
2345 case EM_PPC
: return "PowerPC";
2347 case EM_PPC64
: return "PowerPC64";
2349 case EM_S390
: return "IBM S/390";
2350 case EM_SPU
: return "SPU";
2352 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2353 case EM_FR20
: return "Fujitsu FR20";
2354 case EM_RH32
: return "TRW RH32";
2355 case EM_MCORE
: return "MCORE";
2357 case EM_ARM
: return "ARM";
2358 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2359 case EM_SH
: return "Renesas / SuperH SH";
2360 case EM_SPARCV9
: return "Sparc v9";
2361 case EM_TRICORE
: return "Siemens Tricore";
2362 case EM_ARC
: return "ARC";
2363 case EM_H8_300
: return "Renesas H8/300";
2364 case EM_H8_300H
: return "Renesas H8/300H";
2365 case EM_H8S
: return "Renesas H8S";
2366 case EM_H8_500
: return "Renesas H8/500";
2368 case EM_IA_64
: return "Intel IA-64";
2369 case EM_MIPS_X
: return "Stanford MIPS-X";
2370 case EM_COLDFIRE
: return "Motorola Coldfire";
2371 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2372 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2373 case EM_PCP
: return "Siemens PCP";
2374 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2375 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2376 case EM_STARCORE
: return "Motorola Star*Core processor";
2377 case EM_ME16
: return "Toyota ME16 processor";
2379 case EM_ST100
: return "STMicroelectronics ST100 processor";
2380 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2381 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2382 case EM_PDSP
: return "Sony DSP processor";
2383 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2384 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2385 case EM_FX66
: return "Siemens FX66 microcontroller";
2386 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2387 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2388 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2390 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2391 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2392 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2393 case EM_SVX
: return "Silicon Graphics SVx";
2394 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2395 case EM_VAX
: return "Digital VAX";
2396 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2397 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2398 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2399 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2401 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2402 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2403 case EM_PRISM
: return "Vitesse Prism";
2405 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2406 case EM_CYGNUS_FR30
:
2407 case EM_FR30
: return "Fujitsu FR30";
2408 case EM_CYGNUS_D10V
:
2409 case EM_D10V
: return "d10v";
2410 case EM_CYGNUS_D30V
:
2411 case EM_D30V
: return "d30v";
2412 case EM_CYGNUS_V850
:
2413 case EM_V850
: return "Renesas V850";
2414 case EM_CYGNUS_M32R
:
2415 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2416 case EM_CYGNUS_MN10300
:
2417 case EM_MN10300
: return "mn10300";
2419 case EM_CYGNUS_MN10200
:
2420 case EM_MN10200
: return "mn10200";
2421 case EM_PJ
: return "picoJava";
2422 case EM_OR1K
: return "OpenRISC 1000";
2423 case EM_ARC_COMPACT
: return "ARCompact";
2425 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2426 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2427 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2428 case EM_NS32K
: return "National Semiconductor 32000 series";
2429 case EM_TPC
: return "Tenor Network TPC processor";
2430 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2432 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2434 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2435 case EM_MAX
: return "MAX Processor";
2436 case EM_CR
: return "National Semiconductor CompactRISC";
2437 case EM_F2MC16
: return "Fujitsu F2MC16";
2438 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2439 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2440 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2441 case EM_SEP
: return "Sharp embedded microprocessor";
2442 case EM_ARCA
: return "Arca RISC microprocessor";
2444 case EM_UNICORE
: return "Unicore";
2445 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2446 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2447 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2448 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2449 case EM_XGATE
: return "Motorola XGATE embedded processor";
2451 case EM_XC16X
: return "Infineon Technologies xc16x";
2452 case EM_M16C
: return "Renesas M16C series microprocessors";
2453 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2454 case EM_CE
: return "Freescale Communication Engine RISC core";
2456 case EM_M32C
: return "Renesas M32c";
2458 case EM_TSK3000
: return "Altium TSK3000 core";
2459 case EM_RS08
: return "Freescale RS08 embedded processor";
2460 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2461 case EM_SCORE
: return "SUNPLUS S+Core";
2462 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2463 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2464 case EM_LATTICEMICO32
: return "Lattice Mico32";
2465 case EM_SE_C17
: return "Seiko Epson C17 family";
2467 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2468 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2469 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2470 case EM_TI_PRU
: return "TI PRU I/O processor";
2472 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2473 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2474 case EM_R32C
: return "Renesas R32C series microprocessors";
2475 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2476 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2477 case EM_8051
: return "Intel 8051 and variants";
2478 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2479 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2480 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2481 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2483 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2484 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2485 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2486 case EM_RX
: return "Renesas RX";
2487 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2488 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2489 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2492 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2493 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2494 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2496 case EM_L1OM
: return "Intel L1OM";
2497 case EM_K1OM
: return "Intel K1OM";
2498 case EM_INTEL182
: return "Intel (reserved)";
2499 case EM_AARCH64
: return "AArch64";
2500 case EM_ARM184
: return "ARM (reserved)";
2501 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2502 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2503 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2504 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2506 case EM_CUDA
: return "NVIDIA CUDA architecture";
2507 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2508 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2509 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2510 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2511 case EM_ARC_COMPACT2
: return "ARCv2";
2512 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2513 case EM_RL78
: return "Renesas RL78";
2514 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2515 case EM_78K0R
: return "Renesas 78K0R";
2517 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2518 case EM_BA1
: return "Beyond BA1 CPU architecture";
2519 case EM_BA2
: return "Beyond BA2 CPU architecture";
2520 case EM_XCORE
: return "XMOS xCORE processor family";
2521 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2523 case EM_KM32
: return "KM211 KM32 32-bit processor";
2524 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2525 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2526 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2527 case EM_KVARC
: return "KM211 KVARC processor";
2528 case EM_CDP
: return "Paneve CDP architecture family";
2529 case EM_COGE
: return "Cognitive Smart Memory Processor";
2530 case EM_COOL
: return "Bluechip Systems CoolEngine";
2531 case EM_NORC
: return "Nanoradio Optimized RISC";
2532 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2534 case EM_Z80
: return "Zilog Z80";
2535 case EM_VISIUM
: return "CDS VISIUMcore processor";
2536 case EM_FT32
: return "FTDI Chip FT32";
2537 case EM_MOXIE
: return "Moxie";
2538 case EM_AMDGPU
: return "AMD GPU";
2539 case EM_RISCV
: return "RISC-V";
2540 case EM_LANAI
: return "Lanai 32-bit processor";
2541 case EM_BPF
: return "Linux BPF";
2542 case EM_NFP
: return "Netronome Flow Processor";
2544 /* Large numbers... */
2545 case EM_MT
: return "Morpho Techologies MT processor";
2546 case EM_ALPHA
: return "Alpha";
2547 case EM_WEBASSEMBLY
: return "Web Assembly";
2548 case EM_DLX
: return "OpenDLX";
2549 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2550 case EM_IQ2000
: return "Vitesse IQ2000";
2552 case EM_NIOS32
: return "Altera Nios";
2553 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2554 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2555 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2556 case EM_S12Z
: return "Freescale S12Z";
2557 case EM_CSKY
: return "C-SKY";
2560 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2566 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2568 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2569 other compilers don't a specific architecture type in the e_flags, and
2570 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2571 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2574 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2575 but also sets a specific architecture type in the e_flags field.
2577 However, when decoding the flags we don't worry if we see an
2578 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2579 ARCEM architecture type. */
2581 switch (e_flags
& EF_ARC_MACH_MSK
)
2583 /* We only expect these to occur for EM_ARC_COMPACT2. */
2584 case EF_ARC_CPU_ARCV2EM
:
2585 strcat (buf
, ", ARC EM");
2587 case EF_ARC_CPU_ARCV2HS
:
2588 strcat (buf
, ", ARC HS");
2591 /* We only expect these to occur for EM_ARC_COMPACT. */
2592 case E_ARC_MACH_ARC600
:
2593 strcat (buf
, ", ARC600");
2595 case E_ARC_MACH_ARC601
:
2596 strcat (buf
, ", ARC601");
2598 case E_ARC_MACH_ARC700
:
2599 strcat (buf
, ", ARC700");
2602 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2603 new ELF with new architecture being read by an old version of
2604 readelf, or (c) An ELF built with non-GNU compiler that does not
2605 set the architecture in the e_flags. */
2607 if (e_machine
== EM_ARC_COMPACT
)
2608 strcat (buf
, ", Unknown ARCompact");
2610 strcat (buf
, ", Unknown ARC");
2614 switch (e_flags
& EF_ARC_OSABI_MSK
)
2616 case E_ARC_OSABI_ORIG
:
2617 strcat (buf
, ", (ABI:legacy)");
2619 case E_ARC_OSABI_V2
:
2620 strcat (buf
, ", (ABI:v2)");
2622 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2623 case E_ARC_OSABI_V3
:
2624 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2626 case E_ARC_OSABI_V4
:
2627 strcat (buf
, ", v4 ABI");
2630 strcat (buf
, ", unrecognised ARC OSABI flag");
2636 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2639 bfd_boolean unknown
= FALSE
;
2641 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2642 e_flags
&= ~ EF_ARM_EABIMASK
;
2644 /* Handle "generic" ARM flags. */
2645 if (e_flags
& EF_ARM_RELEXEC
)
2647 strcat (buf
, ", relocatable executable");
2648 e_flags
&= ~ EF_ARM_RELEXEC
;
2651 if (e_flags
& EF_ARM_PIC
)
2653 strcat (buf
, ", position independent");
2654 e_flags
&= ~ EF_ARM_PIC
;
2657 /* Now handle EABI specific flags. */
2661 strcat (buf
, ", <unrecognized EABI>");
2666 case EF_ARM_EABI_VER1
:
2667 strcat (buf
, ", Version1 EABI");
2672 /* Process flags one bit at a time. */
2673 flag
= e_flags
& - e_flags
;
2678 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2679 strcat (buf
, ", sorted symbol tables");
2689 case EF_ARM_EABI_VER2
:
2690 strcat (buf
, ", Version2 EABI");
2695 /* Process flags one bit at a time. */
2696 flag
= e_flags
& - e_flags
;
2701 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2702 strcat (buf
, ", sorted symbol tables");
2705 case EF_ARM_DYNSYMSUSESEGIDX
:
2706 strcat (buf
, ", dynamic symbols use segment index");
2709 case EF_ARM_MAPSYMSFIRST
:
2710 strcat (buf
, ", mapping symbols precede others");
2720 case EF_ARM_EABI_VER3
:
2721 strcat (buf
, ", Version3 EABI");
2724 case EF_ARM_EABI_VER4
:
2725 strcat (buf
, ", Version4 EABI");
2730 /* Process flags one bit at a time. */
2731 flag
= e_flags
& - e_flags
;
2737 strcat (buf
, ", BE8");
2741 strcat (buf
, ", LE8");
2751 case EF_ARM_EABI_VER5
:
2752 strcat (buf
, ", Version5 EABI");
2757 /* Process flags one bit at a time. */
2758 flag
= e_flags
& - e_flags
;
2764 strcat (buf
, ", BE8");
2768 strcat (buf
, ", LE8");
2771 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2772 strcat (buf
, ", soft-float ABI");
2775 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2776 strcat (buf
, ", hard-float ABI");
2786 case EF_ARM_EABI_UNKNOWN
:
2787 strcat (buf
, ", GNU EABI");
2792 /* Process flags one bit at a time. */
2793 flag
= e_flags
& - e_flags
;
2798 case EF_ARM_INTERWORK
:
2799 strcat (buf
, ", interworking enabled");
2802 case EF_ARM_APCS_26
:
2803 strcat (buf
, ", uses APCS/26");
2806 case EF_ARM_APCS_FLOAT
:
2807 strcat (buf
, ", uses APCS/float");
2811 strcat (buf
, ", position independent");
2815 strcat (buf
, ", 8 bit structure alignment");
2818 case EF_ARM_NEW_ABI
:
2819 strcat (buf
, ", uses new ABI");
2822 case EF_ARM_OLD_ABI
:
2823 strcat (buf
, ", uses old ABI");
2826 case EF_ARM_SOFT_FLOAT
:
2827 strcat (buf
, ", software FP");
2830 case EF_ARM_VFP_FLOAT
:
2831 strcat (buf
, ", VFP");
2834 case EF_ARM_MAVERICK_FLOAT
:
2835 strcat (buf
, ", Maverick FP");
2846 strcat (buf
,_(", <unknown>"));
2850 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2852 --size
; /* Leave space for null terminator. */
2854 switch (e_flags
& EF_AVR_MACH
)
2856 case E_AVR_MACH_AVR1
:
2857 strncat (buf
, ", avr:1", size
);
2859 case E_AVR_MACH_AVR2
:
2860 strncat (buf
, ", avr:2", size
);
2862 case E_AVR_MACH_AVR25
:
2863 strncat (buf
, ", avr:25", size
);
2865 case E_AVR_MACH_AVR3
:
2866 strncat (buf
, ", avr:3", size
);
2868 case E_AVR_MACH_AVR31
:
2869 strncat (buf
, ", avr:31", size
);
2871 case E_AVR_MACH_AVR35
:
2872 strncat (buf
, ", avr:35", size
);
2874 case E_AVR_MACH_AVR4
:
2875 strncat (buf
, ", avr:4", size
);
2877 case E_AVR_MACH_AVR5
:
2878 strncat (buf
, ", avr:5", size
);
2880 case E_AVR_MACH_AVR51
:
2881 strncat (buf
, ", avr:51", size
);
2883 case E_AVR_MACH_AVR6
:
2884 strncat (buf
, ", avr:6", size
);
2886 case E_AVR_MACH_AVRTINY
:
2887 strncat (buf
, ", avr:100", size
);
2889 case E_AVR_MACH_XMEGA1
:
2890 strncat (buf
, ", avr:101", size
);
2892 case E_AVR_MACH_XMEGA2
:
2893 strncat (buf
, ", avr:102", size
);
2895 case E_AVR_MACH_XMEGA3
:
2896 strncat (buf
, ", avr:103", size
);
2898 case E_AVR_MACH_XMEGA4
:
2899 strncat (buf
, ", avr:104", size
);
2901 case E_AVR_MACH_XMEGA5
:
2902 strncat (buf
, ", avr:105", size
);
2904 case E_AVR_MACH_XMEGA6
:
2905 strncat (buf
, ", avr:106", size
);
2907 case E_AVR_MACH_XMEGA7
:
2908 strncat (buf
, ", avr:107", size
);
2911 strncat (buf
, ", avr:<unknown>", size
);
2915 size
-= strlen (buf
);
2916 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2917 strncat (buf
, ", link-relax", size
);
2921 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2927 bfd_boolean has_fpu
= FALSE
;
2930 static const char *ABI_STRINGS
[] =
2932 "ABI v0", /* use r5 as return register; only used in N1213HC */
2933 "ABI v1", /* use r0 as return register */
2934 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2935 "ABI v2fp", /* for FPU */
2939 static const char *VER_STRINGS
[] =
2941 "Andes ELF V1.3 or older",
2945 static const char *ARCH_STRINGS
[] =
2954 abi
= EF_NDS_ABI
& e_flags
;
2955 arch
= EF_NDS_ARCH
& e_flags
;
2956 config
= EF_NDS_INST
& e_flags
;
2957 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2959 memset (buf
, 0, size
);
2966 case E_NDS_ABI_V2FP
:
2967 case E_NDS_ABI_AABI
:
2968 case E_NDS_ABI_V2FP_PLUS
:
2969 /* In case there are holes in the array. */
2970 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2974 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2980 case E_NDS32_ELF_VER_1_2
:
2981 case E_NDS32_ELF_VER_1_3
:
2982 case E_NDS32_ELF_VER_1_4
:
2983 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2987 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2991 if (E_NDS_ABI_V0
== abi
)
2993 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2994 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2995 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2996 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3002 case E_NDS_ARCH_STAR_V1_0
:
3003 case E_NDS_ARCH_STAR_V2_0
:
3004 case E_NDS_ARCH_STAR_V3_0
:
3005 case E_NDS_ARCH_STAR_V3_M
:
3006 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3010 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3011 /* ARCH version determines how the e_flags are interpreted.
3012 If it is unknown, we cannot proceed. */
3016 /* Newer ABI; Now handle architecture specific flags. */
3017 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3019 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3020 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3022 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3023 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3025 if (config
& E_NDS32_HAS_DIV_INST
)
3026 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3028 if (config
& E_NDS32_HAS_16BIT_INST
)
3029 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3033 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3035 if (version
<= E_NDS32_ELF_VER_1_3
)
3036 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3038 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3041 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3042 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3044 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3045 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3047 if (config
& E_NDS32_HAS_16BIT_INST
)
3049 if (version
<= E_NDS32_ELF_VER_1_3
)
3050 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3052 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3056 if (config
& E_NDS32_HAS_EXT_INST
)
3057 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3059 if (config
& E_NDS32_HAS_EXT2_INST
)
3060 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3062 if (config
& E_NDS32_HAS_FPU_INST
)
3065 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3068 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3071 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3074 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3077 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3082 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3084 case E_NDS32_FPU_REG_8SP_4DP
:
3085 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3087 case E_NDS32_FPU_REG_16SP_8DP
:
3088 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3090 case E_NDS32_FPU_REG_32SP_16DP
:
3091 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3093 case E_NDS32_FPU_REG_32SP_32DP
:
3094 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3099 if (config
& E_NDS32_HAS_AUDIO_INST
)
3100 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3102 if (config
& E_NDS32_HAS_STRING_INST
)
3103 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3105 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3106 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3108 if (config
& E_NDS32_HAS_VIDEO_INST
)
3110 if (version
<= E_NDS32_ELF_VER_1_3
)
3111 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3113 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3116 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3117 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3119 if (config
& E_NDS32_HAS_L2C_INST
)
3120 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3124 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3126 static char buf
[1024];
3137 case EM_ARC_COMPACT2
:
3138 case EM_ARC_COMPACT
:
3139 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3143 decode_ARM_machine_flags (e_flags
, buf
);
3147 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3151 if (e_flags
& EF_BFIN_PIC
)
3152 strcat (buf
, ", PIC");
3154 if (e_flags
& EF_BFIN_FDPIC
)
3155 strcat (buf
, ", FDPIC");
3157 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3158 strcat (buf
, ", code in L1");
3160 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3161 strcat (buf
, ", data in L1");
3166 switch (e_flags
& EF_FRV_CPU_MASK
)
3168 case EF_FRV_CPU_GENERIC
:
3172 strcat (buf
, ", fr???");
3175 case EF_FRV_CPU_FR300
:
3176 strcat (buf
, ", fr300");
3179 case EF_FRV_CPU_FR400
:
3180 strcat (buf
, ", fr400");
3182 case EF_FRV_CPU_FR405
:
3183 strcat (buf
, ", fr405");
3186 case EF_FRV_CPU_FR450
:
3187 strcat (buf
, ", fr450");
3190 case EF_FRV_CPU_FR500
:
3191 strcat (buf
, ", fr500");
3193 case EF_FRV_CPU_FR550
:
3194 strcat (buf
, ", fr550");
3197 case EF_FRV_CPU_SIMPLE
:
3198 strcat (buf
, ", simple");
3200 case EF_FRV_CPU_TOMCAT
:
3201 strcat (buf
, ", tomcat");
3207 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3208 strcat (buf
, ", m68000");
3209 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3210 strcat (buf
, ", cpu32");
3211 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3212 strcat (buf
, ", fido_a");
3215 char const * isa
= _("unknown");
3216 char const * mac
= _("unknown mac");
3217 char const * additional
= NULL
;
3219 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3221 case EF_M68K_CF_ISA_A_NODIV
:
3223 additional
= ", nodiv";
3225 case EF_M68K_CF_ISA_A
:
3228 case EF_M68K_CF_ISA_A_PLUS
:
3231 case EF_M68K_CF_ISA_B_NOUSP
:
3233 additional
= ", nousp";
3235 case EF_M68K_CF_ISA_B
:
3238 case EF_M68K_CF_ISA_C
:
3241 case EF_M68K_CF_ISA_C_NODIV
:
3243 additional
= ", nodiv";
3246 strcat (buf
, ", cf, isa ");
3249 strcat (buf
, additional
);
3250 if (e_flags
& EF_M68K_CF_FLOAT
)
3251 strcat (buf
, ", float");
3252 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3257 case EF_M68K_CF_MAC
:
3260 case EF_M68K_CF_EMAC
:
3263 case EF_M68K_CF_EMAC_B
:
3276 switch (e_flags
& EF_MEP_CPU_MASK
)
3278 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3279 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3280 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3281 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3282 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3283 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3284 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3287 switch (e_flags
& EF_MEP_COP_MASK
)
3289 case EF_MEP_COP_NONE
: break;
3290 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3291 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3292 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3293 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3294 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3297 if (e_flags
& EF_MEP_LIBRARY
)
3298 strcat (buf
, ", Built for Library");
3300 if (e_flags
& EF_MEP_INDEX_MASK
)
3301 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3302 e_flags
& EF_MEP_INDEX_MASK
);
3304 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3305 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3306 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3310 if (e_flags
& EF_PPC_EMB
)
3311 strcat (buf
, ", emb");
3313 if (e_flags
& EF_PPC_RELOCATABLE
)
3314 strcat (buf
, _(", relocatable"));
3316 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3317 strcat (buf
, _(", relocatable-lib"));
3321 if (e_flags
& EF_PPC64_ABI
)
3323 char abi
[] = ", abiv0";
3325 abi
[6] += e_flags
& EF_PPC64_ABI
;
3331 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3332 strcat (buf
, ", RH850 ABI");
3334 if (e_flags
& EF_V800_850E3
)
3335 strcat (buf
, ", V3 architecture");
3337 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3338 strcat (buf
, ", FPU not used");
3340 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3341 strcat (buf
, ", regmode: COMMON");
3343 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3344 strcat (buf
, ", r4 not used");
3346 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3347 strcat (buf
, ", r30 not used");
3349 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3350 strcat (buf
, ", r5 not used");
3352 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3353 strcat (buf
, ", r2 not used");
3355 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3357 switch (e_flags
& - e_flags
)
3359 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3360 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3361 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3362 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3363 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3364 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3365 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3366 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3367 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3368 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3369 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3370 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3377 case EM_CYGNUS_V850
:
3378 switch (e_flags
& EF_V850_ARCH
)
3380 case E_V850E3V5_ARCH
:
3381 strcat (buf
, ", v850e3v5");
3383 case E_V850E2V3_ARCH
:
3384 strcat (buf
, ", v850e2v3");
3387 strcat (buf
, ", v850e2");
3390 strcat (buf
, ", v850e1");
3393 strcat (buf
, ", v850e");
3396 strcat (buf
, ", v850");
3399 strcat (buf
, _(", unknown v850 architecture variant"));
3405 case EM_CYGNUS_M32R
:
3406 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3407 strcat (buf
, ", m32r");
3411 case EM_MIPS_RS3_LE
:
3412 if (e_flags
& EF_MIPS_NOREORDER
)
3413 strcat (buf
, ", noreorder");
3415 if (e_flags
& EF_MIPS_PIC
)
3416 strcat (buf
, ", pic");
3418 if (e_flags
& EF_MIPS_CPIC
)
3419 strcat (buf
, ", cpic");
3421 if (e_flags
& EF_MIPS_UCODE
)
3422 strcat (buf
, ", ugen_reserved");
3424 if (e_flags
& EF_MIPS_ABI2
)
3425 strcat (buf
, ", abi2");
3427 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3428 strcat (buf
, ", odk first");
3430 if (e_flags
& EF_MIPS_32BITMODE
)
3431 strcat (buf
, ", 32bitmode");
3433 if (e_flags
& EF_MIPS_NAN2008
)
3434 strcat (buf
, ", nan2008");
3436 if (e_flags
& EF_MIPS_FP64
)
3437 strcat (buf
, ", fp64");
3439 switch ((e_flags
& EF_MIPS_MACH
))
3441 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3442 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3443 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3444 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3445 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3446 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3447 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3448 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3449 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3450 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3451 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3452 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3453 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3454 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3455 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3456 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3457 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3458 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3459 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3460 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3461 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3463 /* We simply ignore the field in this case to avoid confusion:
3464 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3467 default: strcat (buf
, _(", unknown CPU")); break;
3470 switch ((e_flags
& EF_MIPS_ABI
))
3472 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3473 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3474 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3475 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3477 /* We simply ignore the field in this case to avoid confusion:
3478 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3479 This means it is likely to be an o32 file, but not for
3482 default: strcat (buf
, _(", unknown ABI")); break;
3485 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3486 strcat (buf
, ", mdmx");
3488 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3489 strcat (buf
, ", mips16");
3491 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3492 strcat (buf
, ", micromips");
3494 switch ((e_flags
& EF_MIPS_ARCH
))
3496 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3497 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3498 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3499 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3500 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3501 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3502 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3503 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3504 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3505 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3506 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3507 default: strcat (buf
, _(", unknown ISA")); break;
3512 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3516 switch (EF_NFP_MACH (e_flags
))
3518 case E_NFP_MACH_3200
:
3519 strcat (buf
, ", NFP-32xx");
3521 case E_NFP_MACH_6000
:
3522 strcat (buf
, ", NFP-6xxx");
3528 if (e_flags
& EF_RISCV_RVC
)
3529 strcat (buf
, ", RVC");
3531 if (e_flags
& EF_RISCV_RVE
)
3532 strcat (buf
, ", RVE");
3534 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3536 case EF_RISCV_FLOAT_ABI_SOFT
:
3537 strcat (buf
, ", soft-float ABI");
3540 case EF_RISCV_FLOAT_ABI_SINGLE
:
3541 strcat (buf
, ", single-float ABI");
3544 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3545 strcat (buf
, ", double-float ABI");
3548 case EF_RISCV_FLOAT_ABI_QUAD
:
3549 strcat (buf
, ", quad-float ABI");
3555 switch ((e_flags
& EF_SH_MACH_MASK
))
3557 case EF_SH1
: strcat (buf
, ", sh1"); break;
3558 case EF_SH2
: strcat (buf
, ", sh2"); break;
3559 case EF_SH3
: strcat (buf
, ", sh3"); break;
3560 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3561 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3562 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3563 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3564 case EF_SH4
: strcat (buf
, ", sh4"); break;
3565 case EF_SH5
: strcat (buf
, ", sh5"); break;
3566 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3567 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3568 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3569 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3570 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3571 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3572 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3573 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3574 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3575 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3576 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3577 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3578 default: strcat (buf
, _(", unknown ISA")); break;
3581 if (e_flags
& EF_SH_PIC
)
3582 strcat (buf
, ", pic");
3584 if (e_flags
& EF_SH_FDPIC
)
3585 strcat (buf
, ", fdpic");
3589 if (e_flags
& EF_OR1K_NODELAY
)
3590 strcat (buf
, ", no delay");
3594 if (e_flags
& EF_SPARC_32PLUS
)
3595 strcat (buf
, ", v8+");
3597 if (e_flags
& EF_SPARC_SUN_US1
)
3598 strcat (buf
, ", ultrasparcI");
3600 if (e_flags
& EF_SPARC_SUN_US3
)
3601 strcat (buf
, ", ultrasparcIII");
3603 if (e_flags
& EF_SPARC_HAL_R1
)
3604 strcat (buf
, ", halr1");
3606 if (e_flags
& EF_SPARC_LEDATA
)
3607 strcat (buf
, ", ledata");
3609 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3610 strcat (buf
, ", tso");
3612 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3613 strcat (buf
, ", pso");
3615 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3616 strcat (buf
, ", rmo");
3620 switch (e_flags
& EF_PARISC_ARCH
)
3622 case EFA_PARISC_1_0
:
3623 strcpy (buf
, ", PA-RISC 1.0");
3625 case EFA_PARISC_1_1
:
3626 strcpy (buf
, ", PA-RISC 1.1");
3628 case EFA_PARISC_2_0
:
3629 strcpy (buf
, ", PA-RISC 2.0");
3634 if (e_flags
& EF_PARISC_TRAPNIL
)
3635 strcat (buf
, ", trapnil");
3636 if (e_flags
& EF_PARISC_EXT
)
3637 strcat (buf
, ", ext");
3638 if (e_flags
& EF_PARISC_LSB
)
3639 strcat (buf
, ", lsb");
3640 if (e_flags
& EF_PARISC_WIDE
)
3641 strcat (buf
, ", wide");
3642 if (e_flags
& EF_PARISC_NO_KABP
)
3643 strcat (buf
, ", no kabp");
3644 if (e_flags
& EF_PARISC_LAZYSWAP
)
3645 strcat (buf
, ", lazyswap");
3650 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3651 strcat (buf
, ", new calling convention");
3653 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3654 strcat (buf
, ", gnu calling convention");
3658 if ((e_flags
& EF_IA_64_ABI64
))
3659 strcat (buf
, ", 64-bit");
3661 strcat (buf
, ", 32-bit");
3662 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3663 strcat (buf
, ", reduced fp model");
3664 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3665 strcat (buf
, ", no function descriptors, constant gp");
3666 else if ((e_flags
& EF_IA_64_CONS_GP
))
3667 strcat (buf
, ", constant gp");
3668 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3669 strcat (buf
, ", absolute");
3670 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3672 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3673 strcat (buf
, ", vms_linkages");
3674 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3676 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3678 case EF_IA_64_VMS_COMCOD_WARNING
:
3679 strcat (buf
, ", warning");
3681 case EF_IA_64_VMS_COMCOD_ERROR
:
3682 strcat (buf
, ", error");
3684 case EF_IA_64_VMS_COMCOD_ABORT
:
3685 strcat (buf
, ", abort");
3688 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3689 e_flags
& EF_IA_64_VMS_COMCOD
);
3690 strcat (buf
, ", <unknown>");
3696 if ((e_flags
& EF_VAX_NONPIC
))
3697 strcat (buf
, ", non-PIC");
3698 if ((e_flags
& EF_VAX_DFLOAT
))
3699 strcat (buf
, ", D-Float");
3700 if ((e_flags
& EF_VAX_GFLOAT
))
3701 strcat (buf
, ", G-Float");
3705 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3706 strcat (buf
, ", mcm");
3707 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3708 strcat (buf
, ", mcm24");
3709 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3710 strcat (buf
, ", gr6");
3714 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3716 case E_FLAG_RL78_ANY_CPU
: break;
3717 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3718 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3719 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3721 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3722 strcat (buf
, ", 64-bit doubles");
3726 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3727 strcat (buf
, ", 64-bit doubles");
3728 if (e_flags
& E_FLAG_RX_DSP
)
3729 strcat (buf
, ", dsp");
3730 if (e_flags
& E_FLAG_RX_PID
)
3731 strcat (buf
, ", pid");
3732 if (e_flags
& E_FLAG_RX_ABI
)
3733 strcat (buf
, ", RX ABI");
3734 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3735 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3736 ? ", uses String instructions" : ", bans String instructions");
3737 if (e_flags
& E_FLAG_RX_V2
)
3738 strcat (buf
, ", V2");
3739 if (e_flags
& E_FLAG_RX_V3
)
3740 strcat (buf
, ", V3");
3744 if (e_flags
& EF_S390_HIGH_GPRS
)
3745 strcat (buf
, ", highgprs");
3749 if ((e_flags
& EF_C6000_REL
))
3750 strcat (buf
, ", relocatable module");
3754 strcat (buf
, _(": architecture variant: "));
3755 switch (e_flags
& EF_MSP430_MACH
)
3757 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3758 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3759 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3760 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3761 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3762 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3763 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3764 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3765 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3766 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3767 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3768 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3769 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3770 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3771 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3773 strcat (buf
, _(": unknown")); break;
3776 if (e_flags
& ~ EF_MSP430_MACH
)
3777 strcat (buf
, _(": unknown extra flag bits also present"));
3781 switch (e_flags
& EF_Z80_MACH_MSK
)
3783 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3784 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3785 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3786 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3787 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3788 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3789 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3791 strcat (buf
, _(", unknown")); break;
3801 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3803 static char buff
[32];
3807 case ELFOSABI_NONE
: return "UNIX - System V";
3808 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3809 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3810 case ELFOSABI_GNU
: return "UNIX - GNU";
3811 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3812 case ELFOSABI_AIX
: return "UNIX - AIX";
3813 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3814 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3815 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3816 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3817 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3818 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3819 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3820 case ELFOSABI_AROS
: return "AROS";
3821 case ELFOSABI_FENIXOS
: return "FenixOS";
3822 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3823 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3826 switch (filedata
->file_header
.e_machine
)
3831 case ELFOSABI_ARM
: return "ARM";
3832 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3843 case ELFOSABI_STANDALONE
: return _("Standalone App");
3852 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3853 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3862 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3868 get_aarch64_segment_type (unsigned long type
)
3872 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3873 default: return NULL
;
3878 get_arm_segment_type (unsigned long type
)
3882 case PT_ARM_EXIDX
: return "EXIDX";
3883 default: return NULL
;
3888 get_s390_segment_type (unsigned long type
)
3892 case PT_S390_PGSTE
: return "S390_PGSTE";
3893 default: return NULL
;
3898 get_mips_segment_type (unsigned long type
)
3902 case PT_MIPS_REGINFO
: return "REGINFO";
3903 case PT_MIPS_RTPROC
: return "RTPROC";
3904 case PT_MIPS_OPTIONS
: return "OPTIONS";
3905 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3906 default: return NULL
;
3911 get_parisc_segment_type (unsigned long type
)
3915 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3916 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3917 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3918 default: return NULL
;
3923 get_ia64_segment_type (unsigned long type
)
3927 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3928 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3929 default: return NULL
;
3934 get_tic6x_segment_type (unsigned long type
)
3938 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3939 default: return NULL
;
3944 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3946 if (e_machine
== EM_PARISC
)
3949 case PT_HP_TLS
: return "HP_TLS";
3950 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3951 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3952 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3953 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3954 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3955 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3956 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3957 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3958 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3959 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3960 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3961 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3962 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3963 case PT_HP_STACK
: return "HP_STACK";
3964 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3965 default: return NULL
;
3968 if (e_machine
== EM_IA_64
)
3971 case PT_HP_TLS
: return "HP_TLS";
3972 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3973 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3974 case PT_IA_64_HP_STACK
: return "HP_STACK";
3975 default: return NULL
;
3982 get_solaris_segment_type (unsigned long type
)
3986 case 0x6464e550: return "PT_SUNW_UNWIND";
3987 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3988 case 0x6ffffff7: return "PT_LOSUNW";
3989 case 0x6ffffffa: return "PT_SUNWBSS";
3990 case 0x6ffffffb: return "PT_SUNWSTACK";
3991 case 0x6ffffffc: return "PT_SUNWDTRACE";
3992 case 0x6ffffffd: return "PT_SUNWCAP";
3993 case 0x6fffffff: return "PT_HISUNW";
3994 default: return NULL
;
3999 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4001 static char buff
[32];
4005 case PT_NULL
: return "NULL";
4006 case PT_LOAD
: return "LOAD";
4007 case PT_DYNAMIC
: return "DYNAMIC";
4008 case PT_INTERP
: return "INTERP";
4009 case PT_NOTE
: return "NOTE";
4010 case PT_SHLIB
: return "SHLIB";
4011 case PT_PHDR
: return "PHDR";
4012 case PT_TLS
: return "TLS";
4013 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4014 case PT_GNU_STACK
: return "GNU_STACK";
4015 case PT_GNU_RELRO
: return "GNU_RELRO";
4016 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4019 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4021 const char * result
;
4023 switch (filedata
->file_header
.e_machine
)
4026 result
= get_aarch64_segment_type (p_type
);
4029 result
= get_arm_segment_type (p_type
);
4032 case EM_MIPS_RS3_LE
:
4033 result
= get_mips_segment_type (p_type
);
4036 result
= get_parisc_segment_type (p_type
);
4039 result
= get_ia64_segment_type (p_type
);
4042 result
= get_tic6x_segment_type (p_type
);
4046 result
= get_s390_segment_type (p_type
);
4056 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4058 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4060 const char * result
= NULL
;
4062 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4065 case ELFOSABI_FREEBSD
:
4066 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4068 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4073 result
= get_hpux_segment_type (p_type
,
4074 filedata
->file_header
.e_machine
);
4076 case ELFOSABI_SOLARIS
:
4077 result
= get_solaris_segment_type (p_type
);
4085 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4088 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4095 get_arc_section_type_name (unsigned int sh_type
)
4099 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4107 get_mips_section_type_name (unsigned int sh_type
)
4111 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4112 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4113 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4114 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4115 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4116 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4117 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4118 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4119 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4120 case SHT_MIPS_RELD
: return "MIPS_RELD";
4121 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4122 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4123 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4124 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4125 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4126 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4127 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4128 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4129 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4130 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4131 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4132 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4133 case SHT_MIPS_LINE
: return "MIPS_LINE";
4134 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4135 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4136 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4137 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4138 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4139 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4140 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4141 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4142 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4143 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4144 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4145 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4146 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4147 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4148 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4149 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4150 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4151 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4159 get_parisc_section_type_name (unsigned int sh_type
)
4163 case SHT_PARISC_EXT
: return "PARISC_EXT";
4164 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4165 case SHT_PARISC_DOC
: return "PARISC_DOC";
4166 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4167 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4168 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4169 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4170 default: return NULL
;
4175 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4177 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4178 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4179 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4183 case SHT_IA_64_EXT
: return "IA_64_EXT";
4184 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4185 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4186 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4187 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4188 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4189 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4190 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4191 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4192 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4200 get_x86_64_section_type_name (unsigned int sh_type
)
4204 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4205 default: return NULL
;
4210 get_aarch64_section_type_name (unsigned int sh_type
)
4214 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4215 default: return NULL
;
4220 get_arm_section_type_name (unsigned int sh_type
)
4224 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4225 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4226 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4227 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4228 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4229 default: return NULL
;
4234 get_tic6x_section_type_name (unsigned int sh_type
)
4238 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4239 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4240 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4241 case SHT_TI_ICODE
: return "TI_ICODE";
4242 case SHT_TI_XREF
: return "TI_XREF";
4243 case SHT_TI_HANDLER
: return "TI_HANDLER";
4244 case SHT_TI_INITINFO
: return "TI_INITINFO";
4245 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4246 default: return NULL
;
4251 get_msp430x_section_type_name (unsigned int sh_type
)
4255 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4256 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4257 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4258 default: return NULL
;
4263 get_nfp_section_type_name (unsigned int sh_type
)
4267 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4268 case SHT_NFP_INITREG
: return "NFP_INITREG";
4269 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4270 default: return NULL
;
4275 get_v850_section_type_name (unsigned int sh_type
)
4279 case SHT_V850_SCOMMON
: return "V850 Small Common";
4280 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4281 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4282 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4283 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4284 default: return NULL
;
4289 get_riscv_section_type_name (unsigned int sh_type
)
4293 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4294 default: return NULL
;
4299 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4301 static char buff
[32];
4302 const char * result
;
4306 case SHT_NULL
: return "NULL";
4307 case SHT_PROGBITS
: return "PROGBITS";
4308 case SHT_SYMTAB
: return "SYMTAB";
4309 case SHT_STRTAB
: return "STRTAB";
4310 case SHT_RELA
: return "RELA";
4311 case SHT_HASH
: return "HASH";
4312 case SHT_DYNAMIC
: return "DYNAMIC";
4313 case SHT_NOTE
: return "NOTE";
4314 case SHT_NOBITS
: return "NOBITS";
4315 case SHT_REL
: return "REL";
4316 case SHT_SHLIB
: return "SHLIB";
4317 case SHT_DYNSYM
: return "DYNSYM";
4318 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4319 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4320 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4321 case SHT_GNU_HASH
: return "GNU_HASH";
4322 case SHT_GROUP
: return "GROUP";
4323 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4324 case SHT_GNU_verdef
: return "VERDEF";
4325 case SHT_GNU_verneed
: return "VERNEED";
4326 case SHT_GNU_versym
: return "VERSYM";
4327 case 0x6ffffff0: return "VERSYM";
4328 case 0x6ffffffc: return "VERDEF";
4329 case 0x7ffffffd: return "AUXILIARY";
4330 case 0x7fffffff: return "FILTER";
4331 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4334 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4336 switch (filedata
->file_header
.e_machine
)
4339 case EM_ARC_COMPACT
:
4340 case EM_ARC_COMPACT2
:
4341 result
= get_arc_section_type_name (sh_type
);
4344 case EM_MIPS_RS3_LE
:
4345 result
= get_mips_section_type_name (sh_type
);
4348 result
= get_parisc_section_type_name (sh_type
);
4351 result
= get_ia64_section_type_name (filedata
, sh_type
);
4356 result
= get_x86_64_section_type_name (sh_type
);
4359 result
= get_aarch64_section_type_name (sh_type
);
4362 result
= get_arm_section_type_name (sh_type
);
4365 result
= get_tic6x_section_type_name (sh_type
);
4368 result
= get_msp430x_section_type_name (sh_type
);
4371 result
= get_nfp_section_type_name (sh_type
);
4375 case EM_CYGNUS_V850
:
4376 result
= get_v850_section_type_name (sh_type
);
4379 result
= get_riscv_section_type_name (sh_type
);
4389 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4391 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4393 switch (filedata
->file_header
.e_machine
)
4396 result
= get_ia64_section_type_name (filedata
, sh_type
);
4399 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4400 result
= get_solaris_section_type (sh_type
);
4405 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4406 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4407 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4408 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4420 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4422 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4424 switch (filedata
->file_header
.e_machine
)
4428 case EM_CYGNUS_V850
:
4429 result
= get_v850_section_type_name (sh_type
);
4439 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4442 /* This message is probably going to be displayed in a 15
4443 character wide field, so put the hex value first. */
4444 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4450 #define OPTION_DEBUG_DUMP 512
4451 #define OPTION_DYN_SYMS 513
4452 #define OPTION_DWARF_DEPTH 514
4453 #define OPTION_DWARF_START 515
4454 #define OPTION_DWARF_CHECK 516
4455 #define OPTION_CTF_DUMP 517
4456 #define OPTION_CTF_PARENT 518
4457 #define OPTION_CTF_SYMBOLS 519
4458 #define OPTION_CTF_STRINGS 520
4460 static struct option options
[] =
4462 {"all", no_argument
, 0, 'a'},
4463 {"file-header", no_argument
, 0, 'h'},
4464 {"program-headers", no_argument
, 0, 'l'},
4465 {"headers", no_argument
, 0, 'e'},
4466 {"histogram", no_argument
, 0, 'I'},
4467 {"segments", no_argument
, 0, 'l'},
4468 {"sections", no_argument
, 0, 'S'},
4469 {"section-headers", no_argument
, 0, 'S'},
4470 {"section-groups", no_argument
, 0, 'g'},
4471 {"section-details", no_argument
, 0, 't'},
4472 {"full-section-name",no_argument
, 0, 'N'},
4473 {"symbols", no_argument
, 0, 's'},
4474 {"syms", no_argument
, 0, 's'},
4475 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4476 {"relocs", no_argument
, 0, 'r'},
4477 {"notes", no_argument
, 0, 'n'},
4478 {"dynamic", no_argument
, 0, 'd'},
4479 {"arch-specific", no_argument
, 0, 'A'},
4480 {"version-info", no_argument
, 0, 'V'},
4481 {"use-dynamic", no_argument
, 0, 'D'},
4482 {"unwind", no_argument
, 0, 'u'},
4483 {"archive-index", no_argument
, 0, 'c'},
4484 {"hex-dump", required_argument
, 0, 'x'},
4485 {"relocated-dump", required_argument
, 0, 'R'},
4486 {"string-dump", required_argument
, 0, 'p'},
4487 {"decompress", no_argument
, 0, 'z'},
4488 #ifdef SUPPORT_DISASSEMBLY
4489 {"instruction-dump", required_argument
, 0, 'i'},
4491 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4493 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4494 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4495 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4497 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4499 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4500 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4501 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4503 {"version", no_argument
, 0, 'v'},
4504 {"wide", no_argument
, 0, 'W'},
4505 {"help", no_argument
, 0, 'H'},
4506 {0, no_argument
, 0, 0}
4510 usage (FILE * stream
)
4512 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4513 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4514 fprintf (stream
, _(" Options are:\n\
4515 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4516 -h --file-header Display the ELF file header\n\
4517 -l --program-headers Display the program headers\n\
4518 --segments An alias for --program-headers\n\
4519 -S --section-headers Display the sections' header\n\
4520 --sections An alias for --section-headers\n\
4521 -g --section-groups Display the section groups\n\
4522 -t --section-details Display the section details\n\
4523 -e --headers Equivalent to: -h -l -S\n\
4524 -s --syms Display the symbol table\n\
4525 --symbols An alias for --syms\n\
4526 --dyn-syms Display the dynamic symbol table\n\
4527 -n --notes Display the core notes (if present)\n\
4528 -r --relocs Display the relocations (if present)\n\
4529 -u --unwind Display the unwind info (if present)\n\
4530 -d --dynamic Display the dynamic section (if present)\n\
4531 -V --version-info Display the version sections (if present)\n\
4532 -A --arch-specific Display architecture specific information (if any)\n\
4533 -c --archive-index Display the symbol/file index in an archive\n\
4534 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4535 -x --hex-dump=<number|name>\n\
4536 Dump the contents of section <number|name> as bytes\n\
4537 -p --string-dump=<number|name>\n\
4538 Dump the contents of section <number|name> as strings\n\
4539 -R --relocated-dump=<number|name>\n\
4540 Dump the contents of section <number|name> as relocated bytes\n\
4541 -z --decompress Decompress section before dumping it\n\
4542 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4543 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4544 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4545 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4546 =addr,=cu_index,=links,=follow-links]\n\
4547 Display the contents of DWARF debug sections\n"));
4548 fprintf (stream
, _("\
4549 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4550 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4552 fprintf (stream
, _("\
4553 --ctf=<number|name> Display CTF info from section <number|name>\n\
4554 --ctf-parent=<number|name>\n\
4555 Use section <number|name> as the CTF parent\n\n\
4556 --ctf-symbols=<number|name>\n\
4557 Use section <number|name> as the CTF external symtab\n\n\
4558 --ctf-strings=<number|name>\n\
4559 Use section <number|name> as the CTF external strtab\n\n"));
4561 #ifdef SUPPORT_DISASSEMBLY
4562 fprintf (stream
, _("\
4563 -i --instruction-dump=<number|name>\n\
4564 Disassemble the contents of section <number|name>\n"));
4566 fprintf (stream
, _("\
4567 -I --histogram Display histogram of bucket list lengths\n\
4568 -W --wide Allow output width to exceed 80 characters\n\
4569 @<file> Read options from <file>\n\
4570 -H --help Display this information\n\
4571 -v --version Display the version number of readelf\n"));
4573 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4574 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4576 exit (stream
== stdout
? 0 : 1);
4579 /* Record the fact that the user wants the contents of section number
4580 SECTION to be displayed using the method(s) encoded as flags bits
4581 in TYPE. Note, TYPE can be zero if we are creating the array for
4585 request_dump_bynumber (struct dump_data
*dumpdata
,
4586 unsigned int section
, dump_type type
)
4588 if (section
>= dumpdata
->num_dump_sects
)
4590 dump_type
* new_dump_sects
;
4592 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4593 sizeof (* new_dump_sects
));
4595 if (new_dump_sects
== NULL
)
4596 error (_("Out of memory allocating dump request table.\n"));
4599 if (dumpdata
->dump_sects
)
4601 /* Copy current flag settings. */
4602 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4603 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4605 free (dumpdata
->dump_sects
);
4608 dumpdata
->dump_sects
= new_dump_sects
;
4609 dumpdata
->num_dump_sects
= section
+ 1;
4613 if (dumpdata
->dump_sects
)
4614 dumpdata
->dump_sects
[section
] |= type
;
4617 /* Request a dump by section name. */
4620 request_dump_byname (const char * section
, dump_type type
)
4622 struct dump_list_entry
* new_request
;
4624 new_request
= (struct dump_list_entry
*)
4625 malloc (sizeof (struct dump_list_entry
));
4627 error (_("Out of memory allocating dump request table.\n"));
4629 new_request
->name
= strdup (section
);
4630 if (!new_request
->name
)
4631 error (_("Out of memory allocating dump request table.\n"));
4633 new_request
->type
= type
;
4635 new_request
->next
= dump_sects_byname
;
4636 dump_sects_byname
= new_request
;
4640 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4646 section
= strtoul (optarg
, & cp
, 0);
4648 if (! *cp
&& section
>= 0)
4649 request_dump_bynumber (dumpdata
, section
, type
);
4651 request_dump_byname (optarg
, type
);
4655 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4662 while ((c
= getopt_long
4663 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4681 do_section_groups
= TRUE
;
4684 do_histogram
= TRUE
;
4689 do_section_groups
= TRUE
;
4694 do_section_details
= TRUE
;
4705 do_using_dynamic
= TRUE
;
4729 do_histogram
= TRUE
;
4735 do_archive_index
= TRUE
;
4738 request_dump (dumpdata
, HEX_DUMP
);
4741 request_dump (dumpdata
, STRING_DUMP
);
4744 request_dump (dumpdata
, RELOC_DUMP
);
4747 decompress_dumps
= TRUE
;
4753 do_debugging
= TRUE
;
4754 dwarf_select_sections_all ();
4758 do_debugging
= FALSE
;
4759 dwarf_select_sections_by_letters (optarg
);
4762 case OPTION_DEBUG_DUMP
:
4765 do_debugging
= TRUE
;
4768 do_debugging
= FALSE
;
4769 dwarf_select_sections_by_names (optarg
);
4772 case OPTION_DWARF_DEPTH
:
4776 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4779 case OPTION_DWARF_START
:
4783 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4786 case OPTION_DWARF_CHECK
:
4789 case OPTION_CTF_DUMP
:
4791 request_dump (dumpdata
, CTF_DUMP
);
4793 case OPTION_CTF_SYMBOLS
:
4794 dump_ctf_symtab_name
= strdup (optarg
);
4796 case OPTION_CTF_STRINGS
:
4797 dump_ctf_strtab_name
= strdup (optarg
);
4799 case OPTION_CTF_PARENT
:
4800 dump_ctf_parent_name
= strdup (optarg
);
4802 case OPTION_DYN_SYMS
:
4805 #ifdef SUPPORT_DISASSEMBLY
4807 request_dump (dumpdata
, DISASS_DUMP
);
4811 print_version (program_name
);
4820 /* xgettext:c-format */
4821 error (_("Invalid option '-%c'\n"), c
);
4828 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4829 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4830 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4831 && !do_section_groups
&& !do_archive_index
4837 get_elf_class (unsigned int elf_class
)
4839 static char buff
[32];
4843 case ELFCLASSNONE
: return _("none");
4844 case ELFCLASS32
: return "ELF32";
4845 case ELFCLASS64
: return "ELF64";
4847 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4853 get_data_encoding (unsigned int encoding
)
4855 static char buff
[32];
4859 case ELFDATANONE
: return _("none");
4860 case ELFDATA2LSB
: return _("2's complement, little endian");
4861 case ELFDATA2MSB
: return _("2's complement, big endian");
4863 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4868 /* Decode the data held in 'filedata->file_header'. */
4871 process_file_header (Filedata
* filedata
)
4873 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4875 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4876 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4877 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4878 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4881 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4885 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4891 printf (_("ELF Header:\n"));
4892 printf (_(" Magic: "));
4893 for (i
= 0; i
< EI_NIDENT
; i
++)
4894 printf ("%2.2x ", header
->e_ident
[i
]);
4896 printf (_(" Class: %s\n"),
4897 get_elf_class (header
->e_ident
[EI_CLASS
]));
4898 printf (_(" Data: %s\n"),
4899 get_data_encoding (header
->e_ident
[EI_DATA
]));
4900 printf (_(" Version: %d%s\n"),
4901 header
->e_ident
[EI_VERSION
],
4902 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4904 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4907 printf (_(" OS/ABI: %s\n"),
4908 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4909 printf (_(" ABI Version: %d\n"),
4910 header
->e_ident
[EI_ABIVERSION
]);
4911 printf (_(" Type: %s\n"),
4912 get_file_type (header
->e_type
));
4913 printf (_(" Machine: %s\n"),
4914 get_machine_name (header
->e_machine
));
4915 printf (_(" Version: 0x%lx\n"),
4918 printf (_(" Entry point address: "));
4919 print_vma (header
->e_entry
, PREFIX_HEX
);
4920 printf (_("\n Start of program headers: "));
4921 print_vma (header
->e_phoff
, DEC
);
4922 printf (_(" (bytes into file)\n Start of section headers: "));
4923 print_vma (header
->e_shoff
, DEC
);
4924 printf (_(" (bytes into file)\n"));
4926 printf (_(" Flags: 0x%lx%s\n"),
4928 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4929 printf (_(" Size of this header: %u (bytes)\n"),
4931 printf (_(" Size of program headers: %u (bytes)\n"),
4932 header
->e_phentsize
);
4933 printf (_(" Number of program headers: %u"),
4935 if (filedata
->section_headers
!= NULL
4936 && header
->e_phnum
== PN_XNUM
4937 && filedata
->section_headers
[0].sh_info
!= 0)
4939 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4940 printf (" (%u)", header
->e_phnum
);
4942 putc ('\n', stdout
);
4943 printf (_(" Size of section headers: %u (bytes)\n"),
4944 header
->e_shentsize
);
4945 printf (_(" Number of section headers: %u"),
4947 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4949 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4950 printf (" (%u)", header
->e_shnum
);
4952 putc ('\n', stdout
);
4953 printf (_(" Section header string table index: %u"),
4954 header
->e_shstrndx
);
4955 if (filedata
->section_headers
!= NULL
4956 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4958 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4959 printf (" (%u)", header
->e_shstrndx
);
4961 if (header
->e_shstrndx
!= SHN_UNDEF
4962 && header
->e_shstrndx
>= header
->e_shnum
)
4964 header
->e_shstrndx
= SHN_UNDEF
;
4965 printf (_(" <corrupt: out of range>"));
4967 putc ('\n', stdout
);
4970 if (filedata
->section_headers
!= NULL
)
4972 if (header
->e_phnum
== PN_XNUM
4973 && filedata
->section_headers
[0].sh_info
!= 0)
4974 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4975 if (header
->e_shnum
== SHN_UNDEF
)
4976 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4977 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4978 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4979 if (header
->e_shstrndx
>= header
->e_shnum
)
4980 header
->e_shstrndx
= SHN_UNDEF
;
4981 free (filedata
->section_headers
);
4982 filedata
->section_headers
= NULL
;
4988 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4989 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4992 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4994 Elf32_External_Phdr
* phdrs
;
4995 Elf32_External_Phdr
* external
;
4996 Elf_Internal_Phdr
* internal
;
4998 unsigned int size
= filedata
->file_header
.e_phentsize
;
4999 unsigned int num
= filedata
->file_header
.e_phnum
;
5001 /* PR binutils/17531: Cope with unexpected section header sizes. */
5002 if (size
== 0 || num
== 0)
5004 if (size
< sizeof * phdrs
)
5006 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5009 if (size
> sizeof * phdrs
)
5010 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5012 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5013 size
, num
, _("program headers"));
5017 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5018 i
< filedata
->file_header
.e_phnum
;
5019 i
++, internal
++, external
++)
5021 internal
->p_type
= BYTE_GET (external
->p_type
);
5022 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5023 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5024 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5025 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5026 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5027 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5028 internal
->p_align
= BYTE_GET (external
->p_align
);
5035 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5036 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5039 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5041 Elf64_External_Phdr
* phdrs
;
5042 Elf64_External_Phdr
* external
;
5043 Elf_Internal_Phdr
* internal
;
5045 unsigned int size
= filedata
->file_header
.e_phentsize
;
5046 unsigned int num
= filedata
->file_header
.e_phnum
;
5048 /* PR binutils/17531: Cope with unexpected section header sizes. */
5049 if (size
== 0 || num
== 0)
5051 if (size
< sizeof * phdrs
)
5053 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5056 if (size
> sizeof * phdrs
)
5057 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5059 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5060 size
, num
, _("program headers"));
5064 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5065 i
< filedata
->file_header
.e_phnum
;
5066 i
++, internal
++, external
++)
5068 internal
->p_type
= BYTE_GET (external
->p_type
);
5069 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5070 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5071 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5072 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5073 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5074 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5075 internal
->p_align
= BYTE_GET (external
->p_align
);
5082 /* Returns TRUE if the program headers were read into `program_headers'. */
5085 get_program_headers (Filedata
* filedata
)
5087 Elf_Internal_Phdr
* phdrs
;
5089 /* Check cache of prior read. */
5090 if (filedata
->program_headers
!= NULL
)
5093 /* Be kind to memory checkers by looking for
5094 e_phnum values which we know must be invalid. */
5095 if (filedata
->file_header
.e_phnum
5096 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5097 >= filedata
->file_size
)
5099 error (_("Too many program headers - %#x - the file is not that big\n"),
5100 filedata
->file_header
.e_phnum
);
5104 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5105 sizeof (Elf_Internal_Phdr
));
5108 error (_("Out of memory reading %u program headers\n"),
5109 filedata
->file_header
.e_phnum
);
5114 ? get_32bit_program_headers (filedata
, phdrs
)
5115 : get_64bit_program_headers (filedata
, phdrs
))
5117 filedata
->program_headers
= phdrs
;
5125 /* Returns TRUE if the program headers were loaded. */
5128 process_program_headers (Filedata
* filedata
)
5130 Elf_Internal_Phdr
* segment
;
5132 Elf_Internal_Phdr
* previous_load
= NULL
;
5137 if (filedata
->file_header
.e_phnum
== 0)
5139 /* PR binutils/12467. */
5140 if (filedata
->file_header
.e_phoff
!= 0)
5142 warn (_("possibly corrupt ELF header - it has a non-zero program"
5143 " header offset, but no program headers\n"));
5146 else if (do_segments
)
5147 printf (_("\nThere are no program headers in this file.\n"));
5151 if (do_segments
&& !do_header
)
5153 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5154 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5155 printf (ngettext ("There is %d program header, starting at offset %s\n",
5156 "There are %d program headers, starting at offset %s\n",
5157 filedata
->file_header
.e_phnum
),
5158 filedata
->file_header
.e_phnum
,
5159 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5162 if (! get_program_headers (filedata
))
5167 if (filedata
->file_header
.e_phnum
> 1)
5168 printf (_("\nProgram Headers:\n"));
5170 printf (_("\nProgram Headers:\n"));
5174 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5177 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5181 (_(" Type Offset VirtAddr PhysAddr\n"));
5183 (_(" FileSiz MemSiz Flags Align\n"));
5187 for (i
= 0, segment
= filedata
->program_headers
;
5188 i
< filedata
->file_header
.e_phnum
;
5193 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5197 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5198 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5199 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5200 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5201 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5203 (segment
->p_flags
& PF_R
? 'R' : ' '),
5204 (segment
->p_flags
& PF_W
? 'W' : ' '),
5205 (segment
->p_flags
& PF_X
? 'E' : ' '));
5206 printf ("%#lx", (unsigned long) segment
->p_align
);
5210 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5211 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5214 print_vma (segment
->p_offset
, FULL_HEX
);
5218 print_vma (segment
->p_vaddr
, FULL_HEX
);
5220 print_vma (segment
->p_paddr
, FULL_HEX
);
5223 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5224 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5227 print_vma (segment
->p_filesz
, FULL_HEX
);
5231 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5232 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5235 print_vma (segment
->p_memsz
, FULL_HEX
);
5239 (segment
->p_flags
& PF_R
? 'R' : ' '),
5240 (segment
->p_flags
& PF_W
? 'W' : ' '),
5241 (segment
->p_flags
& PF_X
? 'E' : ' '));
5243 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5244 printf ("%#lx", (unsigned long) segment
->p_align
);
5247 print_vma (segment
->p_align
, PREFIX_HEX
);
5252 print_vma (segment
->p_offset
, FULL_HEX
);
5254 print_vma (segment
->p_vaddr
, FULL_HEX
);
5256 print_vma (segment
->p_paddr
, FULL_HEX
);
5258 print_vma (segment
->p_filesz
, FULL_HEX
);
5260 print_vma (segment
->p_memsz
, FULL_HEX
);
5262 (segment
->p_flags
& PF_R
? 'R' : ' '),
5263 (segment
->p_flags
& PF_W
? 'W' : ' '),
5264 (segment
->p_flags
& PF_X
? 'E' : ' '));
5265 print_vma (segment
->p_align
, PREFIX_HEX
);
5268 putc ('\n', stdout
);
5271 switch (segment
->p_type
)
5274 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5275 required by the ELF standard, several programs, including the Linux
5276 kernel, make use of non-ordered segments. */
5278 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5279 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5281 if (segment
->p_memsz
< segment
->p_filesz
)
5282 error (_("the segment's file size is larger than its memory size\n"));
5283 previous_load
= segment
;
5287 /* PR 20815 - Verify that the program header is loaded into memory. */
5288 if (i
> 0 && previous_load
!= NULL
)
5289 error (_("the PHDR segment must occur before any LOAD segment\n"));
5290 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5294 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5296 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5297 if (load
->p_type
== PT_LOAD
5298 && load
->p_offset
<= segment
->p_offset
5299 && (load
->p_offset
+ load
->p_filesz
5300 >= segment
->p_offset
+ segment
->p_filesz
)
5301 && load
->p_vaddr
<= segment
->p_vaddr
5302 && (load
->p_vaddr
+ load
->p_filesz
5303 >= segment
->p_vaddr
+ segment
->p_filesz
))
5306 if (j
== filedata
->file_header
.e_phnum
)
5307 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5313 error (_("more than one dynamic segment\n"));
5315 /* By default, assume that the .dynamic section is the first
5316 section in the DYNAMIC segment. */
5317 dynamic_addr
= segment
->p_offset
;
5318 dynamic_size
= segment
->p_filesz
;
5320 /* Try to locate the .dynamic section. If there is
5321 a section header table, we can easily locate it. */
5322 if (filedata
->section_headers
!= NULL
)
5324 Elf_Internal_Shdr
* sec
;
5326 sec
= find_section (filedata
, ".dynamic");
5327 if (sec
== NULL
|| sec
->sh_size
== 0)
5329 /* A corresponding .dynamic section is expected, but on
5330 IA-64/OpenVMS it is OK for it to be missing. */
5331 if (!is_ia64_vms (filedata
))
5332 error (_("no .dynamic section in the dynamic segment\n"));
5336 if (sec
->sh_type
== SHT_NOBITS
)
5342 dynamic_addr
= sec
->sh_offset
;
5343 dynamic_size
= sec
->sh_size
;
5345 if (dynamic_addr
< segment
->p_offset
5346 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5347 warn (_("the .dynamic section is not contained"
5348 " within the dynamic segment\n"));
5349 else if (dynamic_addr
> segment
->p_offset
)
5350 warn (_("the .dynamic section is not the first section"
5351 " in the dynamic segment.\n"));
5354 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5355 segment. Check this after matching against the section headers
5356 so we don't warn on debuginfo file (which have NOBITS .dynamic
5358 if (dynamic_addr
> filedata
->file_size
5359 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5361 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5362 dynamic_addr
= dynamic_size
= 0;
5367 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5369 error (_("Unable to find program interpreter name\n"));
5373 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5375 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5376 error (_("Internal error: failed to create format string to display program interpreter\n"));
5378 program_interpreter
[0] = 0;
5379 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5380 error (_("Unable to read program interpreter name\n"));
5383 printf (_(" [Requesting program interpreter: %s]\n"),
5384 program_interpreter
);
5391 && filedata
->section_headers
!= NULL
5392 && filedata
->string_table
!= NULL
)
5394 printf (_("\n Section to Segment mapping:\n"));
5395 printf (_(" Segment Sections...\n"));
5397 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5400 Elf_Internal_Shdr
* section
;
5402 segment
= filedata
->program_headers
+ i
;
5403 section
= filedata
->section_headers
+ 1;
5405 printf (" %2.2d ", i
);
5407 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5409 if (!ELF_TBSS_SPECIAL (section
, segment
)
5410 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5411 printf ("%s ", printable_section_name (filedata
, section
));
5422 /* Find the file offset corresponding to VMA by using the program headers. */
5425 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5427 Elf_Internal_Phdr
* seg
;
5429 if (! get_program_headers (filedata
))
5431 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5435 for (seg
= filedata
->program_headers
;
5436 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5439 if (seg
->p_type
!= PT_LOAD
)
5442 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5443 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5444 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5447 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5448 (unsigned long) vma
);
5453 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5454 If PROBE is true, this is just a probe and we do not generate any error
5455 messages if the load fails. */
5458 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5460 Elf32_External_Shdr
* shdrs
;
5461 Elf_Internal_Shdr
* internal
;
5463 unsigned int size
= filedata
->file_header
.e_shentsize
;
5464 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5466 /* PR binutils/17531: Cope with unexpected section header sizes. */
5467 if (size
== 0 || num
== 0)
5469 if (size
< sizeof * shdrs
)
5472 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5475 if (!probe
&& size
> sizeof * shdrs
)
5476 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5478 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5480 probe
? NULL
: _("section headers"));
5484 free (filedata
->section_headers
);
5485 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5486 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5487 if (filedata
->section_headers
== NULL
)
5490 error (_("Out of memory reading %u section headers\n"), num
);
5495 for (i
= 0, internal
= filedata
->section_headers
;
5499 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5500 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5501 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5502 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5503 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5504 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5505 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5506 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5507 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5508 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5509 if (!probe
&& internal
->sh_link
> num
)
5510 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5511 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5512 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5519 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5522 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5524 Elf64_External_Shdr
* shdrs
;
5525 Elf_Internal_Shdr
* internal
;
5527 unsigned int size
= filedata
->file_header
.e_shentsize
;
5528 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5530 /* PR binutils/17531: Cope with unexpected section header sizes. */
5531 if (size
== 0 || num
== 0)
5534 if (size
< sizeof * shdrs
)
5537 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5541 if (! probe
&& size
> sizeof * shdrs
)
5542 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5544 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5545 filedata
->file_header
.e_shoff
,
5547 probe
? NULL
: _("section headers"));
5551 free (filedata
->section_headers
);
5552 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5553 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5554 if (filedata
->section_headers
== NULL
)
5557 error (_("Out of memory reading %u section headers\n"), num
);
5562 for (i
= 0, internal
= filedata
->section_headers
;
5566 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5567 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5568 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5569 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5570 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5571 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5572 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5573 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5574 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5575 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5576 if (!probe
&& internal
->sh_link
> num
)
5577 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5578 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5579 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5586 static Elf_Internal_Sym
*
5587 get_32bit_elf_symbols (Filedata
* filedata
,
5588 Elf_Internal_Shdr
* section
,
5589 unsigned long * num_syms_return
)
5591 unsigned long number
= 0;
5592 Elf32_External_Sym
* esyms
= NULL
;
5593 Elf_External_Sym_Shndx
* shndx
= NULL
;
5594 Elf_Internal_Sym
* isyms
= NULL
;
5595 Elf_Internal_Sym
* psym
;
5597 elf_section_list
* entry
;
5599 if (section
->sh_size
== 0)
5601 if (num_syms_return
!= NULL
)
5602 * num_syms_return
= 0;
5606 /* Run some sanity checks first. */
5607 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5609 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5610 printable_section_name (filedata
, section
),
5611 (unsigned long) section
->sh_entsize
);
5615 if (section
->sh_size
> filedata
->file_size
)
5617 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5618 printable_section_name (filedata
, section
),
5619 (unsigned long) section
->sh_size
);
5623 number
= section
->sh_size
/ section
->sh_entsize
;
5625 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5627 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5628 (unsigned long) section
->sh_size
,
5629 printable_section_name (filedata
, section
),
5630 (unsigned long) section
->sh_entsize
);
5634 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5635 section
->sh_size
, _("symbols"));
5640 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5642 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5647 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5651 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5652 entry
->hdr
->sh_offset
,
5653 1, entry
->hdr
->sh_size
,
5654 _("symbol table section indices"));
5658 /* PR17531: file: heap-buffer-overflow */
5659 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5661 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5662 printable_section_name (filedata
, entry
->hdr
),
5663 (unsigned long) entry
->hdr
->sh_size
,
5664 (unsigned long) section
->sh_size
);
5669 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5673 error (_("Out of memory reading %lu symbols\n"),
5674 (unsigned long) number
);
5678 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5680 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5681 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5682 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5683 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5684 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5686 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5687 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5688 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5689 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5690 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5697 if (num_syms_return
!= NULL
)
5698 * num_syms_return
= isyms
== NULL
? 0 : number
;
5703 static Elf_Internal_Sym
*
5704 get_64bit_elf_symbols (Filedata
* filedata
,
5705 Elf_Internal_Shdr
* section
,
5706 unsigned long * num_syms_return
)
5708 unsigned long number
= 0;
5709 Elf64_External_Sym
* esyms
= NULL
;
5710 Elf_External_Sym_Shndx
* shndx
= NULL
;
5711 Elf_Internal_Sym
* isyms
= NULL
;
5712 Elf_Internal_Sym
* psym
;
5714 elf_section_list
* entry
;
5716 if (section
->sh_size
== 0)
5718 if (num_syms_return
!= NULL
)
5719 * num_syms_return
= 0;
5723 /* Run some sanity checks first. */
5724 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5726 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5727 printable_section_name (filedata
, section
),
5728 (unsigned long) section
->sh_entsize
);
5732 if (section
->sh_size
> filedata
->file_size
)
5734 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5735 printable_section_name (filedata
, section
),
5736 (unsigned long) section
->sh_size
);
5740 number
= section
->sh_size
/ section
->sh_entsize
;
5742 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5744 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5745 (unsigned long) section
->sh_size
,
5746 printable_section_name (filedata
, section
),
5747 (unsigned long) section
->sh_entsize
);
5751 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5752 section
->sh_size
, _("symbols"));
5757 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5759 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5764 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5768 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5769 entry
->hdr
->sh_offset
,
5770 1, entry
->hdr
->sh_size
,
5771 _("symbol table section indices"));
5775 /* PR17531: file: heap-buffer-overflow */
5776 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5778 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5779 printable_section_name (filedata
, entry
->hdr
),
5780 (unsigned long) entry
->hdr
->sh_size
,
5781 (unsigned long) section
->sh_size
);
5786 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5790 error (_("Out of memory reading %lu symbols\n"),
5791 (unsigned long) number
);
5795 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5797 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5798 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5799 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5800 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5802 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5804 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5805 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5806 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5808 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5809 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5816 if (num_syms_return
!= NULL
)
5817 * num_syms_return
= isyms
== NULL
? 0 : number
;
5823 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5825 static char buff
[1024];
5827 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5829 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5830 bfd_vma os_flags
= 0;
5831 bfd_vma proc_flags
= 0;
5832 bfd_vma unknown_flags
= 0;
5840 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5841 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5842 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5843 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5844 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5845 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5846 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5847 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5848 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5849 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5850 /* IA-64 specific. */
5851 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5852 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5853 /* IA-64 OpenVMS specific. */
5854 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5855 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5856 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5857 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5858 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5859 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5861 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5862 /* SPARC specific. */
5863 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5864 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5866 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5867 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5868 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5870 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5872 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5875 if (do_section_details
)
5877 sprintf (buff
, "[%*.*lx]: ",
5878 field_size
, field_size
, (unsigned long) sh_flags
);
5879 p
+= field_size
+ 4;
5886 flag
= sh_flags
& - sh_flags
;
5889 if (do_section_details
)
5893 case SHF_WRITE
: sindex
= 0; break;
5894 case SHF_ALLOC
: sindex
= 1; break;
5895 case SHF_EXECINSTR
: sindex
= 2; break;
5896 case SHF_MERGE
: sindex
= 3; break;
5897 case SHF_STRINGS
: sindex
= 4; break;
5898 case SHF_INFO_LINK
: sindex
= 5; break;
5899 case SHF_LINK_ORDER
: sindex
= 6; break;
5900 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5901 case SHF_GROUP
: sindex
= 8; break;
5902 case SHF_TLS
: sindex
= 9; break;
5903 case SHF_EXCLUDE
: sindex
= 18; break;
5904 case SHF_COMPRESSED
: sindex
= 20; break;
5905 case SHF_GNU_MBIND
: sindex
= 24; break;
5909 switch (filedata
->file_header
.e_machine
)
5912 if (flag
== SHF_IA_64_SHORT
)
5914 else if (flag
== SHF_IA_64_NORECOV
)
5917 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5920 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5921 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5922 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5923 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5924 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5925 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5936 case EM_OLD_SPARCV9
:
5937 case EM_SPARC32PLUS
:
5940 if (flag
== SHF_ORDERED
)
5947 case SHF_ENTRYSECT
: sindex
= 21; break;
5948 case SHF_ARM_PURECODE
: sindex
= 22; break;
5949 case SHF_COMDEF
: sindex
= 23; break;
5954 if (flag
== SHF_PPC_VLE
)
5965 if (p
!= buff
+ field_size
+ 4)
5967 if (size
< (10 + 2))
5969 warn (_("Internal error: not enough buffer room for section flag info"));
5970 return _("<unknown>");
5977 size
-= flags
[sindex
].len
;
5978 p
= stpcpy (p
, flags
[sindex
].str
);
5980 else if (flag
& SHF_MASKOS
)
5982 else if (flag
& SHF_MASKPROC
)
5985 unknown_flags
|= flag
;
5991 case SHF_WRITE
: *p
= 'W'; break;
5992 case SHF_ALLOC
: *p
= 'A'; break;
5993 case SHF_EXECINSTR
: *p
= 'X'; break;
5994 case SHF_MERGE
: *p
= 'M'; break;
5995 case SHF_STRINGS
: *p
= 'S'; break;
5996 case SHF_INFO_LINK
: *p
= 'I'; break;
5997 case SHF_LINK_ORDER
: *p
= 'L'; break;
5998 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5999 case SHF_GROUP
: *p
= 'G'; break;
6000 case SHF_TLS
: *p
= 'T'; break;
6001 case SHF_EXCLUDE
: *p
= 'E'; break;
6002 case SHF_COMPRESSED
: *p
= 'C'; break;
6003 case SHF_GNU_MBIND
: *p
= 'D'; break;
6006 if ((filedata
->file_header
.e_machine
== EM_X86_64
6007 || filedata
->file_header
.e_machine
== EM_L1OM
6008 || filedata
->file_header
.e_machine
== EM_K1OM
)
6009 && flag
== SHF_X86_64_LARGE
)
6011 else if (filedata
->file_header
.e_machine
== EM_ARM
6012 && flag
== SHF_ARM_PURECODE
)
6014 else if (filedata
->file_header
.e_machine
== EM_PPC
6015 && flag
== SHF_PPC_VLE
)
6017 else if (flag
& SHF_MASKOS
)
6020 sh_flags
&= ~ SHF_MASKOS
;
6022 else if (flag
& SHF_MASKPROC
)
6025 sh_flags
&= ~ SHF_MASKPROC
;
6035 if (do_section_details
)
6039 size
-= 5 + field_size
;
6040 if (p
!= buff
+ field_size
+ 4)
6044 warn (_("Internal error: not enough buffer room for section flag info"));
6045 return _("<unknown>");
6051 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6052 (unsigned long) os_flags
);
6053 p
+= 5 + field_size
;
6057 size
-= 7 + field_size
;
6058 if (p
!= buff
+ field_size
+ 4)
6062 warn (_("Internal error: not enough buffer room for section flag info"));
6063 return _("<unknown>");
6069 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6070 (unsigned long) proc_flags
);
6071 p
+= 7 + field_size
;
6075 size
-= 10 + field_size
;
6076 if (p
!= buff
+ field_size
+ 4)
6080 warn (_("Internal error: not enough buffer room for section flag info"));
6081 return _("<unknown>");
6087 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6088 (unsigned long) unknown_flags
);
6089 p
+= 10 + field_size
;
6097 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6098 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6102 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6104 if (size
< sizeof (* echdr
))
6106 error (_("Compressed section is too small even for a compression header\n"));
6110 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6111 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6112 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6113 return sizeof (*echdr
);
6117 Elf64_External_Chdr
*echdr
= (Elf64_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
);
6133 process_section_headers (Filedata
* filedata
)
6135 Elf_Internal_Shdr
* section
;
6138 free (filedata
->section_headers
);
6139 filedata
->section_headers
= NULL
;
6140 free (dynamic_symbols
);
6141 dynamic_symbols
= NULL
;
6142 num_dynamic_syms
= 0;
6143 free (dynamic_strings
);
6144 dynamic_strings
= NULL
;
6145 dynamic_strings_length
= 0;
6146 free (dynamic_syminfo
);
6147 dynamic_syminfo
= NULL
;
6148 while (symtab_shndx_list
!= NULL
)
6150 elf_section_list
*next
= symtab_shndx_list
->next
;
6151 free (symtab_shndx_list
);
6152 symtab_shndx_list
= next
;
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 eh_addr_size
= is_32bit_elf
? 4 : 8;
6209 switch (filedata
->file_header
.e_machine
)
6212 case EM_MIPS_RS3_LE
:
6213 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6214 FDE addresses. However, the ABI also has a semi-official ILP32
6215 variant for which the normal FDE address size rules apply.
6217 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6218 section, where XX is the size of longs in bits. Unfortunately,
6219 earlier compilers provided no way of distinguishing ILP32 objects
6220 from LP64 objects, so if there's any doubt, we should assume that
6221 the official LP64 form is being used. */
6222 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6223 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6229 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6231 case E_H8_MACH_H8300
:
6232 case E_H8_MACH_H8300HN
:
6233 case E_H8_MACH_H8300SN
:
6234 case E_H8_MACH_H8300SXN
:
6237 case E_H8_MACH_H8300H
:
6238 case E_H8_MACH_H8300S
:
6239 case E_H8_MACH_H8300SX
:
6247 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6249 case EF_M32C_CPU_M16C
:
6256 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6259 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6260 if (section->sh_entsize != expected_entsize) \
6263 sprintf_vma (buf, section->sh_entsize); \
6264 /* Note: coded this way so that there is a single string for \
6266 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6267 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6268 (unsigned) expected_entsize); \
6269 section->sh_entsize = expected_entsize; \
6274 #define CHECK_ENTSIZE(section, i, type) \
6275 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6276 sizeof (Elf64_External_##type))
6278 for (i
= 0, section
= filedata
->section_headers
;
6279 i
< filedata
->file_header
.e_shnum
;
6282 char * name
= SECTION_NAME (section
);
6284 if (section
->sh_type
== SHT_DYNSYM
)
6286 if (dynamic_symbols
!= NULL
)
6288 error (_("File contains multiple dynamic symbol tables\n"));
6292 CHECK_ENTSIZE (section
, i
, Sym
);
6293 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6295 else if (section
->sh_type
== SHT_STRTAB
6296 && streq (name
, ".dynstr"))
6298 if (dynamic_strings
!= NULL
)
6300 error (_("File contains multiple dynamic string tables\n"));
6304 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6305 1, section
->sh_size
,
6306 _("dynamic strings"));
6307 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6309 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6311 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6313 entry
->hdr
= section
;
6314 entry
->next
= symtab_shndx_list
;
6315 symtab_shndx_list
= entry
;
6317 else if (section
->sh_type
== SHT_SYMTAB
)
6318 CHECK_ENTSIZE (section
, i
, Sym
);
6319 else if (section
->sh_type
== SHT_GROUP
)
6320 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6321 else if (section
->sh_type
== SHT_REL
)
6322 CHECK_ENTSIZE (section
, i
, Rel
);
6323 else if (section
->sh_type
== SHT_RELA
)
6324 CHECK_ENTSIZE (section
, i
, Rela
);
6325 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6326 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6327 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6328 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6329 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6330 && (const_strneq (name
, ".debug_")
6331 || const_strneq (name
, ".zdebug_")))
6334 name
+= sizeof (".zdebug_") - 1;
6336 name
+= sizeof (".debug_") - 1;
6339 || (do_debug_info
&& const_strneq (name
, "info"))
6340 || (do_debug_info
&& const_strneq (name
, "types"))
6341 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6342 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6343 || (do_debug_lines
&& const_strneq (name
, "line."))
6344 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6345 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6346 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6347 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6348 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6349 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6350 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6351 || (do_debug_frames
&& const_strneq (name
, "frame"))
6352 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6353 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6354 || (do_debug_str
&& const_strneq (name
, "str"))
6355 || (do_debug_loc
&& const_strneq (name
, "loc"))
6356 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6357 || (do_debug_addr
&& const_strneq (name
, "addr"))
6358 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6359 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6361 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6363 /* Linkonce section to be combined with .debug_info at link time. */
6364 else if ((do_debugging
|| do_debug_info
)
6365 && const_strneq (name
, ".gnu.linkonce.wi."))
6366 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6367 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6368 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6369 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6370 || streq (name
, ".debug_names")))
6371 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6372 /* Trace sections for Itanium VMS. */
6373 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6374 || do_trace_aranges
)
6375 && const_strneq (name
, ".trace_"))
6377 name
+= sizeof (".trace_") - 1;
6380 || (do_trace_info
&& streq (name
, "info"))
6381 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6382 || (do_trace_aranges
&& streq (name
, "aranges"))
6384 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6386 else if ((do_debugging
|| do_debug_links
)
6387 && (const_strneq (name
, ".gnu_debuglink")
6388 || const_strneq (name
, ".gnu_debugaltlink")))
6389 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6395 if (filedata
->file_header
.e_shnum
> 1)
6396 printf (_("\nSection Headers:\n"));
6398 printf (_("\nSection Header:\n"));
6402 if (do_section_details
)
6404 printf (_(" [Nr] Name\n"));
6405 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6409 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6413 if (do_section_details
)
6415 printf (_(" [Nr] Name\n"));
6416 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6420 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6424 if (do_section_details
)
6426 printf (_(" [Nr] Name\n"));
6427 printf (_(" Type Address Offset Link\n"));
6428 printf (_(" Size EntSize Info Align\n"));
6432 printf (_(" [Nr] Name Type Address Offset\n"));
6433 printf (_(" Size EntSize Flags Link Info Align\n"));
6437 if (do_section_details
)
6438 printf (_(" Flags\n"));
6440 for (i
= 0, section
= filedata
->section_headers
;
6441 i
< filedata
->file_header
.e_shnum
;
6444 /* Run some sanity checks on the section header. */
6446 /* Check the sh_link field. */
6447 switch (section
->sh_type
)
6451 if (section
->sh_link
== 0
6452 && (filedata
->file_header
.e_type
== ET_EXEC
6453 || filedata
->file_header
.e_type
== ET_DYN
))
6454 /* A dynamic relocation section where all entries use a
6455 zero symbol index need not specify a symtab section. */
6458 case SHT_SYMTAB_SHNDX
:
6462 case SHT_GNU_versym
:
6463 if (section
->sh_link
== 0
6464 || section
->sh_link
>= filedata
->file_header
.e_shnum
6465 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6466 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6467 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6468 i
, section
->sh_link
);
6474 case SHT_GNU_verneed
:
6475 case SHT_GNU_verdef
:
6476 case SHT_GNU_LIBLIST
:
6477 if (section
->sh_link
== 0
6478 || section
->sh_link
>= filedata
->file_header
.e_shnum
6479 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6480 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6481 i
, section
->sh_link
);
6484 case SHT_INIT_ARRAY
:
6485 case SHT_FINI_ARRAY
:
6486 case SHT_PREINIT_ARRAY
:
6487 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6488 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6489 i
, section
->sh_link
);
6493 /* FIXME: Add support for target specific section types. */
6494 #if 0 /* Currently we do not check other section types as there are too
6495 many special cases. Stab sections for example have a type
6496 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6498 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6499 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6500 i
, section
->sh_link
);
6505 /* Check the sh_info field. */
6506 switch (section
->sh_type
)
6510 if (section
->sh_info
== 0
6511 && (filedata
->file_header
.e_type
== ET_EXEC
6512 || filedata
->file_header
.e_type
== ET_DYN
))
6513 /* Dynamic relocations apply to segments, so they do not
6514 need to specify the section they relocate. */
6516 if (section
->sh_info
== 0
6517 || section
->sh_info
>= filedata
->file_header
.e_shnum
6518 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6519 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6520 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6521 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6522 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6523 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6524 /* FIXME: Are other section types valid ? */
6525 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6526 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6527 i
, section
->sh_info
);
6532 case SHT_SYMTAB_SHNDX
:
6533 case SHT_INIT_ARRAY
:
6534 case SHT_FINI_ARRAY
:
6535 case SHT_PREINIT_ARRAY
:
6536 if (section
->sh_info
!= 0)
6537 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6538 i
, section
->sh_info
);
6544 /* A symbol index - we assume that it is valid. */
6548 /* FIXME: Add support for target specific section types. */
6549 if (section
->sh_type
== SHT_NOBITS
)
6550 /* NOBITS section headers with non-zero sh_info fields can be
6551 created when a binary is stripped of everything but its debug
6552 information. The stripped sections have their headers
6553 preserved but their types set to SHT_NOBITS. So do not check
6554 this type of section. */
6556 else if (section
->sh_flags
& SHF_INFO_LINK
)
6558 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6559 warn (_("[%2u]: Expected link to another section in info field"), i
);
6561 else if (section
->sh_type
< SHT_LOOS
6562 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6563 && section
->sh_info
!= 0)
6564 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6565 i
, section
->sh_info
);
6569 /* Check the sh_size field. */
6570 if (section
->sh_size
> filedata
->file_size
6571 && section
->sh_type
!= SHT_NOBITS
6572 && section
->sh_type
!= SHT_NULL
6573 && section
->sh_type
< SHT_LOOS
)
6574 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6576 printf (" [%2u] ", i
);
6577 if (do_section_details
)
6578 printf ("%s\n ", printable_section_name (filedata
, section
));
6580 print_symbol (-17, SECTION_NAME (section
));
6582 printf (do_wide
? " %-15s " : " %-15.15s ",
6583 get_section_type_name (filedata
, section
->sh_type
));
6587 const char * link_too_big
= NULL
;
6589 print_vma (section
->sh_addr
, LONG_HEX
);
6591 printf ( " %6.6lx %6.6lx %2.2lx",
6592 (unsigned long) section
->sh_offset
,
6593 (unsigned long) section
->sh_size
,
6594 (unsigned long) section
->sh_entsize
);
6596 if (do_section_details
)
6597 fputs (" ", stdout
);
6599 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6601 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6604 /* The sh_link value is out of range. Normally this indicates
6605 an error but it can have special values in Solaris binaries. */
6606 switch (filedata
->file_header
.e_machine
)
6613 case EM_OLD_SPARCV9
:
6614 case EM_SPARC32PLUS
:
6617 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6618 link_too_big
= "BEFORE";
6619 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6620 link_too_big
= "AFTER";
6627 if (do_section_details
)
6629 if (link_too_big
!= NULL
&& * link_too_big
)
6630 printf ("<%s> ", link_too_big
);
6632 printf ("%2u ", section
->sh_link
);
6633 printf ("%3u %2lu\n", section
->sh_info
,
6634 (unsigned long) section
->sh_addralign
);
6637 printf ("%2u %3u %2lu\n",
6640 (unsigned long) section
->sh_addralign
);
6642 if (link_too_big
&& ! * link_too_big
)
6643 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6644 i
, section
->sh_link
);
6648 print_vma (section
->sh_addr
, LONG_HEX
);
6650 if ((long) section
->sh_offset
== section
->sh_offset
)
6651 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6655 print_vma (section
->sh_offset
, LONG_HEX
);
6658 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6659 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6663 print_vma (section
->sh_size
, LONG_HEX
);
6666 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6667 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6671 print_vma (section
->sh_entsize
, LONG_HEX
);
6674 if (do_section_details
)
6675 fputs (" ", stdout
);
6677 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6679 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6681 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6682 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6685 print_vma (section
->sh_addralign
, DEC
);
6689 else if (do_section_details
)
6692 print_vma (section
->sh_addr
, LONG_HEX
);
6693 if ((long) section
->sh_offset
== section
->sh_offset
)
6694 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6698 print_vma (section
->sh_offset
, LONG_HEX
);
6700 printf (" %u\n ", section
->sh_link
);
6701 print_vma (section
->sh_size
, LONG_HEX
);
6703 print_vma (section
->sh_entsize
, LONG_HEX
);
6705 printf (" %-16u %lu\n",
6707 (unsigned long) section
->sh_addralign
);
6712 print_vma (section
->sh_addr
, LONG_HEX
);
6713 if ((long) section
->sh_offset
== section
->sh_offset
)
6714 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6718 print_vma (section
->sh_offset
, LONG_HEX
);
6721 print_vma (section
->sh_size
, LONG_HEX
);
6723 print_vma (section
->sh_entsize
, LONG_HEX
);
6725 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6727 printf (" %2u %3u %lu\n",
6730 (unsigned long) section
->sh_addralign
);
6733 if (do_section_details
)
6735 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6736 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6738 /* Minimum section size is 12 bytes for 32-bit compression
6739 header + 12 bytes for compressed data header. */
6740 unsigned char buf
[24];
6742 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6743 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6744 sizeof (buf
), _("compression header")))
6746 Elf_Internal_Chdr chdr
;
6748 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6749 printf (_(" [<corrupt>]\n"));
6752 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6755 printf (_(" [<unknown>: 0x%x], "),
6757 print_vma (chdr
.ch_size
, LONG_HEX
);
6758 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6765 if (!do_section_details
)
6767 /* The ordering of the letters shown here matches the ordering of the
6768 corresponding SHF_xxx values, and hence the order in which these
6769 letters will be displayed to the user. */
6770 printf (_("Key to Flags:\n\
6771 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6772 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6773 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6774 if (filedata
->file_header
.e_machine
== EM_X86_64
6775 || filedata
->file_header
.e_machine
== EM_L1OM
6776 || filedata
->file_header
.e_machine
== EM_K1OM
)
6777 printf (_("l (large), "));
6778 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6779 printf (_("y (purecode), "));
6780 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6781 printf (_("v (VLE), "));
6782 printf ("p (processor specific)\n");
6789 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6790 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6791 char **strtab
, unsigned long *strtablen
)
6795 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6797 if (*symtab
== NULL
)
6800 if (symsec
->sh_link
!= 0)
6802 Elf_Internal_Shdr
*strsec
;
6804 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6806 error (_("Bad sh_link in symbol table section\n"));
6813 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6815 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6816 1, strsec
->sh_size
, _("string table"));
6817 if (*strtab
== NULL
)
6824 *strtablen
= strsec
->sh_size
;
6830 get_group_flags (unsigned int flags
)
6832 static char buff
[128];
6836 else if (flags
== GRP_COMDAT
)
6839 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6841 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6842 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6843 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6844 ? _("<unknown>") : ""));
6850 process_section_groups (Filedata
* filedata
)
6852 Elf_Internal_Shdr
* section
;
6854 struct group
* group
;
6855 Elf_Internal_Shdr
* symtab_sec
;
6856 Elf_Internal_Shdr
* strtab_sec
;
6857 Elf_Internal_Sym
* symtab
;
6858 unsigned long num_syms
;
6862 /* Don't process section groups unless needed. */
6863 if (!do_unwind
&& !do_section_groups
)
6866 if (filedata
->file_header
.e_shnum
== 0)
6868 if (do_section_groups
)
6869 printf (_("\nThere are no sections to group in this file.\n"));
6874 if (filedata
->section_headers
== NULL
)
6876 error (_("Section headers are not available!\n"));
6877 /* PR 13622: This can happen with a corrupt ELF header. */
6881 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6882 sizeof (struct group
*));
6884 if (section_headers_groups
== NULL
)
6886 error (_("Out of memory reading %u section group headers\n"),
6887 filedata
->file_header
.e_shnum
);
6891 /* Scan the sections for the group section. */
6893 for (i
= 0, section
= filedata
->section_headers
;
6894 i
< filedata
->file_header
.e_shnum
;
6896 if (section
->sh_type
== SHT_GROUP
)
6899 if (group_count
== 0)
6901 if (do_section_groups
)
6902 printf (_("\nThere are no section groups in this file.\n"));
6907 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6909 if (section_groups
== NULL
)
6911 error (_("Out of memory reading %lu groups\n"),
6912 (unsigned long) group_count
);
6922 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6923 i
< filedata
->file_header
.e_shnum
;
6926 if (section
->sh_type
== SHT_GROUP
)
6928 const char * name
= printable_section_name (filedata
, section
);
6929 const char * group_name
;
6930 unsigned char * start
;
6931 unsigned char * indices
;
6932 unsigned int entry
, j
, size
;
6933 Elf_Internal_Shdr
* sec
;
6934 Elf_Internal_Sym
* sym
;
6936 /* Get the symbol table. */
6937 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6938 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6941 error (_("Bad sh_link in group section `%s'\n"), name
);
6945 if (symtab_sec
!= sec
)
6950 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6955 error (_("Corrupt header in group section `%s'\n"), name
);
6959 if (section
->sh_info
>= num_syms
)
6961 error (_("Bad sh_info in group section `%s'\n"), name
);
6965 sym
= symtab
+ section
->sh_info
;
6967 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6969 if (sym
->st_shndx
== 0
6970 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6972 error (_("Bad sh_info in group section `%s'\n"), name
);
6976 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6985 /* Get the string table. */
6986 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6995 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7001 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7002 1, strtab_sec
->sh_size
,
7004 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7006 group_name
= sym
->st_name
< strtab_size
7007 ? strtab
+ sym
->st_name
: _("<corrupt>");
7010 /* PR 17531: file: loop. */
7011 if (section
->sh_entsize
> section
->sh_size
)
7013 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7014 printable_section_name (filedata
, section
),
7015 (unsigned long) section
->sh_entsize
,
7016 (unsigned long) section
->sh_size
);
7020 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7021 1, section
->sh_size
,
7027 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7028 entry
= byte_get (indices
, 4);
7031 if (do_section_groups
)
7033 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7034 get_group_flags (entry
), i
, name
, group_name
, size
);
7036 printf (_(" [Index] Name\n"));
7039 group
->group_index
= i
;
7041 for (j
= 0; j
< size
; j
++)
7043 struct group_list
* g
;
7045 entry
= byte_get (indices
, 4);
7048 if (entry
>= filedata
->file_header
.e_shnum
)
7050 static unsigned num_group_errors
= 0;
7052 if (num_group_errors
++ < 10)
7054 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7055 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7056 if (num_group_errors
== 10)
7057 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7062 if (section_headers_groups
[entry
] != NULL
)
7066 static unsigned num_errs
= 0;
7068 if (num_errs
++ < 10)
7070 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7072 section_headers_groups
[entry
]->group_index
);
7074 warn (_("Further error messages about already contained group sections suppressed\n"));
7080 /* Intel C/C++ compiler may put section 0 in a
7081 section group. We just warn it the first time
7082 and ignore it afterwards. */
7083 static bfd_boolean warned
= FALSE
;
7086 error (_("section 0 in group section [%5u]\n"),
7087 section_headers_groups
[entry
]->group_index
);
7093 section_headers_groups
[entry
] = group
;
7095 if (do_section_groups
)
7097 sec
= filedata
->section_headers
+ entry
;
7098 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7101 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7102 g
->section_index
= entry
;
7103 g
->next
= group
->root
;
7121 /* Data used to display dynamic fixups. */
7123 struct ia64_vms_dynfixup
7125 bfd_vma needed_ident
; /* Library ident number. */
7126 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7127 bfd_vma fixup_needed
; /* Index of the library. */
7128 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7129 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7132 /* Data used to display dynamic relocations. */
7134 struct ia64_vms_dynimgrela
7136 bfd_vma img_rela_cnt
; /* Number of relocations. */
7137 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7140 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7144 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7145 struct ia64_vms_dynfixup
* fixup
,
7146 const char * strtab
,
7147 unsigned int strtab_sz
)
7149 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7151 const char * lib_name
;
7153 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7154 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7155 _("dynamic section image fixups"));
7159 if (fixup
->needed
< strtab_sz
)
7160 lib_name
= strtab
+ fixup
->needed
;
7163 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7164 (unsigned long) fixup
->needed
);
7168 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7169 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7171 (_("Seg Offset Type SymVec DataType\n"));
7173 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7178 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7179 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7180 type
= BYTE_GET (imfs
[i
].type
);
7181 rtype
= elf_ia64_reloc_type (type
);
7183 printf (" 0x%08x ", type
);
7185 printf (" %-32s ", rtype
);
7186 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7187 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7194 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7197 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7199 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7202 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7203 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7204 _("dynamic section image relocations"));
7208 printf (_("\nImage relocs\n"));
7210 (_("Seg Offset Type Addend Seg Sym Off\n"));
7212 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7217 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7218 printf ("%08" BFD_VMA_FMT
"x ",
7219 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7220 type
= BYTE_GET (imrs
[i
].type
);
7221 rtype
= elf_ia64_reloc_type (type
);
7223 printf ("0x%08x ", type
);
7225 printf ("%-31s ", rtype
);
7226 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7227 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7228 printf ("%08" BFD_VMA_FMT
"x\n",
7229 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7236 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7239 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7241 struct ia64_vms_dynfixup fixup
;
7242 struct ia64_vms_dynimgrela imgrela
;
7243 Elf_Internal_Dyn
*entry
;
7244 bfd_vma strtab_off
= 0;
7245 bfd_vma strtab_sz
= 0;
7246 char *strtab
= NULL
;
7247 bfd_boolean res
= TRUE
;
7249 memset (&fixup
, 0, sizeof (fixup
));
7250 memset (&imgrela
, 0, sizeof (imgrela
));
7252 /* Note: the order of the entries is specified by the OpenVMS specs. */
7253 for (entry
= dynamic_section
;
7254 entry
< dynamic_section
+ dynamic_nent
;
7257 switch (entry
->d_tag
)
7259 case DT_IA_64_VMS_STRTAB_OFFSET
:
7260 strtab_off
= entry
->d_un
.d_val
;
7263 strtab_sz
= entry
->d_un
.d_val
;
7265 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7266 1, strtab_sz
, _("dynamic string section"));
7271 case DT_IA_64_VMS_NEEDED_IDENT
:
7272 fixup
.needed_ident
= entry
->d_un
.d_val
;
7275 fixup
.needed
= entry
->d_un
.d_val
;
7277 case DT_IA_64_VMS_FIXUP_NEEDED
:
7278 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7280 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7281 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7283 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7284 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7285 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7288 case DT_IA_64_VMS_IMG_RELA_CNT
:
7289 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7291 case DT_IA_64_VMS_IMG_RELA_OFF
:
7292 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7293 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7315 dynamic_relocations
[] =
7317 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7318 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7319 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7322 /* Process the reloc section. */
7325 process_relocs (Filedata
* filedata
)
7327 unsigned long rel_size
;
7328 unsigned long rel_offset
;
7333 if (do_using_dynamic
)
7337 bfd_boolean has_dynamic_reloc
;
7340 has_dynamic_reloc
= FALSE
;
7342 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7344 is_rela
= dynamic_relocations
[i
].rela
;
7345 name
= dynamic_relocations
[i
].name
;
7346 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7347 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7350 has_dynamic_reloc
= TRUE
;
7352 if (is_rela
== UNKNOWN
)
7354 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7355 switch (dynamic_info
[DT_PLTREL
])
7369 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7370 name
, rel_offset
, rel_size
);
7372 dump_relocations (filedata
,
7373 offset_from_vma (filedata
, rel_offset
, rel_size
),
7375 dynamic_symbols
, num_dynamic_syms
,
7376 dynamic_strings
, dynamic_strings_length
,
7377 is_rela
, TRUE
/* is_dynamic */);
7381 if (is_ia64_vms (filedata
))
7382 if (process_ia64_vms_dynamic_relocs (filedata
))
7383 has_dynamic_reloc
= TRUE
;
7385 if (! has_dynamic_reloc
)
7386 printf (_("\nThere are no dynamic relocations in this file.\n"));
7390 Elf_Internal_Shdr
* section
;
7392 bfd_boolean found
= FALSE
;
7394 for (i
= 0, section
= filedata
->section_headers
;
7395 i
< filedata
->file_header
.e_shnum
;
7398 if ( section
->sh_type
!= SHT_RELA
7399 && section
->sh_type
!= SHT_REL
)
7402 rel_offset
= section
->sh_offset
;
7403 rel_size
= section
->sh_size
;
7408 unsigned long num_rela
;
7410 printf (_("\nRelocation section "));
7412 if (filedata
->string_table
== NULL
)
7413 printf ("%d", section
->sh_name
);
7415 printf ("'%s'", printable_section_name (filedata
, section
));
7417 num_rela
= rel_size
/ section
->sh_entsize
;
7418 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7419 " at offset 0x%lx contains %lu entries:\n",
7421 rel_offset
, num_rela
);
7423 is_rela
= section
->sh_type
== SHT_RELA
;
7425 if (section
->sh_link
!= 0
7426 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7428 Elf_Internal_Shdr
* symsec
;
7429 Elf_Internal_Sym
* symtab
;
7430 unsigned long nsyms
;
7431 unsigned long strtablen
= 0;
7432 char * strtab
= NULL
;
7434 symsec
= filedata
->section_headers
+ section
->sh_link
;
7435 if (symsec
->sh_type
!= SHT_SYMTAB
7436 && symsec
->sh_type
!= SHT_DYNSYM
)
7439 if (!get_symtab (filedata
, symsec
,
7440 &symtab
, &nsyms
, &strtab
, &strtablen
))
7443 dump_relocations (filedata
, rel_offset
, rel_size
,
7444 symtab
, nsyms
, strtab
, strtablen
,
7446 symsec
->sh_type
== SHT_DYNSYM
);
7452 dump_relocations (filedata
, rel_offset
, rel_size
,
7453 NULL
, 0, NULL
, 0, is_rela
,
7454 FALSE
/* is_dynamic */);
7462 /* Users sometimes forget the -D option, so try to be helpful. */
7463 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7465 if (dynamic_info
[dynamic_relocations
[i
].size
])
7467 printf (_("\nThere are no static relocations in this file."));
7468 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7473 if (i
== ARRAY_SIZE (dynamic_relocations
))
7474 printf (_("\nThere are no relocations in this file.\n"));
7481 /* An absolute address consists of a section and an offset. If the
7482 section is NULL, the offset itself is the address, otherwise, the
7483 address equals to LOAD_ADDRESS(section) + offset. */
7487 unsigned short section
;
7491 /* Find the nearest symbol at or below ADDR. Returns the symbol
7492 name, if found, and the offset from the symbol to ADDR. */
7495 find_symbol_for_address (Filedata
* filedata
,
7496 Elf_Internal_Sym
* symtab
,
7497 unsigned long nsyms
,
7498 const char * strtab
,
7499 unsigned long strtab_size
,
7500 struct absaddr addr
,
7501 const char ** symname
,
7504 bfd_vma dist
= 0x100000;
7505 Elf_Internal_Sym
* sym
;
7506 Elf_Internal_Sym
* beg
;
7507 Elf_Internal_Sym
* end
;
7508 Elf_Internal_Sym
* best
= NULL
;
7510 REMOVE_ARCH_BITS (addr
.offset
);
7512 end
= symtab
+ nsyms
;
7518 sym
= beg
+ (end
- beg
) / 2;
7520 value
= sym
->st_value
;
7521 REMOVE_ARCH_BITS (value
);
7523 if (sym
->st_name
!= 0
7524 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7525 && addr
.offset
>= value
7526 && addr
.offset
- value
< dist
)
7529 dist
= addr
.offset
- value
;
7534 if (addr
.offset
< value
)
7542 *symname
= (best
->st_name
>= strtab_size
7543 ? _("<corrupt>") : strtab
+ best
->st_name
);
7549 *offset
= addr
.offset
;
7552 static /* signed */ int
7553 symcmp (const void *p
, const void *q
)
7555 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7556 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7558 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7561 /* Process the unwind section. */
7563 #include "unwind-ia64.h"
7565 struct ia64_unw_table_entry
7567 struct absaddr start
;
7569 struct absaddr info
;
7572 struct ia64_unw_aux_info
7574 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7575 unsigned long table_len
; /* Length of unwind table. */
7576 unsigned char * info
; /* Unwind info. */
7577 unsigned long info_size
; /* Size of unwind info. */
7578 bfd_vma info_addr
; /* Starting address of unwind info. */
7579 bfd_vma seg_base
; /* Starting address of segment. */
7580 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7581 unsigned long nsyms
; /* Number of symbols. */
7582 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7583 unsigned long nfuns
; /* Number of entries in funtab. */
7584 char * strtab
; /* The string table. */
7585 unsigned long strtab_size
; /* Size of string table. */
7589 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7591 struct ia64_unw_table_entry
* tp
;
7592 unsigned long j
, nfuns
;
7594 bfd_boolean res
= TRUE
;
7596 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7597 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7598 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7599 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7601 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7603 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7607 const unsigned char * dp
;
7608 const unsigned char * head
;
7609 const unsigned char * end
;
7610 const char * procname
;
7612 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7613 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7615 fputs ("\n<", stdout
);
7619 fputs (procname
, stdout
);
7622 printf ("+%lx", (unsigned long) offset
);
7625 fputs (">: [", stdout
);
7626 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7627 fputc ('-', stdout
);
7628 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7629 printf ("], info at +0x%lx\n",
7630 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7632 /* PR 17531: file: 86232b32. */
7633 if (aux
->info
== NULL
)
7636 offset
= tp
->info
.offset
;
7637 if (tp
->info
.section
)
7639 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7641 warn (_("Invalid section %u in table entry %ld\n"),
7642 tp
->info
.section
, (long) (tp
- aux
->table
));
7646 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7648 offset
-= aux
->info_addr
;
7649 /* PR 17531: file: 0997b4d1. */
7650 if (offset
>= aux
->info_size
7651 || aux
->info_size
- offset
< 8)
7653 warn (_("Invalid offset %lx in table entry %ld\n"),
7654 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7659 head
= aux
->info
+ offset
;
7660 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7662 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7663 (unsigned) UNW_VER (stamp
),
7664 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7665 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7666 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7667 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7669 if (UNW_VER (stamp
) != 1)
7671 printf (_("\tUnknown version.\n"));
7676 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7677 /* PR 17531: file: 16ceda89. */
7678 if (end
> aux
->info
+ aux
->info_size
)
7679 end
= aux
->info
+ aux
->info_size
;
7680 for (dp
= head
+ 8; dp
< end
;)
7681 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7690 slurp_ia64_unwind_table (Filedata
* filedata
,
7691 struct ia64_unw_aux_info
* aux
,
7692 Elf_Internal_Shdr
* sec
)
7694 unsigned long size
, nrelas
, i
;
7695 Elf_Internal_Phdr
* seg
;
7696 struct ia64_unw_table_entry
* tep
;
7697 Elf_Internal_Shdr
* relsec
;
7698 Elf_Internal_Rela
* rela
;
7699 Elf_Internal_Rela
* rp
;
7700 unsigned char * table
;
7702 Elf_Internal_Sym
* sym
;
7703 const char * relname
;
7707 /* First, find the starting address of the segment that includes
7710 if (filedata
->file_header
.e_phnum
)
7712 if (! get_program_headers (filedata
))
7715 for (seg
= filedata
->program_headers
;
7716 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7719 if (seg
->p_type
!= PT_LOAD
)
7722 if (sec
->sh_addr
>= seg
->p_vaddr
7723 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7725 aux
->seg_base
= seg
->p_vaddr
;
7731 /* Second, build the unwind table from the contents of the unwind section: */
7732 size
= sec
->sh_size
;
7733 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7738 aux
->table_len
= size
/ (3 * eh_addr_size
);
7739 aux
->table
= (struct ia64_unw_table_entry
*)
7740 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7743 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7745 tep
->start
.section
= SHN_UNDEF
;
7746 tep
->end
.section
= SHN_UNDEF
;
7747 tep
->info
.section
= SHN_UNDEF
;
7748 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7749 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7750 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7751 tep
->start
.offset
+= aux
->seg_base
;
7752 tep
->end
.offset
+= aux
->seg_base
;
7753 tep
->info
.offset
+= aux
->seg_base
;
7757 /* Third, apply any relocations to the unwind table: */
7758 for (relsec
= filedata
->section_headers
;
7759 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7762 if (relsec
->sh_type
!= SHT_RELA
7763 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7764 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7767 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7776 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7778 unsigned int sym_ndx
;
7779 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7780 relname
= elf_ia64_reloc_type (r_type
);
7782 /* PR 17531: file: 9fa67536. */
7783 if (relname
== NULL
)
7785 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7789 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7791 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7795 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7797 /* PR 17531: file: 5bc8d9bf. */
7798 if (i
>= aux
->table_len
)
7800 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7804 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7805 if (sym_ndx
>= aux
->nsyms
)
7807 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7811 sym
= aux
->symtab
+ sym_ndx
;
7813 switch (rp
->r_offset
/ eh_addr_size
% 3)
7816 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7817 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7820 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7821 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7824 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7825 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7839 ia64_process_unwind (Filedata
* filedata
)
7841 Elf_Internal_Shdr
* sec
;
7842 Elf_Internal_Shdr
* unwsec
= NULL
;
7843 unsigned long i
, unwcount
= 0, unwstart
= 0;
7844 struct ia64_unw_aux_info aux
;
7845 bfd_boolean res
= TRUE
;
7847 memset (& aux
, 0, sizeof (aux
));
7849 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7851 if (sec
->sh_type
== SHT_SYMTAB
)
7855 error (_("Multiple symbol tables encountered\n"));
7861 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7862 &aux
.strtab
, &aux
.strtab_size
))
7865 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7870 printf (_("\nThere are no unwind sections in this file.\n"));
7872 while (unwcount
-- > 0)
7877 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7878 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7879 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7884 /* We have already counted the number of SHT_IA64_UNWIND
7885 sections so the loop above should never fail. */
7886 assert (unwsec
!= NULL
);
7889 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7891 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7893 /* We need to find which section group it is in. */
7894 struct group_list
* g
;
7896 if (section_headers_groups
== NULL
7897 || section_headers_groups
[i
] == NULL
)
7898 i
= filedata
->file_header
.e_shnum
;
7901 g
= section_headers_groups
[i
]->root
;
7903 for (; g
!= NULL
; g
= g
->next
)
7905 sec
= filedata
->section_headers
+ g
->section_index
;
7907 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7912 i
= filedata
->file_header
.e_shnum
;
7915 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7917 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7918 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7919 suffix
= SECTION_NAME (unwsec
) + len
;
7920 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7922 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7923 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7928 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7929 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7930 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7931 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7933 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7934 suffix
= SECTION_NAME (unwsec
) + len
;
7935 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7937 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7938 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7942 if (i
== filedata
->file_header
.e_shnum
)
7944 printf (_("\nCould not find unwind info section for "));
7946 if (filedata
->string_table
== NULL
)
7947 printf ("%d", unwsec
->sh_name
);
7949 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7953 aux
.info_addr
= sec
->sh_addr
;
7954 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7957 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7959 printf (_("\nUnwind section "));
7961 if (filedata
->string_table
== NULL
)
7962 printf ("%d", unwsec
->sh_name
);
7964 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7966 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7967 (unsigned long) unwsec
->sh_offset
,
7968 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7970 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7971 && aux
.table_len
> 0)
7972 dump_ia64_unwind (filedata
, & aux
);
7975 free ((char *) aux
.table
);
7977 free ((char *) aux
.info
);
7986 free ((char *) aux
.strtab
);
7991 struct hppa_unw_table_entry
7993 struct absaddr start
;
7995 unsigned int Cannot_unwind
:1; /* 0 */
7996 unsigned int Millicode
:1; /* 1 */
7997 unsigned int Millicode_save_sr0
:1; /* 2 */
7998 unsigned int Region_description
:2; /* 3..4 */
7999 unsigned int reserved1
:1; /* 5 */
8000 unsigned int Entry_SR
:1; /* 6 */
8001 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8002 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8003 unsigned int Args_stored
:1; /* 16 */
8004 unsigned int Variable_Frame
:1; /* 17 */
8005 unsigned int Separate_Package_Body
:1; /* 18 */
8006 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8007 unsigned int Stack_Overflow_Check
:1; /* 20 */
8008 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8009 unsigned int Ada_Region
:1; /* 22 */
8010 unsigned int cxx_info
:1; /* 23 */
8011 unsigned int cxx_try_catch
:1; /* 24 */
8012 unsigned int sched_entry_seq
:1; /* 25 */
8013 unsigned int reserved2
:1; /* 26 */
8014 unsigned int Save_SP
:1; /* 27 */
8015 unsigned int Save_RP
:1; /* 28 */
8016 unsigned int Save_MRP_in_frame
:1; /* 29 */
8017 unsigned int extn_ptr_defined
:1; /* 30 */
8018 unsigned int Cleanup_defined
:1; /* 31 */
8020 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8021 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8022 unsigned int Large_frame
:1; /* 2 */
8023 unsigned int Pseudo_SP_Set
:1; /* 3 */
8024 unsigned int reserved4
:1; /* 4 */
8025 unsigned int Total_frame_size
:27; /* 5..31 */
8028 struct hppa_unw_aux_info
8030 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8031 unsigned long table_len
; /* Length of unwind table. */
8032 bfd_vma seg_base
; /* Starting address of segment. */
8033 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8034 unsigned long nsyms
; /* Number of symbols. */
8035 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8036 unsigned long nfuns
; /* Number of entries in funtab. */
8037 char * strtab
; /* The string table. */
8038 unsigned long strtab_size
; /* Size of string table. */
8042 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8044 struct hppa_unw_table_entry
* tp
;
8045 unsigned long j
, nfuns
;
8046 bfd_boolean res
= TRUE
;
8048 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8049 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8050 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8051 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8053 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8055 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8058 const char * procname
;
8060 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8061 aux
->strtab_size
, tp
->start
, &procname
,
8064 fputs ("\n<", stdout
);
8068 fputs (procname
, stdout
);
8071 printf ("+%lx", (unsigned long) offset
);
8074 fputs (">: [", stdout
);
8075 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8076 fputc ('-', stdout
);
8077 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8080 #define PF(_m) if (tp->_m) printf (#_m " ");
8081 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8084 PF(Millicode_save_sr0
);
8085 /* PV(Region_description); */
8091 PF(Separate_Package_Body
);
8092 PF(Frame_Extension_Millicode
);
8093 PF(Stack_Overflow_Check
);
8094 PF(Two_Instruction_SP_Increment
);
8098 PF(sched_entry_seq
);
8101 PF(Save_MRP_in_frame
);
8102 PF(extn_ptr_defined
);
8103 PF(Cleanup_defined
);
8104 PF(MPE_XL_interrupt_marker
);
8105 PF(HP_UX_interrupt_marker
);
8108 PV(Total_frame_size
);
8121 slurp_hppa_unwind_table (Filedata
* filedata
,
8122 struct hppa_unw_aux_info
* aux
,
8123 Elf_Internal_Shdr
* sec
)
8125 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8126 Elf_Internal_Phdr
* seg
;
8127 struct hppa_unw_table_entry
* tep
;
8128 Elf_Internal_Shdr
* relsec
;
8129 Elf_Internal_Rela
* rela
;
8130 Elf_Internal_Rela
* rp
;
8131 unsigned char * table
;
8133 Elf_Internal_Sym
* sym
;
8134 const char * relname
;
8136 /* First, find the starting address of the segment that includes
8138 if (filedata
->file_header
.e_phnum
)
8140 if (! get_program_headers (filedata
))
8143 for (seg
= filedata
->program_headers
;
8144 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8147 if (seg
->p_type
!= PT_LOAD
)
8150 if (sec
->sh_addr
>= seg
->p_vaddr
8151 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8153 aux
->seg_base
= seg
->p_vaddr
;
8159 /* Second, build the unwind table from the contents of the unwind
8161 size
= sec
->sh_size
;
8162 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8168 nentries
= size
/ unw_ent_size
;
8169 size
= unw_ent_size
* nentries
;
8171 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8172 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8174 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8176 unsigned int tmp1
, tmp2
;
8178 tep
->start
.section
= SHN_UNDEF
;
8179 tep
->end
.section
= SHN_UNDEF
;
8181 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8182 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8183 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8184 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8186 tep
->start
.offset
+= aux
->seg_base
;
8187 tep
->end
.offset
+= aux
->seg_base
;
8189 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8190 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8191 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8192 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8193 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8194 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8195 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8196 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8197 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8198 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8199 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8200 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8201 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8202 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8203 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8204 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8205 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8206 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8207 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8208 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8209 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8210 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8211 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8212 tep
->Cleanup_defined
= tmp1
& 0x1;
8214 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8215 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8216 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8217 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8218 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8219 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8223 /* Third, apply any relocations to the unwind table. */
8224 for (relsec
= filedata
->section_headers
;
8225 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8228 if (relsec
->sh_type
!= SHT_RELA
8229 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8230 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8233 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8237 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8239 unsigned int sym_ndx
;
8240 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8241 relname
= elf_hppa_reloc_type (r_type
);
8243 if (relname
== NULL
)
8245 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8249 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8250 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8252 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8256 i
= rp
->r_offset
/ unw_ent_size
;
8257 if (i
>= aux
->table_len
)
8259 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8263 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8264 if (sym_ndx
>= aux
->nsyms
)
8266 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8270 sym
= aux
->symtab
+ sym_ndx
;
8272 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8275 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8276 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8279 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8280 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8290 aux
->table_len
= nentries
;
8296 hppa_process_unwind (Filedata
* filedata
)
8298 struct hppa_unw_aux_info aux
;
8299 Elf_Internal_Shdr
* unwsec
= NULL
;
8300 Elf_Internal_Shdr
* sec
;
8302 bfd_boolean res
= TRUE
;
8304 if (filedata
->string_table
== NULL
)
8307 memset (& aux
, 0, sizeof (aux
));
8309 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8311 if (sec
->sh_type
== SHT_SYMTAB
)
8315 error (_("Multiple symbol tables encountered\n"));
8321 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8322 &aux
.strtab
, &aux
.strtab_size
))
8325 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8330 printf (_("\nThere are no unwind sections in this file.\n"));
8332 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8334 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8336 unsigned long num_unwind
= sec
->sh_size
/ 16;
8338 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8339 "contains %lu entry:\n",
8340 "\nUnwind section '%s' at offset 0x%lx "
8341 "contains %lu entries:\n",
8343 printable_section_name (filedata
, sec
),
8344 (unsigned long) sec
->sh_offset
,
8347 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8350 if (res
&& aux
.table_len
> 0)
8352 if (! dump_hppa_unwind (filedata
, &aux
))
8357 free ((char *) aux
.table
);
8365 free ((char *) aux
.strtab
);
8372 unsigned char * data
; /* The unwind data. */
8373 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8374 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8375 unsigned long nrelas
; /* The number of relocations. */
8376 unsigned int rel_type
; /* REL or RELA ? */
8377 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8380 struct arm_unw_aux_info
8382 Filedata
* filedata
; /* The file containing the unwind sections. */
8383 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8384 unsigned long nsyms
; /* Number of symbols. */
8385 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8386 unsigned long nfuns
; /* Number of these symbols. */
8387 char * strtab
; /* The file's string table. */
8388 unsigned long strtab_size
; /* Size of string table. */
8392 arm_print_vma_and_name (Filedata
* filedata
,
8393 struct arm_unw_aux_info
* aux
,
8395 struct absaddr addr
)
8397 const char *procname
;
8400 if (addr
.section
== SHN_UNDEF
)
8403 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8404 aux
->strtab_size
, addr
, &procname
,
8407 print_vma (fn
, PREFIX_HEX
);
8411 fputs (" <", stdout
);
8412 fputs (procname
, stdout
);
8415 printf ("+0x%lx", (unsigned long) sym_offset
);
8416 fputc ('>', stdout
);
8423 arm_free_section (struct arm_section
*arm_sec
)
8425 if (arm_sec
->data
!= NULL
)
8426 free (arm_sec
->data
);
8428 if (arm_sec
->rela
!= NULL
)
8429 free (arm_sec
->rela
);
8432 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8433 cached section and install SEC instead.
8434 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8435 and return its valued in * WORDP, relocating if necessary.
8436 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8437 relocation's offset in ADDR.
8438 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8439 into the string table of the symbol associated with the reloc. If no
8440 reloc was applied store -1 there.
8441 5) Return TRUE upon success, FALSE otherwise. */
8444 get_unwind_section_word (Filedata
* filedata
,
8445 struct arm_unw_aux_info
* aux
,
8446 struct arm_section
* arm_sec
,
8447 Elf_Internal_Shdr
* sec
,
8448 bfd_vma word_offset
,
8449 unsigned int * wordp
,
8450 struct absaddr
* addr
,
8453 Elf_Internal_Rela
*rp
;
8454 Elf_Internal_Sym
*sym
;
8455 const char * relname
;
8457 bfd_boolean wrapped
;
8459 if (sec
== NULL
|| arm_sec
== NULL
)
8462 addr
->section
= SHN_UNDEF
;
8465 if (sym_name
!= NULL
)
8466 *sym_name
= (bfd_vma
) -1;
8468 /* If necessary, update the section cache. */
8469 if (sec
!= arm_sec
->sec
)
8471 Elf_Internal_Shdr
*relsec
;
8473 arm_free_section (arm_sec
);
8476 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8477 sec
->sh_size
, _("unwind data"));
8478 arm_sec
->rela
= NULL
;
8479 arm_sec
->nrelas
= 0;
8481 for (relsec
= filedata
->section_headers
;
8482 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8485 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8486 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8487 /* PR 15745: Check the section type as well. */
8488 || (relsec
->sh_type
!= SHT_REL
8489 && relsec
->sh_type
!= SHT_RELA
))
8492 arm_sec
->rel_type
= relsec
->sh_type
;
8493 if (relsec
->sh_type
== SHT_REL
)
8495 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8497 & arm_sec
->rela
, & arm_sec
->nrelas
))
8500 else /* relsec->sh_type == SHT_RELA */
8502 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8504 & arm_sec
->rela
, & arm_sec
->nrelas
))
8510 arm_sec
->next_rela
= arm_sec
->rela
;
8513 /* If there is no unwind data we can do nothing. */
8514 if (arm_sec
->data
== NULL
)
8517 /* If the offset is invalid then fail. */
8518 if (/* PR 21343 *//* PR 18879 */
8520 || word_offset
> (sec
->sh_size
- 4)
8521 || ((bfd_signed_vma
) word_offset
) < 0)
8524 /* Get the word at the required offset. */
8525 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8527 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8528 if (arm_sec
->rela
== NULL
)
8534 /* Look through the relocs to find the one that applies to the provided offset. */
8536 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8538 bfd_vma prelval
, offset
;
8540 if (rp
->r_offset
> word_offset
&& !wrapped
)
8545 if (rp
->r_offset
> word_offset
)
8548 if (rp
->r_offset
& 3)
8550 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8551 (unsigned long) rp
->r_offset
);
8555 if (rp
->r_offset
< word_offset
)
8558 /* PR 17531: file: 027-161405-0.004 */
8559 if (aux
->symtab
== NULL
)
8562 if (arm_sec
->rel_type
== SHT_REL
)
8564 offset
= word
& 0x7fffffff;
8565 if (offset
& 0x40000000)
8566 offset
|= ~ (bfd_vma
) 0x7fffffff;
8568 else if (arm_sec
->rel_type
== SHT_RELA
)
8569 offset
= rp
->r_addend
;
8572 error (_("Unknown section relocation type %d encountered\n"),
8577 /* PR 17531 file: 027-1241568-0.004. */
8578 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8580 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8581 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8585 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8586 offset
+= sym
->st_value
;
8587 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8589 /* Check that we are processing the expected reloc type. */
8590 if (filedata
->file_header
.e_machine
== EM_ARM
)
8592 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8593 if (relname
== NULL
)
8595 warn (_("Skipping unknown ARM relocation type: %d\n"),
8596 (int) ELF32_R_TYPE (rp
->r_info
));
8600 if (streq (relname
, "R_ARM_NONE"))
8603 if (! streq (relname
, "R_ARM_PREL31"))
8605 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8609 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8611 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8612 if (relname
== NULL
)
8614 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8615 (int) ELF32_R_TYPE (rp
->r_info
));
8619 if (streq (relname
, "R_C6000_NONE"))
8622 if (! streq (relname
, "R_C6000_PREL31"))
8624 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8632 /* This function currently only supports ARM and TI unwinders. */
8633 warn (_("Only TI and ARM unwinders are currently supported\n"));
8637 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8638 addr
->section
= sym
->st_shndx
;
8639 addr
->offset
= offset
;
8642 * sym_name
= sym
->st_name
;
8647 arm_sec
->next_rela
= rp
;
8652 static const char *tic6x_unwind_regnames
[16] =
8654 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8655 "A14", "A13", "A12", "A11", "A10",
8656 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8660 decode_tic6x_unwind_regmask (unsigned int mask
)
8664 for (i
= 12; mask
; mask
>>= 1, i
--)
8668 fputs (tic6x_unwind_regnames
[i
], stdout
);
8670 fputs (", ", stdout
);
8676 if (remaining == 0 && more_words) \
8679 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8680 data_offset, & word, & addr, NULL)) \
8686 #define GET_OP(OP) \
8691 (OP) = word >> 24; \
8696 printf (_("[Truncated opcode]\n")); \
8699 printf ("0x%02x ", OP)
8702 decode_arm_unwind_bytecode (Filedata
* filedata
,
8703 struct arm_unw_aux_info
* aux
,
8705 unsigned int remaining
,
8706 unsigned int more_words
,
8707 bfd_vma data_offset
,
8708 Elf_Internal_Shdr
* data_sec
,
8709 struct arm_section
* data_arm_sec
)
8711 struct absaddr addr
;
8712 bfd_boolean res
= TRUE
;
8714 /* Decode the unwinding instructions. */
8717 unsigned int op
, op2
;
8726 printf (" 0x%02x ", op
);
8728 if ((op
& 0xc0) == 0x00)
8730 int offset
= ((op
& 0x3f) << 2) + 4;
8732 printf (" vsp = vsp + %d", offset
);
8734 else if ((op
& 0xc0) == 0x40)
8736 int offset
= ((op
& 0x3f) << 2) + 4;
8738 printf (" vsp = vsp - %d", offset
);
8740 else if ((op
& 0xf0) == 0x80)
8743 if (op
== 0x80 && op2
== 0)
8744 printf (_("Refuse to unwind"));
8747 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8748 bfd_boolean first
= TRUE
;
8752 for (i
= 0; i
< 12; i
++)
8753 if (mask
& (1 << i
))
8759 printf ("r%d", 4 + i
);
8764 else if ((op
& 0xf0) == 0x90)
8766 if (op
== 0x9d || op
== 0x9f)
8767 printf (_(" [Reserved]"));
8769 printf (" vsp = r%d", op
& 0x0f);
8771 else if ((op
& 0xf0) == 0xa0)
8773 int end
= 4 + (op
& 0x07);
8774 bfd_boolean first
= TRUE
;
8778 for (i
= 4; i
<= end
; i
++)
8794 else if (op
== 0xb0)
8795 printf (_(" finish"));
8796 else if (op
== 0xb1)
8799 if (op2
== 0 || (op2
& 0xf0) != 0)
8800 printf (_("[Spare]"));
8803 unsigned int mask
= op2
& 0x0f;
8804 bfd_boolean first
= TRUE
;
8808 for (i
= 0; i
< 12; i
++)
8809 if (mask
& (1 << i
))
8820 else if (op
== 0xb2)
8822 unsigned char buf
[9];
8823 unsigned int i
, len
;
8824 unsigned long offset
;
8826 for (i
= 0; i
< sizeof (buf
); i
++)
8829 if ((buf
[i
] & 0x80) == 0)
8832 if (i
== sizeof (buf
))
8834 error (_("corrupt change to vsp\n"));
8839 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8840 assert (len
== i
+ 1);
8841 offset
= offset
* 4 + 0x204;
8842 printf ("vsp = vsp + %ld", offset
);
8845 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8847 unsigned int first
, last
;
8854 printf ("pop {D%d", first
);
8856 printf ("-D%d", first
+ last
);
8859 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8861 unsigned int count
= op
& 0x07;
8865 printf ("-D%d", 8 + count
);
8868 else if (op
>= 0xc0 && op
<= 0xc5)
8870 unsigned int count
= op
& 0x07;
8872 printf (" pop {wR10");
8874 printf ("-wR%d", 10 + count
);
8877 else if (op
== 0xc6)
8879 unsigned int first
, last
;
8884 printf ("pop {wR%d", first
);
8886 printf ("-wR%d", first
+ last
);
8889 else if (op
== 0xc7)
8892 if (op2
== 0 || (op2
& 0xf0) != 0)
8893 printf (_("[Spare]"));
8896 unsigned int mask
= op2
& 0x0f;
8897 bfd_boolean first
= TRUE
;
8901 for (i
= 0; i
< 4; i
++)
8902 if (mask
& (1 << i
))
8908 printf ("wCGR%d", i
);
8915 printf (_(" [unsupported opcode]"));
8926 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8927 struct arm_unw_aux_info
* aux
,
8929 unsigned int remaining
,
8930 unsigned int more_words
,
8931 bfd_vma data_offset
,
8932 Elf_Internal_Shdr
* data_sec
,
8933 struct arm_section
* data_arm_sec
)
8935 struct absaddr addr
;
8937 /* Decode the unwinding instructions. */
8940 unsigned int op
, op2
;
8949 printf (" 0x%02x ", op
);
8951 if ((op
& 0xc0) == 0x00)
8953 int offset
= ((op
& 0x3f) << 3) + 8;
8954 printf (" sp = sp + %d", offset
);
8956 else if ((op
& 0xc0) == 0x80)
8959 if (op
== 0x80 && op2
== 0)
8960 printf (_("Refuse to unwind"));
8963 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8965 printf ("pop compact {");
8969 decode_tic6x_unwind_regmask (mask
);
8973 else if ((op
& 0xf0) == 0xc0)
8981 unsigned int offset
;
8985 /* Scan entire instruction first so that GET_OP output is not
8986 interleaved with disassembly. */
8988 for (i
= 0; nregs
< (op
& 0xf); i
++)
8994 regpos
[nregs
].offset
= i
* 2;
8995 regpos
[nregs
].reg
= reg
;
9002 regpos
[nregs
].offset
= i
* 2 + 1;
9003 regpos
[nregs
].reg
= reg
;
9008 printf (_("pop frame {"));
9011 printf (_("*corrupt* - no registers specified"));
9016 for (i
= i
* 2; i
> 0; i
--)
9018 if (regpos
[reg
].offset
== i
- 1)
9020 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9027 fputs (name
, stdout
);
9035 else if (op
== 0xd0)
9036 printf (" MOV FP, SP");
9037 else if (op
== 0xd1)
9038 printf (" __c6xabi_pop_rts");
9039 else if (op
== 0xd2)
9041 unsigned char buf
[9];
9042 unsigned int i
, len
;
9043 unsigned long offset
;
9045 for (i
= 0; i
< sizeof (buf
); i
++)
9048 if ((buf
[i
] & 0x80) == 0)
9051 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9052 if (i
== sizeof (buf
))
9054 warn (_("Corrupt stack pointer adjustment detected\n"));
9058 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9059 assert (len
== i
+ 1);
9060 offset
= offset
* 8 + 0x408;
9061 printf (_("sp = sp + %ld"), offset
);
9063 else if ((op
& 0xf0) == 0xe0)
9065 if ((op
& 0x0f) == 7)
9068 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9072 printf (_(" [unsupported opcode]"));
9081 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9085 offset
= word
& 0x7fffffff;
9086 if (offset
& 0x40000000)
9087 offset
|= ~ (bfd_vma
) 0x7fffffff;
9089 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9092 return offset
+ where
;
9096 decode_arm_unwind (Filedata
* filedata
,
9097 struct arm_unw_aux_info
* aux
,
9099 unsigned int remaining
,
9100 bfd_vma data_offset
,
9101 Elf_Internal_Shdr
* data_sec
,
9102 struct arm_section
* data_arm_sec
)
9105 unsigned int more_words
= 0;
9106 struct absaddr addr
;
9107 bfd_vma sym_name
= (bfd_vma
) -1;
9108 bfd_boolean res
= TRUE
;
9112 /* Fetch the first word.
9113 Note - when decoding an object file the address extracted
9114 here will always be 0. So we also pass in the sym_name
9115 parameter so that we can find the symbol associated with
9116 the personality routine. */
9117 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9118 & word
, & addr
, & sym_name
))
9125 addr
.section
= SHN_UNDEF
;
9129 if ((word
& 0x80000000) == 0)
9131 /* Expand prel31 for personality routine. */
9133 const char *procname
;
9135 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9136 printf (_(" Personality routine: "));
9138 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9139 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9141 procname
= aux
->strtab
+ sym_name
;
9142 print_vma (fn
, PREFIX_HEX
);
9145 fputs (" <", stdout
);
9146 fputs (procname
, stdout
);
9147 fputc ('>', stdout
);
9151 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9152 fputc ('\n', stdout
);
9154 /* The GCC personality routines use the standard compact
9155 encoding, starting with one byte giving the number of
9157 if (procname
!= NULL
9158 && (const_strneq (procname
, "__gcc_personality_v0")
9159 || const_strneq (procname
, "__gxx_personality_v0")
9160 || const_strneq (procname
, "__gcj_personality_v0")
9161 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9168 printf (_(" [Truncated data]\n"));
9171 more_words
= word
>> 24;
9181 /* ARM EHABI Section 6.3:
9183 An exception-handling table entry for the compact model looks like:
9187 1 0 index Data for personalityRoutine[index] */
9189 if (filedata
->file_header
.e_machine
== EM_ARM
9190 && (word
& 0x70000000))
9192 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9196 per_index
= (word
>> 24) & 0x7f;
9197 printf (_(" Compact model index: %d\n"), per_index
);
9204 else if (per_index
< 3)
9206 more_words
= (word
>> 16) & 0xff;
9212 switch (filedata
->file_header
.e_machine
)
9217 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9218 data_offset
, data_sec
, data_arm_sec
))
9223 warn (_("Unknown ARM compact model index encountered\n"));
9224 printf (_(" [reserved]\n"));
9232 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9233 data_offset
, data_sec
, data_arm_sec
))
9236 else if (per_index
< 5)
9238 if (((word
>> 17) & 0x7f) == 0x7f)
9239 printf (_(" Restore stack from frame pointer\n"));
9241 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9242 printf (_(" Registers restored: "));
9244 printf (" (compact) ");
9245 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9247 printf (_(" Return register: %s\n"),
9248 tic6x_unwind_regnames
[word
& 0xf]);
9251 printf (_(" [reserved (%d)]\n"), per_index
);
9255 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9256 filedata
->file_header
.e_machine
);
9260 /* Decode the descriptors. Not implemented. */
9266 dump_arm_unwind (Filedata
* filedata
,
9267 struct arm_unw_aux_info
* aux
,
9268 Elf_Internal_Shdr
* exidx_sec
)
9270 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9271 unsigned int i
, exidx_len
;
9272 unsigned long j
, nfuns
;
9273 bfd_boolean res
= TRUE
;
9275 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9276 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9277 exidx_len
= exidx_sec
->sh_size
/ 8;
9279 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9280 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9281 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9282 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9284 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9286 for (i
= 0; i
< exidx_len
; i
++)
9288 unsigned int exidx_fn
, exidx_entry
;
9289 struct absaddr fn_addr
, entry_addr
;
9292 fputc ('\n', stdout
);
9294 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9295 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9296 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9297 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9300 arm_free_section (& exidx_arm_sec
);
9301 arm_free_section (& extab_arm_sec
);
9305 /* ARM EHABI, Section 5:
9306 An index table entry consists of 2 words.
9307 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9308 if (exidx_fn
& 0x80000000)
9310 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9314 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9316 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9317 fputs (": ", stdout
);
9319 if (exidx_entry
== 1)
9321 print_vma (exidx_entry
, PREFIX_HEX
);
9322 fputs (" [cantunwind]\n", stdout
);
9324 else if (exidx_entry
& 0x80000000)
9326 print_vma (exidx_entry
, PREFIX_HEX
);
9327 fputc ('\n', stdout
);
9328 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9332 bfd_vma table
, table_offset
= 0;
9333 Elf_Internal_Shdr
*table_sec
;
9335 fputs ("@", stdout
);
9336 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9337 print_vma (table
, PREFIX_HEX
);
9340 /* Locate the matching .ARM.extab. */
9341 if (entry_addr
.section
!= SHN_UNDEF
9342 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9344 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9345 table_offset
= entry_addr
.offset
;
9347 if (table_offset
> table_sec
->sh_size
9348 || ((bfd_signed_vma
) table_offset
) < 0)
9350 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9351 (unsigned long) table_offset
,
9352 printable_section_name (filedata
, table_sec
));
9359 table_sec
= find_section_by_address (filedata
, table
);
9360 if (table_sec
!= NULL
)
9361 table_offset
= table
- table_sec
->sh_addr
;
9364 if (table_sec
== NULL
)
9366 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9367 (unsigned long) table
);
9372 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9381 arm_free_section (&exidx_arm_sec
);
9382 arm_free_section (&extab_arm_sec
);
9387 /* Used for both ARM and C6X unwinding tables. */
9390 arm_process_unwind (Filedata
* filedata
)
9392 struct arm_unw_aux_info aux
;
9393 Elf_Internal_Shdr
*unwsec
= NULL
;
9394 Elf_Internal_Shdr
*sec
;
9396 unsigned int sec_type
;
9397 bfd_boolean res
= TRUE
;
9399 switch (filedata
->file_header
.e_machine
)
9402 sec_type
= SHT_ARM_EXIDX
;
9406 sec_type
= SHT_C6000_UNWIND
;
9410 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9411 filedata
->file_header
.e_machine
);
9415 if (filedata
->string_table
== NULL
)
9418 memset (& aux
, 0, sizeof (aux
));
9419 aux
.filedata
= filedata
;
9421 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9423 if (sec
->sh_type
== SHT_SYMTAB
)
9427 error (_("Multiple symbol tables encountered\n"));
9433 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9434 &aux
.strtab
, &aux
.strtab_size
))
9437 else if (sec
->sh_type
== sec_type
)
9442 printf (_("\nThere are no unwind sections in this file.\n"));
9444 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9446 if (sec
->sh_type
== sec_type
)
9448 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9449 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9450 "contains %lu entry:\n",
9451 "\nUnwind section '%s' at offset 0x%lx "
9452 "contains %lu entries:\n",
9454 printable_section_name (filedata
, sec
),
9455 (unsigned long) sec
->sh_offset
,
9458 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9466 free ((char *) aux
.strtab
);
9472 process_unwind (Filedata
* filedata
)
9474 struct unwind_handler
9476 unsigned int machtype
;
9477 bfd_boolean (* handler
)(Filedata
*);
9480 { EM_ARM
, arm_process_unwind
},
9481 { EM_IA_64
, ia64_process_unwind
},
9482 { EM_PARISC
, hppa_process_unwind
},
9483 { EM_TI_C6000
, arm_process_unwind
},
9491 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9492 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9493 return handlers
[i
].handler (filedata
);
9495 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9496 get_machine_name (filedata
->file_header
.e_machine
));
9501 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9503 switch (entry
->d_tag
)
9505 case DT_AARCH64_BTI_PLT
:
9506 case DT_AARCH64_PAC_PLT
:
9509 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9516 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9518 switch (entry
->d_tag
)
9521 if (entry
->d_un
.d_val
== 0)
9525 static const char * opts
[] =
9527 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9528 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9529 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9530 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9534 bfd_boolean first
= TRUE
;
9536 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9537 if (entry
->d_un
.d_val
& (1 << cnt
))
9539 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9545 case DT_MIPS_IVERSION
:
9546 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9547 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9551 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9552 /* Note: coded this way so that there is a single string for translation. */
9553 printf (_("<corrupt: %s>"), buf
);
9557 case DT_MIPS_TIME_STAMP
:
9561 time_t atime
= entry
->d_un
.d_val
;
9563 tmp
= gmtime (&atime
);
9564 /* PR 17531: file: 6accc532. */
9566 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9568 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9569 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9570 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9571 printf (_("Time Stamp: %s"), timebuf
);
9575 case DT_MIPS_RLD_VERSION
:
9576 case DT_MIPS_LOCAL_GOTNO
:
9577 case DT_MIPS_CONFLICTNO
:
9578 case DT_MIPS_LIBLISTNO
:
9579 case DT_MIPS_SYMTABNO
:
9580 case DT_MIPS_UNREFEXTNO
:
9581 case DT_MIPS_HIPAGENO
:
9582 case DT_MIPS_DELTA_CLASS_NO
:
9583 case DT_MIPS_DELTA_INSTANCE_NO
:
9584 case DT_MIPS_DELTA_RELOC_NO
:
9585 case DT_MIPS_DELTA_SYM_NO
:
9586 case DT_MIPS_DELTA_CLASSSYM_NO
:
9587 case DT_MIPS_COMPACT_SIZE
:
9588 print_vma (entry
->d_un
.d_val
, DEC
);
9592 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9593 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9594 /* Falls through. */
9597 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9603 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9605 switch (entry
->d_tag
)
9607 case DT_HP_DLD_FLAGS
:
9616 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9617 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9618 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9619 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9620 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9621 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9622 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9623 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9624 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9625 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9626 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9627 { DT_HP_GST
, "HP_GST" },
9628 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9629 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9630 { DT_HP_NODELETE
, "HP_NODELETE" },
9631 { DT_HP_GROUP
, "HP_GROUP" },
9632 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9634 bfd_boolean first
= TRUE
;
9636 bfd_vma val
= entry
->d_un
.d_val
;
9638 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9639 if (val
& flags
[cnt
].bit
)
9643 fputs (flags
[cnt
].str
, stdout
);
9645 val
^= flags
[cnt
].bit
;
9648 if (val
!= 0 || first
)
9652 print_vma (val
, HEX
);
9658 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9666 /* VMS vs Unix time offset and factor. */
9668 #define VMS_EPOCH_OFFSET 35067168000000000LL
9669 #define VMS_GRANULARITY_FACTOR 10000000
9671 /* Display a VMS time in a human readable format. */
9674 print_vms_time (bfd_int64_t vmstime
)
9679 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9680 tm
= gmtime (&unxtime
);
9681 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9682 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9683 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9688 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9690 switch (entry
->d_tag
)
9692 case DT_IA_64_PLT_RESERVE
:
9693 /* First 3 slots reserved. */
9694 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9696 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9699 case DT_IA_64_VMS_LINKTIME
:
9701 print_vms_time (entry
->d_un
.d_val
);
9705 case DT_IA_64_VMS_LNKFLAGS
:
9706 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9707 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9708 printf (" CALL_DEBUG");
9709 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9710 printf (" NOP0BUFS");
9711 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9712 printf (" P0IMAGE");
9713 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9714 printf (" MKTHREADS");
9715 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9716 printf (" UPCALLS");
9717 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9719 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9720 printf (" INITIALIZE");
9721 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9723 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9724 printf (" EXE_INIT");
9725 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9726 printf (" TBK_IN_IMG");
9727 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9728 printf (" DBG_IN_IMG");
9729 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9730 printf (" TBK_IN_DSF");
9731 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9732 printf (" DBG_IN_DSF");
9733 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9734 printf (" SIGNATURES");
9735 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9736 printf (" REL_SEG_OFF");
9740 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9747 get_32bit_dynamic_section (Filedata
* filedata
)
9749 Elf32_External_Dyn
* edyn
;
9750 Elf32_External_Dyn
* ext
;
9751 Elf_Internal_Dyn
* entry
;
9753 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9754 dynamic_size
, _("dynamic section"));
9758 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9759 might not have the luxury of section headers. Look for the DT_NULL
9760 terminator to determine the number of entries. */
9761 for (ext
= edyn
, dynamic_nent
= 0;
9762 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9766 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9770 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9772 if (dynamic_section
== NULL
)
9774 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9775 (unsigned long) dynamic_nent
);
9780 for (ext
= edyn
, entry
= dynamic_section
;
9781 entry
< dynamic_section
+ dynamic_nent
;
9784 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9785 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9794 get_64bit_dynamic_section (Filedata
* filedata
)
9796 Elf64_External_Dyn
* edyn
;
9797 Elf64_External_Dyn
* ext
;
9798 Elf_Internal_Dyn
* entry
;
9800 /* Read in the data. */
9801 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9802 dynamic_size
, _("dynamic section"));
9806 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9807 might not have the luxury of section headers. Look for the DT_NULL
9808 terminator to determine the number of entries. */
9809 for (ext
= edyn
, dynamic_nent
= 0;
9810 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9811 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9815 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9819 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9821 if (dynamic_section
== NULL
)
9823 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9824 (unsigned long) dynamic_nent
);
9829 /* Convert from external to internal formats. */
9830 for (ext
= edyn
, entry
= dynamic_section
;
9831 entry
< dynamic_section
+ dynamic_nent
;
9834 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9835 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9844 print_dynamic_flags (bfd_vma flags
)
9846 bfd_boolean first
= TRUE
;
9852 flag
= flags
& - flags
;
9862 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9863 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9864 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9865 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9866 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9867 default: fputs (_("unknown"), stdout
); break;
9874 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9876 unsigned char * e_data
;
9879 /* If the size_t type is smaller than the bfd_size_type, eg because
9880 you are building a 32-bit tool on a 64-bit host, then make sure
9881 that when (number) is cast to (size_t) no information is lost. */
9882 if (sizeof (size_t) < sizeof (bfd_size_type
)
9883 && (bfd_size_type
) ((size_t) number
) != number
)
9885 error (_("Size truncation prevents reading %s elements of size %u\n"),
9886 bfd_vmatoa ("u", number
), ent_size
);
9890 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9891 attempting to allocate memory when the read is bound to fail. */
9892 if (ent_size
* number
> filedata
->file_size
)
9894 error (_("Invalid number of dynamic entries: %s\n"),
9895 bfd_vmatoa ("u", number
));
9899 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9902 error (_("Out of memory reading %s dynamic entries\n"),
9903 bfd_vmatoa ("u", number
));
9907 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9909 error (_("Unable to read in %s bytes of dynamic data\n"),
9910 bfd_vmatoa ("u", number
* ent_size
));
9915 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
9918 error (_("Out of memory allocating space for %s dynamic entries\n"),
9919 bfd_vmatoa ("u", number
));
9925 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9932 static unsigned long
9933 get_num_dynamic_syms (Filedata
* filedata
)
9935 unsigned long num_of_syms
= 0;
9937 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
9940 if (dynamic_info
[DT_HASH
])
9942 unsigned char nb
[8];
9943 unsigned char nc
[8];
9944 unsigned int hash_ent_size
= 4;
9946 if ((filedata
->file_header
.e_machine
== EM_ALPHA
9947 || filedata
->file_header
.e_machine
== EM_S390
9948 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
9949 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9952 if (fseek (filedata
->handle
,
9953 (archive_file_offset
9954 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
9955 sizeof nb
+ sizeof nc
)),
9958 error (_("Unable to seek to start of dynamic information\n"));
9962 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
9964 error (_("Failed to read in number of buckets\n"));
9968 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
9970 error (_("Failed to read in number of chains\n"));
9974 nbuckets
= byte_get (nb
, hash_ent_size
);
9975 nchains
= byte_get (nc
, hash_ent_size
);
9977 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
9978 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
9980 if (buckets
!= NULL
&& chains
!= NULL
)
9981 num_of_syms
= nchains
;
9984 if (num_of_syms
== 0)
10000 if (dynamic_info_DT_GNU_HASH
)
10002 unsigned char nb
[16];
10003 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10004 bfd_vma buckets_vma
;
10006 bfd_boolean gnu_hash_error
= FALSE
;
10008 if (fseek (filedata
->handle
,
10009 (archive_file_offset
10010 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
10014 error (_("Unable to seek to start of dynamic information\n"));
10015 gnu_hash_error
= TRUE
;
10019 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10021 error (_("Failed to read in number of buckets\n"));
10022 gnu_hash_error
= TRUE
;
10026 ngnubuckets
= byte_get (nb
, 4);
10027 gnusymidx
= byte_get (nb
+ 4, 4);
10028 bitmaskwords
= byte_get (nb
+ 8, 4);
10029 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10031 buckets_vma
+= bitmaskwords
* 4;
10033 buckets_vma
+= bitmaskwords
* 8;
10035 if (fseek (filedata
->handle
,
10036 (archive_file_offset
10037 + offset_from_vma (filedata
, buckets_vma
, 4)),
10040 error (_("Unable to seek to start of dynamic information\n"));
10041 gnu_hash_error
= TRUE
;
10045 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
10047 if (gnubuckets
== NULL
)
10049 gnu_hash_error
= TRUE
;
10053 for (i
= 0; i
< ngnubuckets
; i
++)
10054 if (gnubuckets
[i
] != 0)
10056 if (gnubuckets
[i
] < gnusymidx
)
10058 gnu_hash_error
= TRUE
;
10062 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10063 maxchain
= gnubuckets
[i
];
10066 if (maxchain
== 0xffffffff)
10068 gnu_hash_error
= TRUE
;
10072 maxchain
-= gnusymidx
;
10074 if (fseek (filedata
->handle
,
10075 (archive_file_offset
10076 + offset_from_vma (filedata
, buckets_vma
10077 + 4 * (ngnubuckets
+ maxchain
), 4)),
10080 error (_("Unable to seek to start of dynamic information\n"));
10081 gnu_hash_error
= TRUE
;
10087 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10089 error (_("Failed to determine last chain length\n"));
10090 gnu_hash_error
= TRUE
;
10094 if (maxchain
+ 1 == 0)
10096 gnu_hash_error
= TRUE
;
10102 while ((byte_get (nb
, 4) & 1) == 0);
10104 if (fseek (filedata
->handle
,
10105 (archive_file_offset
10106 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10109 error (_("Unable to seek to start of dynamic information\n"));
10110 gnu_hash_error
= TRUE
;
10114 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10115 ngnuchains
= maxchain
;
10117 if (gnuchains
== NULL
)
10119 gnu_hash_error
= TRUE
;
10123 if (dynamic_info_DT_MIPS_XHASH
)
10125 if (fseek (filedata
->handle
,
10126 (archive_file_offset
10127 + offset_from_vma (filedata
, (buckets_vma
10132 error (_("Unable to seek to start of dynamic information\n"));
10133 gnu_hash_error
= TRUE
;
10137 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10140 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10141 if (gnubuckets
[hn
] != 0)
10143 bfd_vma si
= gnubuckets
[hn
];
10144 bfd_vma off
= si
- gnusymidx
;
10148 if (dynamic_info_DT_MIPS_XHASH
)
10150 if (mipsxlat
[off
] >= num_of_syms
)
10151 num_of_syms
= mipsxlat
[off
] + 1;
10155 if (si
>= num_of_syms
)
10156 num_of_syms
= si
+ 1;
10160 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10164 if (gnu_hash_error
)
10186 return num_of_syms
;
10189 /* Parse and display the contents of the dynamic section. */
10192 process_dynamic_section (Filedata
* filedata
)
10194 Elf_Internal_Dyn
* entry
;
10196 if (dynamic_size
== 0)
10199 printf (_("\nThere is no dynamic section in this file.\n"));
10206 if (! get_32bit_dynamic_section (filedata
))
10211 if (! get_64bit_dynamic_section (filedata
))
10215 /* Find the appropriate symbol table. */
10216 if (dynamic_symbols
== NULL
|| do_histogram
)
10218 for (entry
= dynamic_section
;
10219 entry
< dynamic_section
+ dynamic_nent
;
10221 if (entry
->d_tag
== DT_SYMTAB
)
10222 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10223 else if (entry
->d_tag
== DT_SYMENT
)
10224 dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10225 else if (entry
->d_tag
== DT_HASH
)
10226 dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10227 else if (entry
->d_tag
== DT_GNU_HASH
)
10228 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10229 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10230 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10231 && entry
->d_tag
== DT_MIPS_XHASH
)
10233 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10234 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10237 if (dynamic_info
[DT_SYMTAB
] && dynamic_info
[DT_SYMENT
])
10239 Elf_Internal_Phdr
*seg
;
10240 bfd_vma vma
= dynamic_info
[DT_SYMTAB
];
10242 if (! get_program_headers (filedata
))
10244 error (_("Cannot interpret virtual addresses without program headers.\n"));
10248 for (seg
= filedata
->program_headers
;
10249 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10252 unsigned long num_of_syms
;
10254 if (seg
->p_type
!= PT_LOAD
)
10257 if ((seg
->p_offset
+ seg
->p_filesz
)
10258 > filedata
->file_size
)
10260 /* See PR 21379 for a reproducer. */
10261 error (_("Invalid PT_LOAD entry\n"));
10265 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10266 && vma
<= seg
->p_vaddr
+ seg
->p_filesz
10267 && (num_of_syms
= get_num_dynamic_syms (filedata
)) != 0
10268 && dynamic_symbols
== NULL
)
10270 /* Since we do not know how big the symbol table is,
10271 we default to reading in up to the end of PT_LOAD
10272 segment and processing that. This is overkill, I
10273 know, but it should work. */
10274 Elf_Internal_Shdr section
;
10275 section
.sh_offset
= (vma
- seg
->p_vaddr
10277 section
.sh_size
= (num_of_syms
10278 * dynamic_info
[DT_SYMENT
]);
10279 section
.sh_entsize
= dynamic_info
[DT_SYMENT
];
10280 section
.sh_name
= filedata
->string_table_length
;
10281 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
,
10283 & num_dynamic_syms
);
10284 if (dynamic_symbols
== NULL
10285 || num_dynamic_syms
!= num_of_syms
)
10287 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10295 /* Similarly find a string table. */
10296 if (dynamic_strings
== NULL
)
10297 for (entry
= dynamic_section
;
10298 entry
< dynamic_section
+ dynamic_nent
;
10301 if (entry
->d_tag
== DT_STRTAB
)
10302 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10304 if (entry
->d_tag
== DT_STRSZ
)
10305 dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10307 if (dynamic_info
[DT_STRTAB
] && dynamic_info
[DT_STRSZ
])
10309 unsigned long offset
;
10310 bfd_size_type str_tab_len
= dynamic_info
[DT_STRSZ
];
10312 offset
= offset_from_vma (filedata
,
10313 dynamic_info
[DT_STRTAB
],
10315 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
10317 _("dynamic string table"));
10318 if (dynamic_strings
== NULL
)
10320 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10324 dynamic_strings_length
= str_tab_len
;
10329 /* And find the syminfo section if available. */
10330 if (dynamic_syminfo
== NULL
)
10332 unsigned long syminsz
= 0;
10334 for (entry
= dynamic_section
;
10335 entry
< dynamic_section
+ dynamic_nent
;
10338 if (entry
->d_tag
== DT_SYMINENT
)
10340 /* Note: these braces are necessary to avoid a syntax
10341 error from the SunOS4 C compiler. */
10342 /* PR binutils/17531: A corrupt file can trigger this test.
10343 So do not use an assert, instead generate an error message. */
10344 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10345 error (_("Bad value (%d) for SYMINENT entry\n"),
10346 (int) entry
->d_un
.d_val
);
10348 else if (entry
->d_tag
== DT_SYMINSZ
)
10349 syminsz
= entry
->d_un
.d_val
;
10350 else if (entry
->d_tag
== DT_SYMINFO
)
10351 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
10355 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10357 Elf_External_Syminfo
* extsyminfo
;
10358 Elf_External_Syminfo
* extsym
;
10359 Elf_Internal_Syminfo
* syminfo
;
10361 /* There is a syminfo section. Read the data. */
10362 extsyminfo
= (Elf_External_Syminfo
*)
10363 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
10364 _("symbol information"));
10368 if (dynamic_syminfo
!= NULL
)
10370 error (_("Multiple dynamic symbol information sections found\n"));
10371 free (dynamic_syminfo
);
10373 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10374 if (dynamic_syminfo
== NULL
)
10376 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10377 (unsigned long) syminsz
);
10381 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10382 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10383 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10384 ++syminfo
, ++extsym
)
10386 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10387 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10394 if (do_dynamic
&& dynamic_addr
)
10395 printf (ngettext ("\nDynamic section at offset 0x%lx "
10396 "contains %lu entry:\n",
10397 "\nDynamic section at offset 0x%lx "
10398 "contains %lu entries:\n",
10400 dynamic_addr
, (unsigned long) dynamic_nent
);
10402 printf (_(" Tag Type Name/Value\n"));
10404 for (entry
= dynamic_section
;
10405 entry
< dynamic_section
+ dynamic_nent
;
10410 const char * dtype
;
10413 print_vma (entry
->d_tag
, FULL_HEX
);
10414 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10415 printf (" (%s)%*s", dtype
,
10416 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10419 switch (entry
->d_tag
)
10423 print_dynamic_flags (entry
->d_un
.d_val
);
10433 switch (entry
->d_tag
)
10436 printf (_("Auxiliary library"));
10440 printf (_("Filter library"));
10444 printf (_("Configuration file"));
10448 printf (_("Dependency audit library"));
10452 printf (_("Audit library"));
10456 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10457 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10461 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10470 printf (_("Flags:"));
10472 if (entry
->d_un
.d_val
== 0)
10473 printf (_(" None\n"));
10476 unsigned long int val
= entry
->d_un
.d_val
;
10478 if (val
& DTF_1_PARINIT
)
10480 printf (" PARINIT");
10481 val
^= DTF_1_PARINIT
;
10483 if (val
& DTF_1_CONFEXP
)
10485 printf (" CONFEXP");
10486 val
^= DTF_1_CONFEXP
;
10489 printf (" %lx", val
);
10498 printf (_("Flags:"));
10500 if (entry
->d_un
.d_val
== 0)
10501 printf (_(" None\n"));
10504 unsigned long int val
= entry
->d_un
.d_val
;
10506 if (val
& DF_P1_LAZYLOAD
)
10508 printf (" LAZYLOAD");
10509 val
^= DF_P1_LAZYLOAD
;
10511 if (val
& DF_P1_GROUPPERM
)
10513 printf (" GROUPPERM");
10514 val
^= DF_P1_GROUPPERM
;
10517 printf (" %lx", val
);
10526 printf (_("Flags:"));
10527 if (entry
->d_un
.d_val
== 0)
10528 printf (_(" None\n"));
10531 unsigned long int val
= entry
->d_un
.d_val
;
10533 if (val
& DF_1_NOW
)
10538 if (val
& DF_1_GLOBAL
)
10540 printf (" GLOBAL");
10541 val
^= DF_1_GLOBAL
;
10543 if (val
& DF_1_GROUP
)
10548 if (val
& DF_1_NODELETE
)
10550 printf (" NODELETE");
10551 val
^= DF_1_NODELETE
;
10553 if (val
& DF_1_LOADFLTR
)
10555 printf (" LOADFLTR");
10556 val
^= DF_1_LOADFLTR
;
10558 if (val
& DF_1_INITFIRST
)
10560 printf (" INITFIRST");
10561 val
^= DF_1_INITFIRST
;
10563 if (val
& DF_1_NOOPEN
)
10565 printf (" NOOPEN");
10566 val
^= DF_1_NOOPEN
;
10568 if (val
& DF_1_ORIGIN
)
10570 printf (" ORIGIN");
10571 val
^= DF_1_ORIGIN
;
10573 if (val
& DF_1_DIRECT
)
10575 printf (" DIRECT");
10576 val
^= DF_1_DIRECT
;
10578 if (val
& DF_1_TRANS
)
10583 if (val
& DF_1_INTERPOSE
)
10585 printf (" INTERPOSE");
10586 val
^= DF_1_INTERPOSE
;
10588 if (val
& DF_1_NODEFLIB
)
10590 printf (" NODEFLIB");
10591 val
^= DF_1_NODEFLIB
;
10593 if (val
& DF_1_NODUMP
)
10595 printf (" NODUMP");
10596 val
^= DF_1_NODUMP
;
10598 if (val
& DF_1_CONFALT
)
10600 printf (" CONFALT");
10601 val
^= DF_1_CONFALT
;
10603 if (val
& DF_1_ENDFILTEE
)
10605 printf (" ENDFILTEE");
10606 val
^= DF_1_ENDFILTEE
;
10608 if (val
& DF_1_DISPRELDNE
)
10610 printf (" DISPRELDNE");
10611 val
^= DF_1_DISPRELDNE
;
10613 if (val
& DF_1_DISPRELPND
)
10615 printf (" DISPRELPND");
10616 val
^= DF_1_DISPRELPND
;
10618 if (val
& DF_1_NODIRECT
)
10620 printf (" NODIRECT");
10621 val
^= DF_1_NODIRECT
;
10623 if (val
& DF_1_IGNMULDEF
)
10625 printf (" IGNMULDEF");
10626 val
^= DF_1_IGNMULDEF
;
10628 if (val
& DF_1_NOKSYMS
)
10630 printf (" NOKSYMS");
10631 val
^= DF_1_NOKSYMS
;
10633 if (val
& DF_1_NOHDR
)
10638 if (val
& DF_1_EDITED
)
10640 printf (" EDITED");
10641 val
^= DF_1_EDITED
;
10643 if (val
& DF_1_NORELOC
)
10645 printf (" NORELOC");
10646 val
^= DF_1_NORELOC
;
10648 if (val
& DF_1_SYMINTPOSE
)
10650 printf (" SYMINTPOSE");
10651 val
^= DF_1_SYMINTPOSE
;
10653 if (val
& DF_1_GLOBAUDIT
)
10655 printf (" GLOBAUDIT");
10656 val
^= DF_1_GLOBAUDIT
;
10658 if (val
& DF_1_SINGLETON
)
10660 printf (" SINGLETON");
10661 val
^= DF_1_SINGLETON
;
10663 if (val
& DF_1_STUB
)
10668 if (val
& DF_1_PIE
)
10673 if (val
& DF_1_KMOD
)
10678 if (val
& DF_1_WEAKFILTER
)
10680 printf (" WEAKFILTER");
10681 val
^= DF_1_WEAKFILTER
;
10683 if (val
& DF_1_NOCOMMON
)
10685 printf (" NOCOMMON");
10686 val
^= DF_1_NOCOMMON
;
10689 printf (" %lx", val
);
10696 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10698 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10718 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10724 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10725 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10731 switch (entry
->d_tag
)
10734 printf (_("Shared library: [%s]"), name
);
10736 if (streq (name
, program_interpreter
))
10737 printf (_(" program interpreter"));
10741 printf (_("Library soname: [%s]"), name
);
10745 printf (_("Library rpath: [%s]"), name
);
10749 printf (_("Library runpath: [%s]"), name
);
10753 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10758 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10771 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10772 /* Fall through. */
10776 case DT_INIT_ARRAYSZ
:
10777 case DT_FINI_ARRAYSZ
:
10778 case DT_GNU_CONFLICTSZ
:
10779 case DT_GNU_LIBLISTSZ
:
10782 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10783 printf (_(" (bytes)\n"));
10788 case DT_VERNEEDNUM
:
10793 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10802 case DT_INIT_ARRAY
:
10803 case DT_FINI_ARRAY
:
10806 if (entry
->d_tag
== DT_USED
10807 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10809 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10813 printf (_("Not needed object: [%s]\n"), name
);
10818 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10824 /* The value of this entry is ignored. */
10829 case DT_GNU_PRELINKED
:
10833 time_t atime
= entry
->d_un
.d_val
;
10835 tmp
= gmtime (&atime
);
10836 /* PR 17533 file: 041-1244816-0.004. */
10838 printf (_("<corrupt time val: %lx"),
10839 (unsigned long) atime
);
10841 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10842 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10843 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10849 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10852 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10858 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10859 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10864 switch (filedata
->file_header
.e_machine
)
10867 dynamic_section_aarch64_val (entry
);
10870 case EM_MIPS_RS3_LE
:
10871 dynamic_section_mips_val (entry
);
10874 dynamic_section_parisc_val (entry
);
10877 dynamic_section_ia64_val (entry
);
10880 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10892 get_ver_flags (unsigned int flags
)
10894 static char buff
[128];
10901 if (flags
& VER_FLG_BASE
)
10902 strcat (buff
, "BASE");
10904 if (flags
& VER_FLG_WEAK
)
10906 if (flags
& VER_FLG_BASE
)
10907 strcat (buff
, " | ");
10909 strcat (buff
, "WEAK");
10912 if (flags
& VER_FLG_INFO
)
10914 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10915 strcat (buff
, " | ");
10917 strcat (buff
, "INFO");
10920 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10922 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10923 strcat (buff
, " | ");
10925 strcat (buff
, _("<unknown>"));
10931 /* Display the contents of the version sections. */
10934 process_version_sections (Filedata
* filedata
)
10936 Elf_Internal_Shdr
* section
;
10938 bfd_boolean found
= FALSE
;
10943 for (i
= 0, section
= filedata
->section_headers
;
10944 i
< filedata
->file_header
.e_shnum
;
10947 switch (section
->sh_type
)
10949 case SHT_GNU_verdef
:
10951 Elf_External_Verdef
* edefs
;
10958 printf (ngettext ("\nVersion definition section '%s' "
10959 "contains %u entry:\n",
10960 "\nVersion definition section '%s' "
10961 "contains %u entries:\n",
10963 printable_section_name (filedata
, section
),
10966 printf (_(" Addr: 0x"));
10967 printf_vma (section
->sh_addr
);
10968 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10969 (unsigned long) section
->sh_offset
, section
->sh_link
,
10970 printable_section_name_from_index (filedata
, section
->sh_link
));
10972 edefs
= (Elf_External_Verdef
*)
10973 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10974 _("version definition section"));
10977 endbuf
= (char *) edefs
+ section
->sh_size
;
10979 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10982 Elf_External_Verdef
* edef
;
10983 Elf_Internal_Verdef ent
;
10984 Elf_External_Verdaux
* eaux
;
10985 Elf_Internal_Verdaux aux
;
10986 unsigned long isum
;
10989 vstart
= ((char *) edefs
) + idx
;
10990 if (vstart
+ sizeof (*edef
) > endbuf
)
10993 edef
= (Elf_External_Verdef
*) vstart
;
10995 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10996 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10997 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10998 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10999 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11000 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11001 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11003 printf (_(" %#06lx: Rev: %d Flags: %s"),
11004 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11006 printf (_(" Index: %d Cnt: %d "),
11007 ent
.vd_ndx
, ent
.vd_cnt
);
11009 /* Check for overflow. */
11010 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11013 vstart
+= ent
.vd_aux
;
11015 if (vstart
+ sizeof (*eaux
) > endbuf
)
11017 eaux
= (Elf_External_Verdaux
*) vstart
;
11019 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11020 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11022 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
11023 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
11025 printf (_("Name index: %ld\n"), aux
.vda_name
);
11027 isum
= idx
+ ent
.vd_aux
;
11029 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11031 if (aux
.vda_next
< sizeof (*eaux
)
11032 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11034 warn (_("Invalid vda_next field of %lx\n"),
11039 /* Check for overflow. */
11040 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11043 isum
+= aux
.vda_next
;
11044 vstart
+= aux
.vda_next
;
11046 if (vstart
+ sizeof (*eaux
) > endbuf
)
11048 eaux
= (Elf_External_Verdaux
*) vstart
;
11050 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11051 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11053 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
11054 printf (_(" %#06lx: Parent %d: %s\n"),
11055 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
11057 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11058 isum
, j
, aux
.vda_name
);
11061 if (j
< ent
.vd_cnt
)
11062 printf (_(" Version def aux past end of section\n"));
11065 file: id:000001,src:000172+005151,op:splice,rep:2. */
11066 if (ent
.vd_next
< sizeof (*edef
)
11067 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11069 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11070 cnt
= section
->sh_info
;
11073 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11076 idx
+= ent
.vd_next
;
11079 if (cnt
< section
->sh_info
)
11080 printf (_(" Version definition past end of section\n"));
11086 case SHT_GNU_verneed
:
11088 Elf_External_Verneed
* eneed
;
11095 printf (ngettext ("\nVersion needs section '%s' "
11096 "contains %u entry:\n",
11097 "\nVersion needs section '%s' "
11098 "contains %u entries:\n",
11100 printable_section_name (filedata
, section
), section
->sh_info
);
11102 printf (_(" Addr: 0x"));
11103 printf_vma (section
->sh_addr
);
11104 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11105 (unsigned long) section
->sh_offset
, section
->sh_link
,
11106 printable_section_name_from_index (filedata
, section
->sh_link
));
11108 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11109 section
->sh_offset
, 1,
11111 _("Version Needs section"));
11114 endbuf
= (char *) eneed
+ section
->sh_size
;
11116 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11118 Elf_External_Verneed
* entry
;
11119 Elf_Internal_Verneed ent
;
11120 unsigned long isum
;
11124 vstart
= ((char *) eneed
) + idx
;
11125 if (vstart
+ sizeof (*entry
) > endbuf
)
11128 entry
= (Elf_External_Verneed
*) vstart
;
11130 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11131 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11132 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11133 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11134 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11136 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11138 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
11139 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
11141 printf (_(" File: %lx"), ent
.vn_file
);
11143 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11145 /* Check for overflow. */
11146 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11148 vstart
+= ent
.vn_aux
;
11150 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11152 Elf_External_Vernaux
* eaux
;
11153 Elf_Internal_Vernaux aux
;
11155 if (vstart
+ sizeof (*eaux
) > endbuf
)
11157 eaux
= (Elf_External_Vernaux
*) vstart
;
11159 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11160 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11161 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11162 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11163 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11165 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
11166 printf (_(" %#06lx: Name: %s"),
11167 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
11169 printf (_(" %#06lx: Name index: %lx"),
11170 isum
, aux
.vna_name
);
11172 printf (_(" Flags: %s Version: %d\n"),
11173 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11175 if (aux
.vna_next
< sizeof (*eaux
)
11176 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11178 warn (_("Invalid vna_next field of %lx\n"),
11183 /* Check for overflow. */
11184 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11186 isum
+= aux
.vna_next
;
11187 vstart
+= aux
.vna_next
;
11190 if (j
< ent
.vn_cnt
)
11191 warn (_("Missing Version Needs auxillary information\n"));
11193 if (ent
.vn_next
< sizeof (*entry
)
11194 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11196 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11197 cnt
= section
->sh_info
;
11200 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11202 idx
+= ent
.vn_next
;
11205 if (cnt
< section
->sh_info
)
11206 warn (_("Missing Version Needs information\n"));
11212 case SHT_GNU_versym
:
11214 Elf_Internal_Shdr
* link_section
;
11217 unsigned char * edata
;
11218 unsigned short * data
;
11220 Elf_Internal_Sym
* symbols
;
11221 Elf_Internal_Shdr
* string_sec
;
11222 unsigned long num_syms
;
11225 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11228 link_section
= filedata
->section_headers
+ section
->sh_link
;
11229 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11231 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11236 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11237 if (symbols
== NULL
)
11240 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11242 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11243 string_sec
->sh_size
,
11244 _("version string table"));
11251 printf (ngettext ("\nVersion symbols section '%s' "
11252 "contains %lu entry:\n",
11253 "\nVersion symbols section '%s' "
11254 "contains %lu entries:\n",
11256 printable_section_name (filedata
, section
), (unsigned long) total
);
11258 printf (_(" Addr: 0x"));
11259 printf_vma (section
->sh_addr
);
11260 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11261 (unsigned long) section
->sh_offset
, section
->sh_link
,
11262 printable_section_name (filedata
, link_section
));
11264 off
= offset_from_vma (filedata
,
11265 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11266 total
* sizeof (short));
11267 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11268 sizeof (short), total
,
11269 _("version symbol data"));
11277 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11279 for (cnt
= total
; cnt
--;)
11280 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11285 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11289 char *invalid
= _("*invalid*");
11291 printf (" %03x:", cnt
);
11293 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11294 switch (data
[cnt
+ j
])
11297 fputs (_(" 0 (*local*) "), stdout
);
11301 fputs (_(" 1 (*global*) "), stdout
);
11305 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11306 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11308 /* If this index value is greater than the size of the symbols
11309 array, break to avoid an out-of-bounds read. */
11310 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11312 warn (_("invalid index into symbol array\n"));
11317 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11319 Elf_Internal_Verneed ivn
;
11320 unsigned long offset
;
11322 offset
= offset_from_vma
11323 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11324 sizeof (Elf_External_Verneed
));
11328 Elf_Internal_Vernaux ivna
;
11329 Elf_External_Verneed evn
;
11330 Elf_External_Vernaux evna
;
11331 unsigned long a_off
;
11333 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11334 _("version need")) == NULL
)
11337 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11338 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11340 a_off
= offset
+ ivn
.vn_aux
;
11344 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11345 1, _("version need aux (2)")) == NULL
)
11348 ivna
.vna_other
= 0;
11352 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11353 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11356 a_off
+= ivna
.vna_next
;
11358 while (ivna
.vna_other
!= data
[cnt
+ j
]
11359 && ivna
.vna_next
!= 0);
11361 if (ivna
.vna_other
== data
[cnt
+ j
])
11363 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11365 if (ivna
.vna_name
>= string_sec
->sh_size
)
11368 name
= strtab
+ ivna
.vna_name
;
11372 offset
+= ivn
.vn_next
;
11374 while (ivn
.vn_next
);
11377 if (data
[cnt
+ j
] != 0x8001
11378 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11380 Elf_Internal_Verdef ivd
;
11381 Elf_External_Verdef evd
;
11382 unsigned long offset
;
11384 offset
= offset_from_vma
11385 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11390 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11391 _("version def")) == NULL
)
11394 /* PR 17531: file: 046-1082287-0.004. */
11395 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11400 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11401 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11404 offset
+= ivd
.vd_next
;
11406 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11407 && ivd
.vd_next
!= 0);
11409 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11411 Elf_External_Verdaux evda
;
11412 Elf_Internal_Verdaux ivda
;
11414 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11416 if (get_data (&evda
, filedata
,
11417 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11419 _("version def aux")) == NULL
)
11422 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11424 if (ivda
.vda_name
>= string_sec
->sh_size
)
11426 else if (name
!= NULL
&& name
!= invalid
)
11427 name
= _("*both*");
11429 name
= strtab
+ ivda
.vda_name
;
11433 nn
+= printf ("(%s%-*s",
11435 12 - (int) strlen (name
),
11439 printf ("%*c", 18 - nn
, ' ');
11457 printf (_("\nNo version information found in this file.\n"));
11462 static const char *
11463 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11465 static char buff
[64];
11469 case STB_LOCAL
: return "LOCAL";
11470 case STB_GLOBAL
: return "GLOBAL";
11471 case STB_WEAK
: return "WEAK";
11473 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11474 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11476 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11478 if (binding
== STB_GNU_UNIQUE
11479 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11481 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11484 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11489 static const char *
11490 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11492 static char buff
[64];
11496 case STT_NOTYPE
: return "NOTYPE";
11497 case STT_OBJECT
: return "OBJECT";
11498 case STT_FUNC
: return "FUNC";
11499 case STT_SECTION
: return "SECTION";
11500 case STT_FILE
: return "FILE";
11501 case STT_COMMON
: return "COMMON";
11502 case STT_TLS
: return "TLS";
11503 case STT_RELC
: return "RELC";
11504 case STT_SRELC
: return "SRELC";
11506 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11508 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11509 return "THUMB_FUNC";
11511 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11514 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11515 return "PARISC_MILLI";
11517 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11519 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11521 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11523 if (type
== STT_HP_OPAQUE
)
11524 return "HP_OPAQUE";
11525 if (type
== STT_HP_STUB
)
11529 if (type
== STT_GNU_IFUNC
11530 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11531 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11534 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11537 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11542 static const char *
11543 get_symbol_visibility (unsigned int visibility
)
11545 switch (visibility
)
11547 case STV_DEFAULT
: return "DEFAULT";
11548 case STV_INTERNAL
: return "INTERNAL";
11549 case STV_HIDDEN
: return "HIDDEN";
11550 case STV_PROTECTED
: return "PROTECTED";
11552 error (_("Unrecognized visibility value: %u\n"), visibility
);
11553 return _("<unknown>");
11557 static const char *
11558 get_alpha_symbol_other (unsigned int other
)
11562 case STO_ALPHA_NOPV
: return "NOPV";
11563 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11565 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11566 return _("<unknown>");
11570 static const char *
11571 get_solaris_symbol_visibility (unsigned int visibility
)
11573 switch (visibility
)
11575 case 4: return "EXPORTED";
11576 case 5: return "SINGLETON";
11577 case 6: return "ELIMINATE";
11578 default: return get_symbol_visibility (visibility
);
11582 static const char *
11583 get_aarch64_symbol_other (unsigned int other
)
11585 static char buf
[32];
11587 if (other
& STO_AARCH64_VARIANT_PCS
)
11589 other
&= ~STO_AARCH64_VARIANT_PCS
;
11591 return "VARIANT_PCS";
11592 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11598 static const char *
11599 get_mips_symbol_other (unsigned int other
)
11603 case STO_OPTIONAL
: return "OPTIONAL";
11604 case STO_MIPS_PLT
: return "MIPS PLT";
11605 case STO_MIPS_PIC
: return "MIPS PIC";
11606 case STO_MICROMIPS
: return "MICROMIPS";
11607 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11608 case STO_MIPS16
: return "MIPS16";
11609 default: return NULL
;
11613 static const char *
11614 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11616 if (is_ia64_vms (filedata
))
11618 static char res
[32];
11622 /* Function types is for images and .STB files only. */
11623 switch (filedata
->file_header
.e_type
)
11627 switch (VMS_ST_FUNC_TYPE (other
))
11629 case VMS_SFT_CODE_ADDR
:
11630 strcat (res
, " CA");
11632 case VMS_SFT_SYMV_IDX
:
11633 strcat (res
, " VEC");
11636 strcat (res
, " FD");
11638 case VMS_SFT_RESERVE
:
11639 strcat (res
, " RSV");
11642 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11643 VMS_ST_FUNC_TYPE (other
));
11644 strcat (res
, " <unknown>");
11651 switch (VMS_ST_LINKAGE (other
))
11653 case VMS_STL_IGNORE
:
11654 strcat (res
, " IGN");
11656 case VMS_STL_RESERVE
:
11657 strcat (res
, " RSV");
11660 strcat (res
, " STD");
11663 strcat (res
, " LNK");
11666 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11667 VMS_ST_LINKAGE (other
));
11668 strcat (res
, " <unknown>");
11680 static const char *
11681 get_ppc64_symbol_other (unsigned int other
)
11683 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11686 other
>>= STO_PPC64_LOCAL_BIT
;
11689 static char buf
[64];
11691 other
= ppc64_decode_local_entry (other
);
11692 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11698 static const char *
11699 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11701 const char * result
= NULL
;
11702 static char buff
[64];
11707 switch (filedata
->file_header
.e_machine
)
11710 result
= get_alpha_symbol_other (other
);
11713 result
= get_aarch64_symbol_other (other
);
11716 result
= get_mips_symbol_other (other
);
11719 result
= get_ia64_symbol_other (filedata
, other
);
11722 result
= get_ppc64_symbol_other (other
);
11732 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11736 static const char *
11737 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11739 static char buff
[32];
11743 case SHN_UNDEF
: return "UND";
11744 case SHN_ABS
: return "ABS";
11745 case SHN_COMMON
: return "COM";
11747 if (type
== SHN_IA_64_ANSI_COMMON
11748 && filedata
->file_header
.e_machine
== EM_IA_64
11749 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11751 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11752 || filedata
->file_header
.e_machine
== EM_L1OM
11753 || filedata
->file_header
.e_machine
== EM_K1OM
)
11754 && type
== SHN_X86_64_LCOMMON
)
11755 return "LARGE_COM";
11756 else if ((type
== SHN_MIPS_SCOMMON
11757 && filedata
->file_header
.e_machine
== EM_MIPS
)
11758 || (type
== SHN_TIC6X_SCOMMON
11759 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11761 else if (type
== SHN_MIPS_SUNDEFINED
11762 && filedata
->file_header
.e_machine
== EM_MIPS
)
11764 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11765 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11766 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11767 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11768 else if (type
>= SHN_LORESERVE
)
11769 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11770 else if (filedata
->file_header
.e_shnum
!= 0
11771 && type
>= filedata
->file_header
.e_shnum
)
11772 sprintf (buff
, _("bad section index[%3d]"), type
);
11774 sprintf (buff
, "%3d", type
);
11781 static const char *
11782 get_symbol_version_string (Filedata
* filedata
,
11783 bfd_boolean is_dynsym
,
11784 const char * strtab
,
11785 unsigned long int strtab_size
,
11787 Elf_Internal_Sym
* psym
,
11788 enum versioned_symbol_info
* sym_info
,
11789 unsigned short * vna_other
)
11791 unsigned char data
[2];
11792 unsigned short vers_data
;
11793 unsigned long offset
;
11794 unsigned short max_vd_ndx
;
11797 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11800 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11801 sizeof data
+ si
* sizeof (vers_data
));
11803 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11804 sizeof (data
), 1, _("version data")) == NULL
)
11807 vers_data
= byte_get (data
, 2);
11809 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11812 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11815 /* Usually we'd only see verdef for defined symbols, and verneed for
11816 undefined symbols. However, symbols defined by the linker in
11817 .dynbss for variables copied from a shared library in order to
11818 avoid text relocations are defined yet have verneed. We could
11819 use a heuristic to detect the special case, for example, check
11820 for verneed first on symbols defined in SHT_NOBITS sections, but
11821 it is simpler and more reliable to just look for both verdef and
11822 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11824 if (psym
->st_shndx
!= SHN_UNDEF
11825 && vers_data
!= 0x8001
11826 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11828 Elf_Internal_Verdef ivd
;
11829 Elf_Internal_Verdaux ivda
;
11830 Elf_External_Verdaux evda
;
11833 off
= offset_from_vma (filedata
,
11834 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11835 sizeof (Elf_External_Verdef
));
11839 Elf_External_Verdef evd
;
11841 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11842 _("version def")) == NULL
)
11851 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11852 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11853 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11854 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11857 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11858 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11860 off
+= ivd
.vd_next
;
11862 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11864 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11866 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11869 off
-= ivd
.vd_next
;
11872 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11873 _("version def aux")) != NULL
)
11875 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11877 if (psym
->st_name
!= ivda
.vda_name
)
11878 return (ivda
.vda_name
< strtab_size
11879 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11884 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11886 Elf_External_Verneed evn
;
11887 Elf_Internal_Verneed ivn
;
11888 Elf_Internal_Vernaux ivna
;
11890 offset
= offset_from_vma (filedata
,
11891 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11895 unsigned long vna_off
;
11897 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11898 _("version need")) == NULL
)
11901 ivna
.vna_other
= 0;
11906 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11907 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11909 vna_off
= offset
+ ivn
.vn_aux
;
11913 Elf_External_Vernaux evna
;
11915 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11916 _("version need aux (3)")) == NULL
)
11919 ivna
.vna_other
= 0;
11924 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11925 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11926 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11929 vna_off
+= ivna
.vna_next
;
11931 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11933 if (ivna
.vna_other
== vers_data
)
11936 offset
+= ivn
.vn_next
;
11938 while (ivn
.vn_next
!= 0);
11940 if (ivna
.vna_other
== vers_data
)
11942 *sym_info
= symbol_undefined
;
11943 *vna_other
= ivna
.vna_other
;
11944 return (ivna
.vna_name
< strtab_size
11945 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11947 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11948 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11949 return _("<corrupt>");
11955 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
11956 Elf_Internal_Sym
*symtab
,
11957 Elf_Internal_Shdr
*section
,
11958 char *strtab
, size_t strtab_size
)
11960 const char *version_string
;
11961 enum versioned_symbol_info sym_info
;
11962 unsigned short vna_other
;
11963 Elf_Internal_Sym
*psym
= symtab
+ si
;
11965 printf ("%6ld: ", si
);
11966 print_vma (psym
->st_value
, LONG_HEX
);
11968 print_vma (psym
->st_size
, DEC_5
);
11969 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11970 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11971 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11972 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11975 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11977 printf (" %-7s", get_symbol_visibility (vis
));
11978 /* Check to see if any other bits in the st_other field are set.
11979 Note - displaying this information disrupts the layout of the
11980 table being generated, but for the moment this case is very rare. */
11981 if (psym
->st_other
^ vis
)
11982 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11984 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11985 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
11987 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11990 = get_symbol_version_string (filedata
,
11992 || section
->sh_type
== SHT_DYNSYM
),
11993 strtab
, strtab_size
, si
,
11994 psym
, &sym_info
, &vna_other
);
11995 if (version_string
)
11997 if (sym_info
== symbol_undefined
)
11998 printf ("@%s (%d)", version_string
, vna_other
);
12000 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12006 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12008 && si
>= section
->sh_info
12009 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12010 && filedata
->file_header
.e_machine
!= EM_MIPS
12011 /* Solaris binaries have been found to violate this requirement as
12012 well. Not sure if this is a bug or an ABI requirement. */
12013 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12014 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12015 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12018 /* Dump the symbol table. */
12020 process_symbol_table (Filedata
* filedata
)
12022 Elf_Internal_Shdr
* section
;
12024 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12027 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
12029 && do_using_dynamic
12030 && dynamic_strings
!= NULL
12031 && dynamic_symbols
!= NULL
)
12035 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12036 "\nSymbol table for image contains %lu entries:\n",
12037 num_dynamic_syms
), num_dynamic_syms
);
12039 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12041 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12043 for (si
= 0; si
< num_dynamic_syms
; si
++)
12044 print_dynamic_symbol (filedata
, si
, dynamic_symbols
, NULL
,
12045 dynamic_strings
, dynamic_strings_length
);
12047 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12048 && filedata
->section_headers
!= NULL
)
12052 for (i
= 0, section
= filedata
->section_headers
;
12053 i
< filedata
->file_header
.e_shnum
;
12056 char * strtab
= NULL
;
12057 unsigned long int strtab_size
= 0;
12058 Elf_Internal_Sym
* symtab
;
12059 unsigned long si
, num_syms
;
12061 if ((section
->sh_type
!= SHT_SYMTAB
12062 && section
->sh_type
!= SHT_DYNSYM
)
12064 && section
->sh_type
== SHT_SYMTAB
))
12067 if (section
->sh_entsize
== 0)
12069 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12070 printable_section_name (filedata
, section
));
12074 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12075 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12076 "\nSymbol table '%s' contains %lu entries:\n",
12078 printable_section_name (filedata
, section
),
12082 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12084 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12086 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12087 if (symtab
== NULL
)
12090 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12092 strtab
= filedata
->string_table
;
12093 strtab_size
= filedata
->string_table_length
;
12095 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12097 Elf_Internal_Shdr
* string_sec
;
12099 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12101 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12102 1, string_sec
->sh_size
,
12103 _("string table"));
12104 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12107 for (si
= 0; si
< num_syms
; si
++)
12108 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12109 strtab
, strtab_size
);
12112 if (strtab
!= filedata
->string_table
)
12118 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12120 if (do_histogram
&& buckets
!= NULL
)
12122 unsigned long * lengths
;
12123 unsigned long * counts
;
12126 unsigned long maxlength
= 0;
12127 unsigned long nzero_counts
= 0;
12128 unsigned long nsyms
= 0;
12131 printf (ngettext ("\nHistogram for bucket list length "
12132 "(total of %lu bucket):\n",
12133 "\nHistogram for bucket list length "
12134 "(total of %lu buckets):\n",
12135 (unsigned long) nbuckets
),
12136 (unsigned long) nbuckets
);
12138 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12139 if (lengths
== NULL
)
12141 error (_("Out of memory allocating space for histogram buckets\n"));
12144 visited
= xcmalloc (nchains
, 1);
12145 memset (visited
, 0, nchains
);
12147 printf (_(" Length Number %% of total Coverage\n"));
12148 for (hn
= 0; hn
< nbuckets
; ++hn
)
12150 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12153 if (maxlength
< ++lengths
[hn
])
12155 if (si
>= nchains
|| visited
[si
])
12157 error (_("histogram chain is corrupt\n"));
12165 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12166 if (counts
== NULL
)
12169 error (_("Out of memory allocating space for histogram counts\n"));
12173 for (hn
= 0; hn
< nbuckets
; ++hn
)
12174 ++counts
[lengths
[hn
]];
12179 printf (" 0 %-10lu (%5.1f%%)\n",
12180 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12181 for (i
= 1; i
<= maxlength
; ++i
)
12183 nzero_counts
+= counts
[i
] * i
;
12184 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12185 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12186 (nzero_counts
* 100.0) / nsyms
);
12200 if (do_histogram
&& gnubuckets
!= NULL
)
12202 unsigned long * lengths
;
12203 unsigned long * counts
;
12205 unsigned long maxlength
= 0;
12206 unsigned long nzero_counts
= 0;
12207 unsigned long nsyms
= 0;
12209 printf (ngettext ("\nHistogram for `%s' bucket list length "
12210 "(total of %lu bucket):\n",
12211 "\nHistogram for `%s' bucket list length "
12212 "(total of %lu buckets):\n",
12213 (unsigned long) ngnubuckets
),
12214 GNU_HASH_SECTION_NAME
,
12215 (unsigned long) ngnubuckets
);
12217 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12218 if (lengths
== NULL
)
12220 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12224 printf (_(" Length Number %% of total Coverage\n"));
12226 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12227 if (gnubuckets
[hn
] != 0)
12229 bfd_vma off
, length
= 1;
12231 for (off
= gnubuckets
[hn
] - gnusymidx
;
12232 /* PR 17531 file: 010-77222-0.004. */
12233 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12236 lengths
[hn
] = length
;
12237 if (length
> maxlength
)
12238 maxlength
= length
;
12242 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12243 if (counts
== NULL
)
12246 error (_("Out of memory allocating space for gnu histogram counts\n"));
12250 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12251 ++counts
[lengths
[hn
]];
12253 if (ngnubuckets
> 0)
12256 printf (" 0 %-10lu (%5.1f%%)\n",
12257 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12258 for (j
= 1; j
<= maxlength
; ++j
)
12260 nzero_counts
+= counts
[j
] * j
;
12261 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12262 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12263 (nzero_counts
* 100.0) / nsyms
);
12298 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12302 if (dynamic_syminfo
== NULL
12304 /* No syminfo, this is ok. */
12307 /* There better should be a dynamic symbol section. */
12308 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12312 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12313 "contains %d entry:\n",
12314 "\nDynamic info segment at offset 0x%lx "
12315 "contains %d entries:\n",
12316 dynamic_syminfo_nent
),
12317 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12319 printf (_(" Num: Name BoundTo Flags\n"));
12320 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12322 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12324 printf ("%4d: ", i
);
12325 if (i
>= num_dynamic_syms
)
12326 printf (_("<corrupt index>"));
12327 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12328 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12330 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12333 switch (dynamic_syminfo
[i
].si_boundto
)
12335 case SYMINFO_BT_SELF
:
12336 fputs ("SELF ", stdout
);
12338 case SYMINFO_BT_PARENT
:
12339 fputs ("PARENT ", stdout
);
12342 if (dynamic_syminfo
[i
].si_boundto
> 0
12343 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12344 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12346 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12350 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12354 if (flags
& SYMINFO_FLG_DIRECT
)
12355 printf (" DIRECT");
12356 if (flags
& SYMINFO_FLG_PASSTHRU
)
12357 printf (" PASSTHRU");
12358 if (flags
& SYMINFO_FLG_COPY
)
12360 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12361 printf (" LAZYLOAD");
12369 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12370 is contained by the region START .. END. The types of ADDR, START
12371 and END should all be the same. Note both ADDR + NELEM and END
12372 point to just beyond the end of the regions that are being tested. */
12373 #define IN_RANGE(START,END,ADDR,NELEM) \
12374 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12376 /* Check to see if the given reloc needs to be handled in a target specific
12377 manner. If so then process the reloc and return TRUE otherwise return
12380 If called with reloc == NULL, then this is a signal that reloc processing
12381 for the current section has finished, and any saved state should be
12385 target_specific_reloc_handling (Filedata
* filedata
,
12386 Elf_Internal_Rela
* reloc
,
12387 unsigned char * start
,
12388 unsigned char * end
,
12389 Elf_Internal_Sym
* symtab
,
12390 unsigned long num_syms
)
12392 unsigned int reloc_type
= 0;
12393 unsigned long sym_index
= 0;
12397 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12398 sym_index
= get_reloc_symindex (reloc
->r_info
);
12401 switch (filedata
->file_header
.e_machine
)
12404 case EM_MSP430_OLD
:
12406 static Elf_Internal_Sym
* saved_sym
= NULL
;
12414 switch (reloc_type
)
12416 case 10: /* R_MSP430_SYM_DIFF */
12417 if (uses_msp430x_relocs (filedata
))
12419 /* Fall through. */
12420 case 21: /* R_MSP430X_SYM_DIFF */
12422 if (sym_index
>= num_syms
)
12423 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12426 saved_sym
= symtab
+ sym_index
;
12429 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12430 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12431 goto handle_sym_diff
;
12433 case 5: /* R_MSP430_16_BYTE */
12434 case 9: /* R_MSP430_8 */
12435 if (uses_msp430x_relocs (filedata
))
12437 goto handle_sym_diff
;
12439 case 2: /* R_MSP430_ABS16 */
12440 case 15: /* R_MSP430X_ABS16 */
12441 if (! uses_msp430x_relocs (filedata
))
12443 goto handle_sym_diff
;
12446 if (saved_sym
!= NULL
)
12448 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12451 if (sym_index
>= num_syms
)
12452 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12456 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12457 - saved_sym
->st_value
);
12459 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12460 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12463 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12464 (long) reloc
->r_offset
);
12473 if (saved_sym
!= NULL
)
12474 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12481 case EM_CYGNUS_MN10300
:
12483 static Elf_Internal_Sym
* saved_sym
= NULL
;
12491 switch (reloc_type
)
12493 case 34: /* R_MN10300_ALIGN */
12495 case 33: /* R_MN10300_SYM_DIFF */
12496 if (sym_index
>= num_syms
)
12497 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12500 saved_sym
= symtab
+ sym_index
;
12503 case 1: /* R_MN10300_32 */
12504 case 2: /* R_MN10300_16 */
12505 if (saved_sym
!= NULL
)
12507 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12510 if (sym_index
>= num_syms
)
12511 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12515 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12516 - saved_sym
->st_value
);
12518 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12519 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12521 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12522 (long) reloc
->r_offset
);
12530 if (saved_sym
!= NULL
)
12531 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12539 static bfd_vma saved_sym1
= 0;
12540 static bfd_vma saved_sym2
= 0;
12541 static bfd_vma value
;
12545 saved_sym1
= saved_sym2
= 0;
12549 switch (reloc_type
)
12551 case 0x80: /* R_RL78_SYM. */
12552 saved_sym1
= saved_sym2
;
12553 if (sym_index
>= num_syms
)
12554 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12558 saved_sym2
= symtab
[sym_index
].st_value
;
12559 saved_sym2
+= reloc
->r_addend
;
12563 case 0x83: /* R_RL78_OPsub. */
12564 value
= saved_sym1
- saved_sym2
;
12565 saved_sym2
= saved_sym1
= 0;
12569 case 0x41: /* R_RL78_ABS32. */
12570 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12571 byte_put (start
+ reloc
->r_offset
, value
, 4);
12573 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12574 (long) reloc
->r_offset
);
12578 case 0x43: /* R_RL78_ABS16. */
12579 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12580 byte_put (start
+ reloc
->r_offset
, value
, 2);
12582 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12583 (long) reloc
->r_offset
);
12597 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12598 DWARF debug sections. This is a target specific test. Note - we do not
12599 go through the whole including-target-headers-multiple-times route, (as
12600 we have already done with <elf/h8.h>) because this would become very
12601 messy and even then this function would have to contain target specific
12602 information (the names of the relocs instead of their numeric values).
12603 FIXME: This is not the correct way to solve this problem. The proper way
12604 is to have target specific reloc sizing and typing functions created by
12605 the reloc-macros.h header, in the same way that it already creates the
12606 reloc naming functions. */
12609 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12611 /* Please keep this table alpha-sorted for ease of visual lookup. */
12612 switch (filedata
->file_header
.e_machine
)
12616 return reloc_type
== 1; /* R_386_32. */
12618 return reloc_type
== 1; /* R_68K_32. */
12620 return reloc_type
== 1; /* R_860_32. */
12622 return reloc_type
== 2; /* R_960_32. */
12624 return (reloc_type
== 258
12625 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12627 return reloc_type
== 11; /* R_BPF_DATA_32 */
12628 case EM_ADAPTEVA_EPIPHANY
:
12629 return reloc_type
== 3;
12631 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12633 return reloc_type
== 1; /* R_ARC_32. */
12634 case EM_ARC_COMPACT
:
12635 case EM_ARC_COMPACT2
:
12636 return reloc_type
== 4; /* R_ARC_32. */
12638 return reloc_type
== 2; /* R_ARM_ABS32 */
12641 return reloc_type
== 1;
12643 return reloc_type
== 0x12; /* R_byte4_data. */
12645 return reloc_type
== 3; /* R_CRIS_32. */
12647 return reloc_type
== 3; /* R_CR16_NUM32. */
12649 return reloc_type
== 15; /* R_CRX_NUM32. */
12651 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12652 case EM_CYGNUS_FRV
:
12653 return reloc_type
== 1;
12654 case EM_CYGNUS_D10V
:
12656 return reloc_type
== 6; /* R_D10V_32. */
12657 case EM_CYGNUS_D30V
:
12659 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12661 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12662 case EM_CYGNUS_FR30
:
12664 return reloc_type
== 3; /* R_FR30_32. */
12666 return reloc_type
== 1; /* R_FT32_32. */
12670 return reloc_type
== 1; /* R_H8_DIR32. */
12672 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12673 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12674 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12675 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12678 return reloc_type
== 2; /* R_IP2K_32. */
12680 return reloc_type
== 2; /* R_IQ2000_32. */
12681 case EM_LATTICEMICO32
:
12682 return reloc_type
== 3; /* R_LM32_32. */
12685 return reloc_type
== 3; /* R_M32C_32. */
12687 return reloc_type
== 34; /* R_M32R_32_RELA. */
12690 return reloc_type
== 6; /* R_M68HC11_32. */
12692 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12693 reloc_type
== 6; /* R_S12Z_CW32. */
12695 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12696 case EM_CYGNUS_MEP
:
12697 return reloc_type
== 4; /* R_MEP_32. */
12699 return reloc_type
== 2; /* R_METAG_ADDR32. */
12700 case EM_MICROBLAZE
:
12701 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12703 return reloc_type
== 2; /* R_MIPS_32. */
12705 return reloc_type
== 4; /* R_MMIX_32. */
12706 case EM_CYGNUS_MN10200
:
12708 return reloc_type
== 1; /* R_MN10200_32. */
12709 case EM_CYGNUS_MN10300
:
12711 return reloc_type
== 1; /* R_MN10300_32. */
12713 return reloc_type
== 1; /* R_MOXIE_32. */
12714 case EM_MSP430_OLD
:
12716 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12718 return reloc_type
== 2; /* R_MT_32. */
12720 return reloc_type
== 20; /* R_NDS32_RELA. */
12721 case EM_ALTERA_NIOS2
:
12722 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12724 return reloc_type
== 1; /* R_NIOS_32. */
12726 return reloc_type
== 1; /* R_OR1K_32. */
12728 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12729 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12730 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12733 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12735 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12737 return reloc_type
== 1; /* R_PPC_ADDR32. */
12739 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12741 return reloc_type
== 1; /* R_RISCV_32. */
12743 return reloc_type
== 1; /* R_RL78_DIR32. */
12745 return reloc_type
== 1; /* R_RX_DIR32. */
12747 return reloc_type
== 1; /* R_I370_ADDR31. */
12750 return reloc_type
== 4; /* R_S390_32. */
12752 return reloc_type
== 8; /* R_SCORE_ABS32. */
12754 return reloc_type
== 1; /* R_SH_DIR32. */
12755 case EM_SPARC32PLUS
:
12758 return reloc_type
== 3 /* R_SPARC_32. */
12759 || reloc_type
== 23; /* R_SPARC_UA32. */
12761 return reloc_type
== 6; /* R_SPU_ADDR32 */
12763 return reloc_type
== 1; /* R_C6000_ABS32. */
12765 return reloc_type
== 2; /* R_TILEGX_32. */
12767 return reloc_type
== 1; /* R_TILEPRO_32. */
12768 case EM_CYGNUS_V850
:
12770 return reloc_type
== 6; /* R_V850_ABS32. */
12772 return reloc_type
== 0x33; /* R_V810_WORD. */
12774 return reloc_type
== 1; /* R_VAX_32. */
12776 return reloc_type
== 3; /* R_VISIUM_32. */
12777 case EM_WEBASSEMBLY
:
12778 return reloc_type
== 1; /* R_WASM32_32. */
12782 return reloc_type
== 10; /* R_X86_64_32. */
12785 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12787 return reloc_type
== 4; /* R_XGATE_32. */
12789 return reloc_type
== 1; /* R_XSTROMY16_32. */
12790 case EM_XTENSA_OLD
:
12792 return reloc_type
== 1; /* R_XTENSA_32. */
12794 return reloc_type
== 6; /* R_Z80_32. */
12797 static unsigned int prev_warn
= 0;
12799 /* Avoid repeating the same warning multiple times. */
12800 if (prev_warn
!= filedata
->file_header
.e_machine
)
12801 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12802 filedata
->file_header
.e_machine
);
12803 prev_warn
= filedata
->file_header
.e_machine
;
12809 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12810 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12813 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12815 switch (filedata
->file_header
.e_machine
)
12816 /* Please keep this table alpha-sorted for ease of visual lookup. */
12820 return reloc_type
== 2; /* R_386_PC32. */
12822 return reloc_type
== 4; /* R_68K_PC32. */
12824 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12825 case EM_ADAPTEVA_EPIPHANY
:
12826 return reloc_type
== 6;
12828 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12829 case EM_ARC_COMPACT
:
12830 case EM_ARC_COMPACT2
:
12831 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12833 return reloc_type
== 3; /* R_ARM_REL32 */
12836 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12837 case EM_MICROBLAZE
:
12838 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12840 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12842 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12844 return reloc_type
== 26; /* R_PPC_REL32. */
12846 return reloc_type
== 26; /* R_PPC64_REL32. */
12848 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12851 return reloc_type
== 5; /* R_390_PC32. */
12853 return reloc_type
== 2; /* R_SH_REL32. */
12854 case EM_SPARC32PLUS
:
12857 return reloc_type
== 6; /* R_SPARC_DISP32. */
12859 return reloc_type
== 13; /* R_SPU_REL32. */
12861 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12863 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12865 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12869 return reloc_type
== 2; /* R_X86_64_PC32. */
12871 return reloc_type
== 4; /* R_VAX_PCREL32. */
12872 case EM_XTENSA_OLD
:
12874 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12876 /* Do not abort or issue an error message here. Not all targets use
12877 pc-relative 32-bit relocs in their DWARF debug information and we
12878 have already tested for target coverage in is_32bit_abs_reloc. A
12879 more helpful warning message will be generated by apply_relocations
12880 anyway, so just return. */
12885 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12886 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12889 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12891 switch (filedata
->file_header
.e_machine
)
12894 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12896 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12898 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12899 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12901 return reloc_type
== 80; /* R_PARISC_DIR64. */
12903 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12905 return reloc_type
== 2; /* R_RISCV_64. */
12906 case EM_SPARC32PLUS
:
12909 return reloc_type
== 32 /* R_SPARC_64. */
12910 || reloc_type
== 54; /* R_SPARC_UA64. */
12914 return reloc_type
== 1; /* R_X86_64_64. */
12917 return reloc_type
== 22; /* R_S390_64. */
12919 return reloc_type
== 1; /* R_TILEGX_64. */
12921 return reloc_type
== 18; /* R_MIPS_64. */
12927 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12928 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12931 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12933 switch (filedata
->file_header
.e_machine
)
12936 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12938 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12940 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12941 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12943 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12945 return reloc_type
== 44; /* R_PPC64_REL64. */
12946 case EM_SPARC32PLUS
:
12949 return reloc_type
== 46; /* R_SPARC_DISP64. */
12953 return reloc_type
== 24; /* R_X86_64_PC64. */
12956 return reloc_type
== 23; /* R_S390_PC64. */
12958 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12964 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12965 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12968 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12970 switch (filedata
->file_header
.e_machine
)
12972 case EM_CYGNUS_MN10200
:
12974 return reloc_type
== 4; /* R_MN10200_24. */
12976 return reloc_type
== 5; /* R_FT32_20. */
12978 return reloc_type
== 5; /* R_Z80_24. */
12984 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12985 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12988 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12990 /* Please keep this table alpha-sorted for ease of visual lookup. */
12991 switch (filedata
->file_header
.e_machine
)
12994 case EM_ARC_COMPACT
:
12995 case EM_ARC_COMPACT2
:
12996 return reloc_type
== 2; /* R_ARC_16. */
12997 case EM_ADAPTEVA_EPIPHANY
:
12998 return reloc_type
== 5;
13001 return reloc_type
== 4; /* R_AVR_16. */
13002 case EM_CYGNUS_D10V
:
13004 return reloc_type
== 3; /* R_D10V_16. */
13006 return reloc_type
== 2; /* R_FT32_16. */
13010 return reloc_type
== R_H8_DIR16
;
13013 return reloc_type
== 1; /* R_IP2K_16. */
13016 return reloc_type
== 1; /* R_M32C_16 */
13017 case EM_CYGNUS_MN10200
:
13019 return reloc_type
== 2; /* R_MN10200_16. */
13020 case EM_CYGNUS_MN10300
:
13022 return reloc_type
== 2; /* R_MN10300_16. */
13024 if (uses_msp430x_relocs (filedata
))
13025 return reloc_type
== 2; /* R_MSP430_ABS16. */
13026 /* Fall through. */
13027 case EM_MSP430_OLD
:
13028 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13030 return reloc_type
== 19; /* R_NDS32_RELA. */
13031 case EM_ALTERA_NIOS2
:
13032 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13034 return reloc_type
== 9; /* R_NIOS_16. */
13036 return reloc_type
== 2; /* R_OR1K_16. */
13038 return reloc_type
== 55; /* R_RISCV_SET16. */
13040 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13042 return reloc_type
== 2; /* R_C6000_ABS16. */
13044 return reloc_type
== 2; /* R_VISIUM_16. */
13047 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13049 return reloc_type
== 3; /* R_XGATE_16. */
13051 return reloc_type
== 4; /* R_Z80_16. */
13057 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13058 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13061 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13063 switch (filedata
->file_header
.e_machine
)
13066 return reloc_type
== 54; /* R_RISCV_SET8. */
13068 return reloc_type
== 1; /* R_Z80_8. */
13074 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13075 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13078 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13080 switch (filedata
->file_header
.e_machine
)
13083 return reloc_type
== 53; /* R_RISCV_SET6. */
13089 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13090 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13093 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13095 /* Please keep this table alpha-sorted for ease of visual lookup. */
13096 switch (filedata
->file_header
.e_machine
)
13099 return reloc_type
== 35; /* R_RISCV_ADD32. */
13105 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13106 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13109 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13111 /* Please keep this table alpha-sorted for ease of visual lookup. */
13112 switch (filedata
->file_header
.e_machine
)
13115 return reloc_type
== 39; /* R_RISCV_SUB32. */
13121 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13122 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13125 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13127 /* Please keep this table alpha-sorted for ease of visual lookup. */
13128 switch (filedata
->file_header
.e_machine
)
13131 return reloc_type
== 36; /* R_RISCV_ADD64. */
13137 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13138 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13141 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13143 /* Please keep this table alpha-sorted for ease of visual lookup. */
13144 switch (filedata
->file_header
.e_machine
)
13147 return reloc_type
== 40; /* R_RISCV_SUB64. */
13153 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13154 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13157 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13159 /* Please keep this table alpha-sorted for ease of visual lookup. */
13160 switch (filedata
->file_header
.e_machine
)
13163 return reloc_type
== 34; /* R_RISCV_ADD16. */
13169 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13170 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13173 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13175 /* Please keep this table alpha-sorted for ease of visual lookup. */
13176 switch (filedata
->file_header
.e_machine
)
13179 return reloc_type
== 38; /* R_RISCV_SUB16. */
13185 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13186 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13189 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13191 /* Please keep this table alpha-sorted for ease of visual lookup. */
13192 switch (filedata
->file_header
.e_machine
)
13195 return reloc_type
== 33; /* R_RISCV_ADD8. */
13201 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13202 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13205 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13207 /* Please keep this table alpha-sorted for ease of visual lookup. */
13208 switch (filedata
->file_header
.e_machine
)
13211 return reloc_type
== 37; /* R_RISCV_SUB8. */
13217 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13218 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13221 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13223 switch (filedata
->file_header
.e_machine
)
13226 return reloc_type
== 52; /* R_RISCV_SUB6. */
13232 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13233 relocation entries (possibly formerly used for SHT_GROUP sections). */
13236 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13238 switch (filedata
->file_header
.e_machine
)
13240 case EM_386
: /* R_386_NONE. */
13241 case EM_68K
: /* R_68K_NONE. */
13242 case EM_ADAPTEVA_EPIPHANY
:
13243 case EM_ALPHA
: /* R_ALPHA_NONE. */
13244 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13245 case EM_ARC
: /* R_ARC_NONE. */
13246 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13247 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13248 case EM_ARM
: /* R_ARM_NONE. */
13249 case EM_C166
: /* R_XC16X_NONE. */
13250 case EM_CRIS
: /* R_CRIS_NONE. */
13251 case EM_FT32
: /* R_FT32_NONE. */
13252 case EM_IA_64
: /* R_IA64_NONE. */
13253 case EM_K1OM
: /* R_X86_64_NONE. */
13254 case EM_L1OM
: /* R_X86_64_NONE. */
13255 case EM_M32R
: /* R_M32R_NONE. */
13256 case EM_MIPS
: /* R_MIPS_NONE. */
13257 case EM_MN10300
: /* R_MN10300_NONE. */
13258 case EM_MOXIE
: /* R_MOXIE_NONE. */
13259 case EM_NIOS32
: /* R_NIOS_NONE. */
13260 case EM_OR1K
: /* R_OR1K_NONE. */
13261 case EM_PARISC
: /* R_PARISC_NONE. */
13262 case EM_PPC64
: /* R_PPC64_NONE. */
13263 case EM_PPC
: /* R_PPC_NONE. */
13264 case EM_RISCV
: /* R_RISCV_NONE. */
13265 case EM_S390
: /* R_390_NONE. */
13267 case EM_SH
: /* R_SH_NONE. */
13268 case EM_SPARC32PLUS
:
13269 case EM_SPARC
: /* R_SPARC_NONE. */
13271 case EM_TILEGX
: /* R_TILEGX_NONE. */
13272 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13273 case EM_TI_C6000
:/* R_C6000_NONE. */
13274 case EM_X86_64
: /* R_X86_64_NONE. */
13276 case EM_Z80
: /* R_Z80_NONE. */
13277 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13278 return reloc_type
== 0;
13281 return reloc_type
== 0 || reloc_type
== 256;
13284 return (reloc_type
== 0 /* R_AVR_NONE. */
13285 || reloc_type
== 30 /* R_AVR_DIFF8. */
13286 || reloc_type
== 31 /* R_AVR_DIFF16. */
13287 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13289 return reloc_type
== 3; /* R_METAG_NONE. */
13291 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13292 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13293 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13294 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13295 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13297 return (reloc_type
== 0 /* R_PRU_NONE. */
13298 || reloc_type
== 65 /* R_PRU_DIFF8. */
13299 || reloc_type
== 66 /* R_PRU_DIFF16. */
13300 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13301 case EM_XTENSA_OLD
:
13303 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13304 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13305 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13306 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13311 /* Returns TRUE if there is a relocation against
13312 section NAME at OFFSET bytes. */
13315 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13317 Elf_Internal_Rela
* relocs
;
13318 Elf_Internal_Rela
* rp
;
13320 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13323 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13325 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13326 if (rp
->r_offset
== offset
)
13332 /* Apply relocations to a section.
13333 Returns TRUE upon success, FALSE otherwise.
13334 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13335 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13336 will be set to the number of relocs loaded.
13338 Note: So far support has been added only for those relocations
13339 which can be found in debug sections. FIXME: Add support for
13340 more relocations ? */
13343 apply_relocations (Filedata
* filedata
,
13344 const Elf_Internal_Shdr
* section
,
13345 unsigned char * start
,
13346 bfd_size_type size
,
13347 void ** relocs_return
,
13348 unsigned long * num_relocs_return
)
13350 Elf_Internal_Shdr
* relsec
;
13351 unsigned char * end
= start
+ size
;
13353 if (relocs_return
!= NULL
)
13355 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13356 * num_relocs_return
= 0;
13359 if (filedata
->file_header
.e_type
!= ET_REL
)
13360 /* No relocs to apply. */
13363 /* Find the reloc section associated with the section. */
13364 for (relsec
= filedata
->section_headers
;
13365 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13368 bfd_boolean is_rela
;
13369 unsigned long num_relocs
;
13370 Elf_Internal_Rela
* relocs
;
13371 Elf_Internal_Rela
* rp
;
13372 Elf_Internal_Shdr
* symsec
;
13373 Elf_Internal_Sym
* symtab
;
13374 unsigned long num_syms
;
13375 Elf_Internal_Sym
* sym
;
13377 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13378 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13379 || filedata
->section_headers
+ relsec
->sh_info
!= section
13380 || relsec
->sh_size
== 0
13381 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13384 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13385 if (symsec
->sh_type
!= SHT_SYMTAB
13386 && symsec
->sh_type
!= SHT_DYNSYM
)
13389 is_rela
= relsec
->sh_type
== SHT_RELA
;
13393 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13394 relsec
->sh_size
, & relocs
, & num_relocs
))
13399 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13400 relsec
->sh_size
, & relocs
, & num_relocs
))
13404 /* SH uses RELA but uses in place value instead of the addend field. */
13405 if (filedata
->file_header
.e_machine
== EM_SH
)
13408 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13410 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13413 unsigned int reloc_type
;
13414 unsigned int reloc_size
;
13415 bfd_boolean reloc_inplace
= FALSE
;
13416 bfd_boolean reloc_subtract
= FALSE
;
13417 unsigned char * rloc
;
13418 unsigned long sym_index
;
13420 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13422 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13424 else if (is_none_reloc (filedata
, reloc_type
))
13426 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13427 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13429 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13430 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13432 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13434 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13436 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13437 || is_6bit_abs_reloc (filedata
, reloc_type
))
13439 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13441 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13444 reloc_inplace
= TRUE
;
13446 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13448 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13451 reloc_inplace
= TRUE
;
13453 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13455 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13458 reloc_inplace
= TRUE
;
13460 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13462 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13465 reloc_inplace
= TRUE
;
13467 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13471 reloc_inplace
= TRUE
;
13475 static unsigned int prev_reloc
= 0;
13477 if (reloc_type
!= prev_reloc
)
13478 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13479 reloc_type
, printable_section_name (filedata
, section
));
13480 prev_reloc
= reloc_type
;
13484 rloc
= start
+ rp
->r_offset
;
13485 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13487 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13488 (unsigned long) rp
->r_offset
,
13489 printable_section_name (filedata
, section
));
13493 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13494 if (sym_index
>= num_syms
)
13496 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13497 sym_index
, printable_section_name (filedata
, section
));
13500 sym
= symtab
+ sym_index
;
13502 /* If the reloc has a symbol associated with it,
13503 make sure that it is of an appropriate type.
13505 Relocations against symbols without type can happen.
13506 Gcc -feliminate-dwarf2-dups may generate symbols
13507 without type for debug info.
13509 Icc generates relocations against function symbols
13510 instead of local labels.
13512 Relocations against object symbols can happen, eg when
13513 referencing a global array. For an example of this see
13514 the _clz.o binary in libgcc.a. */
13516 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13517 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13519 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13520 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13521 printable_section_name (filedata
, relsec
),
13522 (long int)(rp
- relocs
));
13528 addend
+= rp
->r_addend
;
13529 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13530 partial_inplace. */
13532 || (filedata
->file_header
.e_machine
== EM_XTENSA
13533 && reloc_type
== 1)
13534 || ((filedata
->file_header
.e_machine
== EM_PJ
13535 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13536 && reloc_type
== 1)
13537 || ((filedata
->file_header
.e_machine
== EM_D30V
13538 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13539 && reloc_type
== 12)
13542 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13543 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13545 addend
+= byte_get (rloc
, reloc_size
);
13548 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13549 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13551 /* On HPPA, all pc-relative relocations are biased by 8. */
13552 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13554 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13557 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13558 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13560 if (reloc_subtract
)
13561 addend
-= sym
->st_value
;
13563 addend
+= sym
->st_value
;
13564 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13565 byte_put (rloc
, addend
, reloc_size
);
13567 else if (reloc_subtract
)
13568 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13570 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13574 /* Let the target specific reloc processing code know that
13575 we have finished with these relocs. */
13576 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13580 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13581 * num_relocs_return
= num_relocs
;
13592 #ifdef SUPPORT_DISASSEMBLY
13594 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13596 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13598 /* FIXME: XXX -- to be done --- XXX */
13604 /* Reads in the contents of SECTION from FILE, returning a pointer
13605 to a malloc'ed buffer or NULL if something went wrong. */
13608 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13610 bfd_size_type num_bytes
= section
->sh_size
;
13612 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13614 printf (_("Section '%s' has no data to dump.\n"),
13615 printable_section_name (filedata
, section
));
13619 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13620 _("section contents"));
13623 /* Uncompresses a section that was compressed using zlib, in place. */
13626 uncompress_section_contents (unsigned char ** buffer
,
13627 dwarf_size_type uncompressed_size
,
13628 dwarf_size_type
* size
)
13630 dwarf_size_type compressed_size
= *size
;
13631 unsigned char * compressed_buffer
= *buffer
;
13632 unsigned char * uncompressed_buffer
;
13636 /* It is possible the section consists of several compressed
13637 buffers concatenated together, so we uncompress in a loop. */
13638 /* PR 18313: The state field in the z_stream structure is supposed
13639 to be invisible to the user (ie us), but some compilers will
13640 still complain about it being used without initialisation. So
13641 we first zero the entire z_stream structure and then set the fields
13643 memset (& strm
, 0, sizeof strm
);
13644 strm
.avail_in
= compressed_size
;
13645 strm
.next_in
= (Bytef
*) compressed_buffer
;
13646 strm
.avail_out
= uncompressed_size
;
13647 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13649 rc
= inflateInit (& strm
);
13650 while (strm
.avail_in
> 0)
13654 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13655 + (uncompressed_size
- strm
.avail_out
));
13656 rc
= inflate (&strm
, Z_FINISH
);
13657 if (rc
!= Z_STREAM_END
)
13659 rc
= inflateReset (& strm
);
13661 rc
= inflateEnd (& strm
);
13663 || strm
.avail_out
!= 0)
13666 *buffer
= uncompressed_buffer
;
13667 *size
= uncompressed_size
;
13671 free (uncompressed_buffer
);
13672 /* Indicate decompression failure. */
13678 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13680 Elf_Internal_Shdr
* relsec
;
13681 bfd_size_type num_bytes
;
13682 unsigned char * data
;
13683 unsigned char * end
;
13684 unsigned char * real_start
;
13685 unsigned char * start
;
13686 bfd_boolean some_strings_shown
;
13688 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13690 /* PR 21820: Do not fail if the section was empty. */
13691 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13693 num_bytes
= section
->sh_size
;
13695 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13697 if (decompress_dumps
)
13699 dwarf_size_type new_size
= num_bytes
;
13700 dwarf_size_type uncompressed_size
= 0;
13702 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13704 Elf_Internal_Chdr chdr
;
13705 unsigned int compression_header_size
13706 = get_compression_header (& chdr
, (unsigned char *) start
,
13708 if (compression_header_size
== 0)
13709 /* An error message will have already been generated
13710 by get_compression_header. */
13713 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13715 warn (_("section '%s' has unsupported compress type: %d\n"),
13716 printable_section_name (filedata
, section
), chdr
.ch_type
);
13719 uncompressed_size
= chdr
.ch_size
;
13720 start
+= compression_header_size
;
13721 new_size
-= compression_header_size
;
13723 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13725 /* Read the zlib header. In this case, it should be "ZLIB"
13726 followed by the uncompressed section size, 8 bytes in
13727 big-endian order. */
13728 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13729 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13730 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13731 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13732 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13733 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13734 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13735 uncompressed_size
+= start
[11];
13740 if (uncompressed_size
)
13742 if (uncompress_section_contents (& start
,
13743 uncompressed_size
, & new_size
))
13744 num_bytes
= new_size
;
13747 error (_("Unable to decompress section %s\n"),
13748 printable_section_name (filedata
, section
));
13753 start
= real_start
;
13756 /* If the section being dumped has relocations against it the user might
13757 be expecting these relocations to have been applied. Check for this
13758 case and issue a warning message in order to avoid confusion.
13759 FIXME: Maybe we ought to have an option that dumps a section with
13760 relocs applied ? */
13761 for (relsec
= filedata
->section_headers
;
13762 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13765 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13766 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13767 || filedata
->section_headers
+ relsec
->sh_info
!= section
13768 || relsec
->sh_size
== 0
13769 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13772 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13777 end
= start
+ num_bytes
;
13778 some_strings_shown
= FALSE
;
13780 #ifdef HAVE_MBSTATE_T
13782 /* Initialise the multibyte conversion state. */
13783 memset (& state
, 0, sizeof (state
));
13786 bfd_boolean continuing
= FALSE
;
13790 while (!ISPRINT (* data
))
13791 if (++ data
>= end
)
13796 size_t maxlen
= end
- data
;
13801 continuing
= FALSE
;
13806 /* PR 11128: Use two separate invocations in order to work
13807 around bugs in the Solaris 8 implementation of printf. */
13808 printf (" [%6tx] ", data
- start
);
13810 printf (" [%6Ix] ", (size_t) (data
- start
));
13825 /* PR 25543: Treat new-lines as string-ending characters. */
13834 /* Do not print control characters directly as they can affect terminal
13835 settings. Such characters usually appear in the names generated
13836 by the assembler for local labels. */
13839 printf ("^%c", c
+ 0x40);
13841 else if (ISPRINT (c
))
13848 #ifdef HAVE_MBSTATE_T
13851 /* Let printf do the hard work of displaying multibyte characters. */
13852 printf ("%.1s", data
- 1);
13853 #ifdef HAVE_MBSTATE_T
13854 /* Try to find out how many bytes made up the character that was
13855 just printed. Advance the symbol pointer past the bytes that
13857 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13861 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13871 printf (_("<corrupt>\n"));
13874 some_strings_shown
= TRUE
;
13878 if (! some_strings_shown
)
13879 printf (_(" No strings found in this section."));
13892 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13893 Filedata
* filedata
,
13894 bfd_boolean relocate
)
13896 Elf_Internal_Shdr
* relsec
;
13897 bfd_size_type bytes
;
13898 bfd_size_type section_size
;
13900 unsigned char * data
;
13901 unsigned char * real_start
;
13902 unsigned char * start
;
13904 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13906 /* PR 21820: Do not fail if the section was empty. */
13907 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13909 section_size
= section
->sh_size
;
13911 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13913 if (decompress_dumps
)
13915 dwarf_size_type new_size
= section_size
;
13916 dwarf_size_type uncompressed_size
= 0;
13918 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13920 Elf_Internal_Chdr chdr
;
13921 unsigned int compression_header_size
13922 = get_compression_header (& chdr
, start
, section_size
);
13924 if (compression_header_size
== 0)
13925 /* An error message will have already been generated
13926 by get_compression_header. */
13929 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13931 warn (_("section '%s' has unsupported compress type: %d\n"),
13932 printable_section_name (filedata
, section
), chdr
.ch_type
);
13935 uncompressed_size
= chdr
.ch_size
;
13936 start
+= compression_header_size
;
13937 new_size
-= compression_header_size
;
13939 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13941 /* Read the zlib header. In this case, it should be "ZLIB"
13942 followed by the uncompressed section size, 8 bytes in
13943 big-endian order. */
13944 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13945 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13946 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13947 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13948 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13949 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13950 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13951 uncompressed_size
+= start
[11];
13956 if (uncompressed_size
)
13958 if (uncompress_section_contents (& start
, uncompressed_size
,
13961 section_size
= new_size
;
13965 error (_("Unable to decompress section %s\n"),
13966 printable_section_name (filedata
, section
));
13967 /* FIXME: Print the section anyway ? */
13972 start
= real_start
;
13977 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13982 /* If the section being dumped has relocations against it the user might
13983 be expecting these relocations to have been applied. Check for this
13984 case and issue a warning message in order to avoid confusion.
13985 FIXME: Maybe we ought to have an option that dumps a section with
13986 relocs applied ? */
13987 for (relsec
= filedata
->section_headers
;
13988 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13991 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13992 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13993 || filedata
->section_headers
+ relsec
->sh_info
!= section
13994 || relsec
->sh_size
== 0
13995 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13998 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14003 addr
= section
->sh_addr
;
14004 bytes
= section_size
;
14013 lbytes
= (bytes
> 16 ? 16 : bytes
);
14015 printf (" 0x%8.8lx ", (unsigned long) addr
);
14017 for (j
= 0; j
< 16; j
++)
14020 printf ("%2.2x", data
[j
]);
14028 for (j
= 0; j
< lbytes
; j
++)
14031 if (k
>= ' ' && k
< 0x7f)
14054 static ctf_sect_t
*
14055 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14057 buf
->cts_name
= SECTION_NAME (shdr
);
14058 buf
->cts_size
= shdr
->sh_size
;
14059 buf
->cts_entsize
= shdr
->sh_entsize
;
14064 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14065 it is passed, or a pointer to newly-allocated storage, in which case
14066 dump_ctf() will free it when it no longer needs it. */
14068 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14069 char *s
, void *arg
)
14071 const char *blanks
= arg
;
14074 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14080 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14082 Elf_Internal_Shdr
* parent_sec
= NULL
;
14083 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14084 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14085 void * data
= NULL
;
14086 void * symdata
= NULL
;
14087 void * strdata
= NULL
;
14088 void * parentdata
= NULL
;
14089 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14090 ctf_sect_t
* symsectp
= NULL
;
14091 ctf_sect_t
* strsectp
= NULL
;
14092 ctf_file_t
* ctf
= NULL
;
14093 ctf_file_t
* parent
= NULL
;
14095 const char *things
[] = {"Header", "Labels", "Data objects",
14096 "Function objects", "Variables", "Types", "Strings",
14098 const char **thing
;
14100 bfd_boolean ret
= FALSE
;
14103 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14104 data
= get_section_contents (section
, filedata
);
14105 ctfsect
.cts_data
= data
;
14107 if (!dump_ctf_symtab_name
)
14108 dump_ctf_symtab_name
= strdup (".symtab");
14110 if (!dump_ctf_strtab_name
)
14111 dump_ctf_strtab_name
= strdup (".strtab");
14113 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14115 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14117 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14120 if ((symdata
= (void *) get_data (NULL
, filedata
,
14121 symtab_sec
->sh_offset
, 1,
14122 symtab_sec
->sh_size
,
14123 _("symbols"))) == NULL
)
14125 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14126 symsect
.cts_data
= symdata
;
14128 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14130 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14132 error (_("No string table section named %s\n"),
14133 dump_ctf_strtab_name
);
14136 if ((strdata
= (void *) get_data (NULL
, filedata
,
14137 strtab_sec
->sh_offset
, 1,
14138 strtab_sec
->sh_size
,
14139 _("strings"))) == NULL
)
14141 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14142 strsect
.cts_data
= strdata
;
14144 if (dump_ctf_parent_name
)
14146 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14148 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14151 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14152 parent_sec
->sh_offset
, 1,
14153 parent_sec
->sh_size
,
14154 _("CTF parent"))) == NULL
)
14156 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14157 parentsect
.cts_data
= parentdata
;
14160 /* Load the CTF file and dump it. */
14162 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14164 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14170 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14172 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14176 ctf_import (ctf
, parent
);
14181 printf (_("\nDump of CTF section '%s':\n"),
14182 printable_section_name (filedata
, section
));
14184 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14186 ctf_dump_state_t
*s
= NULL
;
14189 printf ("\n %s:\n", *thing
);
14190 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14191 (void *) " ")) != NULL
)
14193 printf ("%s\n", item
);
14197 if (ctf_errno (ctf
))
14199 error (_("Iteration failed: %s, %s\n"), *thing
,
14200 ctf_errmsg (ctf_errno (ctf
)));
14206 ctf_file_close (ctf
);
14207 ctf_file_close (parent
);
14216 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14217 const Elf_Internal_Shdr
* sec
,
14220 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14222 Filedata
* filedata
= (Filedata
*) data
;
14224 if (section
->start
!= NULL
)
14226 /* If it is already loaded, do nothing. */
14227 if (streq (section
->filename
, filedata
->file_name
))
14229 free (section
->start
);
14232 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14233 section
->address
= sec
->sh_addr
;
14234 section
->user_data
= NULL
;
14235 section
->filename
= filedata
->file_name
;
14236 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14238 sec
->sh_size
, buf
);
14239 if (section
->start
== NULL
)
14243 unsigned char *start
= section
->start
;
14244 dwarf_size_type size
= sec
->sh_size
;
14245 dwarf_size_type uncompressed_size
= 0;
14247 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14249 Elf_Internal_Chdr chdr
;
14250 unsigned int compression_header_size
;
14252 if (size
< (is_32bit_elf
14253 ? sizeof (Elf32_External_Chdr
)
14254 : sizeof (Elf64_External_Chdr
)))
14256 warn (_("compressed section %s is too small to contain a compression header\n"),
14261 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14262 if (compression_header_size
== 0)
14263 /* An error message will have already been generated
14264 by get_compression_header. */
14267 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14269 warn (_("section '%s' has unsupported compress type: %d\n"),
14270 section
->name
, chdr
.ch_type
);
14273 uncompressed_size
= chdr
.ch_size
;
14274 start
+= compression_header_size
;
14275 size
-= compression_header_size
;
14277 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14279 /* Read the zlib header. In this case, it should be "ZLIB"
14280 followed by the uncompressed section size, 8 bytes in
14281 big-endian order. */
14282 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14283 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14284 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14285 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14286 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14287 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14288 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14289 uncompressed_size
+= start
[11];
14294 if (uncompressed_size
)
14296 if (uncompress_section_contents (&start
, uncompressed_size
,
14299 /* Free the compressed buffer, update the section buffer
14300 and the section size if uncompress is successful. */
14301 free (section
->start
);
14302 section
->start
= start
;
14306 error (_("Unable to decompress section %s\n"),
14307 printable_section_name (filedata
, sec
));
14312 section
->size
= size
;
14315 if (section
->start
== NULL
)
14318 if (debug_displays
[debug
].relocate
)
14320 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14321 & section
->reloc_info
, & section
->num_relocs
))
14326 section
->reloc_info
= NULL
;
14327 section
->num_relocs
= 0;
14333 #if HAVE_LIBDEBUGINFOD
14334 /* Return a hex string representation of the build-id. */
14336 get_build_id (void * data
)
14338 Filedata
* filedata
= (Filedata
*)data
;
14339 Elf_Internal_Shdr
* shdr
;
14342 /* Iterate through notes to find note.gnu.build-id.
14343 FIXME: Only the first note in any note section is examined. */
14344 for (i
= 0, shdr
= filedata
->section_headers
;
14345 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14348 if (shdr
->sh_type
!= SHT_NOTE
)
14353 size_t data_remaining
;
14355 Elf_External_Note
* enote
;
14356 Elf_Internal_Note inote
;
14358 bfd_vma offset
= shdr
->sh_offset
;
14359 bfd_vma align
= shdr
->sh_addralign
;
14360 bfd_vma length
= shdr
->sh_size
;
14362 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14368 else if (align
!= 4 && align
!= 8)
14374 end
= (char *) enote
+ length
;
14375 data_remaining
= end
- (char *) enote
;
14377 if (!is_ia64_vms (filedata
))
14379 min_notesz
= offsetof (Elf_External_Note
, name
);
14380 if (data_remaining
< min_notesz
)
14383 malformed note encountered in section %s whilst scanning for build-id note\n"),
14384 printable_section_name (filedata
, shdr
));
14388 data_remaining
-= min_notesz
;
14390 inote
.type
= BYTE_GET (enote
->type
);
14391 inote
.namesz
= BYTE_GET (enote
->namesz
);
14392 inote
.namedata
= enote
->name
;
14393 inote
.descsz
= BYTE_GET (enote
->descsz
);
14394 inote
.descdata
= ((char *) enote
14395 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14396 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14397 next
= ((char *) enote
14398 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14402 Elf64_External_VMS_Note
*vms_enote
;
14404 /* PR binutils/15191
14405 Make sure that there is enough data to read. */
14406 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14407 if (data_remaining
< min_notesz
)
14410 malformed note encountered in section %s whilst scanning for build-id note\n"),
14411 printable_section_name (filedata
, shdr
));
14415 data_remaining
-= min_notesz
;
14417 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14418 inote
.type
= BYTE_GET (vms_enote
->type
);
14419 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14420 inote
.namedata
= vms_enote
->name
;
14421 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14422 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14423 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14424 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14427 /* Skip malformed notes. */
14428 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14429 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14430 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14431 || ((size_t) (next
- inote
.descdata
)
14432 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14435 malformed note encountered in section %s whilst scanning for build-id note\n"),
14436 printable_section_name (filedata
, shdr
));
14441 /* Check if this is the build-id note. If so then convert the build-id
14442 bytes to a hex string. */
14443 if (inote
.namesz
> 0
14444 && const_strneq (inote
.namedata
, "GNU")
14445 && inote
.type
== NT_GNU_BUILD_ID
)
14450 build_id
= malloc (inote
.descsz
* 2 + 1);
14451 if (build_id
== NULL
)
14457 for (j
= 0; j
< inote
.descsz
; ++j
)
14458 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14459 build_id
[inote
.descsz
* 2] = '\0';
14462 return (unsigned char *) build_id
;
14469 #endif /* HAVE_LIBDEBUGINFOD */
14471 /* If this is not NULL, load_debug_section will only look for sections
14472 within the list of sections given here. */
14473 static unsigned int * section_subset
= NULL
;
14476 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14478 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14479 Elf_Internal_Shdr
* sec
;
14480 Filedata
* filedata
= (Filedata
*) data
;
14482 /* Without section headers we cannot find any sections. */
14483 if (filedata
->section_headers
== NULL
)
14486 if (filedata
->string_table
== NULL
14487 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14488 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14490 Elf_Internal_Shdr
* strs
;
14492 /* Read in the string table, so that we have section names to scan. */
14493 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14495 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14497 filedata
->string_table
14498 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14499 1, strs
->sh_size
, _("string table"));
14501 filedata
->string_table_length
14502 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14506 /* Locate the debug section. */
14507 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14509 section
->name
= section
->uncompressed_name
;
14512 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14514 section
->name
= section
->compressed_name
;
14519 /* If we're loading from a subset of sections, and we've loaded
14520 a section matching this name before, it's likely that it's a
14522 if (section_subset
!= NULL
)
14523 free_debug_section (debug
);
14525 return load_specific_debug_section (debug
, sec
, data
);
14529 free_debug_section (enum dwarf_section_display_enum debug
)
14531 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14533 if (section
->start
== NULL
)
14536 free ((char *) section
->start
);
14537 section
->start
= NULL
;
14538 section
->address
= 0;
14541 if (section
->reloc_info
!= NULL
)
14543 free (section
->reloc_info
);
14544 section
->reloc_info
= NULL
;
14545 section
->num_relocs
= 0;
14550 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14552 char * name
= SECTION_NAME (section
);
14553 const char * print_name
= printable_section_name (filedata
, section
);
14554 bfd_size_type length
;
14555 bfd_boolean result
= TRUE
;
14558 length
= section
->sh_size
;
14561 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14564 if (section
->sh_type
== SHT_NOBITS
)
14566 /* There is no point in dumping the contents of a debugging section
14567 which has the NOBITS type - the bits in the file will be random.
14568 This can happen when a file containing a .eh_frame section is
14569 stripped with the --only-keep-debug command line option. */
14570 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14575 if (const_strneq (name
, ".gnu.linkonce.wi."))
14576 name
= ".debug_info";
14578 /* See if we know how to display the contents of this section. */
14579 for (i
= 0; i
< max
; i
++)
14581 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14582 struct dwarf_section_display
* display
= debug_displays
+ i
;
14583 struct dwarf_section
* sec
= & display
->section
;
14585 if (streq (sec
->uncompressed_name
, name
)
14586 || (id
== line
&& const_strneq (name
, ".debug_line."))
14587 || streq (sec
->compressed_name
, name
))
14589 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14592 free_debug_section (id
);
14594 if (i
== line
&& const_strneq (name
, ".debug_line."))
14596 else if (streq (sec
->uncompressed_name
, name
))
14597 sec
->name
= sec
->uncompressed_name
;
14599 sec
->name
= sec
->compressed_name
;
14601 if (load_specific_debug_section (id
, section
, filedata
))
14603 /* If this debug section is part of a CU/TU set in a .dwp file,
14604 restrict load_debug_section to the sections in that set. */
14605 section_subset
= find_cu_tu_set (filedata
, shndx
);
14607 result
&= display
->display (sec
, filedata
);
14609 section_subset
= NULL
;
14611 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14612 free_debug_section (id
);
14620 printf (_("Unrecognized debug section: %s\n"), print_name
);
14627 /* Set DUMP_SECTS for all sections where dumps were requested
14628 based on section name. */
14631 initialise_dumps_byname (Filedata
* filedata
)
14633 struct dump_list_entry
* cur
;
14635 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14638 bfd_boolean any
= FALSE
;
14640 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14641 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14643 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14648 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14654 process_section_contents (Filedata
* filedata
)
14656 Elf_Internal_Shdr
* section
;
14658 bfd_boolean res
= TRUE
;
14663 initialise_dumps_byname (filedata
);
14665 for (i
= 0, section
= filedata
->section_headers
;
14666 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14669 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14671 #ifdef SUPPORT_DISASSEMBLY
14672 if (dump
& DISASS_DUMP
)
14674 if (! disassemble_section (section
, filedata
))
14678 if (dump
& HEX_DUMP
)
14680 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14684 if (dump
& RELOC_DUMP
)
14686 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14690 if (dump
& STRING_DUMP
)
14692 if (! dump_section_as_strings (section
, filedata
))
14696 if (dump
& DEBUG_DUMP
)
14698 if (! display_debug_section (i
, section
, filedata
))
14702 if (dump
& CTF_DUMP
)
14704 if (! dump_section_as_ctf (section
, filedata
))
14709 /* Check to see if the user requested a
14710 dump of a section that does not exist. */
14711 while (i
< filedata
->dump
.num_dump_sects
)
14713 if (filedata
->dump
.dump_sects
[i
])
14715 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14725 process_mips_fpe_exception (int mask
)
14729 bfd_boolean first
= TRUE
;
14731 if (mask
& OEX_FPU_INEX
)
14732 fputs ("INEX", stdout
), first
= FALSE
;
14733 if (mask
& OEX_FPU_UFLO
)
14734 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14735 if (mask
& OEX_FPU_OFLO
)
14736 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14737 if (mask
& OEX_FPU_DIV0
)
14738 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14739 if (mask
& OEX_FPU_INVAL
)
14740 printf ("%sINVAL", first
? "" : "|");
14743 fputs ("0", stdout
);
14746 /* Display's the value of TAG at location P. If TAG is
14747 greater than 0 it is assumed to be an unknown tag, and
14748 a message is printed to this effect. Otherwise it is
14749 assumed that a message has already been printed.
14751 If the bottom bit of TAG is set it assumed to have a
14752 string value, otherwise it is assumed to have an integer
14755 Returns an updated P pointing to the first unread byte
14756 beyond the end of TAG's value.
14758 Reads at or beyond END will not be made. */
14760 static unsigned char *
14761 display_tag_value (signed int tag
,
14763 const unsigned char * const end
)
14768 printf (" Tag_unknown_%d: ", tag
);
14772 warn (_("<corrupt tag>\n"));
14776 /* PR 17531 file: 027-19978-0.004. */
14777 size_t maxlen
= (end
- p
) - 1;
14782 print_symbol ((int) maxlen
, (const char *) p
);
14783 p
+= strnlen ((char *) p
, maxlen
) + 1;
14787 printf (_("<corrupt string tag>"));
14788 p
= (unsigned char *) end
;
14794 READ_ULEB (val
, p
, end
);
14795 printf ("%ld (0x%lx)\n", val
, val
);
14802 /* ARC ABI attributes section. */
14804 static unsigned char *
14805 display_arc_attribute (unsigned char * p
,
14806 const unsigned char * const end
)
14811 READ_ULEB (tag
, p
, end
);
14815 case Tag_ARC_PCS_config
:
14816 READ_ULEB (val
, p
, end
);
14817 printf (" Tag_ARC_PCS_config: ");
14821 printf (_("Absent/Non standard\n"));
14824 printf (_("Bare metal/mwdt\n"));
14827 printf (_("Bare metal/newlib\n"));
14830 printf (_("Linux/uclibc\n"));
14833 printf (_("Linux/glibc\n"));
14836 printf (_("Unknown\n"));
14841 case Tag_ARC_CPU_base
:
14842 READ_ULEB (val
, p
, end
);
14843 printf (" Tag_ARC_CPU_base: ");
14848 printf (_("Absent\n"));
14850 case TAG_CPU_ARC6xx
:
14851 printf ("ARC6xx\n");
14853 case TAG_CPU_ARC7xx
:
14854 printf ("ARC7xx\n");
14856 case TAG_CPU_ARCEM
:
14857 printf ("ARCEM\n");
14859 case TAG_CPU_ARCHS
:
14860 printf ("ARCHS\n");
14865 case Tag_ARC_CPU_variation
:
14866 READ_ULEB (val
, p
, end
);
14867 printf (" Tag_ARC_CPU_variation: ");
14871 if (val
> 0 && val
< 16)
14872 printf ("Core%d\n", val
);
14874 printf ("Unknown\n");
14878 printf (_("Absent\n"));
14883 case Tag_ARC_CPU_name
:
14884 printf (" Tag_ARC_CPU_name: ");
14885 p
= display_tag_value (-1, p
, end
);
14888 case Tag_ARC_ABI_rf16
:
14889 READ_ULEB (val
, p
, end
);
14890 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14893 case Tag_ARC_ABI_osver
:
14894 READ_ULEB (val
, p
, end
);
14895 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14898 case Tag_ARC_ABI_pic
:
14899 case Tag_ARC_ABI_sda
:
14900 READ_ULEB (val
, p
, end
);
14901 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14902 : " Tag_ARC_ABI_pic: ");
14906 printf (_("Absent\n"));
14915 printf (_("Unknown\n"));
14920 case Tag_ARC_ABI_tls
:
14921 READ_ULEB (val
, p
, end
);
14922 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14925 case Tag_ARC_ABI_enumsize
:
14926 READ_ULEB (val
, p
, end
);
14927 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14931 case Tag_ARC_ABI_exceptions
:
14932 READ_ULEB (val
, p
, end
);
14933 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14937 case Tag_ARC_ABI_double_size
:
14938 READ_ULEB (val
, p
, end
);
14939 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14942 case Tag_ARC_ISA_config
:
14943 printf (" Tag_ARC_ISA_config: ");
14944 p
= display_tag_value (-1, p
, end
);
14947 case Tag_ARC_ISA_apex
:
14948 printf (" Tag_ARC_ISA_apex: ");
14949 p
= display_tag_value (-1, p
, end
);
14952 case Tag_ARC_ISA_mpy_option
:
14953 READ_ULEB (val
, p
, end
);
14954 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14957 case Tag_ARC_ATR_version
:
14958 READ_ULEB (val
, p
, end
);
14959 printf (" Tag_ARC_ATR_version: %d\n", val
);
14963 return display_tag_value (tag
& 1, p
, end
);
14969 /* ARM EABI attributes section. */
14974 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14976 const char ** table
;
14977 } arm_attr_public_tag
;
14979 static const char * arm_attr_tag_CPU_arch
[] =
14980 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14981 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14982 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14983 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14984 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14985 {"No", "Thumb-1", "Thumb-2", "Yes"};
14986 static const char * arm_attr_tag_FP_arch
[] =
14987 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14988 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14989 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14990 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14991 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14992 "NEON for ARMv8.1"};
14993 static const char * arm_attr_tag_PCS_config
[] =
14994 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14995 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14996 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14997 {"V6", "SB", "TLS", "Unused"};
14998 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14999 {"Absolute", "PC-relative", "SB-relative", "None"};
15000 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15001 {"Absolute", "PC-relative", "None"};
15002 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15003 {"None", "direct", "GOT-indirect"};
15004 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15005 {"None", "??? 1", "2", "??? 3", "4"};
15006 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15007 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15008 {"Unused", "Needed", "Sign only"};
15009 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15010 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15011 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15012 {"Unused", "Finite", "RTABI", "IEEE 754"};
15013 static const char * arm_attr_tag_ABI_enum_size
[] =
15014 {"Unused", "small", "int", "forced to int"};
15015 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15016 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15017 static const char * arm_attr_tag_ABI_VFP_args
[] =
15018 {"AAPCS", "VFP registers", "custom", "compatible"};
15019 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15020 {"AAPCS", "WMMX registers", "custom"};
15021 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15022 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15023 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15024 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15025 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15026 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15027 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15028 static const char * arm_attr_tag_FP_HP_extension
[] =
15029 {"Not Allowed", "Allowed"};
15030 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15031 {"None", "IEEE 754", "Alternative Format"};
15032 static const char * arm_attr_tag_DSP_extension
[] =
15033 {"Follow architecture", "Allowed"};
15034 static const char * arm_attr_tag_MPextension_use
[] =
15035 {"Not Allowed", "Allowed"};
15036 static const char * arm_attr_tag_DIV_use
[] =
15037 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15038 "Allowed in v7-A with integer division extension"};
15039 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15040 static const char * arm_attr_tag_Virtualization_use
[] =
15041 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15042 "TrustZone and Virtualization Extensions"};
15043 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15044 {"Not Allowed", "Allowed"};
15046 static const char * arm_attr_tag_MVE_arch
[] =
15047 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15049 #define LOOKUP(id, name) \
15050 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15051 static arm_attr_public_tag arm_attr_public_tags
[] =
15053 {4, "CPU_raw_name", 1, NULL
},
15054 {5, "CPU_name", 1, NULL
},
15055 LOOKUP(6, CPU_arch
),
15056 {7, "CPU_arch_profile", 0, NULL
},
15057 LOOKUP(8, ARM_ISA_use
),
15058 LOOKUP(9, THUMB_ISA_use
),
15059 LOOKUP(10, FP_arch
),
15060 LOOKUP(11, WMMX_arch
),
15061 LOOKUP(12, Advanced_SIMD_arch
),
15062 LOOKUP(13, PCS_config
),
15063 LOOKUP(14, ABI_PCS_R9_use
),
15064 LOOKUP(15, ABI_PCS_RW_data
),
15065 LOOKUP(16, ABI_PCS_RO_data
),
15066 LOOKUP(17, ABI_PCS_GOT_use
),
15067 LOOKUP(18, ABI_PCS_wchar_t
),
15068 LOOKUP(19, ABI_FP_rounding
),
15069 LOOKUP(20, ABI_FP_denormal
),
15070 LOOKUP(21, ABI_FP_exceptions
),
15071 LOOKUP(22, ABI_FP_user_exceptions
),
15072 LOOKUP(23, ABI_FP_number_model
),
15073 {24, "ABI_align_needed", 0, NULL
},
15074 {25, "ABI_align_preserved", 0, NULL
},
15075 LOOKUP(26, ABI_enum_size
),
15076 LOOKUP(27, ABI_HardFP_use
),
15077 LOOKUP(28, ABI_VFP_args
),
15078 LOOKUP(29, ABI_WMMX_args
),
15079 LOOKUP(30, ABI_optimization_goals
),
15080 LOOKUP(31, ABI_FP_optimization_goals
),
15081 {32, "compatibility", 0, NULL
},
15082 LOOKUP(34, CPU_unaligned_access
),
15083 LOOKUP(36, FP_HP_extension
),
15084 LOOKUP(38, ABI_FP_16bit_format
),
15085 LOOKUP(42, MPextension_use
),
15086 LOOKUP(44, DIV_use
),
15087 LOOKUP(46, DSP_extension
),
15088 LOOKUP(48, MVE_arch
),
15089 {64, "nodefaults", 0, NULL
},
15090 {65, "also_compatible_with", 0, NULL
},
15091 LOOKUP(66, T2EE_use
),
15092 {67, "conformance", 1, NULL
},
15093 LOOKUP(68, Virtualization_use
),
15094 LOOKUP(70, MPextension_use_legacy
)
15098 static unsigned char *
15099 display_arm_attribute (unsigned char * p
,
15100 const unsigned char * const end
)
15104 arm_attr_public_tag
* attr
;
15108 READ_ULEB (tag
, p
, end
);
15110 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15112 if (arm_attr_public_tags
[i
].tag
== tag
)
15114 attr
= &arm_attr_public_tags
[i
];
15121 printf (" Tag_%s: ", attr
->name
);
15122 switch (attr
->type
)
15127 case 7: /* Tag_CPU_arch_profile. */
15128 READ_ULEB (val
, p
, end
);
15131 case 0: printf (_("None\n")); break;
15132 case 'A': printf (_("Application\n")); break;
15133 case 'R': printf (_("Realtime\n")); break;
15134 case 'M': printf (_("Microcontroller\n")); break;
15135 case 'S': printf (_("Application or Realtime\n")); break;
15136 default: printf ("??? (%d)\n", val
); break;
15140 case 24: /* Tag_align_needed. */
15141 READ_ULEB (val
, p
, end
);
15144 case 0: printf (_("None\n")); break;
15145 case 1: printf (_("8-byte\n")); break;
15146 case 2: printf (_("4-byte\n")); break;
15147 case 3: printf ("??? 3\n"); break;
15150 printf (_("8-byte and up to %d-byte extended\n"),
15153 printf ("??? (%d)\n", val
);
15158 case 25: /* Tag_align_preserved. */
15159 READ_ULEB (val
, p
, end
);
15162 case 0: printf (_("None\n")); break;
15163 case 1: printf (_("8-byte, except leaf SP\n")); break;
15164 case 2: printf (_("8-byte\n")); break;
15165 case 3: printf ("??? 3\n"); break;
15168 printf (_("8-byte and up to %d-byte extended\n"),
15171 printf ("??? (%d)\n", val
);
15176 case 32: /* Tag_compatibility. */
15178 READ_ULEB (val
, p
, end
);
15179 printf (_("flag = %d, vendor = "), val
);
15182 size_t maxlen
= (end
- p
) - 1;
15184 print_symbol ((int) maxlen
, (const char *) p
);
15185 p
+= strnlen ((char *) p
, maxlen
) + 1;
15189 printf (_("<corrupt>"));
15190 p
= (unsigned char *) end
;
15196 case 64: /* Tag_nodefaults. */
15197 /* PR 17531: file: 001-505008-0.01. */
15200 printf (_("True\n"));
15203 case 65: /* Tag_also_compatible_with. */
15204 READ_ULEB (val
, p
, end
);
15205 if (val
== 6 /* Tag_CPU_arch. */)
15207 READ_ULEB (val
, p
, end
);
15208 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15209 printf ("??? (%d)\n", val
);
15211 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15215 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15220 printf (_("<unknown: %d>\n"), tag
);
15226 return display_tag_value (-1, p
, end
);
15228 return display_tag_value (0, p
, end
);
15231 assert (attr
->type
& 0x80);
15232 READ_ULEB (val
, p
, end
);
15233 type
= attr
->type
& 0x7f;
15235 printf ("??? (%d)\n", val
);
15237 printf ("%s\n", attr
->table
[val
]);
15242 return display_tag_value (tag
, p
, end
);
15245 static unsigned char *
15246 display_gnu_attribute (unsigned char * p
,
15247 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15248 const unsigned char * const end
)
15253 READ_ULEB (tag
, p
, end
);
15255 /* Tag_compatibility is the only generic GNU attribute defined at
15259 READ_ULEB (val
, p
, end
);
15261 printf (_("flag = %d, vendor = "), val
);
15264 printf (_("<corrupt>\n"));
15265 warn (_("corrupt vendor attribute\n"));
15271 size_t maxlen
= (end
- p
) - 1;
15273 print_symbol ((int) maxlen
, (const char *) p
);
15274 p
+= strnlen ((char *) p
, maxlen
) + 1;
15278 printf (_("<corrupt>"));
15279 p
= (unsigned char *) end
;
15286 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15287 return display_proc_gnu_attribute (p
, tag
, end
);
15289 return display_tag_value (tag
, p
, end
);
15292 static unsigned char *
15293 display_power_gnu_attribute (unsigned char * p
,
15295 const unsigned char * const end
)
15299 if (tag
== Tag_GNU_Power_ABI_FP
)
15301 printf (" Tag_GNU_Power_ABI_FP: ");
15304 printf (_("<corrupt>\n"));
15307 READ_ULEB (val
, p
, end
);
15310 printf ("(%#x), ", val
);
15315 printf (_("unspecified hard/soft float, "));
15318 printf (_("hard float, "));
15321 printf (_("soft float, "));
15324 printf (_("single-precision hard float, "));
15331 printf (_("unspecified long double\n"));
15334 printf (_("128-bit IBM long double\n"));
15337 printf (_("64-bit long double\n"));
15340 printf (_("128-bit IEEE long double\n"));
15346 if (tag
== Tag_GNU_Power_ABI_Vector
)
15348 printf (" Tag_GNU_Power_ABI_Vector: ");
15351 printf (_("<corrupt>\n"));
15354 READ_ULEB (val
, p
, end
);
15357 printf ("(%#x), ", val
);
15362 printf (_("unspecified\n"));
15365 printf (_("generic\n"));
15368 printf ("AltiVec\n");
15377 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15379 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15382 printf (_("<corrupt>\n"));
15385 READ_ULEB (val
, p
, end
);
15388 printf ("(%#x), ", val
);
15393 printf (_("unspecified\n"));
15396 printf ("r3/r4\n");
15399 printf (_("memory\n"));
15408 return display_tag_value (tag
& 1, p
, end
);
15411 static unsigned char *
15412 display_s390_gnu_attribute (unsigned char * p
,
15414 const unsigned char * const end
)
15418 if (tag
== Tag_GNU_S390_ABI_Vector
)
15420 printf (" Tag_GNU_S390_ABI_Vector: ");
15421 READ_ULEB (val
, p
, end
);
15426 printf (_("any\n"));
15429 printf (_("software\n"));
15432 printf (_("hardware\n"));
15435 printf ("??? (%d)\n", val
);
15441 return display_tag_value (tag
& 1, p
, end
);
15445 display_sparc_hwcaps (unsigned int mask
)
15449 bfd_boolean first
= TRUE
;
15451 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15452 fputs ("mul32", stdout
), first
= FALSE
;
15453 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15454 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15455 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15456 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15457 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15458 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15459 if (mask
& ELF_SPARC_HWCAP_POPC
)
15460 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15461 if (mask
& ELF_SPARC_HWCAP_VIS
)
15462 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15463 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15464 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15465 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15466 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15467 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15468 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15469 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15470 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15471 if (mask
& ELF_SPARC_HWCAP_HPC
)
15472 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15473 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15474 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15475 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15476 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15477 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15478 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15479 if (mask
& ELF_SPARC_HWCAP_IMA
)
15480 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15481 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15482 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15485 fputc ('0', stdout
);
15486 fputc ('\n', stdout
);
15490 display_sparc_hwcaps2 (unsigned int mask
)
15494 bfd_boolean first
= TRUE
;
15496 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15497 fputs ("fjathplus", stdout
), first
= FALSE
;
15498 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15499 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15500 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15501 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15502 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15503 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15504 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15505 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15506 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15507 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15508 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15509 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15510 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15511 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15512 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15513 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15514 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15515 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15516 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15517 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15520 fputc ('0', stdout
);
15521 fputc ('\n', stdout
);
15524 static unsigned char *
15525 display_sparc_gnu_attribute (unsigned char * p
,
15527 const unsigned char * const end
)
15531 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15533 READ_ULEB (val
, p
, end
);
15534 printf (" Tag_GNU_Sparc_HWCAPS: ");
15535 display_sparc_hwcaps (val
);
15538 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15540 READ_ULEB (val
, p
, end
);
15541 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15542 display_sparc_hwcaps2 (val
);
15546 return display_tag_value (tag
, p
, end
);
15550 print_mips_fp_abi_value (unsigned int val
)
15554 case Val_GNU_MIPS_ABI_FP_ANY
:
15555 printf (_("Hard or soft float\n"));
15557 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15558 printf (_("Hard float (double precision)\n"));
15560 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15561 printf (_("Hard float (single precision)\n"));
15563 case Val_GNU_MIPS_ABI_FP_SOFT
:
15564 printf (_("Soft float\n"));
15566 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15567 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15569 case Val_GNU_MIPS_ABI_FP_XX
:
15570 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15572 case Val_GNU_MIPS_ABI_FP_64
:
15573 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15575 case Val_GNU_MIPS_ABI_FP_64A
:
15576 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15578 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15579 printf (_("NaN 2008 compatibility\n"));
15582 printf ("??? (%d)\n", val
);
15587 static unsigned char *
15588 display_mips_gnu_attribute (unsigned char * p
,
15590 const unsigned char * const end
)
15592 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15596 printf (" Tag_GNU_MIPS_ABI_FP: ");
15597 READ_ULEB (val
, p
, end
);
15598 print_mips_fp_abi_value (val
);
15602 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15606 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15607 READ_ULEB (val
, p
, end
);
15611 case Val_GNU_MIPS_ABI_MSA_ANY
:
15612 printf (_("Any MSA or not\n"));
15614 case Val_GNU_MIPS_ABI_MSA_128
:
15615 printf (_("128-bit MSA\n"));
15618 printf ("??? (%d)\n", val
);
15624 return display_tag_value (tag
& 1, p
, end
);
15627 static unsigned char *
15628 display_tic6x_attribute (unsigned char * p
,
15629 const unsigned char * const end
)
15634 READ_ULEB (tag
, p
, end
);
15639 printf (" Tag_ISA: ");
15640 READ_ULEB (val
, p
, end
);
15644 case C6XABI_Tag_ISA_none
:
15645 printf (_("None\n"));
15647 case C6XABI_Tag_ISA_C62X
:
15650 case C6XABI_Tag_ISA_C67X
:
15653 case C6XABI_Tag_ISA_C67XP
:
15654 printf ("C67x+\n");
15656 case C6XABI_Tag_ISA_C64X
:
15659 case C6XABI_Tag_ISA_C64XP
:
15660 printf ("C64x+\n");
15662 case C6XABI_Tag_ISA_C674X
:
15663 printf ("C674x\n");
15666 printf ("??? (%d)\n", val
);
15671 case Tag_ABI_wchar_t
:
15672 printf (" Tag_ABI_wchar_t: ");
15673 READ_ULEB (val
, p
, end
);
15677 printf (_("Not used\n"));
15680 printf (_("2 bytes\n"));
15683 printf (_("4 bytes\n"));
15686 printf ("??? (%d)\n", val
);
15691 case Tag_ABI_stack_align_needed
:
15692 printf (" Tag_ABI_stack_align_needed: ");
15693 READ_ULEB (val
, p
, end
);
15697 printf (_("8-byte\n"));
15700 printf (_("16-byte\n"));
15703 printf ("??? (%d)\n", val
);
15708 case Tag_ABI_stack_align_preserved
:
15709 READ_ULEB (val
, p
, end
);
15710 printf (" Tag_ABI_stack_align_preserved: ");
15714 printf (_("8-byte\n"));
15717 printf (_("16-byte\n"));
15720 printf ("??? (%d)\n", val
);
15726 READ_ULEB (val
, p
, end
);
15727 printf (" Tag_ABI_DSBT: ");
15731 printf (_("DSBT addressing not used\n"));
15734 printf (_("DSBT addressing used\n"));
15737 printf ("??? (%d)\n", val
);
15743 READ_ULEB (val
, p
, end
);
15744 printf (" Tag_ABI_PID: ");
15748 printf (_("Data addressing position-dependent\n"));
15751 printf (_("Data addressing position-independent, GOT near DP\n"));
15754 printf (_("Data addressing position-independent, GOT far from DP\n"));
15757 printf ("??? (%d)\n", val
);
15763 READ_ULEB (val
, p
, end
);
15764 printf (" Tag_ABI_PIC: ");
15768 printf (_("Code addressing position-dependent\n"));
15771 printf (_("Code addressing position-independent\n"));
15774 printf ("??? (%d)\n", val
);
15779 case Tag_ABI_array_object_alignment
:
15780 READ_ULEB (val
, p
, end
);
15781 printf (" Tag_ABI_array_object_alignment: ");
15785 printf (_("8-byte\n"));
15788 printf (_("4-byte\n"));
15791 printf (_("16-byte\n"));
15794 printf ("??? (%d)\n", val
);
15799 case Tag_ABI_array_object_align_expected
:
15800 READ_ULEB (val
, p
, end
);
15801 printf (" Tag_ABI_array_object_align_expected: ");
15805 printf (_("8-byte\n"));
15808 printf (_("4-byte\n"));
15811 printf (_("16-byte\n"));
15814 printf ("??? (%d)\n", val
);
15819 case Tag_ABI_compatibility
:
15821 READ_ULEB (val
, p
, end
);
15822 printf (" Tag_ABI_compatibility: ");
15823 printf (_("flag = %d, vendor = "), val
);
15826 size_t maxlen
= (end
- p
) - 1;
15828 print_symbol ((int) maxlen
, (const char *) p
);
15829 p
+= strnlen ((char *) p
, maxlen
) + 1;
15833 printf (_("<corrupt>"));
15834 p
= (unsigned char *) end
;
15840 case Tag_ABI_conformance
:
15842 printf (" Tag_ABI_conformance: \"");
15845 size_t maxlen
= (end
- p
) - 1;
15847 print_symbol ((int) maxlen
, (const char *) p
);
15848 p
+= strnlen ((char *) p
, maxlen
) + 1;
15852 printf (_("<corrupt>"));
15853 p
= (unsigned char *) end
;
15860 return display_tag_value (tag
, p
, end
);
15864 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15866 unsigned long addr
= 0;
15867 size_t bytes
= end
- p
;
15874 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15876 printf (" 0x%8.8lx ", addr
);
15878 for (j
= 0; j
< 16; j
++)
15881 printf ("%2.2x", p
[j
]);
15889 for (j
= 0; j
< lbytes
; j
++)
15892 if (k
>= ' ' && k
< 0x7f)
15908 static unsigned char *
15909 display_msp430x_attribute (unsigned char * p
,
15910 const unsigned char * const end
)
15915 READ_ULEB (tag
, p
, end
);
15919 case OFBA_MSPABI_Tag_ISA
:
15920 printf (" Tag_ISA: ");
15921 READ_ULEB (val
, p
, end
);
15924 case 0: printf (_("None\n")); break;
15925 case 1: printf (_("MSP430\n")); break;
15926 case 2: printf (_("MSP430X\n")); break;
15927 default: printf ("??? (%d)\n", val
); break;
15931 case OFBA_MSPABI_Tag_Code_Model
:
15932 printf (" Tag_Code_Model: ");
15933 READ_ULEB (val
, p
, end
);
15936 case 0: printf (_("None\n")); break;
15937 case 1: printf (_("Small\n")); break;
15938 case 2: printf (_("Large\n")); break;
15939 default: printf ("??? (%d)\n", val
); break;
15943 case OFBA_MSPABI_Tag_Data_Model
:
15944 printf (" Tag_Data_Model: ");
15945 READ_ULEB (val
, p
, end
);
15948 case 0: printf (_("None\n")); break;
15949 case 1: printf (_("Small\n")); break;
15950 case 2: printf (_("Large\n")); break;
15951 case 3: printf (_("Restricted Large\n")); break;
15952 default: printf ("??? (%d)\n", val
); break;
15957 printf (_(" <unknown tag %d>: "), tag
);
15964 size_t maxlen
= (end
- p
) - 1;
15966 print_symbol ((int) maxlen
, (const char *) p
);
15967 p
+= strnlen ((char *) p
, maxlen
) + 1;
15971 printf (_("<corrupt>"));
15972 p
= (unsigned char *) end
;
15978 READ_ULEB (val
, p
, end
);
15979 printf ("%d (0x%x)\n", val
, val
);
15988 static unsigned char *
15989 display_msp430_gnu_attribute (unsigned char * p
,
15991 const unsigned char * const end
)
15993 if (tag
== Tag_GNU_MSP430_Data_Region
)
15997 printf (" Tag_GNU_MSP430_Data_Region: ");
15998 READ_ULEB (val
, p
, end
);
16002 case Val_GNU_MSP430_Data_Region_Any
:
16003 printf (_("Any Region\n"));
16005 case Val_GNU_MSP430_Data_Region_Lower
:
16006 printf (_("Lower Region Only\n"));
16009 printf ("??? (%u)\n", val
);
16013 return display_tag_value (tag
& 1, p
, end
);
16016 struct riscv_attr_tag_t
{
16021 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16023 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16026 T(priv_spec_minor
),
16027 T(priv_spec_revision
),
16028 T(unaligned_access
),
16033 static unsigned char *
16034 display_riscv_attribute (unsigned char *p
,
16035 const unsigned char * const end
)
16039 struct riscv_attr_tag_t
*attr
= NULL
;
16042 READ_ULEB (tag
, p
, end
);
16044 /* Find the name of attribute. */
16045 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16047 if (riscv_attr_tag
[i
].tag
== tag
)
16049 attr
= &riscv_attr_tag
[i
];
16055 printf (" %s: ", attr
->name
);
16057 return display_tag_value (tag
, p
, end
);
16061 case Tag_RISCV_priv_spec
:
16062 case Tag_RISCV_priv_spec_minor
:
16063 case Tag_RISCV_priv_spec_revision
:
16064 READ_ULEB (val
, p
, end
);
16065 printf (_("%u\n"), val
);
16067 case Tag_RISCV_unaligned_access
:
16068 READ_ULEB (val
, p
, end
);
16072 printf (_("No unaligned access\n"));
16075 printf (_("Unaligned access\n"));
16079 case Tag_RISCV_stack_align
:
16080 READ_ULEB (val
, p
, end
);
16081 printf (_("%u-bytes\n"), val
);
16083 case Tag_RISCV_arch
:
16084 p
= display_tag_value (-1, p
, end
);
16087 return display_tag_value (tag
, p
, end
);
16094 process_attributes (Filedata
* filedata
,
16095 const char * public_name
,
16096 unsigned int proc_type
,
16097 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16098 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16100 Elf_Internal_Shdr
* sect
;
16102 bfd_boolean res
= TRUE
;
16104 /* Find the section header so that we get the size. */
16105 for (i
= 0, sect
= filedata
->section_headers
;
16106 i
< filedata
->file_header
.e_shnum
;
16109 unsigned char * contents
;
16112 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16115 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16116 sect
->sh_size
, _("attributes"));
16117 if (contents
== NULL
)
16124 /* The first character is the version of the attributes.
16125 Currently only version 1, (aka 'A') is recognised here. */
16128 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16133 bfd_vma section_len
;
16135 section_len
= sect
->sh_size
- 1;
16138 while (section_len
> 0)
16141 unsigned int namelen
;
16142 bfd_boolean public_section
;
16143 bfd_boolean gnu_section
;
16145 if (section_len
<= 4)
16147 error (_("Tag section ends prematurely\n"));
16151 attr_len
= byte_get (p
, 4);
16154 if (attr_len
> section_len
)
16156 error (_("Bad attribute length (%u > %u)\n"),
16157 (unsigned) attr_len
, (unsigned) section_len
);
16158 attr_len
= section_len
;
16161 /* PR 17531: file: 001-101425-0.004 */
16162 else if (attr_len
< 5)
16164 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16169 section_len
-= attr_len
;
16172 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16173 if (namelen
== 0 || namelen
>= attr_len
)
16175 error (_("Corrupt attribute section name\n"));
16180 printf (_("Attribute Section: "));
16181 print_symbol (INT_MAX
, (const char *) p
);
16184 if (public_name
&& streq ((char *) p
, public_name
))
16185 public_section
= TRUE
;
16187 public_section
= FALSE
;
16189 if (streq ((char *) p
, "gnu"))
16190 gnu_section
= TRUE
;
16192 gnu_section
= FALSE
;
16195 attr_len
-= namelen
;
16197 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16202 unsigned char * end
;
16204 /* PR binutils/17531: Safe handling of corrupt files. */
16207 error (_("Unused bytes at end of section\n"));
16214 size
= byte_get (p
, 4);
16215 if (size
> attr_len
)
16217 error (_("Bad subsection length (%u > %u)\n"),
16218 (unsigned) size
, (unsigned) attr_len
);
16222 /* PR binutils/17531: Safe handling of corrupt files. */
16225 error (_("Bad subsection length (%u < 6)\n"),
16233 end
= p
+ size
- 1;
16234 assert (end
<= contents
+ sect
->sh_size
);
16240 printf (_("File Attributes\n"));
16243 printf (_("Section Attributes:"));
16246 printf (_("Symbol Attributes:"));
16247 /* Fall through. */
16251 READ_ULEB (val
, p
, end
);
16254 printf (" %d", val
);
16259 printf (_("Unknown tag: %d\n"), tag
);
16260 public_section
= FALSE
;
16264 if (public_section
&& display_pub_attribute
!= NULL
)
16267 p
= display_pub_attribute (p
, end
);
16270 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16273 p
= display_gnu_attribute (p
,
16274 display_proc_gnu_attribute
,
16280 printf (_(" Unknown attribute:\n"));
16281 display_raw_attribute (p
, end
);
16296 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16297 Print the Address, Access and Initial fields of an entry at VMA ADDR
16298 and return the VMA of the next entry, or -1 if there was a problem.
16299 Does not read from DATA_END or beyond. */
16302 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16303 unsigned char * data_end
)
16306 print_vma (addr
, LONG_HEX
);
16308 if (addr
< pltgot
+ 0xfff0)
16309 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16311 printf ("%10s", "");
16314 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16318 unsigned char * from
= data
+ addr
- pltgot
;
16320 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16322 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16323 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16324 return (bfd_vma
) -1;
16328 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16329 print_vma (entry
, LONG_HEX
);
16332 return addr
+ (is_32bit_elf
? 4 : 8);
16335 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16336 PLTGOT. Print the Address and Initial fields of an entry at VMA
16337 ADDR and return the VMA of the next entry. */
16340 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16343 print_vma (addr
, LONG_HEX
);
16346 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16351 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16352 print_vma (entry
, LONG_HEX
);
16354 return addr
+ (is_32bit_elf
? 4 : 8);
16358 print_mips_ases (unsigned int mask
)
16360 if (mask
& AFL_ASE_DSP
)
16361 fputs ("\n\tDSP ASE", stdout
);
16362 if (mask
& AFL_ASE_DSPR2
)
16363 fputs ("\n\tDSP R2 ASE", stdout
);
16364 if (mask
& AFL_ASE_DSPR3
)
16365 fputs ("\n\tDSP R3 ASE", stdout
);
16366 if (mask
& AFL_ASE_EVA
)
16367 fputs ("\n\tEnhanced VA Scheme", stdout
);
16368 if (mask
& AFL_ASE_MCU
)
16369 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16370 if (mask
& AFL_ASE_MDMX
)
16371 fputs ("\n\tMDMX ASE", stdout
);
16372 if (mask
& AFL_ASE_MIPS3D
)
16373 fputs ("\n\tMIPS-3D ASE", stdout
);
16374 if (mask
& AFL_ASE_MT
)
16375 fputs ("\n\tMT ASE", stdout
);
16376 if (mask
& AFL_ASE_SMARTMIPS
)
16377 fputs ("\n\tSmartMIPS ASE", stdout
);
16378 if (mask
& AFL_ASE_VIRT
)
16379 fputs ("\n\tVZ ASE", stdout
);
16380 if (mask
& AFL_ASE_MSA
)
16381 fputs ("\n\tMSA ASE", stdout
);
16382 if (mask
& AFL_ASE_MIPS16
)
16383 fputs ("\n\tMIPS16 ASE", stdout
);
16384 if (mask
& AFL_ASE_MICROMIPS
)
16385 fputs ("\n\tMICROMIPS ASE", stdout
);
16386 if (mask
& AFL_ASE_XPA
)
16387 fputs ("\n\tXPA ASE", stdout
);
16388 if (mask
& AFL_ASE_MIPS16E2
)
16389 fputs ("\n\tMIPS16e2 ASE", stdout
);
16390 if (mask
& AFL_ASE_CRC
)
16391 fputs ("\n\tCRC ASE", stdout
);
16392 if (mask
& AFL_ASE_GINV
)
16393 fputs ("\n\tGINV ASE", stdout
);
16394 if (mask
& AFL_ASE_LOONGSON_MMI
)
16395 fputs ("\n\tLoongson MMI ASE", stdout
);
16396 if (mask
& AFL_ASE_LOONGSON_CAM
)
16397 fputs ("\n\tLoongson CAM ASE", stdout
);
16398 if (mask
& AFL_ASE_LOONGSON_EXT
)
16399 fputs ("\n\tLoongson EXT ASE", stdout
);
16400 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16401 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16403 fprintf (stdout
, "\n\t%s", _("None"));
16404 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16405 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16409 print_mips_isa_ext (unsigned int isa_ext
)
16414 fputs (_("None"), stdout
);
16417 fputs ("RMI XLR", stdout
);
16419 case AFL_EXT_OCTEON3
:
16420 fputs ("Cavium Networks Octeon3", stdout
);
16422 case AFL_EXT_OCTEON2
:
16423 fputs ("Cavium Networks Octeon2", stdout
);
16425 case AFL_EXT_OCTEONP
:
16426 fputs ("Cavium Networks OcteonP", stdout
);
16428 case AFL_EXT_OCTEON
:
16429 fputs ("Cavium Networks Octeon", stdout
);
16432 fputs ("Toshiba R5900", stdout
);
16435 fputs ("MIPS R4650", stdout
);
16438 fputs ("LSI R4010", stdout
);
16441 fputs ("NEC VR4100", stdout
);
16444 fputs ("Toshiba R3900", stdout
);
16446 case AFL_EXT_10000
:
16447 fputs ("MIPS R10000", stdout
);
16450 fputs ("Broadcom SB-1", stdout
);
16453 fputs ("NEC VR4111/VR4181", stdout
);
16456 fputs ("NEC VR4120", stdout
);
16459 fputs ("NEC VR5400", stdout
);
16462 fputs ("NEC VR5500", stdout
);
16464 case AFL_EXT_LOONGSON_2E
:
16465 fputs ("ST Microelectronics Loongson 2E", stdout
);
16467 case AFL_EXT_LOONGSON_2F
:
16468 fputs ("ST Microelectronics Loongson 2F", stdout
);
16470 case AFL_EXT_INTERAPTIV_MR2
:
16471 fputs ("Imagination interAptiv MR2", stdout
);
16474 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16479 get_mips_reg_size (int reg_size
)
16481 return (reg_size
== AFL_REG_NONE
) ? 0
16482 : (reg_size
== AFL_REG_32
) ? 32
16483 : (reg_size
== AFL_REG_64
) ? 64
16484 : (reg_size
== AFL_REG_128
) ? 128
16489 process_mips_specific (Filedata
* filedata
)
16491 Elf_Internal_Dyn
* entry
;
16492 Elf_Internal_Shdr
*sect
= NULL
;
16493 size_t liblist_offset
= 0;
16494 size_t liblistno
= 0;
16495 size_t conflictsno
= 0;
16496 size_t options_offset
= 0;
16497 size_t conflicts_offset
= 0;
16498 size_t pltrelsz
= 0;
16500 bfd_vma pltgot
= 0;
16501 bfd_vma mips_pltgot
= 0;
16502 bfd_vma jmprel
= 0;
16503 bfd_vma local_gotno
= 0;
16504 bfd_vma gotsym
= 0;
16505 bfd_vma symtabno
= 0;
16506 bfd_boolean res
= TRUE
;
16508 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16509 display_mips_gnu_attribute
))
16512 sect
= find_section (filedata
, ".MIPS.abiflags");
16516 Elf_External_ABIFlags_v0
*abiflags_ext
;
16517 Elf_Internal_ABIFlags_v0 abiflags_in
;
16519 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16521 error (_("Corrupt MIPS ABI Flags section.\n"));
16526 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16527 sect
->sh_size
, _("MIPS ABI Flags section"));
16530 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16531 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16532 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16533 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16534 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16535 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16536 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16537 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16538 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16539 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16540 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16542 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16543 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16544 if (abiflags_in
.isa_rev
> 1)
16545 printf ("r%d", abiflags_in
.isa_rev
);
16546 printf ("\nGPR size: %d",
16547 get_mips_reg_size (abiflags_in
.gpr_size
));
16548 printf ("\nCPR1 size: %d",
16549 get_mips_reg_size (abiflags_in
.cpr1_size
));
16550 printf ("\nCPR2 size: %d",
16551 get_mips_reg_size (abiflags_in
.cpr2_size
));
16552 fputs ("\nFP ABI: ", stdout
);
16553 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16554 fputs ("ISA Extension: ", stdout
);
16555 print_mips_isa_ext (abiflags_in
.isa_ext
);
16556 fputs ("\nASEs:", stdout
);
16557 print_mips_ases (abiflags_in
.ases
);
16558 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16559 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16560 fputc ('\n', stdout
);
16561 free (abiflags_ext
);
16566 /* We have a lot of special sections. Thanks SGI! */
16567 if (dynamic_section
== NULL
)
16569 /* No dynamic information available. See if there is static GOT. */
16570 sect
= find_section (filedata
, ".got");
16573 unsigned char *data_end
;
16574 unsigned char *data
;
16578 pltgot
= sect
->sh_addr
;
16581 addr_size
= (is_32bit_elf
? 4 : 8);
16582 end
= pltgot
+ sect
->sh_size
;
16584 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16586 _("Global Offset Table data"));
16587 /* PR 12855: Null data is handled gracefully throughout. */
16588 data_end
= data
+ (end
- pltgot
);
16590 printf (_("\nStatic GOT:\n"));
16591 printf (_(" Canonical gp value: "));
16592 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16595 /* In a dynamic binary GOT[0] is reserved for the dynamic
16596 loader to store the lazy resolver pointer, however in
16597 a static binary it may well have been omitted and GOT
16598 reduced to a table of addresses.
16599 PR 21344: Check for the entry being fully available
16600 before fetching it. */
16602 && data
+ ent
- pltgot
+ addr_size
<= data_end
16603 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16605 printf (_(" Reserved entries:\n"));
16606 printf (_(" %*s %10s %*s\n"),
16607 addr_size
* 2, _("Address"), _("Access"),
16608 addr_size
* 2, _("Value"));
16609 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16611 if (ent
== (bfd_vma
) -1)
16612 goto sgot_print_fail
;
16614 /* Check for the MSB of GOT[1] being set, identifying a
16615 GNU object. This entry will be used by some runtime
16616 loaders, to store the module pointer. Otherwise this
16617 is an ordinary local entry.
16618 PR 21344: Check for the entry being fully available
16619 before fetching it. */
16621 && data
+ ent
- pltgot
+ addr_size
<= data_end
16622 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16623 >> (addr_size
* 8 - 1)) != 0)
16625 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16627 if (ent
== (bfd_vma
) -1)
16628 goto sgot_print_fail
;
16633 if (data
!= NULL
&& ent
< end
)
16635 printf (_(" Local entries:\n"));
16636 printf (" %*s %10s %*s\n",
16637 addr_size
* 2, _("Address"), _("Access"),
16638 addr_size
* 2, _("Value"));
16641 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16643 if (ent
== (bfd_vma
) -1)
16644 goto sgot_print_fail
;
16656 for (entry
= dynamic_section
;
16657 /* PR 17531 file: 012-50589-0.004. */
16658 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16660 switch (entry
->d_tag
)
16662 case DT_MIPS_LIBLIST
:
16664 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16665 liblistno
* sizeof (Elf32_External_Lib
));
16667 case DT_MIPS_LIBLISTNO
:
16668 liblistno
= entry
->d_un
.d_val
;
16670 case DT_MIPS_OPTIONS
:
16671 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16673 case DT_MIPS_CONFLICT
:
16675 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16676 conflictsno
* sizeof (Elf32_External_Conflict
));
16678 case DT_MIPS_CONFLICTNO
:
16679 conflictsno
= entry
->d_un
.d_val
;
16682 pltgot
= entry
->d_un
.d_ptr
;
16684 case DT_MIPS_LOCAL_GOTNO
:
16685 local_gotno
= entry
->d_un
.d_val
;
16687 case DT_MIPS_GOTSYM
:
16688 gotsym
= entry
->d_un
.d_val
;
16690 case DT_MIPS_SYMTABNO
:
16691 symtabno
= entry
->d_un
.d_val
;
16693 case DT_MIPS_PLTGOT
:
16694 mips_pltgot
= entry
->d_un
.d_ptr
;
16697 pltrel
= entry
->d_un
.d_val
;
16700 pltrelsz
= entry
->d_un
.d_val
;
16703 jmprel
= entry
->d_un
.d_ptr
;
16709 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16711 Elf32_External_Lib
* elib
;
16714 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16715 sizeof (Elf32_External_Lib
),
16717 _("liblist section data"));
16720 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16721 "\nSection '.liblist' contains %lu entries:\n",
16722 (unsigned long) liblistno
),
16723 (unsigned long) liblistno
);
16724 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16727 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16734 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16735 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16736 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16737 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16738 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16740 tmp
= gmtime (&atime
);
16741 snprintf (timebuf
, sizeof (timebuf
),
16742 "%04u-%02u-%02uT%02u:%02u:%02u",
16743 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16744 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16746 printf ("%3lu: ", (unsigned long) cnt
);
16747 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16748 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16750 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16751 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16752 liblist
.l_version
);
16754 if (liblist
.l_flags
== 0)
16758 static const struct
16765 { " EXACT_MATCH", LL_EXACT_MATCH
},
16766 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16767 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16768 { " EXPORTS", LL_EXPORTS
},
16769 { " DELAY_LOAD", LL_DELAY_LOAD
},
16770 { " DELTA", LL_DELTA
}
16772 int flags
= liblist
.l_flags
;
16775 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16776 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16778 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16779 flags
^= l_flags_vals
[fcnt
].bit
;
16782 printf (" %#x", (unsigned int) flags
);
16794 if (options_offset
!= 0)
16796 Elf_External_Options
* eopt
;
16799 sect
= filedata
->section_headers
;
16801 /* Find the section header so that we get the size. */
16802 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16803 /* PR 17533 file: 012-277276-0.004. */
16806 error (_("No MIPS_OPTIONS header found\n"));
16810 if (sect
->sh_size
< sizeof (* eopt
))
16812 error (_("The MIPS options section is too small.\n"));
16816 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16817 sect
->sh_size
, _("options"));
16820 Elf_Internal_Options
* iopt
;
16821 Elf_Internal_Options
* option
;
16822 Elf_Internal_Options
* iopt_end
;
16824 iopt
= (Elf_Internal_Options
*)
16825 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16828 error (_("Out of memory allocating space for MIPS options\n"));
16835 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16837 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16839 Elf_External_Options
* eoption
;
16841 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16843 option
->kind
= BYTE_GET (eoption
->kind
);
16844 option
->size
= BYTE_GET (eoption
->size
);
16845 option
->section
= BYTE_GET (eoption
->section
);
16846 option
->info
= BYTE_GET (eoption
->info
);
16848 /* PR 17531: file: ffa0fa3b. */
16849 if (option
->size
< sizeof (* eopt
)
16850 || offset
+ option
->size
> sect
->sh_size
)
16852 error (_("Invalid size (%u) for MIPS option\n"),
16858 offset
+= option
->size
;
16864 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16865 "\nSection '%s' contains %d entries:\n",
16867 printable_section_name (filedata
, sect
), cnt
);
16876 switch (option
->kind
)
16879 /* This shouldn't happen. */
16880 printf (" NULL %d %lx", option
->section
, option
->info
);
16884 printf (" REGINFO ");
16885 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16887 Elf32_External_RegInfo
* ereg
;
16888 Elf32_RegInfo reginfo
;
16891 if (option
+ 2 > iopt_end
)
16893 printf (_("<corrupt>\n"));
16894 error (_("Truncated MIPS REGINFO option\n"));
16899 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16901 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16902 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16903 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16904 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16905 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16906 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16908 printf ("GPR %08lx GP 0x%lx\n",
16909 reginfo
.ri_gprmask
,
16910 (unsigned long) reginfo
.ri_gp_value
);
16911 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16912 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16913 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16918 Elf64_External_RegInfo
* ereg
;
16919 Elf64_Internal_RegInfo reginfo
;
16921 if (option
+ 2 > iopt_end
)
16923 printf (_("<corrupt>\n"));
16924 error (_("Truncated MIPS REGINFO option\n"));
16929 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16930 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16931 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16932 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16933 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16934 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16935 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16937 printf ("GPR %08lx GP 0x",
16938 reginfo
.ri_gprmask
);
16939 printf_vma (reginfo
.ri_gp_value
);
16942 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16943 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16944 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16949 case ODK_EXCEPTIONS
:
16950 fputs (" EXCEPTIONS fpe_min(", stdout
);
16951 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16952 fputs (") fpe_max(", stdout
);
16953 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16954 fputs (")", stdout
);
16956 if (option
->info
& OEX_PAGE0
)
16957 fputs (" PAGE0", stdout
);
16958 if (option
->info
& OEX_SMM
)
16959 fputs (" SMM", stdout
);
16960 if (option
->info
& OEX_FPDBUG
)
16961 fputs (" FPDBUG", stdout
);
16962 if (option
->info
& OEX_DISMISS
)
16963 fputs (" DISMISS", stdout
);
16967 fputs (" PAD ", stdout
);
16968 if (option
->info
& OPAD_PREFIX
)
16969 fputs (" PREFIX", stdout
);
16970 if (option
->info
& OPAD_POSTFIX
)
16971 fputs (" POSTFIX", stdout
);
16972 if (option
->info
& OPAD_SYMBOL
)
16973 fputs (" SYMBOL", stdout
);
16977 fputs (" HWPATCH ", stdout
);
16978 if (option
->info
& OHW_R4KEOP
)
16979 fputs (" R4KEOP", stdout
);
16980 if (option
->info
& OHW_R8KPFETCH
)
16981 fputs (" R8KPFETCH", stdout
);
16982 if (option
->info
& OHW_R5KEOP
)
16983 fputs (" R5KEOP", stdout
);
16984 if (option
->info
& OHW_R5KCVTL
)
16985 fputs (" R5KCVTL", stdout
);
16989 fputs (" FILL ", stdout
);
16990 /* XXX Print content of info word? */
16994 fputs (" TAGS ", stdout
);
16995 /* XXX Print content of info word? */
16999 fputs (" HWAND ", stdout
);
17000 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17001 fputs (" R4KEOP_CHECKED", stdout
);
17002 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17003 fputs (" R4KEOP_CLEAN", stdout
);
17007 fputs (" HWOR ", stdout
);
17008 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17009 fputs (" R4KEOP_CHECKED", stdout
);
17010 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17011 fputs (" R4KEOP_CLEAN", stdout
);
17015 printf (" GP_GROUP %#06lx self-contained %#06lx",
17016 option
->info
& OGP_GROUP
,
17017 (option
->info
& OGP_SELF
) >> 16);
17021 printf (" IDENT %#06lx self-contained %#06lx",
17022 option
->info
& OGP_GROUP
,
17023 (option
->info
& OGP_SELF
) >> 16);
17027 /* This shouldn't happen. */
17028 printf (" %3d ??? %d %lx",
17029 option
->kind
, option
->section
, option
->info
);
17033 len
= sizeof (* eopt
);
17034 while (len
< option
->size
)
17036 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17038 if (ISPRINT (datum
))
17039 printf ("%c", datum
);
17041 printf ("\\%03o", datum
);
17044 fputs ("\n", stdout
);
17046 offset
+= option
->size
;
17056 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17058 Elf32_Conflict
* iconf
;
17061 if (dynamic_symbols
== NULL
)
17063 error (_("conflict list found without a dynamic symbol table\n"));
17067 /* PR 21345 - print a slightly more helpful error message
17068 if we are sure that the cmalloc will fail. */
17069 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17071 error (_("Overlarge number of conflicts detected: %lx\n"),
17072 (long) conflictsno
);
17076 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17079 error (_("Out of memory allocating space for dynamic conflicts\n"));
17085 Elf32_External_Conflict
* econf32
;
17087 econf32
= (Elf32_External_Conflict
*)
17088 get_data (NULL
, filedata
, conflicts_offset
,
17089 sizeof (*econf32
), conflictsno
, _("conflict"));
17096 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17097 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17103 Elf64_External_Conflict
* econf64
;
17105 econf64
= (Elf64_External_Conflict
*)
17106 get_data (NULL
, filedata
, conflicts_offset
,
17107 sizeof (*econf64
), conflictsno
, _("conflict"));
17114 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17115 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17120 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17121 "\nSection '.conflict' contains %lu entries:\n",
17122 (unsigned long) conflictsno
),
17123 (unsigned long) conflictsno
);
17124 puts (_(" Num: Index Value Name"));
17126 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17128 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17130 if (iconf
[cnt
] >= num_dynamic_syms
)
17131 printf (_("<corrupt symbol index>"));
17134 Elf_Internal_Sym
* psym
;
17136 psym
= & dynamic_symbols
[iconf
[cnt
]];
17137 print_vma (psym
->st_value
, FULL_HEX
);
17139 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17140 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
17142 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17150 if (pltgot
!= 0 && local_gotno
!= 0)
17152 bfd_vma ent
, local_end
, global_end
;
17154 unsigned char * data
;
17155 unsigned char * data_end
;
17159 addr_size
= (is_32bit_elf
? 4 : 8);
17160 local_end
= pltgot
+ local_gotno
* addr_size
;
17162 /* PR binutils/17533 file: 012-111227-0.004 */
17163 if (symtabno
< gotsym
)
17165 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17166 (unsigned long) gotsym
, (unsigned long) symtabno
);
17170 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17171 /* PR 17531: file: 54c91a34. */
17172 if (global_end
< local_end
)
17174 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17178 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17179 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17180 global_end
- pltgot
, 1,
17181 _("Global Offset Table data"));
17182 /* PR 12855: Null data is handled gracefully throughout. */
17183 data_end
= data
+ (global_end
- pltgot
);
17185 printf (_("\nPrimary GOT:\n"));
17186 printf (_(" Canonical gp value: "));
17187 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17190 printf (_(" Reserved entries:\n"));
17191 printf (_(" %*s %10s %*s Purpose\n"),
17192 addr_size
* 2, _("Address"), _("Access"),
17193 addr_size
* 2, _("Initial"));
17194 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17195 printf (_(" Lazy resolver\n"));
17196 if (ent
== (bfd_vma
) -1)
17197 goto got_print_fail
;
17199 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17200 This entry will be used by some runtime loaders, to store the
17201 module pointer. Otherwise this is an ordinary local entry.
17202 PR 21344: Check for the entry being fully available before
17205 && data
+ ent
- pltgot
+ addr_size
<= data_end
17206 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17207 >> (addr_size
* 8 - 1)) != 0)
17209 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17210 printf (_(" Module pointer (GNU extension)\n"));
17211 if (ent
== (bfd_vma
) -1)
17212 goto got_print_fail
;
17216 if (data
!= NULL
&& ent
< local_end
)
17218 printf (_(" Local entries:\n"));
17219 printf (" %*s %10s %*s\n",
17220 addr_size
* 2, _("Address"), _("Access"),
17221 addr_size
* 2, _("Initial"));
17222 while (ent
< local_end
)
17224 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17226 if (ent
== (bfd_vma
) -1)
17227 goto got_print_fail
;
17232 if (data
!= NULL
&& gotsym
< symtabno
)
17236 printf (_(" Global entries:\n"));
17237 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17238 addr_size
* 2, _("Address"),
17240 addr_size
* 2, _("Initial"),
17241 addr_size
* 2, _("Sym.Val."),
17243 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17244 _("Ndx"), _("Name"));
17246 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17248 for (i
= gotsym
; i
< symtabno
; i
++)
17250 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17253 if (dynamic_symbols
== NULL
)
17254 printf (_("<no dynamic symbols>"));
17255 else if (i
< num_dynamic_syms
)
17257 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17259 print_vma (psym
->st_value
, LONG_HEX
);
17260 printf (" %-7s %3s ",
17261 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17262 get_symbol_index_type (filedata
, psym
->st_shndx
));
17264 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17265 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17267 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17270 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17271 (unsigned long) i
);
17274 if (ent
== (bfd_vma
) -1)
17285 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17288 size_t offset
, rel_offset
;
17289 unsigned long count
, i
;
17290 unsigned char * data
;
17291 int addr_size
, sym_width
;
17292 Elf_Internal_Rela
* rels
;
17294 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17295 if (pltrel
== DT_RELA
)
17297 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17302 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17307 addr_size
= (is_32bit_elf
? 4 : 8);
17308 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17310 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17311 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17312 1, _("Procedure Linkage Table data"));
17316 printf ("\nPLT GOT:\n\n");
17317 printf (_(" Reserved entries:\n"));
17318 printf (_(" %*s %*s Purpose\n"),
17319 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17320 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17321 printf (_(" PLT lazy resolver\n"));
17322 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17323 printf (_(" Module pointer\n"));
17326 printf (_(" Entries:\n"));
17327 printf (" %*s %*s %*s %-7s %3s %s\n",
17328 addr_size
* 2, _("Address"),
17329 addr_size
* 2, _("Initial"),
17330 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17331 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17332 for (i
= 0; i
< count
; i
++)
17334 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17336 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17339 if (idx
>= num_dynamic_syms
)
17340 printf (_("<corrupt symbol index: %lu>"), idx
);
17343 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17345 print_vma (psym
->st_value
, LONG_HEX
);
17346 printf (" %-7s %3s ",
17347 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17348 get_symbol_index_type (filedata
, psym
->st_shndx
));
17349 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17350 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17352 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17367 process_nds32_specific (Filedata
* filedata
)
17369 Elf_Internal_Shdr
*sect
= NULL
;
17371 sect
= find_section (filedata
, ".nds32_e_flags");
17374 unsigned int *flag
;
17376 printf ("\nNDS32 elf flags section:\n");
17377 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17378 sect
->sh_size
, _("NDS32 elf flags section"));
17383 switch ((*flag
) & 0x3)
17386 printf ("(VEC_SIZE):\tNo entry.\n");
17389 printf ("(VEC_SIZE):\t4 bytes\n");
17392 printf ("(VEC_SIZE):\t16 bytes\n");
17395 printf ("(VEC_SIZE):\treserved\n");
17404 process_gnu_liblist (Filedata
* filedata
)
17406 Elf_Internal_Shdr
* section
;
17407 Elf_Internal_Shdr
* string_sec
;
17408 Elf32_External_Lib
* elib
;
17410 size_t strtab_size
;
17412 unsigned long num_liblist
;
17414 bfd_boolean res
= TRUE
;
17419 for (i
= 0, section
= filedata
->section_headers
;
17420 i
< filedata
->file_header
.e_shnum
;
17423 switch (section
->sh_type
)
17425 case SHT_GNU_LIBLIST
:
17426 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17429 elib
= (Elf32_External_Lib
*)
17430 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17431 _("liblist section data"));
17439 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17440 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17441 string_sec
->sh_size
,
17442 _("liblist string table"));
17444 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17451 strtab_size
= string_sec
->sh_size
;
17453 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17454 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17455 "\nLibrary list section '%s' contains %lu entries:\n",
17457 printable_section_name (filedata
, section
),
17460 puts (_(" Library Time Stamp Checksum Version Flags"));
17462 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17470 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17471 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17472 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17473 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17474 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17476 tmp
= gmtime (&atime
);
17477 snprintf (timebuf
, sizeof (timebuf
),
17478 "%04u-%02u-%02uT%02u:%02u:%02u",
17479 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17480 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17482 printf ("%3lu: ", (unsigned long) cnt
);
17484 printf ("%-20s", liblist
.l_name
< strtab_size
17485 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17487 printf ("%-20.20s", liblist
.l_name
< strtab_size
17488 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17489 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17490 liblist
.l_version
, liblist
.l_flags
);
17501 static const char *
17502 get_note_type (Filedata
* filedata
, unsigned e_type
)
17504 static char buff
[64];
17506 if (filedata
->file_header
.e_type
== ET_CORE
)
17510 return _("NT_AUXV (auxiliary vector)");
17512 return _("NT_PRSTATUS (prstatus structure)");
17514 return _("NT_FPREGSET (floating point registers)");
17516 return _("NT_PRPSINFO (prpsinfo structure)");
17517 case NT_TASKSTRUCT
:
17518 return _("NT_TASKSTRUCT (task structure)");
17520 return _("NT_PRXFPREG (user_xfpregs structure)");
17522 return _("NT_PPC_VMX (ppc Altivec registers)");
17524 return _("NT_PPC_VSX (ppc VSX registers)");
17526 return _("NT_PPC_TAR (ppc TAR register)");
17528 return _("NT_PPC_PPR (ppc PPR register)");
17530 return _("NT_PPC_DSCR (ppc DSCR register)");
17532 return _("NT_PPC_EBB (ppc EBB registers)");
17534 return _("NT_PPC_PMU (ppc PMU registers)");
17535 case NT_PPC_TM_CGPR
:
17536 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17537 case NT_PPC_TM_CFPR
:
17538 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17539 case NT_PPC_TM_CVMX
:
17540 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17541 case NT_PPC_TM_CVSX
:
17542 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17543 case NT_PPC_TM_SPR
:
17544 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17545 case NT_PPC_TM_CTAR
:
17546 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17547 case NT_PPC_TM_CPPR
:
17548 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17549 case NT_PPC_TM_CDSCR
:
17550 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17552 return _("NT_386_TLS (x86 TLS information)");
17553 case NT_386_IOPERM
:
17554 return _("NT_386_IOPERM (x86 I/O permissions)");
17555 case NT_X86_XSTATE
:
17556 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17557 case NT_S390_HIGH_GPRS
:
17558 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17559 case NT_S390_TIMER
:
17560 return _("NT_S390_TIMER (s390 timer register)");
17561 case NT_S390_TODCMP
:
17562 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17563 case NT_S390_TODPREG
:
17564 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17566 return _("NT_S390_CTRS (s390 control registers)");
17567 case NT_S390_PREFIX
:
17568 return _("NT_S390_PREFIX (s390 prefix register)");
17569 case NT_S390_LAST_BREAK
:
17570 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17571 case NT_S390_SYSTEM_CALL
:
17572 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17574 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17575 case NT_S390_VXRS_LOW
:
17576 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17577 case NT_S390_VXRS_HIGH
:
17578 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17579 case NT_S390_GS_CB
:
17580 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17581 case NT_S390_GS_BC
:
17582 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17584 return _("NT_ARM_VFP (arm VFP registers)");
17586 return _("NT_ARM_TLS (AArch TLS registers)");
17587 case NT_ARM_HW_BREAK
:
17588 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17589 case NT_ARM_HW_WATCH
:
17590 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17592 return _("NT_PSTATUS (pstatus structure)");
17594 return _("NT_FPREGS (floating point registers)");
17596 return _("NT_PSINFO (psinfo structure)");
17598 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17600 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17601 case NT_WIN32PSTATUS
:
17602 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17604 return _("NT_SIGINFO (siginfo_t data)");
17606 return _("NT_FILE (mapped files)");
17614 return _("NT_VERSION (version)");
17616 return _("NT_ARCH (architecture)");
17617 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17619 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17625 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17630 print_core_note (Elf_Internal_Note
*pnote
)
17632 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17633 bfd_vma count
, page_size
;
17634 unsigned char *descdata
, *filenames
, *descend
;
17636 if (pnote
->type
!= NT_FILE
)
17646 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17647 /* Still "successful". */
17652 if (pnote
->descsz
< 2 * addr_size
)
17654 error (_(" Malformed note - too short for header\n"));
17658 descdata
= (unsigned char *) pnote
->descdata
;
17659 descend
= descdata
+ pnote
->descsz
;
17661 if (descdata
[pnote
->descsz
- 1] != '\0')
17663 error (_(" Malformed note - does not end with \\0\n"));
17667 count
= byte_get (descdata
, addr_size
);
17668 descdata
+= addr_size
;
17670 page_size
= byte_get (descdata
, addr_size
);
17671 descdata
+= addr_size
;
17673 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17674 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17676 error (_(" Malformed note - too short for supplied file count\n"));
17680 printf (_(" Page size: "));
17681 print_vma (page_size
, DEC
);
17684 printf (_(" %*s%*s%*s\n"),
17685 (int) (2 + 2 * addr_size
), _("Start"),
17686 (int) (4 + 2 * addr_size
), _("End"),
17687 (int) (4 + 2 * addr_size
), _("Page Offset"));
17688 filenames
= descdata
+ count
* 3 * addr_size
;
17689 while (count
-- > 0)
17691 bfd_vma start
, end
, file_ofs
;
17693 if (filenames
== descend
)
17695 error (_(" Malformed note - filenames end too early\n"));
17699 start
= byte_get (descdata
, addr_size
);
17700 descdata
+= addr_size
;
17701 end
= byte_get (descdata
, addr_size
);
17702 descdata
+= addr_size
;
17703 file_ofs
= byte_get (descdata
, addr_size
);
17704 descdata
+= addr_size
;
17707 print_vma (start
, FULL_HEX
);
17709 print_vma (end
, FULL_HEX
);
17711 print_vma (file_ofs
, FULL_HEX
);
17712 printf ("\n %s\n", filenames
);
17714 filenames
+= 1 + strlen ((char *) filenames
);
17720 static const char *
17721 get_gnu_elf_note_type (unsigned e_type
)
17723 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17726 case NT_GNU_ABI_TAG
:
17727 return _("NT_GNU_ABI_TAG (ABI version tag)");
17729 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17730 case NT_GNU_BUILD_ID
:
17731 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17732 case NT_GNU_GOLD_VERSION
:
17733 return _("NT_GNU_GOLD_VERSION (gold version)");
17734 case NT_GNU_PROPERTY_TYPE_0
:
17735 return _("NT_GNU_PROPERTY_TYPE_0");
17736 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17737 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17738 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17739 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17742 static char buff
[64];
17744 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17751 decode_x86_compat_isa (unsigned int bitmask
)
17755 unsigned int bit
= bitmask
& (- bitmask
);
17760 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17763 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17766 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17769 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17772 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17775 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17778 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17781 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17784 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17787 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17790 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17793 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17794 printf ("AVX512F");
17796 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17797 printf ("AVX512CD");
17799 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17800 printf ("AVX512ER");
17802 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17803 printf ("AVX512PF");
17805 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17806 printf ("AVX512VL");
17808 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17809 printf ("AVX512DQ");
17811 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17812 printf ("AVX512BW");
17815 printf (_("<unknown: %x>"), bit
);
17824 decode_x86_isa (unsigned int bitmask
)
17828 printf (_("<None>"));
17834 unsigned int bit
= bitmask
& (- bitmask
);
17839 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17842 case GNU_PROPERTY_X86_ISA_1_SSE
:
17845 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17848 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17851 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17854 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17857 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17860 case GNU_PROPERTY_X86_ISA_1_AVX
:
17863 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17866 case GNU_PROPERTY_X86_ISA_1_FMA
:
17869 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17870 printf ("AVX512F");
17872 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17873 printf ("AVX512CD");
17875 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17876 printf ("AVX512ER");
17878 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17879 printf ("AVX512PF");
17881 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17882 printf ("AVX512VL");
17884 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17885 printf ("AVX512DQ");
17887 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17888 printf ("AVX512BW");
17890 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17891 printf ("AVX512_4FMAPS");
17893 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17894 printf ("AVX512_4VNNIW");
17896 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17897 printf ("AVX512_BITALG");
17899 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17900 printf ("AVX512_IFMA");
17902 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17903 printf ("AVX512_VBMI");
17905 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17906 printf ("AVX512_VBMI2");
17908 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17909 printf ("AVX512_VNNI");
17911 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17912 printf ("AVX512_BF16");
17915 printf (_("<unknown: %x>"), bit
);
17924 decode_x86_feature_1 (unsigned int bitmask
)
17928 printf (_("<None>"));
17934 unsigned int bit
= bitmask
& (- bitmask
);
17939 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17942 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17946 printf (_("<unknown: %x>"), bit
);
17955 decode_x86_feature_2 (unsigned int bitmask
)
17959 printf (_("<None>"));
17965 unsigned int bit
= bitmask
& (- bitmask
);
17970 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17973 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17976 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17979 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17982 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17985 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17988 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17991 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17994 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17995 printf ("XSAVEOPT");
17997 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18001 printf (_("<unknown: %x>"), bit
);
18010 decode_aarch64_feature_1_and (unsigned int bitmask
)
18014 unsigned int bit
= bitmask
& (- bitmask
);
18019 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18023 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18028 printf (_("<unknown: %x>"), bit
);
18037 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18039 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18040 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18041 unsigned int size
= is_32bit_elf
? 4 : 8;
18043 printf (_(" Properties: "));
18045 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18047 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18051 while (ptr
< ptr_end
)
18055 unsigned int datasz
;
18057 if ((size_t) (ptr_end
- ptr
) < 8)
18059 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18063 type
= byte_get (ptr
, 4);
18064 datasz
= byte_get (ptr
+ 4, 4);
18068 if (datasz
> (size_t) (ptr_end
- ptr
))
18070 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18075 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18077 if (filedata
->file_header
.e_machine
== EM_X86_64
18078 || filedata
->file_header
.e_machine
== EM_IAMCU
18079 || filedata
->file_header
.e_machine
== EM_386
)
18081 unsigned int bitmask
;
18084 bitmask
= byte_get (ptr
, 4);
18090 case GNU_PROPERTY_X86_ISA_1_USED
:
18092 printf (_("x86 ISA used: <corrupt length: %#x> "),
18096 printf ("x86 ISA used: ");
18097 decode_x86_isa (bitmask
);
18101 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18103 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18107 printf ("x86 ISA needed: ");
18108 decode_x86_isa (bitmask
);
18112 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18114 printf (_("x86 feature: <corrupt length: %#x> "),
18118 printf ("x86 feature: ");
18119 decode_x86_feature_1 (bitmask
);
18123 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18125 printf (_("x86 feature used: <corrupt length: %#x> "),
18129 printf ("x86 feature used: ");
18130 decode_x86_feature_2 (bitmask
);
18134 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18136 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18139 printf ("x86 feature needed: ");
18140 decode_x86_feature_2 (bitmask
);
18144 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18146 printf (_("x86 ISA used: <corrupt length: %#x> "),
18150 printf ("x86 ISA used: ");
18151 decode_x86_compat_isa (bitmask
);
18155 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18157 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18161 printf ("x86 ISA needed: ");
18162 decode_x86_compat_isa (bitmask
);
18170 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18172 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18174 printf ("AArch64 feature: ");
18176 printf (_("<corrupt length: %#x> "), datasz
);
18178 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18187 case GNU_PROPERTY_STACK_SIZE
:
18188 printf (_("stack size: "));
18189 if (datasz
!= size
)
18190 printf (_("<corrupt length: %#x> "), datasz
);
18192 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18195 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18196 printf ("no copy on protected ");
18198 printf (_("<corrupt length: %#x> "), datasz
);
18206 if (type
< GNU_PROPERTY_LOPROC
)
18207 printf (_("<unknown type %#x data: "), type
);
18208 else if (type
< GNU_PROPERTY_LOUSER
)
18209 printf (_("<procesor-specific type %#x data: "), type
);
18211 printf (_("<application-specific type %#x data: "), type
);
18212 for (j
= 0; j
< datasz
; ++j
)
18213 printf ("%02x ", ptr
[j
] & 0xff);
18217 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18218 if (ptr
== ptr_end
)
18231 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18233 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18234 switch (pnote
->type
)
18236 case NT_GNU_BUILD_ID
:
18240 printf (_(" Build ID: "));
18241 for (i
= 0; i
< pnote
->descsz
; ++i
)
18242 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18247 case NT_GNU_ABI_TAG
:
18249 unsigned long os
, major
, minor
, subminor
;
18250 const char *osname
;
18252 /* PR 17531: file: 030-599401-0.004. */
18253 if (pnote
->descsz
< 16)
18255 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18259 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18260 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18261 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18262 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18266 case GNU_ABI_TAG_LINUX
:
18269 case GNU_ABI_TAG_HURD
:
18272 case GNU_ABI_TAG_SOLARIS
:
18273 osname
= "Solaris";
18275 case GNU_ABI_TAG_FREEBSD
:
18276 osname
= "FreeBSD";
18278 case GNU_ABI_TAG_NETBSD
:
18281 case GNU_ABI_TAG_SYLLABLE
:
18282 osname
= "Syllable";
18284 case GNU_ABI_TAG_NACL
:
18288 osname
= "Unknown";
18292 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18293 major
, minor
, subminor
);
18297 case NT_GNU_GOLD_VERSION
:
18301 printf (_(" Version: "));
18302 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18303 printf ("%c", pnote
->descdata
[i
]);
18310 unsigned long num_entries
, mask
;
18312 /* Hardware capabilities information. Word 0 is the number of entries.
18313 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18314 is a series of entries, where each entry is a single byte followed
18315 by a nul terminated string. The byte gives the bit number to test
18316 if enabled in the bitmask. */
18317 printf (_(" Hardware Capabilities: "));
18318 if (pnote
->descsz
< 8)
18320 error (_("<corrupt GNU_HWCAP>\n"));
18323 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18324 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18325 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18326 /* FIXME: Add code to display the entries... */
18330 case NT_GNU_PROPERTY_TYPE_0
:
18331 print_gnu_property_note (filedata
, pnote
);
18335 /* Handle unrecognised types. An error message should have already been
18336 created by get_gnu_elf_note_type(), so all that we need to do is to
18337 display the data. */
18341 printf (_(" Description data: "));
18342 for (i
= 0; i
< pnote
->descsz
; ++i
)
18343 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18352 static const char *
18353 get_v850_elf_note_type (enum v850_notes n_type
)
18355 static char buff
[64];
18359 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18360 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18361 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18362 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18363 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18364 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18366 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18372 print_v850_note (Elf_Internal_Note
* pnote
)
18376 if (pnote
->descsz
!= 4)
18379 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18383 printf (_("not set\n"));
18387 switch (pnote
->type
)
18389 case V850_NOTE_ALIGNMENT
:
18392 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18393 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18397 case V850_NOTE_DATA_SIZE
:
18400 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18401 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18405 case V850_NOTE_FPU_INFO
:
18408 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18409 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18413 case V850_NOTE_MMU_INFO
:
18414 case V850_NOTE_CACHE_INFO
:
18415 case V850_NOTE_SIMD_INFO
:
18416 if (val
== EF_RH850_SIMD
)
18418 printf (_("yes\n"));
18424 /* An 'unknown note type' message will already have been displayed. */
18428 printf (_("unknown value: %x\n"), val
);
18433 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18435 unsigned int version
;
18437 switch (pnote
->type
)
18439 case NT_NETBSD_IDENT
:
18440 if (pnote
->descsz
< 1)
18442 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18443 if ((version
/ 10000) % 100)
18444 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18445 version
, version
/ 100000000, (version
/ 1000000) % 100,
18446 (version
/ 10000) % 100 > 26 ? "Z" : "",
18447 'A' + (version
/ 10000) % 26);
18449 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18450 version
, version
/ 100000000, (version
/ 1000000) % 100,
18451 (version
/ 100) % 100);
18454 case NT_NETBSD_MARCH
:
18455 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18459 #ifdef NT_NETBSD_PAX
18460 case NT_NETBSD_PAX
:
18461 if (pnote
->descsz
< 1)
18463 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18464 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18465 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18466 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18467 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18468 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18469 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18470 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18475 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18476 pnote
->descsz
, pnote
->type
);
18480 static const char *
18481 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18485 case NT_FREEBSD_THRMISC
:
18486 return _("NT_THRMISC (thrmisc structure)");
18487 case NT_FREEBSD_PROCSTAT_PROC
:
18488 return _("NT_PROCSTAT_PROC (proc data)");
18489 case NT_FREEBSD_PROCSTAT_FILES
:
18490 return _("NT_PROCSTAT_FILES (files data)");
18491 case NT_FREEBSD_PROCSTAT_VMMAP
:
18492 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18493 case NT_FREEBSD_PROCSTAT_GROUPS
:
18494 return _("NT_PROCSTAT_GROUPS (groups data)");
18495 case NT_FREEBSD_PROCSTAT_UMASK
:
18496 return _("NT_PROCSTAT_UMASK (umask data)");
18497 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18498 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18499 case NT_FREEBSD_PROCSTAT_OSREL
:
18500 return _("NT_PROCSTAT_OSREL (osreldate data)");
18501 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18502 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18503 case NT_FREEBSD_PROCSTAT_AUXV
:
18504 return _("NT_PROCSTAT_AUXV (auxv data)");
18505 case NT_FREEBSD_PTLWPINFO
:
18506 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18508 return get_note_type (filedata
, e_type
);
18511 static const char *
18512 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18514 static char buff
[64];
18518 case NT_NETBSDCORE_PROCINFO
:
18519 /* NetBSD core "procinfo" structure. */
18520 return _("NetBSD procinfo structure");
18522 #ifdef NT_NETBSDCORE_AUXV
18523 case NT_NETBSDCORE_AUXV
:
18524 return _("NetBSD ELF auxiliary vector data");
18527 #ifdef NT_NETBSDCORE_LWPSTATUS
18528 case NT_NETBSDCORE_LWPSTATUS
:
18529 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18533 /* As of Jan 2020 there are no other machine-independent notes
18534 defined for NetBSD core files. If the note type is less
18535 than the start of the machine-dependent note types, we don't
18538 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18540 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18546 switch (filedata
->file_header
.e_machine
)
18548 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18549 and PT_GETFPREGS == mach+2. */
18554 case EM_SPARC32PLUS
:
18558 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18559 return _("PT_GETREGS (reg structure)");
18560 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18561 return _("PT_GETFPREGS (fpreg structure)");
18567 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18568 There's also old PT___GETREGS40 == mach + 1 for old reg
18569 structure which lacks GBR. */
18573 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18574 return _("PT___GETREGS40 (old reg structure)");
18575 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18576 return _("PT_GETREGS (reg structure)");
18577 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18578 return _("PT_GETFPREGS (fpreg structure)");
18584 /* On all other arch's, PT_GETREGS == mach+1 and
18585 PT_GETFPREGS == mach+3. */
18589 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18590 return _("PT_GETREGS (reg structure)");
18591 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18592 return _("PT_GETFPREGS (fpreg structure)");
18598 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18599 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18603 static const char *
18604 get_stapsdt_note_type (unsigned e_type
)
18606 static char buff
[64];
18611 return _("NT_STAPSDT (SystemTap probe descriptors)");
18617 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18622 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18624 size_t len
, maxlen
;
18625 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18626 char *data
= pnote
->descdata
;
18627 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18628 bfd_vma pc
, base_addr
, semaphore
;
18629 char *provider
, *probe
, *arg_fmt
;
18631 if (pnote
->descsz
< (addr_size
* 3))
18632 goto stapdt_note_too_small
;
18634 pc
= byte_get ((unsigned char *) data
, addr_size
);
18637 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18640 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18643 if (data
>= data_end
)
18644 goto stapdt_note_too_small
;
18645 maxlen
= data_end
- data
;
18646 len
= strnlen (data
, maxlen
);
18653 goto stapdt_note_too_small
;
18655 if (data
>= data_end
)
18656 goto stapdt_note_too_small
;
18657 maxlen
= data_end
- data
;
18658 len
= strnlen (data
, maxlen
);
18665 goto stapdt_note_too_small
;
18667 if (data
>= data_end
)
18668 goto stapdt_note_too_small
;
18669 maxlen
= data_end
- data
;
18670 len
= strnlen (data
, maxlen
);
18677 goto stapdt_note_too_small
;
18679 printf (_(" Provider: %s\n"), provider
);
18680 printf (_(" Name: %s\n"), probe
);
18681 printf (_(" Location: "));
18682 print_vma (pc
, FULL_HEX
);
18683 printf (_(", Base: "));
18684 print_vma (base_addr
, FULL_HEX
);
18685 printf (_(", Semaphore: "));
18686 print_vma (semaphore
, FULL_HEX
);
18688 printf (_(" Arguments: %s\n"), arg_fmt
);
18690 return data
== data_end
;
18692 stapdt_note_too_small
:
18693 printf (_(" <corrupt - note is too small>\n"));
18694 error (_("corrupt stapdt note - the data size is too small\n"));
18698 static const char *
18699 get_ia64_vms_note_type (unsigned e_type
)
18701 static char buff
[64];
18706 return _("NT_VMS_MHD (module header)");
18708 return _("NT_VMS_LNM (language name)");
18710 return _("NT_VMS_SRC (source files)");
18712 return "NT_VMS_TITLE";
18714 return _("NT_VMS_EIDC (consistency check)");
18715 case NT_VMS_FPMODE
:
18716 return _("NT_VMS_FPMODE (FP mode)");
18717 case NT_VMS_LINKTIME
:
18718 return "NT_VMS_LINKTIME";
18719 case NT_VMS_IMGNAM
:
18720 return _("NT_VMS_IMGNAM (image name)");
18722 return _("NT_VMS_IMGID (image id)");
18723 case NT_VMS_LINKID
:
18724 return _("NT_VMS_LINKID (link id)");
18725 case NT_VMS_IMGBID
:
18726 return _("NT_VMS_IMGBID (build id)");
18727 case NT_VMS_GSTNAM
:
18728 return _("NT_VMS_GSTNAM (sym table name)");
18729 case NT_VMS_ORIG_DYN
:
18730 return "NT_VMS_ORIG_DYN";
18731 case NT_VMS_PATCHTIME
:
18732 return "NT_VMS_PATCHTIME";
18734 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18740 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18742 int maxlen
= pnote
->descsz
;
18744 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18745 goto desc_size_fail
;
18747 switch (pnote
->type
)
18751 goto desc_size_fail
;
18753 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18755 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18756 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18757 if (l
+ 34 < maxlen
)
18759 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18760 if (l
+ 35 < maxlen
)
18761 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18763 printf (_(" Module version : <missing>\n"));
18767 printf (_(" Module name : <missing>\n"));
18768 printf (_(" Module version : <missing>\n"));
18773 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18777 case NT_VMS_FPMODE
:
18778 printf (_(" Floating Point mode: "));
18780 goto desc_size_fail
;
18781 /* FIXME: Generate an error if descsz > 8 ? */
18783 printf ("0x%016" BFD_VMA_FMT
"x\n",
18784 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18787 case NT_VMS_LINKTIME
:
18788 printf (_(" Link time: "));
18790 goto desc_size_fail
;
18791 /* FIXME: Generate an error if descsz > 8 ? */
18794 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18798 case NT_VMS_PATCHTIME
:
18799 printf (_(" Patch time: "));
18801 goto desc_size_fail
;
18802 /* FIXME: Generate an error if descsz > 8 ? */
18805 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18809 case NT_VMS_ORIG_DYN
:
18811 goto desc_size_fail
;
18813 printf (_(" Major id: %u, minor id: %u\n"),
18814 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18815 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18816 printf (_(" Last modified : "));
18818 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18819 printf (_("\n Link flags : "));
18820 printf ("0x%016" BFD_VMA_FMT
"x\n",
18821 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18822 printf (_(" Header flags: 0x%08x\n"),
18823 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18824 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18828 case NT_VMS_IMGNAM
:
18829 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18832 case NT_VMS_GSTNAM
:
18833 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18837 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18840 case NT_VMS_LINKID
:
18841 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18851 printf (_(" <corrupt - data size is too small>\n"));
18852 error (_("corrupt IA64 note: data size is too small\n"));
18856 struct build_attr_cache
{
18857 Filedata
*filedata
;
18859 unsigned long strtablen
;
18860 Elf_Internal_Sym
*symtab
;
18861 unsigned long nsyms
;
18864 /* Find the symbol associated with a build attribute that is attached
18865 to address OFFSET. If PNAME is non-NULL then store the name of
18866 the symbol (if found) in the provided pointer, Returns NULL if a
18867 symbol could not be found. */
18869 static Elf_Internal_Sym
*
18870 get_symbol_for_build_attribute (Filedata
* filedata
,
18871 unsigned long offset
,
18872 bfd_boolean is_open_attr
,
18873 const char ** pname
)
18875 Elf_Internal_Sym
*saved_sym
= NULL
;
18876 Elf_Internal_Sym
*sym
;
18878 if (filedata
->section_headers
!= NULL
18879 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18881 Elf_Internal_Shdr
* symsec
;
18883 free (ba_cache
.strtab
);
18884 ba_cache
.strtab
= NULL
;
18885 free (ba_cache
.symtab
);
18886 ba_cache
.symtab
= NULL
;
18888 /* Load the symbol and string sections. */
18889 for (symsec
= filedata
->section_headers
;
18890 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18893 if (symsec
->sh_type
== SHT_SYMTAB
18894 && get_symtab (filedata
, symsec
,
18895 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18896 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18899 ba_cache
.filedata
= filedata
;
18902 if (ba_cache
.symtab
== NULL
)
18905 /* Find a symbol whose value matches offset. */
18906 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18907 if (sym
->st_value
== offset
)
18909 if (sym
->st_name
>= ba_cache
.strtablen
)
18910 /* Huh ? This should not happen. */
18913 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18916 /* The AArch64 and ARM architectures define mapping symbols
18917 (eg $d, $x, $t) which we want to ignore. */
18918 if (ba_cache
.strtab
[sym
->st_name
] == '$'
18919 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
18920 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
18925 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18926 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18927 FUNC symbols entirely. */
18928 switch (ELF_ST_TYPE (sym
->st_info
))
18935 /* If the symbol has a size associated
18936 with it then we can stop searching. */
18937 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
18942 /* Ignore function symbols. */
18949 switch (ELF_ST_BIND (sym
->st_info
))
18952 if (saved_sym
== NULL
18953 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18958 if (saved_sym
== NULL
)
18968 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18976 if (saved_sym
&& pname
)
18977 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
18982 /* Returns true iff addr1 and addr2 are in the same section. */
18985 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18987 Elf_Internal_Shdr
* a1
;
18988 Elf_Internal_Shdr
* a2
;
18990 a1
= find_section_by_address (filedata
, addr1
);
18991 a2
= find_section_by_address (filedata
, addr2
);
18993 return a1
== a2
&& a1
!= NULL
;
18997 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18998 Filedata
* filedata
)
19000 static unsigned long global_offset
= 0;
19001 static unsigned long global_end
= 0;
19002 static unsigned long func_offset
= 0;
19003 static unsigned long func_end
= 0;
19005 Elf_Internal_Sym
* sym
;
19007 unsigned long start
;
19009 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19011 switch (pnote
->descsz
)
19014 /* A zero-length description means that the range of
19015 the previous note of the same type should be used. */
19018 if (global_end
> global_offset
)
19019 printf (_(" Applies to region from %#lx to %#lx\n"),
19020 global_offset
, global_end
);
19022 printf (_(" Applies to region from %#lx\n"), global_offset
);
19026 if (func_end
> func_offset
)
19027 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19029 printf (_(" Applies to region from %#lx\n"), func_offset
);
19034 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19041 /* FIXME: We should check that version 3+ notes are being used here... */
19042 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19043 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19047 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19053 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19054 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19058 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19059 printf (_(" <invalid descsz>"));
19064 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19065 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19066 in order to avoid them being confused with the start address of the
19067 first function in the file... */
19068 if (sym
== NULL
&& is_open_attr
)
19069 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19072 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19073 end
= start
+ sym
->st_size
;
19077 /* FIXME: Need to properly allow for section alignment.
19078 16 is just the alignment used on x86_64. */
19080 && start
> BFD_ALIGN (global_end
, 16)
19081 /* Build notes are not guaranteed to be organised in order of
19082 increasing address, but we should find the all of the notes
19083 for one section in the same place. */
19084 && same_section (filedata
, start
, global_end
))
19085 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19086 global_end
+ 1, start
- 1);
19088 printf (_(" Applies to region from %#lx"), start
);
19089 global_offset
= start
;
19093 printf (_(" to %#lx"), end
);
19099 printf (_(" Applies to region from %#lx"), start
);
19100 func_offset
= start
;
19104 printf (_(" to %#lx"), end
);
19110 printf (_(" (%s)"), name
);
19117 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19119 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19120 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19121 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19123 char name_attribute
;
19124 const char * expected_types
;
19125 const char * name
= pnote
->namedata
;
19129 if (name
== NULL
|| pnote
->namesz
< 2)
19131 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19132 print_symbol (-20, _(" <corrupt name>"));
19141 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19142 if (name
[0] == 'G' && name
[1] == 'A')
19144 if (pnote
->namesz
< 4)
19146 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19147 print_symbol (-20, _(" <corrupt name>"));
19156 switch ((name_type
= * name
))
19158 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19159 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19160 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19161 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19162 printf ("%c", * name
);
19166 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19167 print_symbol (-20, _("<unknown name type>"));
19174 switch ((name_attribute
= * name
))
19176 case GNU_BUILD_ATTRIBUTE_VERSION
:
19177 text
= _("<version>");
19178 expected_types
= string_expected
;
19181 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19182 text
= _("<stack prot>");
19183 expected_types
= "!+*";
19186 case GNU_BUILD_ATTRIBUTE_RELRO
:
19187 text
= _("<relro>");
19188 expected_types
= bool_expected
;
19191 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19192 text
= _("<stack size>");
19193 expected_types
= number_expected
;
19196 case GNU_BUILD_ATTRIBUTE_TOOL
:
19197 text
= _("<tool>");
19198 expected_types
= string_expected
;
19201 case GNU_BUILD_ATTRIBUTE_ABI
:
19203 expected_types
= "$*";
19206 case GNU_BUILD_ATTRIBUTE_PIC
:
19208 expected_types
= number_expected
;
19211 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19212 text
= _("<short enum>");
19213 expected_types
= bool_expected
;
19217 if (ISPRINT (* name
))
19219 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19221 if (len
> left
&& ! do_wide
)
19223 printf ("%.*s:", len
, name
);
19229 static char tmpbuf
[128];
19231 error (_("unrecognised byte in name field: %d\n"), * name
);
19232 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19236 expected_types
= "*$!+";
19241 left
-= printf ("%s", text
);
19243 if (strchr (expected_types
, name_type
) == NULL
)
19244 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19246 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19248 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19249 (unsigned long) pnote
->namesz
,
19250 (long) (name
- pnote
->namedata
));
19254 if (left
< 1 && ! do_wide
)
19259 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19261 unsigned int bytes
;
19262 unsigned long long val
= 0;
19263 unsigned int shift
= 0;
19264 char * decoded
= NULL
;
19266 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19268 /* The -1 is because the name field is always 0 terminated, and we
19269 want to be able to ensure that the shift in the while loop below
19270 will not overflow. */
19273 if (bytes
> sizeof (val
))
19275 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19277 bytes
= sizeof (val
);
19279 /* We do not bother to warn if bytes == 0 as this can
19280 happen with some early versions of the gcc plugin. */
19284 unsigned long byte
= (* name
++) & 0xff;
19286 val
|= byte
<< shift
;
19290 switch (name_attribute
)
19292 case GNU_BUILD_ATTRIBUTE_PIC
:
19295 case 0: decoded
= "static"; break;
19296 case 1: decoded
= "pic"; break;
19297 case 2: decoded
= "PIC"; break;
19298 case 3: decoded
= "pie"; break;
19299 case 4: decoded
= "PIE"; break;
19303 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19306 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19307 case 0: decoded
= "off"; break;
19308 case 1: decoded
= "on"; break;
19309 case 2: decoded
= "all"; break;
19310 case 3: decoded
= "strong"; break;
19311 case 4: decoded
= "explicit"; break;
19319 if (decoded
!= NULL
)
19321 print_symbol (-left
, decoded
);
19332 left
-= printf ("0x%llx", val
);
19334 left
-= printf ("0x%-.*llx", left
, val
);
19338 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19339 left
-= print_symbol (- left
, name
);
19341 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19342 left
-= print_symbol (- left
, "true");
19344 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19345 left
-= print_symbol (- left
, "false");
19349 if (do_wide
&& left
> 0)
19350 printf ("%-*s", left
, " ");
19355 /* Note that by the ELF standard, the name field is already null byte
19356 terminated, and namesz includes the terminating null byte.
19357 I.E. the value of namesz for the name "FSF" is 4.
19359 If the value of namesz is zero, there is no name present. */
19362 process_note (Elf_Internal_Note
* pnote
,
19363 Filedata
* filedata
)
19365 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19368 if (pnote
->namesz
== 0)
19369 /* If there is no note name, then use the default set of
19370 note type strings. */
19371 nt
= get_note_type (filedata
, pnote
->type
);
19373 else if (const_strneq (pnote
->namedata
, "GNU"))
19374 /* GNU-specific object file notes. */
19375 nt
= get_gnu_elf_note_type (pnote
->type
);
19377 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19378 /* FreeBSD-specific core file notes. */
19379 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19381 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19382 /* NetBSD-specific core file notes. */
19383 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19385 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19386 /* NetBSD-specific core file notes. */
19387 return process_netbsd_elf_note (pnote
);
19389 else if (const_strneq (pnote
->namedata
, "PaX"))
19390 /* NetBSD-specific core file notes. */
19391 return process_netbsd_elf_note (pnote
);
19393 else if (strneq (pnote
->namedata
, "SPU/", 4))
19395 /* SPU-specific core file notes. */
19396 nt
= pnote
->namedata
+ 4;
19400 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19401 /* VMS/ia64-specific file notes. */
19402 nt
= get_ia64_vms_note_type (pnote
->type
);
19404 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19405 nt
= get_stapsdt_note_type (pnote
->type
);
19408 /* Don't recognize this note name; just use the default set of
19409 note type strings. */
19410 nt
= get_note_type (filedata
, pnote
->type
);
19414 if (((const_strneq (pnote
->namedata
, "GA")
19415 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19416 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19417 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19418 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19419 print_gnu_build_attribute_name (pnote
);
19421 print_symbol (-20, name
);
19424 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19426 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19428 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19429 return print_ia64_vms_note (pnote
);
19430 else if (const_strneq (pnote
->namedata
, "GNU"))
19431 return print_gnu_note (filedata
, pnote
);
19432 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19433 return print_stapsdt_note (pnote
);
19434 else if (const_strneq (pnote
->namedata
, "CORE"))
19435 return print_core_note (pnote
);
19436 else if (((const_strneq (pnote
->namedata
, "GA")
19437 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19438 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19439 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19440 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19441 return print_gnu_build_attribute_description (pnote
, filedata
);
19447 printf (_(" description data: "));
19448 for (i
= 0; i
< pnote
->descsz
; i
++)
19449 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19461 process_notes_at (Filedata
* filedata
,
19462 Elf_Internal_Shdr
* section
,
19467 Elf_External_Note
* pnotes
;
19468 Elf_External_Note
* external
;
19470 bfd_boolean res
= TRUE
;
19477 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19480 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19488 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19491 if (pnotes
== NULL
)
19497 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19499 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19500 (unsigned long) offset
, (unsigned long) length
);
19502 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19503 specifies that notes should be aligned to 4 bytes in 32-bit
19504 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19505 we also support 4 byte alignment in 64-bit objects. If section
19506 alignment is less than 4, we treate alignment as 4 bytes. */
19509 else if (align
!= 4 && align
!= 8)
19511 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19517 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19519 end
= (char *) pnotes
+ length
;
19520 while ((char *) external
< end
)
19522 Elf_Internal_Note inote
;
19525 char * temp
= NULL
;
19526 size_t data_remaining
= end
- (char *) external
;
19528 if (!is_ia64_vms (filedata
))
19530 /* PR binutils/15191
19531 Make sure that there is enough data to read. */
19532 min_notesz
= offsetof (Elf_External_Note
, name
);
19533 if (data_remaining
< min_notesz
)
19535 warn (ngettext ("Corrupt note: only %ld byte remains, "
19536 "not enough for a full note\n",
19537 "Corrupt note: only %ld bytes remain, "
19538 "not enough for a full note\n",
19540 (long) data_remaining
);
19543 data_remaining
-= min_notesz
;
19545 inote
.type
= BYTE_GET (external
->type
);
19546 inote
.namesz
= BYTE_GET (external
->namesz
);
19547 inote
.namedata
= external
->name
;
19548 inote
.descsz
= BYTE_GET (external
->descsz
);
19549 inote
.descdata
= ((char *) external
19550 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19551 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19552 next
= ((char *) external
19553 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19557 Elf64_External_VMS_Note
*vms_external
;
19559 /* PR binutils/15191
19560 Make sure that there is enough data to read. */
19561 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19562 if (data_remaining
< min_notesz
)
19564 warn (ngettext ("Corrupt note: only %ld byte remains, "
19565 "not enough for a full note\n",
19566 "Corrupt note: only %ld bytes remain, "
19567 "not enough for a full note\n",
19569 (long) data_remaining
);
19572 data_remaining
-= min_notesz
;
19574 vms_external
= (Elf64_External_VMS_Note
*) external
;
19575 inote
.type
= BYTE_GET (vms_external
->type
);
19576 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19577 inote
.namedata
= vms_external
->name
;
19578 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19579 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19580 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19581 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19584 /* PR 17531: file: 3443835e. */
19585 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19586 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19587 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19588 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19589 || ((size_t) (next
- inote
.descdata
)
19590 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19592 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19593 (unsigned long) ((char *) external
- (char *) pnotes
));
19594 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19595 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19599 external
= (Elf_External_Note
*) next
;
19601 /* Verify that name is null terminated. It appears that at least
19602 one version of Linux (RedHat 6.0) generates corefiles that don't
19603 comply with the ELF spec by failing to include the null byte in
19605 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19607 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19609 temp
= (char *) malloc (inote
.namesz
+ 1);
19612 error (_("Out of memory allocating space for inote name\n"));
19617 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19618 inote
.namedata
= temp
;
19620 inote
.namedata
[inote
.namesz
] = 0;
19623 if (! process_note (& inote
, filedata
))
19639 process_corefile_note_segments (Filedata
* filedata
)
19641 Elf_Internal_Phdr
* segment
;
19643 bfd_boolean res
= TRUE
;
19645 if (! get_program_headers (filedata
))
19648 for (i
= 0, segment
= filedata
->program_headers
;
19649 i
< filedata
->file_header
.e_phnum
;
19652 if (segment
->p_type
== PT_NOTE
)
19653 if (! process_notes_at (filedata
, NULL
,
19654 (bfd_vma
) segment
->p_offset
,
19655 (bfd_vma
) segment
->p_filesz
,
19656 (bfd_vma
) segment
->p_align
))
19664 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19666 Elf_External_Note
* pnotes
;
19667 Elf_External_Note
* external
;
19669 bfd_boolean res
= TRUE
;
19674 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19676 if (pnotes
== NULL
)
19680 end
= (char*) pnotes
+ length
;
19682 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19683 (unsigned long) offset
, (unsigned long) length
);
19685 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19687 Elf_External_Note
* next
;
19688 Elf_Internal_Note inote
;
19690 inote
.type
= BYTE_GET (external
->type
);
19691 inote
.namesz
= BYTE_GET (external
->namesz
);
19692 inote
.namedata
= external
->name
;
19693 inote
.descsz
= BYTE_GET (external
->descsz
);
19694 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19695 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19697 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19699 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19700 inote
.descdata
= inote
.namedata
;
19704 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19706 if ( ((char *) next
> end
)
19707 || ((char *) next
< (char *) pnotes
))
19709 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19710 (unsigned long) ((char *) external
- (char *) pnotes
));
19711 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19712 inote
.type
, inote
.namesz
, inote
.descsz
);
19718 /* Prevent out-of-bounds indexing. */
19719 if ( inote
.namedata
+ inote
.namesz
> end
19720 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19722 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19723 (unsigned long) ((char *) external
- (char *) pnotes
));
19724 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19725 inote
.type
, inote
.namesz
, inote
.descsz
);
19729 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19731 if (! print_v850_note (& inote
))
19734 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19735 inote
.namesz
, inote
.descsz
);
19745 process_note_sections (Filedata
* filedata
)
19747 Elf_Internal_Shdr
* section
;
19749 unsigned int n
= 0;
19750 bfd_boolean res
= TRUE
;
19752 for (i
= 0, section
= filedata
->section_headers
;
19753 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19756 if (section
->sh_type
== SHT_NOTE
)
19758 if (! process_notes_at (filedata
, section
,
19759 (bfd_vma
) section
->sh_offset
,
19760 (bfd_vma
) section
->sh_size
,
19761 (bfd_vma
) section
->sh_addralign
))
19766 if (( filedata
->file_header
.e_machine
== EM_V800
19767 || filedata
->file_header
.e_machine
== EM_V850
19768 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19769 && section
->sh_type
== SHT_RENESAS_INFO
)
19771 if (! process_v850_notes (filedata
,
19772 (bfd_vma
) section
->sh_offset
,
19773 (bfd_vma
) section
->sh_size
))
19780 /* Try processing NOTE segments instead. */
19781 return process_corefile_note_segments (filedata
);
19787 process_notes (Filedata
* filedata
)
19789 /* If we have not been asked to display the notes then do nothing. */
19793 if (filedata
->file_header
.e_type
!= ET_CORE
)
19794 return process_note_sections (filedata
);
19796 /* No program headers means no NOTE segment. */
19797 if (filedata
->file_header
.e_phnum
> 0)
19798 return process_corefile_note_segments (filedata
);
19800 printf (_("No note segments present in the core file.\n"));
19804 static unsigned char *
19805 display_public_gnu_attributes (unsigned char * start
,
19806 const unsigned char * const end
)
19808 printf (_(" Unknown GNU attribute: %s\n"), start
);
19810 start
+= strnlen ((char *) start
, end
- start
);
19811 display_raw_attribute (start
, end
);
19813 return (unsigned char *) end
;
19816 static unsigned char *
19817 display_generic_attribute (unsigned char * start
,
19819 const unsigned char * const end
)
19822 return (unsigned char *) end
;
19824 return display_tag_value (tag
, start
, end
);
19828 process_arch_specific (Filedata
* filedata
)
19833 switch (filedata
->file_header
.e_machine
)
19836 case EM_ARC_COMPACT
:
19837 case EM_ARC_COMPACT2
:
19838 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19839 display_arc_attribute
,
19840 display_generic_attribute
);
19842 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19843 display_arm_attribute
,
19844 display_generic_attribute
);
19847 case EM_MIPS_RS3_LE
:
19848 return process_mips_specific (filedata
);
19851 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19852 display_msp430x_attribute
,
19853 display_msp430_gnu_attribute
);
19856 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19857 display_riscv_attribute
,
19858 display_generic_attribute
);
19861 return process_nds32_specific (filedata
);
19865 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19866 display_power_gnu_attribute
);
19870 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19871 display_s390_gnu_attribute
);
19874 case EM_SPARC32PLUS
:
19876 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19877 display_sparc_gnu_attribute
);
19880 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19881 display_tic6x_attribute
,
19882 display_generic_attribute
);
19885 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19886 display_public_gnu_attributes
,
19887 display_generic_attribute
);
19892 get_file_header (Filedata
* filedata
)
19894 /* Read in the identity array. */
19895 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19898 /* Determine how to read the rest of the header. */
19899 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19904 byte_get
= byte_get_little_endian
;
19905 byte_put
= byte_put_little_endian
;
19908 byte_get
= byte_get_big_endian
;
19909 byte_put
= byte_put_big_endian
;
19913 /* For now we only support 32 bit and 64 bit ELF files. */
19914 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19916 /* Read in the rest of the header. */
19919 Elf32_External_Ehdr ehdr32
;
19921 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19924 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19925 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19926 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19927 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19928 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19929 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19930 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19931 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19932 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19933 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19934 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19935 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19936 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19940 Elf64_External_Ehdr ehdr64
;
19942 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19943 we will not be able to cope with the 64bit data found in
19944 64 ELF files. Detect this now and abort before we start
19945 overwriting things. */
19946 if (sizeof (bfd_vma
) < 8)
19948 error (_("This instance of readelf has been built without support for a\n\
19949 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19953 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19956 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19957 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19958 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19959 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19960 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19961 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19962 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19963 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19964 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19965 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19966 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19967 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19968 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19971 if (filedata
->file_header
.e_shoff
)
19973 /* There may be some extensions in the first section header. Don't
19974 bomb if we can't read it. */
19976 get_32bit_section_headers (filedata
, TRUE
);
19978 get_64bit_section_headers (filedata
, TRUE
);
19985 close_file (Filedata
* filedata
)
19989 if (filedata
->handle
)
19990 fclose (filedata
->handle
);
19996 close_debug_file (void * data
)
19998 close_file ((Filedata
*) data
);
20002 open_file (const char * pathname
)
20004 struct stat statbuf
;
20005 Filedata
* filedata
= NULL
;
20007 if (stat (pathname
, & statbuf
) < 0
20008 || ! S_ISREG (statbuf
.st_mode
))
20011 filedata
= calloc (1, sizeof * filedata
);
20012 if (filedata
== NULL
)
20015 filedata
->handle
= fopen (pathname
, "rb");
20016 if (filedata
->handle
== NULL
)
20019 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20020 filedata
->file_name
= pathname
;
20022 if (! get_file_header (filedata
))
20025 if (filedata
->file_header
.e_shoff
)
20029 /* Read the section headers again, this time for real. */
20031 res
= get_32bit_section_headers (filedata
, FALSE
);
20033 res
= get_64bit_section_headers (filedata
, FALSE
);
20044 if (filedata
->handle
)
20045 fclose (filedata
->handle
);
20052 open_debug_file (const char * pathname
)
20054 return open_file (pathname
);
20057 /* Process one ELF object file according to the command line options.
20058 This file may actually be stored in an archive. The file is
20059 positioned at the start of the ELF object. Returns TRUE if no
20060 problems were encountered, FALSE otherwise. */
20063 process_object (Filedata
* filedata
)
20065 bfd_boolean have_separate_files
;
20067 bfd_boolean res
= TRUE
;
20069 if (! get_file_header (filedata
))
20071 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20075 /* Initialise per file variables. */
20076 for (i
= ARRAY_SIZE (version_info
); i
--;)
20077 version_info
[i
] = 0;
20079 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
20080 dynamic_info
[i
] = 0;
20081 dynamic_info_DT_GNU_HASH
= 0;
20082 dynamic_info_DT_MIPS_XHASH
= 0;
20084 /* Process the file. */
20086 printf (_("\nFile: %s\n"), filedata
->file_name
);
20088 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20089 Note we do this even if cmdline_dump_sects is empty because we
20090 must make sure that the dump_sets array is zeroed out before each
20091 object file is processed. */
20092 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20093 memset (filedata
->dump
.dump_sects
, 0,
20094 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20096 if (cmdline
.num_dump_sects
> 0)
20098 if (filedata
->dump
.num_dump_sects
== 0)
20099 /* A sneaky way of allocating the dump_sects array. */
20100 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20102 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20103 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20104 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20107 if (! process_file_header (filedata
))
20110 if (! process_section_headers (filedata
))
20112 /* Without loaded section headers we cannot process lots of things. */
20113 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20115 if (! do_using_dynamic
)
20116 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20119 if (! process_section_groups (filedata
))
20120 /* Without loaded section groups we cannot process unwind. */
20123 if (process_program_headers (filedata
))
20124 process_dynamic_section (filedata
);
20128 if (! process_relocs (filedata
))
20131 if (! process_unwind (filedata
))
20134 if (! process_symbol_table (filedata
))
20137 if (! process_syminfo (filedata
))
20140 if (! process_version_sections (filedata
))
20143 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20144 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20146 have_separate_files
= FALSE
;
20148 if (! process_section_contents (filedata
))
20151 if (have_separate_files
)
20155 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20157 if (! process_section_headers (d
->handle
))
20159 else if (! process_section_contents (d
->handle
))
20163 /* The file handles are closed by the call to free_debug_memory() below. */
20166 if (! process_notes (filedata
))
20169 if (! process_gnu_liblist (filedata
))
20172 if (! process_arch_specific (filedata
))
20175 free (filedata
->program_headers
);
20176 filedata
->program_headers
= NULL
;
20178 free (filedata
->section_headers
);
20179 filedata
->section_headers
= NULL
;
20181 free (filedata
->string_table
);
20182 filedata
->string_table
= NULL
;
20183 filedata
->string_table_length
= 0;
20185 if (filedata
->dump
.dump_sects
!= NULL
)
20187 free (filedata
->dump
.dump_sects
);
20188 filedata
->dump
.dump_sects
= NULL
;
20189 filedata
->dump
.num_dump_sects
= 0;
20192 if (dynamic_strings
)
20194 free (dynamic_strings
);
20195 dynamic_strings
= NULL
;
20196 dynamic_strings_length
= 0;
20199 if (dynamic_symbols
)
20201 free (dynamic_symbols
);
20202 dynamic_symbols
= NULL
;
20203 num_dynamic_syms
= 0;
20206 if (dynamic_syminfo
)
20208 free (dynamic_syminfo
);
20209 dynamic_syminfo
= NULL
;
20212 if (dynamic_section
)
20214 free (dynamic_section
);
20215 dynamic_section
= NULL
;
20218 while (symtab_shndx_list
!= NULL
)
20220 elf_section_list
*next
= symtab_shndx_list
->next
;
20221 free (symtab_shndx_list
);
20222 symtab_shndx_list
= next
;
20225 if (section_headers_groups
)
20227 free (section_headers_groups
);
20228 section_headers_groups
= NULL
;
20231 if (section_groups
)
20233 struct group_list
* g
;
20234 struct group_list
* next
;
20236 for (i
= 0; i
< group_count
; i
++)
20238 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
20245 free (section_groups
);
20246 section_groups
= NULL
;
20249 free_debug_memory ();
20254 /* Process an ELF archive.
20255 On entry the file is positioned just after the ARMAG string.
20256 Returns TRUE upon success, FALSE otherwise. */
20259 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20261 struct archive_info arch
;
20262 struct archive_info nested_arch
;
20264 bfd_boolean ret
= TRUE
;
20268 /* The ARCH structure is used to hold information about this archive. */
20269 arch
.file_name
= NULL
;
20271 arch
.index_array
= NULL
;
20272 arch
.sym_table
= NULL
;
20273 arch
.longnames
= NULL
;
20275 /* The NESTED_ARCH structure is used as a single-item cache of information
20276 about a nested archive (when members of a thin archive reside within
20277 another regular archive file). */
20278 nested_arch
.file_name
= NULL
;
20279 nested_arch
.file
= NULL
;
20280 nested_arch
.index_array
= NULL
;
20281 nested_arch
.sym_table
= NULL
;
20282 nested_arch
.longnames
= NULL
;
20284 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20285 filedata
->file_size
, is_thin_archive
,
20286 do_archive_index
) != 0)
20292 if (do_archive_index
)
20294 if (arch
.sym_table
== NULL
)
20295 error (_("%s: unable to dump the index as none was found\n"),
20296 filedata
->file_name
);
20299 unsigned long i
, l
;
20300 unsigned long current_pos
;
20302 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20303 "in the symbol table)\n"),
20304 filedata
->file_name
, (unsigned long) arch
.index_num
,
20307 current_pos
= ftell (filedata
->handle
);
20309 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20312 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20315 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20318 if (member_name
!= NULL
)
20320 char * qualified_name
20321 = make_qualified_name (&arch
, &nested_arch
,
20324 if (qualified_name
!= NULL
)
20326 printf (_("Contents of binary %s at offset "),
20328 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20330 free (qualified_name
);
20332 free (member_name
);
20336 if (l
>= arch
.sym_size
)
20338 error (_("%s: end of the symbol table reached "
20339 "before the end of the index\n"),
20340 filedata
->file_name
);
20344 /* PR 17531: file: 0b6630b2. */
20345 printf ("\t%.*s\n",
20346 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20347 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20350 if (arch
.uses_64bit_indices
)
20355 if (l
< arch
.sym_size
)
20357 error (ngettext ("%s: %ld byte remains in the symbol table, "
20358 "but without corresponding entries in "
20359 "the index table\n",
20360 "%s: %ld bytes remain in the symbol table, "
20361 "but without corresponding entries in "
20362 "the index table\n",
20363 arch
.sym_size
- l
),
20364 filedata
->file_name
, arch
.sym_size
- l
);
20368 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20370 error (_("%s: failed to seek back to start of object files "
20371 "in the archive\n"),
20372 filedata
->file_name
);
20378 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20379 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20380 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20381 && !do_section_groups
&& !do_dyn_syms
)
20383 ret
= TRUE
; /* Archive index only. */
20392 char * qualified_name
;
20394 /* Read the next archive header. */
20395 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20397 error (_("%s: failed to seek to next archive header\n"),
20402 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20403 if (got
!= sizeof arch
.arhdr
)
20407 /* PR 24049 - we cannot use filedata->file_name as this will
20408 have already been freed. */
20409 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20414 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20416 error (_("%s: did not find a valid archive header\n"),
20422 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20424 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20425 if (archive_file_size
& 01)
20426 ++archive_file_size
;
20428 name
= get_archive_member_name (&arch
, &nested_arch
);
20431 error (_("%s: bad archive file name\n"), arch
.file_name
);
20435 namelen
= strlen (name
);
20437 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20438 if (qualified_name
== NULL
)
20440 error (_("%s: bad archive file name\n"), arch
.file_name
);
20446 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20448 /* This is a proxy for an external member of a thin archive. */
20449 Filedata
* member_filedata
;
20450 char * member_file_name
= adjust_relative_path
20451 (filedata
->file_name
, name
, namelen
);
20454 if (member_file_name
== NULL
)
20456 free (qualified_name
);
20461 member_filedata
= open_file (member_file_name
);
20462 if (member_filedata
== NULL
)
20464 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20465 free (member_file_name
);
20466 free (qualified_name
);
20471 archive_file_offset
= arch
.nested_member_origin
;
20472 member_filedata
->file_name
= qualified_name
;
20474 if (! process_object (member_filedata
))
20477 close_file (member_filedata
);
20478 free (member_file_name
);
20480 else if (is_thin_archive
)
20482 Filedata thin_filedata
;
20484 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20486 /* PR 15140: Allow for corrupt thin archives. */
20487 if (nested_arch
.file
== NULL
)
20489 error (_("%s: contains corrupt thin archive: %s\n"),
20490 qualified_name
, name
);
20491 free (qualified_name
);
20498 /* This is a proxy for a member of a nested archive. */
20499 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20501 /* The nested archive file will have been opened and setup by
20502 get_archive_member_name. */
20503 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20505 error (_("%s: failed to seek to archive member.\n"),
20506 nested_arch
.file_name
);
20507 free (qualified_name
);
20512 thin_filedata
.handle
= nested_arch
.file
;
20513 thin_filedata
.file_name
= qualified_name
;
20515 if (! process_object (& thin_filedata
))
20521 archive_file_offset
= arch
.next_arhdr_offset
;
20522 filedata
->file_name
= qualified_name
;
20523 if (! process_object (filedata
))
20525 arch
.next_arhdr_offset
+= archive_file_size
;
20526 /* Stop looping with "negative" archive_file_size. */
20527 if (arch
.next_arhdr_offset
< archive_file_size
)
20528 arch
.next_arhdr_offset
= -1ul;
20531 free (qualified_name
);
20535 if (nested_arch
.file
!= NULL
)
20536 fclose (nested_arch
.file
);
20537 release_archive (&nested_arch
);
20538 release_archive (&arch
);
20544 process_file (char * file_name
)
20546 Filedata
* filedata
= NULL
;
20547 struct stat statbuf
;
20548 char armag
[SARMAG
];
20549 bfd_boolean ret
= TRUE
;
20551 if (stat (file_name
, &statbuf
) < 0)
20553 if (errno
== ENOENT
)
20554 error (_("'%s': No such file\n"), file_name
);
20556 error (_("Could not locate '%s'. System error message: %s\n"),
20557 file_name
, strerror (errno
));
20561 if (! S_ISREG (statbuf
.st_mode
))
20563 error (_("'%s' is not an ordinary file\n"), file_name
);
20567 filedata
= calloc (1, sizeof * filedata
);
20568 if (filedata
== NULL
)
20570 error (_("Out of memory allocating file data structure\n"));
20574 filedata
->file_name
= file_name
;
20575 filedata
->handle
= fopen (file_name
, "rb");
20576 if (filedata
->handle
== NULL
)
20578 error (_("Input file '%s' is not readable.\n"), file_name
);
20583 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20585 error (_("%s: Failed to read file's magic number\n"), file_name
);
20586 fclose (filedata
->handle
);
20591 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20593 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20595 if (! process_archive (filedata
, FALSE
))
20598 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20600 if ( ! process_archive (filedata
, TRUE
))
20605 if (do_archive_index
)
20606 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20609 rewind (filedata
->handle
);
20610 archive_file_size
= archive_file_offset
= 0;
20612 if (! process_object (filedata
))
20616 fclose (filedata
->handle
);
20617 free (filedata
->section_headers
);
20618 free (filedata
->program_headers
);
20619 free (filedata
->string_table
);
20620 free (filedata
->dump
.dump_sects
);
20623 free (ba_cache
.strtab
);
20624 ba_cache
.strtab
= NULL
;
20625 free (ba_cache
.symtab
);
20626 ba_cache
.symtab
= NULL
;
20627 ba_cache
.filedata
= NULL
;
20632 #ifdef SUPPORT_DISASSEMBLY
20633 /* Needed by the i386 disassembler. For extra credit, someone could
20634 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20638 print_address (unsigned int addr
, FILE * outfile
)
20640 fprintf (outfile
,"0x%8.8x", addr
);
20643 /* Needed by the i386 disassembler. */
20646 db_task_printsym (unsigned int addr
)
20648 print_address (addr
, stderr
);
20653 main (int argc
, char ** argv
)
20657 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20658 setlocale (LC_MESSAGES
, "");
20660 #if defined (HAVE_SETLOCALE)
20661 setlocale (LC_CTYPE
, "");
20663 bindtextdomain (PACKAGE
, LOCALEDIR
);
20664 textdomain (PACKAGE
);
20666 expandargv (&argc
, &argv
);
20668 parse_args (& cmdline
, argc
, argv
);
20670 if (optind
< (argc
- 1))
20672 else if (optind
>= argc
)
20674 warn (_("Nothing to do.\n"));
20679 while (optind
< argc
)
20680 if (! process_file (argv
[optind
++]))
20683 if (cmdline
.dump_sects
!= NULL
)
20684 free (cmdline
.dump_sects
);
20686 free (dump_ctf_symtab_name
);
20687 free (dump_ctf_strtab_name
);
20688 free (dump_ctf_parent_name
);
20690 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;