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. */
204 dump_type
* dump_sects
;
205 unsigned int num_dump_sects
;
208 static struct dump_data cmdline
;
210 static struct dump_list_entry
* dump_sects_byname
;
212 char * program_name
= "readelf";
214 static bfd_boolean show_name
= FALSE
;
215 static bfd_boolean do_dynamic
= FALSE
;
216 static bfd_boolean do_syms
= FALSE
;
217 static bfd_boolean do_dyn_syms
= FALSE
;
218 static bfd_boolean do_reloc
= FALSE
;
219 static bfd_boolean do_sections
= FALSE
;
220 static bfd_boolean do_section_groups
= FALSE
;
221 static bfd_boolean do_section_details
= FALSE
;
222 static bfd_boolean do_segments
= FALSE
;
223 static bfd_boolean do_unwind
= FALSE
;
224 static bfd_boolean do_using_dynamic
= FALSE
;
225 static bfd_boolean do_header
= FALSE
;
226 static bfd_boolean do_dump
= FALSE
;
227 static bfd_boolean do_version
= FALSE
;
228 static bfd_boolean do_histogram
= FALSE
;
229 static bfd_boolean do_debugging
= FALSE
;
230 static bfd_boolean do_ctf
= FALSE
;
231 static bfd_boolean do_arch
= FALSE
;
232 static bfd_boolean do_notes
= FALSE
;
233 static bfd_boolean do_archive_index
= FALSE
;
234 static bfd_boolean check_all
= FALSE
;
235 static bfd_boolean is_32bit_elf
= FALSE
;
236 static bfd_boolean decompress_dumps
= FALSE
;
237 static bfd_boolean do_not_show_symbol_truncation
= FALSE
;
239 static char *dump_ctf_parent_name
;
240 static char *dump_ctf_symtab_name
;
241 static char *dump_ctf_strtab_name
;
245 struct group_list
* next
;
246 unsigned int section_index
;
251 struct group_list
* root
;
252 unsigned int group_index
;
255 typedef struct filedata
257 const char * file_name
;
259 bfd_size_type file_size
;
260 Elf_Internal_Ehdr file_header
;
261 Elf_Internal_Shdr
* section_headers
;
262 Elf_Internal_Phdr
* program_headers
;
264 unsigned long string_table_length
;
265 unsigned long archive_file_offset
;
266 unsigned long archive_file_size
;
267 unsigned long dynamic_addr
;
268 bfd_size_type dynamic_size
;
270 Elf_Internal_Dyn
* dynamic_section
;
271 Elf_Internal_Shdr
* dynamic_strtab_section
;
272 char * dynamic_strings
;
273 unsigned long dynamic_strings_length
;
274 Elf_Internal_Shdr
* dynamic_symtab_section
;
275 unsigned long num_dynamic_syms
;
276 Elf_Internal_Sym
* dynamic_symbols
;
277 bfd_vma version_info
[16];
278 unsigned int dynamic_syminfo_nent
;
279 Elf_Internal_Syminfo
* dynamic_syminfo
;
280 unsigned long dynamic_syminfo_offset
;
281 bfd_size_type nbuckets
;
282 bfd_size_type nchains
;
285 bfd_size_type ngnubuckets
;
286 bfd_size_type ngnuchains
;
287 bfd_vma
* gnubuckets
;
291 char program_interpreter
[PATH_MAX
];
292 bfd_vma dynamic_info
[DT_ENCODING
];
293 bfd_vma dynamic_info_DT_GNU_HASH
;
294 bfd_vma dynamic_info_DT_MIPS_XHASH
;
295 elf_section_list
* symtab_shndx_list
;
297 struct group
* section_groups
;
298 struct group
** section_headers_groups
;
299 /* A dynamic array of flags indicating for which sections a dump of
300 some kind has been requested. It is reset on a per-object file
301 basis and then initialised from the cmdline_dump_sects array,
302 the results of interpreting the -w switch, and the
303 dump_sects_byname list. */
304 struct dump_data dump
;
307 /* How to print a vma value. */
308 typedef enum print_mode
320 /* Versioned symbol info. */
321 enum versioned_symbol_info
328 static const char * get_symbol_version_string
329 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
330 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
334 #define SECTION_NAME(X) \
335 ((X) == NULL ? _("<none>") \
336 : filedata->string_table == NULL ? _("<no-strings>") \
337 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
338 : filedata->string_table + (X)->sh_name))
340 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
342 #define GET_ELF_SYMBOLS(file, section, sym_count) \
343 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
344 : get_64bit_elf_symbols (file, section, sym_count))
346 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
347 (strtab != NULL && offset < strtab_size)
348 #define VALID_DYNAMIC_NAME(filedata, offset) \
349 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
350 filedata->dynamic_strings_length, offset)
351 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
352 already been called and verified that the string exists. */
353 #define GET_DYNAMIC_NAME(filedata, offset) \
354 (filedata->dynamic_strings + offset)
356 #define REMOVE_ARCH_BITS(ADDR) \
359 if (filedata->file_header.e_machine == EM_ARM) \
364 /* Get the correct GNU hash section name. */
365 #define GNU_HASH_SECTION_NAME(filedata) \
366 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
368 /* Print a BFD_VMA to an internal buffer, for use in error messages.
369 BFD_FMA_FMT can't be used in translated strings. */
372 bfd_vmatoa (char *fmtch
, bfd_vma value
)
374 /* bfd_vmatoa is used more then once in a printf call for output.
375 Cycle through an array of buffers. */
376 static int buf_pos
= 0;
377 static struct bfd_vmatoa_buf
384 ret
= buf
[buf_pos
++].place
;
385 buf_pos
%= ARRAY_SIZE (buf
);
387 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
388 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
392 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
393 OFFSET + the offset of the current archive member, if we are examining an
394 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
395 allocate a buffer using malloc and fill that. In either case return the
396 pointer to the start of the retrieved data or NULL if something went wrong.
397 If something does go wrong and REASON is not NULL then emit an error
398 message using REASON as part of the context. */
401 get_data (void * var
,
403 unsigned long offset
,
409 bfd_size_type amt
= size
* nmemb
;
411 if (size
== 0 || nmemb
== 0)
414 /* If the size_t type is smaller than the bfd_size_type, eg because
415 you are building a 32-bit tool on a 64-bit host, then make sure
416 that when the sizes are cast to (size_t) no information is lost. */
417 if ((size_t) size
!= size
418 || (size_t) nmemb
!= nmemb
419 || (size_t) amt
!= amt
)
422 error (_("Size truncation prevents reading %s"
423 " elements of size %s for %s\n"),
424 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
428 /* Check for size overflow. */
429 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
432 error (_("Size overflow prevents reading %s"
433 " elements of size %s for %s\n"),
434 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
438 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
439 attempting to allocate memory when the read is bound to fail. */
440 if (filedata
->archive_file_offset
> filedata
->file_size
441 || offset
> filedata
->file_size
- filedata
->archive_file_offset
442 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
445 error (_("Reading %s bytes extends past end of file for %s\n"),
446 bfd_vmatoa ("u", amt
), reason
);
450 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
454 error (_("Unable to seek to 0x%lx for %s\n"),
455 filedata
->archive_file_offset
+ offset
, reason
);
462 /* + 1 so that we can '\0' terminate invalid string table sections. */
463 mvar
= malloc ((size_t) amt
+ 1);
468 error (_("Out of memory allocating %s bytes for %s\n"),
469 bfd_vmatoa ("u", amt
), reason
);
473 ((char *) mvar
)[amt
] = '\0';
476 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
479 error (_("Unable to read in %s bytes of %s\n"),
480 bfd_vmatoa ("u", amt
), reason
);
489 /* Print a VMA value in the MODE specified.
490 Returns the number of characters displayed. */
493 print_vma (bfd_vma vma
, print_mode mode
)
505 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
512 return printf ("%5" BFD_VMA_FMT
"d", vma
);
518 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
521 return printf ("%" BFD_VMA_FMT
"d", vma
);
524 return printf ("%" BFD_VMA_FMT
"u", vma
);
527 /* FIXME: Report unrecognised mode ? */
532 /* Display a symbol on stdout. Handles the display of control characters and
533 multibye characters (assuming the host environment supports them).
535 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
537 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
538 abs(WIDTH) - 5 characters followed by "[...]".
540 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
541 padding as necessary.
543 Returns the number of emitted characters. */
546 print_symbol (signed int width
, const char * symbol
)
548 bfd_boolean extra_padding
= FALSE
;
549 bfd_boolean do_dots
= FALSE
;
550 signed int num_printed
= 0;
551 #ifdef HAVE_MBSTATE_T
554 unsigned int width_remaining
;
558 /* Keep the width positive. This helps the code below. */
560 extra_padding
= TRUE
;
566 /* Set the remaining width to a very large value.
567 This simplifies the code below. */
568 width_remaining
= INT_MAX
;
571 width_remaining
= width
;
572 if (! do_not_show_symbol_truncation
573 && (int) strlen (symbol
) > width
)
575 width_remaining
-= 5;
576 if ((int) width_remaining
< 0)
582 #ifdef HAVE_MBSTATE_T
583 /* Initialise the multibyte conversion state. */
584 memset (& state
, 0, sizeof (state
));
587 while (width_remaining
)
590 const char c
= *symbol
++;
595 /* Do not print control characters directly as they can affect terminal
596 settings. Such characters usually appear in the names generated
597 by the assembler for local labels. */
600 if (width_remaining
< 2)
603 printf ("^%c", c
+ 0x40);
604 width_remaining
-= 2;
607 else if (ISPRINT (c
))
615 #ifdef HAVE_MBSTATE_T
618 /* Let printf do the hard work of displaying multibyte characters. */
619 printf ("%.1s", symbol
- 1);
623 #ifdef HAVE_MBSTATE_T
624 /* Try to find out how many bytes made up the character that was
625 just printed. Advance the symbol pointer past the bytes that
627 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
631 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
637 num_printed
+= printf ("[...]");
639 if (extra_padding
&& num_printed
< width
)
641 /* Fill in the remaining spaces. */
642 printf ("%-*s", width
- num_printed
, " ");
649 /* Returns a pointer to a static buffer containing a printable version of
650 the given section's name. Like print_symbol, except that it does not try
651 to print multibyte characters, it just interprets them as hex values. */
654 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
656 #define MAX_PRINT_SEC_NAME_LEN 128
657 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
658 const char * name
= SECTION_NAME (sec
);
659 char * buf
= sec_name_buf
;
661 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
663 while ((c
= * name
++) != 0)
674 else if (ISPRINT (c
))
681 static char hex
[17] = "0123456789ABCDEF";
686 * buf
++ = hex
[(c
& 0xf0) >> 4];
687 * buf
++ = hex
[c
& 0x0f];
701 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
703 if (ndx
>= filedata
->file_header
.e_shnum
)
704 return _("<corrupt>");
706 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
709 /* Return a pointer to section NAME, or NULL if no such section exists. */
711 static Elf_Internal_Shdr
*
712 find_section (Filedata
* filedata
, const char * name
)
716 if (filedata
->section_headers
== NULL
)
719 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
720 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
721 return filedata
->section_headers
+ i
;
726 /* Return a pointer to a section containing ADDR, or NULL if no such
729 static Elf_Internal_Shdr
*
730 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
734 if (filedata
->section_headers
== NULL
)
737 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
739 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
741 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
748 static Elf_Internal_Shdr
*
749 find_section_by_type (Filedata
* filedata
, unsigned int type
)
753 if (filedata
->section_headers
== NULL
)
756 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
758 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
760 if (sec
->sh_type
== type
)
767 /* Return a pointer to section NAME, or NULL if no such section exists,
768 restricted to the list of sections given in SET. */
770 static Elf_Internal_Shdr
*
771 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
775 if (filedata
->section_headers
== NULL
)
780 while ((i
= *set
++) > 0)
782 /* See PR 21156 for a reproducer. */
783 if (i
>= filedata
->file_header
.e_shnum
)
784 continue; /* FIXME: Should we issue an error message ? */
786 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
787 return filedata
->section_headers
+ i
;
791 return find_section (filedata
, name
);
794 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
795 This OS has so many departures from the ELF standard that we test it at
798 static inline bfd_boolean
799 is_ia64_vms (Filedata
* filedata
)
801 return filedata
->file_header
.e_machine
== EM_IA_64
802 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
805 /* Guess the relocation size commonly used by the specific machines. */
808 guess_is_rela (unsigned int e_machine
)
812 /* Targets that use REL relocations. */
829 /* Targets that use RELA relocations. */
833 case EM_ADAPTEVA_EPIPHANY
:
835 case EM_ALTERA_NIOS2
:
838 case EM_ARC_COMPACT2
:
859 case EM_LATTICEMICO32
:
868 case EM_CYGNUS_MN10200
:
870 case EM_CYGNUS_MN10300
:
906 case EM_MICROBLAZE_OLD
:
928 warn (_("Don't know about relocations on this machine architecture\n"));
933 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
934 Returns TRUE upon success, FALSE otherwise. If successful then a
935 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
936 and the number of relocs loaded is placed in *NRELASP. It is the caller's
937 responsibility to free the allocated buffer. */
940 slurp_rela_relocs (Filedata
* filedata
,
941 unsigned long rel_offset
,
942 unsigned long rel_size
,
943 Elf_Internal_Rela
** relasp
,
944 unsigned long * nrelasp
)
946 Elf_Internal_Rela
* relas
;
952 Elf32_External_Rela
* erelas
;
954 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
955 rel_size
, _("32-bit relocation data"));
959 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
961 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
962 sizeof (Elf_Internal_Rela
));
967 error (_("out of memory parsing relocs\n"));
971 for (i
= 0; i
< nrelas
; i
++)
973 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
974 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
975 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
982 Elf64_External_Rela
* erelas
;
984 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
985 rel_size
, _("64-bit relocation data"));
989 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
991 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
992 sizeof (Elf_Internal_Rela
));
997 error (_("out of memory parsing relocs\n"));
1001 for (i
= 0; i
< nrelas
; i
++)
1003 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1004 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1005 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1007 /* The #ifdef BFD64 below is to prevent a compile time
1008 warning. We know that if we do not have a 64 bit data
1009 type that we will never execute this code anyway. */
1011 if (filedata
->file_header
.e_machine
== EM_MIPS
1012 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1014 /* In little-endian objects, r_info isn't really a
1015 64-bit little-endian value: it has a 32-bit
1016 little-endian symbol index followed by four
1017 individual byte fields. Reorder INFO
1019 bfd_vma inf
= relas
[i
].r_info
;
1020 inf
= (((inf
& 0xffffffff) << 32)
1021 | ((inf
>> 56) & 0xff)
1022 | ((inf
>> 40) & 0xff00)
1023 | ((inf
>> 24) & 0xff0000)
1024 | ((inf
>> 8) & 0xff000000));
1025 relas
[i
].r_info
= inf
;
1038 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1039 Returns TRUE upon success, FALSE otherwise. If successful then a
1040 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1041 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1042 responsibility to free the allocated buffer. */
1045 slurp_rel_relocs (Filedata
* filedata
,
1046 unsigned long rel_offset
,
1047 unsigned long rel_size
,
1048 Elf_Internal_Rela
** relsp
,
1049 unsigned long * nrelsp
)
1051 Elf_Internal_Rela
* rels
;
1057 Elf32_External_Rel
* erels
;
1059 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1060 rel_size
, _("32-bit relocation data"));
1064 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1066 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1071 error (_("out of memory parsing relocs\n"));
1075 for (i
= 0; i
< nrels
; i
++)
1077 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1078 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1079 rels
[i
].r_addend
= 0;
1086 Elf64_External_Rel
* erels
;
1088 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1089 rel_size
, _("64-bit relocation data"));
1093 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1095 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1100 error (_("out of memory parsing relocs\n"));
1104 for (i
= 0; i
< nrels
; i
++)
1106 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1107 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1108 rels
[i
].r_addend
= 0;
1110 /* The #ifdef BFD64 below is to prevent a compile time
1111 warning. We know that if we do not have a 64 bit data
1112 type that we will never execute this code anyway. */
1114 if (filedata
->file_header
.e_machine
== EM_MIPS
1115 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1117 /* In little-endian objects, r_info isn't really a
1118 64-bit little-endian value: it has a 32-bit
1119 little-endian symbol index followed by four
1120 individual byte fields. Reorder INFO
1122 bfd_vma inf
= rels
[i
].r_info
;
1123 inf
= (((inf
& 0xffffffff) << 32)
1124 | ((inf
>> 56) & 0xff)
1125 | ((inf
>> 40) & 0xff00)
1126 | ((inf
>> 24) & 0xff0000)
1127 | ((inf
>> 8) & 0xff000000));
1128 rels
[i
].r_info
= inf
;
1141 /* Returns the reloc type extracted from the reloc info field. */
1144 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1147 return ELF32_R_TYPE (reloc_info
);
1149 switch (filedata
->file_header
.e_machine
)
1152 /* Note: We assume that reloc_info has already been adjusted for us. */
1153 return ELF64_MIPS_R_TYPE (reloc_info
);
1156 return ELF64_R_TYPE_ID (reloc_info
);
1159 return ELF64_R_TYPE (reloc_info
);
1163 /* Return the symbol index extracted from the reloc info field. */
1166 get_reloc_symindex (bfd_vma reloc_info
)
1168 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1171 static inline bfd_boolean
1172 uses_msp430x_relocs (Filedata
* filedata
)
1175 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1176 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1177 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1178 /* TI compiler uses ELFOSABI_NONE. */
1179 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1182 /* Display the contents of the relocation data found at the specified
1186 dump_relocations (Filedata
* filedata
,
1187 unsigned long rel_offset
,
1188 unsigned long rel_size
,
1189 Elf_Internal_Sym
* symtab
,
1190 unsigned long nsyms
,
1192 unsigned long strtablen
,
1194 bfd_boolean is_dynsym
)
1197 Elf_Internal_Rela
* rels
;
1198 bfd_boolean res
= TRUE
;
1200 if (is_rela
== UNKNOWN
)
1201 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1205 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1210 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1219 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1221 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1226 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1228 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1236 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1238 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1243 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1245 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1249 for (i
= 0; i
< rel_size
; i
++)
1254 bfd_vma symtab_index
;
1257 offset
= rels
[i
].r_offset
;
1258 inf
= rels
[i
].r_info
;
1260 type
= get_reloc_type (filedata
, inf
);
1261 symtab_index
= get_reloc_symindex (inf
);
1265 printf ("%8.8lx %8.8lx ",
1266 (unsigned long) offset
& 0xffffffff,
1267 (unsigned long) inf
& 0xffffffff);
1271 #if BFD_HOST_64BIT_LONG
1273 ? "%16.16lx %16.16lx "
1274 : "%12.12lx %12.12lx ",
1276 #elif BFD_HOST_64BIT_LONG_LONG
1279 ? "%16.16llx %16.16llx "
1280 : "%12.12llx %12.12llx ",
1284 ? "%16.16I64x %16.16I64x "
1285 : "%12.12I64x %12.12I64x ",
1290 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1291 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1292 _bfd_int64_high (offset
),
1293 _bfd_int64_low (offset
),
1294 _bfd_int64_high (inf
),
1295 _bfd_int64_low (inf
));
1299 switch (filedata
->file_header
.e_machine
)
1306 rtype
= elf_aarch64_reloc_type (type
);
1310 case EM_CYGNUS_M32R
:
1311 rtype
= elf_m32r_reloc_type (type
);
1316 rtype
= elf_i386_reloc_type (type
);
1321 rtype
= elf_m68hc11_reloc_type (type
);
1325 rtype
= elf_s12z_reloc_type (type
);
1329 rtype
= elf_m68k_reloc_type (type
);
1333 rtype
= elf_i960_reloc_type (type
);
1338 rtype
= elf_avr_reloc_type (type
);
1341 case EM_OLD_SPARCV9
:
1342 case EM_SPARC32PLUS
:
1345 rtype
= elf_sparc_reloc_type (type
);
1349 rtype
= elf_spu_reloc_type (type
);
1353 rtype
= v800_reloc_type (type
);
1356 case EM_CYGNUS_V850
:
1357 rtype
= v850_reloc_type (type
);
1361 case EM_CYGNUS_D10V
:
1362 rtype
= elf_d10v_reloc_type (type
);
1366 case EM_CYGNUS_D30V
:
1367 rtype
= elf_d30v_reloc_type (type
);
1371 rtype
= elf_dlx_reloc_type (type
);
1375 rtype
= elf_sh_reloc_type (type
);
1379 case EM_CYGNUS_MN10300
:
1380 rtype
= elf_mn10300_reloc_type (type
);
1384 case EM_CYGNUS_MN10200
:
1385 rtype
= elf_mn10200_reloc_type (type
);
1389 case EM_CYGNUS_FR30
:
1390 rtype
= elf_fr30_reloc_type (type
);
1394 rtype
= elf_frv_reloc_type (type
);
1398 rtype
= elf_csky_reloc_type (type
);
1402 rtype
= elf_ft32_reloc_type (type
);
1406 rtype
= elf_mcore_reloc_type (type
);
1410 rtype
= elf_mmix_reloc_type (type
);
1414 rtype
= elf_moxie_reloc_type (type
);
1418 if (uses_msp430x_relocs (filedata
))
1420 rtype
= elf_msp430x_reloc_type (type
);
1425 rtype
= elf_msp430_reloc_type (type
);
1429 rtype
= elf_nds32_reloc_type (type
);
1433 rtype
= elf_ppc_reloc_type (type
);
1437 rtype
= elf_ppc64_reloc_type (type
);
1441 case EM_MIPS_RS3_LE
:
1442 rtype
= elf_mips_reloc_type (type
);
1446 rtype
= elf_riscv_reloc_type (type
);
1450 rtype
= elf_alpha_reloc_type (type
);
1454 rtype
= elf_arm_reloc_type (type
);
1458 case EM_ARC_COMPACT
:
1459 case EM_ARC_COMPACT2
:
1460 rtype
= elf_arc_reloc_type (type
);
1464 rtype
= elf_hppa_reloc_type (type
);
1470 rtype
= elf_h8_reloc_type (type
);
1474 rtype
= elf_or1k_reloc_type (type
);
1479 rtype
= elf_pj_reloc_type (type
);
1482 rtype
= elf_ia64_reloc_type (type
);
1486 rtype
= elf_cris_reloc_type (type
);
1490 rtype
= elf_i860_reloc_type (type
);
1496 rtype
= elf_x86_64_reloc_type (type
);
1500 rtype
= i370_reloc_type (type
);
1505 rtype
= elf_s390_reloc_type (type
);
1509 rtype
= elf_score_reloc_type (type
);
1513 rtype
= elf_xstormy16_reloc_type (type
);
1517 rtype
= elf_crx_reloc_type (type
);
1521 rtype
= elf_vax_reloc_type (type
);
1525 rtype
= elf_visium_reloc_type (type
);
1529 rtype
= elf_bpf_reloc_type (type
);
1532 case EM_ADAPTEVA_EPIPHANY
:
1533 rtype
= elf_epiphany_reloc_type (type
);
1538 rtype
= elf_ip2k_reloc_type (type
);
1542 rtype
= elf_iq2000_reloc_type (type
);
1547 rtype
= elf_xtensa_reloc_type (type
);
1550 case EM_LATTICEMICO32
:
1551 rtype
= elf_lm32_reloc_type (type
);
1556 rtype
= elf_m32c_reloc_type (type
);
1560 rtype
= elf_mt_reloc_type (type
);
1564 rtype
= elf_bfin_reloc_type (type
);
1568 rtype
= elf_mep_reloc_type (type
);
1572 rtype
= elf_cr16_reloc_type (type
);
1576 case EM_MICROBLAZE_OLD
:
1577 rtype
= elf_microblaze_reloc_type (type
);
1581 rtype
= elf_rl78_reloc_type (type
);
1585 rtype
= elf_rx_reloc_type (type
);
1589 rtype
= elf_metag_reloc_type (type
);
1594 rtype
= elf_xc16x_reloc_type (type
);
1598 rtype
= elf_tic6x_reloc_type (type
);
1602 rtype
= elf_tilegx_reloc_type (type
);
1606 rtype
= elf_tilepro_reloc_type (type
);
1609 case EM_WEBASSEMBLY
:
1610 rtype
= elf_wasm32_reloc_type (type
);
1614 rtype
= elf_xgate_reloc_type (type
);
1617 case EM_ALTERA_NIOS2
:
1618 rtype
= elf_nios2_reloc_type (type
);
1622 rtype
= elf_pru_reloc_type (type
);
1626 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1627 rtype
= elf_nfp3200_reloc_type (type
);
1629 rtype
= elf_nfp_reloc_type (type
);
1633 rtype
= elf_z80_reloc_type (type
);
1638 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1640 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1642 if (filedata
->file_header
.e_machine
== EM_ALPHA
1644 && streq (rtype
, "R_ALPHA_LITUSE")
1647 switch (rels
[i
].r_addend
)
1649 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1650 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1651 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1652 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1653 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1654 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1655 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1656 default: rtype
= NULL
;
1660 printf (" (%s)", rtype
);
1664 printf (_("<unknown addend: %lx>"),
1665 (unsigned long) rels
[i
].r_addend
);
1669 else if (symtab_index
)
1671 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1673 error (_(" bad symbol index: %08lx in reloc\n"),
1674 (unsigned long) symtab_index
);
1679 Elf_Internal_Sym
* psym
;
1680 const char * version_string
;
1681 enum versioned_symbol_info sym_info
;
1682 unsigned short vna_other
;
1684 psym
= symtab
+ symtab_index
;
1687 = get_symbol_version_string (filedata
, is_dynsym
,
1696 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1700 unsigned int width
= is_32bit_elf
? 8 : 14;
1702 /* Relocations against GNU_IFUNC symbols do not use the value
1703 of the symbol as the address to relocate against. Instead
1704 they invoke the function named by the symbol and use its
1705 result as the address for relocation.
1707 To indicate this to the user, do not display the value of
1708 the symbol in the "Symbols's Value" field. Instead show
1709 its name followed by () as a hint that the symbol is
1713 || psym
->st_name
== 0
1714 || psym
->st_name
>= strtablen
)
1717 name
= strtab
+ psym
->st_name
;
1719 len
= print_symbol (width
, name
);
1721 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1723 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1727 print_vma (psym
->st_value
, LONG_HEX
);
1729 printf (is_32bit_elf
? " " : " ");
1732 if (psym
->st_name
== 0)
1734 const char * sec_name
= "<null>";
1737 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1739 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1740 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1741 else if (psym
->st_shndx
== SHN_ABS
)
1743 else if (psym
->st_shndx
== SHN_COMMON
)
1744 sec_name
= "COMMON";
1745 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1746 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1747 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1748 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1749 sec_name
= "SCOMMON";
1750 else if (filedata
->file_header
.e_machine
== EM_MIPS
1751 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1752 sec_name
= "SUNDEF";
1753 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1754 || filedata
->file_header
.e_machine
== EM_L1OM
1755 || filedata
->file_header
.e_machine
== EM_K1OM
)
1756 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1757 sec_name
= "LARGE_COMMON";
1758 else if (filedata
->file_header
.e_machine
== EM_IA_64
1759 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1760 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1761 sec_name
= "ANSI_COM";
1762 else if (is_ia64_vms (filedata
)
1763 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1764 sec_name
= "VMS_SYMVEC";
1767 sprintf (name_buf
, "<section 0x%x>",
1768 (unsigned int) psym
->st_shndx
);
1769 sec_name
= name_buf
;
1772 print_symbol (22, sec_name
);
1774 else if (strtab
== NULL
)
1775 printf (_("<string table index: %3ld>"), psym
->st_name
);
1776 else if (psym
->st_name
>= strtablen
)
1778 error (_("<corrupt string table index: %3ld>\n"),
1784 print_symbol (22, strtab
+ psym
->st_name
);
1786 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1792 bfd_vma off
= rels
[i
].r_addend
;
1794 if ((bfd_signed_vma
) off
< 0)
1795 printf (" - %" BFD_VMA_FMT
"x", - off
);
1797 printf (" + %" BFD_VMA_FMT
"x", off
);
1803 bfd_vma off
= rels
[i
].r_addend
;
1805 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1806 if ((bfd_signed_vma
) off
< 0)
1807 printf ("-%" BFD_VMA_FMT
"x", - off
);
1809 printf ("%" BFD_VMA_FMT
"x", off
);
1812 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1814 && streq (rtype
, "R_SPARC_OLO10"))
1815 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1820 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1822 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1823 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1824 const char * rtype2
= elf_mips_reloc_type (type2
);
1825 const char * rtype3
= elf_mips_reloc_type (type3
);
1827 printf (" Type2: ");
1830 printf (_("unrecognized: %-7lx"),
1831 (unsigned long) type2
& 0xffffffff);
1833 printf ("%-17.17s", rtype2
);
1835 printf ("\n Type3: ");
1838 printf (_("unrecognized: %-7lx"),
1839 (unsigned long) type3
& 0xffffffff);
1841 printf ("%-17.17s", rtype3
);
1854 get_aarch64_dynamic_type (unsigned long type
)
1858 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1859 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1860 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1867 get_mips_dynamic_type (unsigned long type
)
1871 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1872 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1873 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1874 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1875 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1876 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1877 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1878 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1879 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1880 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1881 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1882 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1883 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1884 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1885 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1886 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1887 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1888 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1889 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1890 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1891 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1892 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1893 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1894 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1895 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1896 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1897 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1898 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1899 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1900 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1901 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1902 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1903 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1904 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1905 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1906 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1907 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1908 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1909 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1910 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1911 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1912 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1913 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1914 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1915 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1916 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1917 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1924 get_sparc64_dynamic_type (unsigned long type
)
1928 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1935 get_ppc_dynamic_type (unsigned long type
)
1939 case DT_PPC_GOT
: return "PPC_GOT";
1940 case DT_PPC_OPT
: return "PPC_OPT";
1947 get_ppc64_dynamic_type (unsigned long type
)
1951 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1952 case DT_PPC64_OPD
: return "PPC64_OPD";
1953 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1954 case DT_PPC64_OPT
: return "PPC64_OPT";
1961 get_parisc_dynamic_type (unsigned long type
)
1965 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1966 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1967 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1968 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1969 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1970 case DT_HP_PREINIT
: return "HP_PREINIT";
1971 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1972 case DT_HP_NEEDED
: return "HP_NEEDED";
1973 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1974 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1975 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1976 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1977 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1978 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1979 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1980 case DT_HP_FILTERED
: return "HP_FILTERED";
1981 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1982 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1983 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1984 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1985 case DT_PLT
: return "PLT";
1986 case DT_PLT_SIZE
: return "PLT_SIZE";
1987 case DT_DLT
: return "DLT";
1988 case DT_DLT_SIZE
: return "DLT_SIZE";
1995 get_ia64_dynamic_type (unsigned long type
)
1999 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2000 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2001 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2002 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2003 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2004 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2005 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2006 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2007 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2008 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2009 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2010 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2011 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2012 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2013 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2014 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2015 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2016 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2017 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2018 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2019 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2020 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2021 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2022 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2023 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2024 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2025 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2026 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2027 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2028 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2029 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2036 get_solaris_section_type (unsigned long type
)
2040 case 0x6fffffee: return "SUNW_ancillary";
2041 case 0x6fffffef: return "SUNW_capchain";
2042 case 0x6ffffff0: return "SUNW_capinfo";
2043 case 0x6ffffff1: return "SUNW_symsort";
2044 case 0x6ffffff2: return "SUNW_tlssort";
2045 case 0x6ffffff3: return "SUNW_LDYNSYM";
2046 case 0x6ffffff4: return "SUNW_dof";
2047 case 0x6ffffff5: return "SUNW_cap";
2048 case 0x6ffffff6: return "SUNW_SIGNATURE";
2049 case 0x6ffffff7: return "SUNW_ANNOTATE";
2050 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2051 case 0x6ffffff9: return "SUNW_DEBUG";
2052 case 0x6ffffffa: return "SUNW_move";
2053 case 0x6ffffffb: return "SUNW_COMDAT";
2054 case 0x6ffffffc: return "SUNW_syminfo";
2055 case 0x6ffffffd: return "SUNW_verdef";
2056 case 0x6ffffffe: return "SUNW_verneed";
2057 case 0x6fffffff: return "SUNW_versym";
2058 case 0x70000000: return "SPARC_GOTDATA";
2059 default: return NULL
;
2064 get_alpha_dynamic_type (unsigned long type
)
2068 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2069 default: return NULL
;
2074 get_score_dynamic_type (unsigned long type
)
2078 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2079 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2080 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2081 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2082 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2083 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2084 default: return NULL
;
2089 get_tic6x_dynamic_type (unsigned long type
)
2093 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2094 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2095 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2096 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2097 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2098 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2099 default: return NULL
;
2104 get_nios2_dynamic_type (unsigned long type
)
2108 case DT_NIOS2_GP
: return "NIOS2_GP";
2109 default: return NULL
;
2114 get_solaris_dynamic_type (unsigned long type
)
2118 case 0x6000000d: return "SUNW_AUXILIARY";
2119 case 0x6000000e: return "SUNW_RTLDINF";
2120 case 0x6000000f: return "SUNW_FILTER";
2121 case 0x60000010: return "SUNW_CAP";
2122 case 0x60000011: return "SUNW_SYMTAB";
2123 case 0x60000012: return "SUNW_SYMSZ";
2124 case 0x60000013: return "SUNW_SORTENT";
2125 case 0x60000014: return "SUNW_SYMSORT";
2126 case 0x60000015: return "SUNW_SYMSORTSZ";
2127 case 0x60000016: return "SUNW_TLSSORT";
2128 case 0x60000017: return "SUNW_TLSSORTSZ";
2129 case 0x60000018: return "SUNW_CAPINFO";
2130 case 0x60000019: return "SUNW_STRPAD";
2131 case 0x6000001a: return "SUNW_CAPCHAIN";
2132 case 0x6000001b: return "SUNW_LDMACH";
2133 case 0x6000001d: return "SUNW_CAPCHAINENT";
2134 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2135 case 0x60000021: return "SUNW_PARENT";
2136 case 0x60000023: return "SUNW_ASLR";
2137 case 0x60000025: return "SUNW_RELAX";
2138 case 0x60000029: return "SUNW_NXHEAP";
2139 case 0x6000002b: return "SUNW_NXSTACK";
2141 case 0x70000001: return "SPARC_REGISTER";
2142 case 0x7ffffffd: return "AUXILIARY";
2143 case 0x7ffffffe: return "USED";
2144 case 0x7fffffff: return "FILTER";
2146 default: return NULL
;
2151 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2153 static char buff
[64];
2157 case DT_NULL
: return "NULL";
2158 case DT_NEEDED
: return "NEEDED";
2159 case DT_PLTRELSZ
: return "PLTRELSZ";
2160 case DT_PLTGOT
: return "PLTGOT";
2161 case DT_HASH
: return "HASH";
2162 case DT_STRTAB
: return "STRTAB";
2163 case DT_SYMTAB
: return "SYMTAB";
2164 case DT_RELA
: return "RELA";
2165 case DT_RELASZ
: return "RELASZ";
2166 case DT_RELAENT
: return "RELAENT";
2167 case DT_STRSZ
: return "STRSZ";
2168 case DT_SYMENT
: return "SYMENT";
2169 case DT_INIT
: return "INIT";
2170 case DT_FINI
: return "FINI";
2171 case DT_SONAME
: return "SONAME";
2172 case DT_RPATH
: return "RPATH";
2173 case DT_SYMBOLIC
: return "SYMBOLIC";
2174 case DT_REL
: return "REL";
2175 case DT_RELSZ
: return "RELSZ";
2176 case DT_RELENT
: return "RELENT";
2177 case DT_PLTREL
: return "PLTREL";
2178 case DT_DEBUG
: return "DEBUG";
2179 case DT_TEXTREL
: return "TEXTREL";
2180 case DT_JMPREL
: return "JMPREL";
2181 case DT_BIND_NOW
: return "BIND_NOW";
2182 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2183 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2184 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2185 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2186 case DT_RUNPATH
: return "RUNPATH";
2187 case DT_FLAGS
: return "FLAGS";
2189 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2190 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2191 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2193 case DT_CHECKSUM
: return "CHECKSUM";
2194 case DT_PLTPADSZ
: return "PLTPADSZ";
2195 case DT_MOVEENT
: return "MOVEENT";
2196 case DT_MOVESZ
: return "MOVESZ";
2197 case DT_FEATURE
: return "FEATURE";
2198 case DT_POSFLAG_1
: return "POSFLAG_1";
2199 case DT_SYMINSZ
: return "SYMINSZ";
2200 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2202 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2203 case DT_CONFIG
: return "CONFIG";
2204 case DT_DEPAUDIT
: return "DEPAUDIT";
2205 case DT_AUDIT
: return "AUDIT";
2206 case DT_PLTPAD
: return "PLTPAD";
2207 case DT_MOVETAB
: return "MOVETAB";
2208 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2210 case DT_VERSYM
: return "VERSYM";
2212 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2213 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2214 case DT_RELACOUNT
: return "RELACOUNT";
2215 case DT_RELCOUNT
: return "RELCOUNT";
2216 case DT_FLAGS_1
: return "FLAGS_1";
2217 case DT_VERDEF
: return "VERDEF";
2218 case DT_VERDEFNUM
: return "VERDEFNUM";
2219 case DT_VERNEED
: return "VERNEED";
2220 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2222 case DT_AUXILIARY
: return "AUXILIARY";
2223 case DT_USED
: return "USED";
2224 case DT_FILTER
: return "FILTER";
2226 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2227 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2228 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2229 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2230 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2231 case DT_GNU_HASH
: return "GNU_HASH";
2234 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2236 const char * result
;
2238 switch (filedata
->file_header
.e_machine
)
2241 result
= get_aarch64_dynamic_type (type
);
2244 case EM_MIPS_RS3_LE
:
2245 result
= get_mips_dynamic_type (type
);
2248 result
= get_sparc64_dynamic_type (type
);
2251 result
= get_ppc_dynamic_type (type
);
2254 result
= get_ppc64_dynamic_type (type
);
2257 result
= get_ia64_dynamic_type (type
);
2260 result
= get_alpha_dynamic_type (type
);
2263 result
= get_score_dynamic_type (type
);
2266 result
= get_tic6x_dynamic_type (type
);
2268 case EM_ALTERA_NIOS2
:
2269 result
= get_nios2_dynamic_type (type
);
2272 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2273 result
= get_solaris_dynamic_type (type
);
2282 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2284 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2285 || (filedata
->file_header
.e_machine
== EM_PARISC
2286 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2288 const char * result
;
2290 switch (filedata
->file_header
.e_machine
)
2293 result
= get_parisc_dynamic_type (type
);
2296 result
= get_ia64_dynamic_type (type
);
2299 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2300 result
= get_solaris_dynamic_type (type
);
2309 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2313 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2320 get_file_type (unsigned e_type
)
2322 static char buff
[64];
2326 case ET_NONE
: return _("NONE (None)");
2327 case ET_REL
: return _("REL (Relocatable file)");
2328 case ET_EXEC
: return _("EXEC (Executable file)");
2329 case ET_DYN
: return _("DYN (Shared object file)");
2330 case ET_CORE
: return _("CORE (Core file)");
2333 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2334 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2335 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2336 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2338 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2344 get_machine_name (unsigned e_machine
)
2346 static char buff
[64]; /* XXX */
2350 /* Please keep this switch table sorted by increasing EM_ value. */
2352 case EM_NONE
: return _("None");
2353 case EM_M32
: return "WE32100";
2354 case EM_SPARC
: return "Sparc";
2355 case EM_386
: return "Intel 80386";
2356 case EM_68K
: return "MC68000";
2357 case EM_88K
: return "MC88000";
2358 case EM_IAMCU
: return "Intel MCU";
2359 case EM_860
: return "Intel 80860";
2360 case EM_MIPS
: return "MIPS R3000";
2361 case EM_S370
: return "IBM System/370";
2363 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2364 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2365 case EM_PARISC
: return "HPPA";
2366 case EM_VPP550
: return "Fujitsu VPP500";
2367 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2368 case EM_960
: return "Intel 80960";
2369 case EM_PPC
: return "PowerPC";
2371 case EM_PPC64
: return "PowerPC64";
2373 case EM_S390
: return "IBM S/390";
2374 case EM_SPU
: return "SPU";
2376 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2377 case EM_FR20
: return "Fujitsu FR20";
2378 case EM_RH32
: return "TRW RH32";
2379 case EM_MCORE
: return "MCORE";
2381 case EM_ARM
: return "ARM";
2382 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2383 case EM_SH
: return "Renesas / SuperH SH";
2384 case EM_SPARCV9
: return "Sparc v9";
2385 case EM_TRICORE
: return "Siemens Tricore";
2386 case EM_ARC
: return "ARC";
2387 case EM_H8_300
: return "Renesas H8/300";
2388 case EM_H8_300H
: return "Renesas H8/300H";
2389 case EM_H8S
: return "Renesas H8S";
2390 case EM_H8_500
: return "Renesas H8/500";
2392 case EM_IA_64
: return "Intel IA-64";
2393 case EM_MIPS_X
: return "Stanford MIPS-X";
2394 case EM_COLDFIRE
: return "Motorola Coldfire";
2395 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2396 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2397 case EM_PCP
: return "Siemens PCP";
2398 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2399 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2400 case EM_STARCORE
: return "Motorola Star*Core processor";
2401 case EM_ME16
: return "Toyota ME16 processor";
2403 case EM_ST100
: return "STMicroelectronics ST100 processor";
2404 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2405 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2406 case EM_PDSP
: return "Sony DSP processor";
2407 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2408 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2409 case EM_FX66
: return "Siemens FX66 microcontroller";
2410 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2411 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2412 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2414 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2415 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2416 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2417 case EM_SVX
: return "Silicon Graphics SVx";
2418 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2419 case EM_VAX
: return "Digital VAX";
2420 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2421 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2422 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2423 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2425 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2426 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2427 case EM_PRISM
: return "Vitesse Prism";
2429 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2430 case EM_CYGNUS_FR30
:
2431 case EM_FR30
: return "Fujitsu FR30";
2432 case EM_CYGNUS_D10V
:
2433 case EM_D10V
: return "d10v";
2434 case EM_CYGNUS_D30V
:
2435 case EM_D30V
: return "d30v";
2436 case EM_CYGNUS_V850
:
2437 case EM_V850
: return "Renesas V850";
2438 case EM_CYGNUS_M32R
:
2439 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2440 case EM_CYGNUS_MN10300
:
2441 case EM_MN10300
: return "mn10300";
2443 case EM_CYGNUS_MN10200
:
2444 case EM_MN10200
: return "mn10200";
2445 case EM_PJ
: return "picoJava";
2446 case EM_OR1K
: return "OpenRISC 1000";
2447 case EM_ARC_COMPACT
: return "ARCompact";
2449 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2450 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2451 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2452 case EM_NS32K
: return "National Semiconductor 32000 series";
2453 case EM_TPC
: return "Tenor Network TPC processor";
2454 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2456 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2458 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2459 case EM_MAX
: return "MAX Processor";
2460 case EM_CR
: return "National Semiconductor CompactRISC";
2461 case EM_F2MC16
: return "Fujitsu F2MC16";
2462 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2463 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2464 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2465 case EM_SEP
: return "Sharp embedded microprocessor";
2466 case EM_ARCA
: return "Arca RISC microprocessor";
2468 case EM_UNICORE
: return "Unicore";
2469 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2470 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2471 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2472 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2473 case EM_XGATE
: return "Motorola XGATE embedded processor";
2475 case EM_XC16X
: return "Infineon Technologies xc16x";
2476 case EM_M16C
: return "Renesas M16C series microprocessors";
2477 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2478 case EM_CE
: return "Freescale Communication Engine RISC core";
2480 case EM_M32C
: return "Renesas M32c";
2482 case EM_TSK3000
: return "Altium TSK3000 core";
2483 case EM_RS08
: return "Freescale RS08 embedded processor";
2484 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2485 case EM_SCORE
: return "SUNPLUS S+Core";
2486 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2487 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2488 case EM_LATTICEMICO32
: return "Lattice Mico32";
2489 case EM_SE_C17
: return "Seiko Epson C17 family";
2491 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2492 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2493 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2494 case EM_TI_PRU
: return "TI PRU I/O processor";
2496 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2497 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2498 case EM_R32C
: return "Renesas R32C series microprocessors";
2499 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2500 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2501 case EM_8051
: return "Intel 8051 and variants";
2502 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2503 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2504 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2505 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2507 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2508 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2509 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2510 case EM_RX
: return "Renesas RX";
2511 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2512 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2513 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2516 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2517 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2518 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2520 case EM_L1OM
: return "Intel L1OM";
2521 case EM_K1OM
: return "Intel K1OM";
2522 case EM_INTEL182
: return "Intel (reserved)";
2523 case EM_AARCH64
: return "AArch64";
2524 case EM_ARM184
: return "ARM (reserved)";
2525 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2526 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2527 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2528 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2530 case EM_CUDA
: return "NVIDIA CUDA architecture";
2531 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2532 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2533 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2534 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2535 case EM_ARC_COMPACT2
: return "ARCv2";
2536 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2537 case EM_RL78
: return "Renesas RL78";
2538 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2539 case EM_78K0R
: return "Renesas 78K0R";
2541 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2542 case EM_BA1
: return "Beyond BA1 CPU architecture";
2543 case EM_BA2
: return "Beyond BA2 CPU architecture";
2544 case EM_XCORE
: return "XMOS xCORE processor family";
2545 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2547 case EM_KM32
: return "KM211 KM32 32-bit processor";
2548 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2549 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2550 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2551 case EM_KVARC
: return "KM211 KVARC processor";
2552 case EM_CDP
: return "Paneve CDP architecture family";
2553 case EM_COGE
: return "Cognitive Smart Memory Processor";
2554 case EM_COOL
: return "Bluechip Systems CoolEngine";
2555 case EM_NORC
: return "Nanoradio Optimized RISC";
2556 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2558 case EM_Z80
: return "Zilog Z80";
2559 case EM_VISIUM
: return "CDS VISIUMcore processor";
2560 case EM_FT32
: return "FTDI Chip FT32";
2561 case EM_MOXIE
: return "Moxie";
2562 case EM_AMDGPU
: return "AMD GPU";
2563 case EM_RISCV
: return "RISC-V";
2564 case EM_LANAI
: return "Lanai 32-bit processor";
2565 case EM_BPF
: return "Linux BPF";
2566 case EM_NFP
: return "Netronome Flow Processor";
2568 /* Large numbers... */
2569 case EM_MT
: return "Morpho Techologies MT processor";
2570 case EM_ALPHA
: return "Alpha";
2571 case EM_WEBASSEMBLY
: return "Web Assembly";
2572 case EM_DLX
: return "OpenDLX";
2573 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2574 case EM_IQ2000
: return "Vitesse IQ2000";
2576 case EM_NIOS32
: return "Altera Nios";
2577 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2578 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2579 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2580 case EM_S12Z
: return "Freescale S12Z";
2581 case EM_CSKY
: return "C-SKY";
2584 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2590 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2592 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2593 other compilers don't a specific architecture type in the e_flags, and
2594 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2595 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2598 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2599 but also sets a specific architecture type in the e_flags field.
2601 However, when decoding the flags we don't worry if we see an
2602 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2603 ARCEM architecture type. */
2605 switch (e_flags
& EF_ARC_MACH_MSK
)
2607 /* We only expect these to occur for EM_ARC_COMPACT2. */
2608 case EF_ARC_CPU_ARCV2EM
:
2609 strcat (buf
, ", ARC EM");
2611 case EF_ARC_CPU_ARCV2HS
:
2612 strcat (buf
, ", ARC HS");
2615 /* We only expect these to occur for EM_ARC_COMPACT. */
2616 case E_ARC_MACH_ARC600
:
2617 strcat (buf
, ", ARC600");
2619 case E_ARC_MACH_ARC601
:
2620 strcat (buf
, ", ARC601");
2622 case E_ARC_MACH_ARC700
:
2623 strcat (buf
, ", ARC700");
2626 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2627 new ELF with new architecture being read by an old version of
2628 readelf, or (c) An ELF built with non-GNU compiler that does not
2629 set the architecture in the e_flags. */
2631 if (e_machine
== EM_ARC_COMPACT
)
2632 strcat (buf
, ", Unknown ARCompact");
2634 strcat (buf
, ", Unknown ARC");
2638 switch (e_flags
& EF_ARC_OSABI_MSK
)
2640 case E_ARC_OSABI_ORIG
:
2641 strcat (buf
, ", (ABI:legacy)");
2643 case E_ARC_OSABI_V2
:
2644 strcat (buf
, ", (ABI:v2)");
2646 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2647 case E_ARC_OSABI_V3
:
2648 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2650 case E_ARC_OSABI_V4
:
2651 strcat (buf
, ", v4 ABI");
2654 strcat (buf
, ", unrecognised ARC OSABI flag");
2660 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2663 bfd_boolean unknown
= FALSE
;
2665 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2666 e_flags
&= ~ EF_ARM_EABIMASK
;
2668 /* Handle "generic" ARM flags. */
2669 if (e_flags
& EF_ARM_RELEXEC
)
2671 strcat (buf
, ", relocatable executable");
2672 e_flags
&= ~ EF_ARM_RELEXEC
;
2675 if (e_flags
& EF_ARM_PIC
)
2677 strcat (buf
, ", position independent");
2678 e_flags
&= ~ EF_ARM_PIC
;
2681 /* Now handle EABI specific flags. */
2685 strcat (buf
, ", <unrecognized EABI>");
2690 case EF_ARM_EABI_VER1
:
2691 strcat (buf
, ", Version1 EABI");
2696 /* Process flags one bit at a time. */
2697 flag
= e_flags
& - e_flags
;
2702 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2703 strcat (buf
, ", sorted symbol tables");
2713 case EF_ARM_EABI_VER2
:
2714 strcat (buf
, ", Version2 EABI");
2719 /* Process flags one bit at a time. */
2720 flag
= e_flags
& - e_flags
;
2725 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2726 strcat (buf
, ", sorted symbol tables");
2729 case EF_ARM_DYNSYMSUSESEGIDX
:
2730 strcat (buf
, ", dynamic symbols use segment index");
2733 case EF_ARM_MAPSYMSFIRST
:
2734 strcat (buf
, ", mapping symbols precede others");
2744 case EF_ARM_EABI_VER3
:
2745 strcat (buf
, ", Version3 EABI");
2748 case EF_ARM_EABI_VER4
:
2749 strcat (buf
, ", Version4 EABI");
2754 /* Process flags one bit at a time. */
2755 flag
= e_flags
& - e_flags
;
2761 strcat (buf
, ", BE8");
2765 strcat (buf
, ", LE8");
2775 case EF_ARM_EABI_VER5
:
2776 strcat (buf
, ", Version5 EABI");
2781 /* Process flags one bit at a time. */
2782 flag
= e_flags
& - e_flags
;
2788 strcat (buf
, ", BE8");
2792 strcat (buf
, ", LE8");
2795 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2796 strcat (buf
, ", soft-float ABI");
2799 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2800 strcat (buf
, ", hard-float ABI");
2810 case EF_ARM_EABI_UNKNOWN
:
2811 strcat (buf
, ", GNU EABI");
2816 /* Process flags one bit at a time. */
2817 flag
= e_flags
& - e_flags
;
2822 case EF_ARM_INTERWORK
:
2823 strcat (buf
, ", interworking enabled");
2826 case EF_ARM_APCS_26
:
2827 strcat (buf
, ", uses APCS/26");
2830 case EF_ARM_APCS_FLOAT
:
2831 strcat (buf
, ", uses APCS/float");
2835 strcat (buf
, ", position independent");
2839 strcat (buf
, ", 8 bit structure alignment");
2842 case EF_ARM_NEW_ABI
:
2843 strcat (buf
, ", uses new ABI");
2846 case EF_ARM_OLD_ABI
:
2847 strcat (buf
, ", uses old ABI");
2850 case EF_ARM_SOFT_FLOAT
:
2851 strcat (buf
, ", software FP");
2854 case EF_ARM_VFP_FLOAT
:
2855 strcat (buf
, ", VFP");
2858 case EF_ARM_MAVERICK_FLOAT
:
2859 strcat (buf
, ", Maverick FP");
2870 strcat (buf
,_(", <unknown>"));
2874 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2876 --size
; /* Leave space for null terminator. */
2878 switch (e_flags
& EF_AVR_MACH
)
2880 case E_AVR_MACH_AVR1
:
2881 strncat (buf
, ", avr:1", size
);
2883 case E_AVR_MACH_AVR2
:
2884 strncat (buf
, ", avr:2", size
);
2886 case E_AVR_MACH_AVR25
:
2887 strncat (buf
, ", avr:25", size
);
2889 case E_AVR_MACH_AVR3
:
2890 strncat (buf
, ", avr:3", size
);
2892 case E_AVR_MACH_AVR31
:
2893 strncat (buf
, ", avr:31", size
);
2895 case E_AVR_MACH_AVR35
:
2896 strncat (buf
, ", avr:35", size
);
2898 case E_AVR_MACH_AVR4
:
2899 strncat (buf
, ", avr:4", size
);
2901 case E_AVR_MACH_AVR5
:
2902 strncat (buf
, ", avr:5", size
);
2904 case E_AVR_MACH_AVR51
:
2905 strncat (buf
, ", avr:51", size
);
2907 case E_AVR_MACH_AVR6
:
2908 strncat (buf
, ", avr:6", size
);
2910 case E_AVR_MACH_AVRTINY
:
2911 strncat (buf
, ", avr:100", size
);
2913 case E_AVR_MACH_XMEGA1
:
2914 strncat (buf
, ", avr:101", size
);
2916 case E_AVR_MACH_XMEGA2
:
2917 strncat (buf
, ", avr:102", size
);
2919 case E_AVR_MACH_XMEGA3
:
2920 strncat (buf
, ", avr:103", size
);
2922 case E_AVR_MACH_XMEGA4
:
2923 strncat (buf
, ", avr:104", size
);
2925 case E_AVR_MACH_XMEGA5
:
2926 strncat (buf
, ", avr:105", size
);
2928 case E_AVR_MACH_XMEGA6
:
2929 strncat (buf
, ", avr:106", size
);
2931 case E_AVR_MACH_XMEGA7
:
2932 strncat (buf
, ", avr:107", size
);
2935 strncat (buf
, ", avr:<unknown>", size
);
2939 size
-= strlen (buf
);
2940 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2941 strncat (buf
, ", link-relax", size
);
2945 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2951 bfd_boolean has_fpu
= FALSE
;
2954 static const char *ABI_STRINGS
[] =
2956 "ABI v0", /* use r5 as return register; only used in N1213HC */
2957 "ABI v1", /* use r0 as return register */
2958 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2959 "ABI v2fp", /* for FPU */
2963 static const char *VER_STRINGS
[] =
2965 "Andes ELF V1.3 or older",
2969 static const char *ARCH_STRINGS
[] =
2978 abi
= EF_NDS_ABI
& e_flags
;
2979 arch
= EF_NDS_ARCH
& e_flags
;
2980 config
= EF_NDS_INST
& e_flags
;
2981 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2983 memset (buf
, 0, size
);
2990 case E_NDS_ABI_V2FP
:
2991 case E_NDS_ABI_AABI
:
2992 case E_NDS_ABI_V2FP_PLUS
:
2993 /* In case there are holes in the array. */
2994 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2998 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3004 case E_NDS32_ELF_VER_1_2
:
3005 case E_NDS32_ELF_VER_1_3
:
3006 case E_NDS32_ELF_VER_1_4
:
3007 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3011 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3015 if (E_NDS_ABI_V0
== abi
)
3017 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3018 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3019 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3020 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3026 case E_NDS_ARCH_STAR_V1_0
:
3027 case E_NDS_ARCH_STAR_V2_0
:
3028 case E_NDS_ARCH_STAR_V3_0
:
3029 case E_NDS_ARCH_STAR_V3_M
:
3030 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3034 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3035 /* ARCH version determines how the e_flags are interpreted.
3036 If it is unknown, we cannot proceed. */
3040 /* Newer ABI; Now handle architecture specific flags. */
3041 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3043 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3044 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3046 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3047 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3049 if (config
& E_NDS32_HAS_DIV_INST
)
3050 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3052 if (config
& E_NDS32_HAS_16BIT_INST
)
3053 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3057 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3059 if (version
<= E_NDS32_ELF_VER_1_3
)
3060 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3062 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3065 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3066 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3068 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3069 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3071 if (config
& E_NDS32_HAS_16BIT_INST
)
3073 if (version
<= E_NDS32_ELF_VER_1_3
)
3074 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3076 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3080 if (config
& E_NDS32_HAS_EXT_INST
)
3081 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3083 if (config
& E_NDS32_HAS_EXT2_INST
)
3084 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3086 if (config
& E_NDS32_HAS_FPU_INST
)
3089 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3092 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3095 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3098 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3101 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3106 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3108 case E_NDS32_FPU_REG_8SP_4DP
:
3109 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3111 case E_NDS32_FPU_REG_16SP_8DP
:
3112 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3114 case E_NDS32_FPU_REG_32SP_16DP
:
3115 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3117 case E_NDS32_FPU_REG_32SP_32DP
:
3118 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3123 if (config
& E_NDS32_HAS_AUDIO_INST
)
3124 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3126 if (config
& E_NDS32_HAS_STRING_INST
)
3127 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3129 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3130 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3132 if (config
& E_NDS32_HAS_VIDEO_INST
)
3134 if (version
<= E_NDS32_ELF_VER_1_3
)
3135 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3137 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3140 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3141 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3143 if (config
& E_NDS32_HAS_L2C_INST
)
3144 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3148 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3150 static char buf
[1024];
3161 case EM_ARC_COMPACT2
:
3162 case EM_ARC_COMPACT
:
3163 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3167 decode_ARM_machine_flags (e_flags
, buf
);
3171 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3175 if (e_flags
& EF_BFIN_PIC
)
3176 strcat (buf
, ", PIC");
3178 if (e_flags
& EF_BFIN_FDPIC
)
3179 strcat (buf
, ", FDPIC");
3181 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3182 strcat (buf
, ", code in L1");
3184 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3185 strcat (buf
, ", data in L1");
3190 switch (e_flags
& EF_FRV_CPU_MASK
)
3192 case EF_FRV_CPU_GENERIC
:
3196 strcat (buf
, ", fr???");
3199 case EF_FRV_CPU_FR300
:
3200 strcat (buf
, ", fr300");
3203 case EF_FRV_CPU_FR400
:
3204 strcat (buf
, ", fr400");
3206 case EF_FRV_CPU_FR405
:
3207 strcat (buf
, ", fr405");
3210 case EF_FRV_CPU_FR450
:
3211 strcat (buf
, ", fr450");
3214 case EF_FRV_CPU_FR500
:
3215 strcat (buf
, ", fr500");
3217 case EF_FRV_CPU_FR550
:
3218 strcat (buf
, ", fr550");
3221 case EF_FRV_CPU_SIMPLE
:
3222 strcat (buf
, ", simple");
3224 case EF_FRV_CPU_TOMCAT
:
3225 strcat (buf
, ", tomcat");
3231 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3232 strcat (buf
, ", m68000");
3233 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3234 strcat (buf
, ", cpu32");
3235 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3236 strcat (buf
, ", fido_a");
3239 char const * isa
= _("unknown");
3240 char const * mac
= _("unknown mac");
3241 char const * additional
= NULL
;
3243 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3245 case EF_M68K_CF_ISA_A_NODIV
:
3247 additional
= ", nodiv";
3249 case EF_M68K_CF_ISA_A
:
3252 case EF_M68K_CF_ISA_A_PLUS
:
3255 case EF_M68K_CF_ISA_B_NOUSP
:
3257 additional
= ", nousp";
3259 case EF_M68K_CF_ISA_B
:
3262 case EF_M68K_CF_ISA_C
:
3265 case EF_M68K_CF_ISA_C_NODIV
:
3267 additional
= ", nodiv";
3270 strcat (buf
, ", cf, isa ");
3273 strcat (buf
, additional
);
3274 if (e_flags
& EF_M68K_CF_FLOAT
)
3275 strcat (buf
, ", float");
3276 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3281 case EF_M68K_CF_MAC
:
3284 case EF_M68K_CF_EMAC
:
3287 case EF_M68K_CF_EMAC_B
:
3300 switch (e_flags
& EF_MEP_CPU_MASK
)
3302 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3303 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3304 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3305 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3306 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3307 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3308 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3311 switch (e_flags
& EF_MEP_COP_MASK
)
3313 case EF_MEP_COP_NONE
: break;
3314 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3315 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3316 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3317 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3318 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3321 if (e_flags
& EF_MEP_LIBRARY
)
3322 strcat (buf
, ", Built for Library");
3324 if (e_flags
& EF_MEP_INDEX_MASK
)
3325 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3326 e_flags
& EF_MEP_INDEX_MASK
);
3328 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3329 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3330 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3334 if (e_flags
& EF_PPC_EMB
)
3335 strcat (buf
, ", emb");
3337 if (e_flags
& EF_PPC_RELOCATABLE
)
3338 strcat (buf
, _(", relocatable"));
3340 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3341 strcat (buf
, _(", relocatable-lib"));
3345 if (e_flags
& EF_PPC64_ABI
)
3347 char abi
[] = ", abiv0";
3349 abi
[6] += e_flags
& EF_PPC64_ABI
;
3355 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3356 strcat (buf
, ", RH850 ABI");
3358 if (e_flags
& EF_V800_850E3
)
3359 strcat (buf
, ", V3 architecture");
3361 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3362 strcat (buf
, ", FPU not used");
3364 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3365 strcat (buf
, ", regmode: COMMON");
3367 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3368 strcat (buf
, ", r4 not used");
3370 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3371 strcat (buf
, ", r30 not used");
3373 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3374 strcat (buf
, ", r5 not used");
3376 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3377 strcat (buf
, ", r2 not used");
3379 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3381 switch (e_flags
& - e_flags
)
3383 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3384 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3385 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3386 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3387 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3388 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3389 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3390 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3391 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3392 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3393 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3394 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3401 case EM_CYGNUS_V850
:
3402 switch (e_flags
& EF_V850_ARCH
)
3404 case E_V850E3V5_ARCH
:
3405 strcat (buf
, ", v850e3v5");
3407 case E_V850E2V3_ARCH
:
3408 strcat (buf
, ", v850e2v3");
3411 strcat (buf
, ", v850e2");
3414 strcat (buf
, ", v850e1");
3417 strcat (buf
, ", v850e");
3420 strcat (buf
, ", v850");
3423 strcat (buf
, _(", unknown v850 architecture variant"));
3429 case EM_CYGNUS_M32R
:
3430 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3431 strcat (buf
, ", m32r");
3435 case EM_MIPS_RS3_LE
:
3436 if (e_flags
& EF_MIPS_NOREORDER
)
3437 strcat (buf
, ", noreorder");
3439 if (e_flags
& EF_MIPS_PIC
)
3440 strcat (buf
, ", pic");
3442 if (e_flags
& EF_MIPS_CPIC
)
3443 strcat (buf
, ", cpic");
3445 if (e_flags
& EF_MIPS_UCODE
)
3446 strcat (buf
, ", ugen_reserved");
3448 if (e_flags
& EF_MIPS_ABI2
)
3449 strcat (buf
, ", abi2");
3451 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3452 strcat (buf
, ", odk first");
3454 if (e_flags
& EF_MIPS_32BITMODE
)
3455 strcat (buf
, ", 32bitmode");
3457 if (e_flags
& EF_MIPS_NAN2008
)
3458 strcat (buf
, ", nan2008");
3460 if (e_flags
& EF_MIPS_FP64
)
3461 strcat (buf
, ", fp64");
3463 switch ((e_flags
& EF_MIPS_MACH
))
3465 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3466 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3467 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3468 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3469 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3470 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3471 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3472 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3473 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3474 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3475 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3476 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3477 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3478 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3479 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3480 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3481 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3482 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3483 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3484 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3485 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3487 /* We simply ignore the field in this case to avoid confusion:
3488 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3491 default: strcat (buf
, _(", unknown CPU")); break;
3494 switch ((e_flags
& EF_MIPS_ABI
))
3496 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3497 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3498 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3499 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3501 /* We simply ignore the field in this case to avoid confusion:
3502 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3503 This means it is likely to be an o32 file, but not for
3506 default: strcat (buf
, _(", unknown ABI")); break;
3509 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3510 strcat (buf
, ", mdmx");
3512 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3513 strcat (buf
, ", mips16");
3515 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3516 strcat (buf
, ", micromips");
3518 switch ((e_flags
& EF_MIPS_ARCH
))
3520 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3521 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3522 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3523 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3524 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3525 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3526 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3527 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3528 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3529 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3530 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3531 default: strcat (buf
, _(", unknown ISA")); break;
3536 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3540 switch (EF_NFP_MACH (e_flags
))
3542 case E_NFP_MACH_3200
:
3543 strcat (buf
, ", NFP-32xx");
3545 case E_NFP_MACH_6000
:
3546 strcat (buf
, ", NFP-6xxx");
3552 if (e_flags
& EF_RISCV_RVC
)
3553 strcat (buf
, ", RVC");
3555 if (e_flags
& EF_RISCV_RVE
)
3556 strcat (buf
, ", RVE");
3558 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3560 case EF_RISCV_FLOAT_ABI_SOFT
:
3561 strcat (buf
, ", soft-float ABI");
3564 case EF_RISCV_FLOAT_ABI_SINGLE
:
3565 strcat (buf
, ", single-float ABI");
3568 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3569 strcat (buf
, ", double-float ABI");
3572 case EF_RISCV_FLOAT_ABI_QUAD
:
3573 strcat (buf
, ", quad-float ABI");
3579 switch ((e_flags
& EF_SH_MACH_MASK
))
3581 case EF_SH1
: strcat (buf
, ", sh1"); break;
3582 case EF_SH2
: strcat (buf
, ", sh2"); break;
3583 case EF_SH3
: strcat (buf
, ", sh3"); break;
3584 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3585 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3586 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3587 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3588 case EF_SH4
: strcat (buf
, ", sh4"); break;
3589 case EF_SH5
: strcat (buf
, ", sh5"); break;
3590 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3591 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3592 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3593 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3594 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3595 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3596 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3597 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3598 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3599 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3600 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3601 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3602 default: strcat (buf
, _(", unknown ISA")); break;
3605 if (e_flags
& EF_SH_PIC
)
3606 strcat (buf
, ", pic");
3608 if (e_flags
& EF_SH_FDPIC
)
3609 strcat (buf
, ", fdpic");
3613 if (e_flags
& EF_OR1K_NODELAY
)
3614 strcat (buf
, ", no delay");
3618 if (e_flags
& EF_SPARC_32PLUS
)
3619 strcat (buf
, ", v8+");
3621 if (e_flags
& EF_SPARC_SUN_US1
)
3622 strcat (buf
, ", ultrasparcI");
3624 if (e_flags
& EF_SPARC_SUN_US3
)
3625 strcat (buf
, ", ultrasparcIII");
3627 if (e_flags
& EF_SPARC_HAL_R1
)
3628 strcat (buf
, ", halr1");
3630 if (e_flags
& EF_SPARC_LEDATA
)
3631 strcat (buf
, ", ledata");
3633 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3634 strcat (buf
, ", tso");
3636 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3637 strcat (buf
, ", pso");
3639 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3640 strcat (buf
, ", rmo");
3644 switch (e_flags
& EF_PARISC_ARCH
)
3646 case EFA_PARISC_1_0
:
3647 strcpy (buf
, ", PA-RISC 1.0");
3649 case EFA_PARISC_1_1
:
3650 strcpy (buf
, ", PA-RISC 1.1");
3652 case EFA_PARISC_2_0
:
3653 strcpy (buf
, ", PA-RISC 2.0");
3658 if (e_flags
& EF_PARISC_TRAPNIL
)
3659 strcat (buf
, ", trapnil");
3660 if (e_flags
& EF_PARISC_EXT
)
3661 strcat (buf
, ", ext");
3662 if (e_flags
& EF_PARISC_LSB
)
3663 strcat (buf
, ", lsb");
3664 if (e_flags
& EF_PARISC_WIDE
)
3665 strcat (buf
, ", wide");
3666 if (e_flags
& EF_PARISC_NO_KABP
)
3667 strcat (buf
, ", no kabp");
3668 if (e_flags
& EF_PARISC_LAZYSWAP
)
3669 strcat (buf
, ", lazyswap");
3674 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3675 strcat (buf
, ", new calling convention");
3677 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3678 strcat (buf
, ", gnu calling convention");
3682 if ((e_flags
& EF_IA_64_ABI64
))
3683 strcat (buf
, ", 64-bit");
3685 strcat (buf
, ", 32-bit");
3686 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3687 strcat (buf
, ", reduced fp model");
3688 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3689 strcat (buf
, ", no function descriptors, constant gp");
3690 else if ((e_flags
& EF_IA_64_CONS_GP
))
3691 strcat (buf
, ", constant gp");
3692 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3693 strcat (buf
, ", absolute");
3694 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3696 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3697 strcat (buf
, ", vms_linkages");
3698 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3700 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3702 case EF_IA_64_VMS_COMCOD_WARNING
:
3703 strcat (buf
, ", warning");
3705 case EF_IA_64_VMS_COMCOD_ERROR
:
3706 strcat (buf
, ", error");
3708 case EF_IA_64_VMS_COMCOD_ABORT
:
3709 strcat (buf
, ", abort");
3712 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3713 e_flags
& EF_IA_64_VMS_COMCOD
);
3714 strcat (buf
, ", <unknown>");
3720 if ((e_flags
& EF_VAX_NONPIC
))
3721 strcat (buf
, ", non-PIC");
3722 if ((e_flags
& EF_VAX_DFLOAT
))
3723 strcat (buf
, ", D-Float");
3724 if ((e_flags
& EF_VAX_GFLOAT
))
3725 strcat (buf
, ", G-Float");
3729 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3730 strcat (buf
, ", mcm");
3731 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3732 strcat (buf
, ", mcm24");
3733 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3734 strcat (buf
, ", gr6");
3738 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3740 case E_FLAG_RL78_ANY_CPU
: break;
3741 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3742 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3743 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3745 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3746 strcat (buf
, ", 64-bit doubles");
3750 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3751 strcat (buf
, ", 64-bit doubles");
3752 if (e_flags
& E_FLAG_RX_DSP
)
3753 strcat (buf
, ", dsp");
3754 if (e_flags
& E_FLAG_RX_PID
)
3755 strcat (buf
, ", pid");
3756 if (e_flags
& E_FLAG_RX_ABI
)
3757 strcat (buf
, ", RX ABI");
3758 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3759 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3760 ? ", uses String instructions" : ", bans String instructions");
3761 if (e_flags
& E_FLAG_RX_V2
)
3762 strcat (buf
, ", V2");
3763 if (e_flags
& E_FLAG_RX_V3
)
3764 strcat (buf
, ", V3");
3768 if (e_flags
& EF_S390_HIGH_GPRS
)
3769 strcat (buf
, ", highgprs");
3773 if ((e_flags
& EF_C6000_REL
))
3774 strcat (buf
, ", relocatable module");
3778 strcat (buf
, _(": architecture variant: "));
3779 switch (e_flags
& EF_MSP430_MACH
)
3781 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3782 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3783 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3784 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3785 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3786 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3787 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3788 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3789 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3790 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3791 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3792 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3793 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3794 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3795 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3797 strcat (buf
, _(": unknown")); break;
3800 if (e_flags
& ~ EF_MSP430_MACH
)
3801 strcat (buf
, _(": unknown extra flag bits also present"));
3805 switch (e_flags
& EF_Z80_MACH_MSK
)
3807 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3808 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3809 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3810 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3811 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3812 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3813 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3815 strcat (buf
, _(", unknown")); break;
3825 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3827 static char buff
[32];
3831 case ELFOSABI_NONE
: return "UNIX - System V";
3832 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3833 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3834 case ELFOSABI_GNU
: return "UNIX - GNU";
3835 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3836 case ELFOSABI_AIX
: return "UNIX - AIX";
3837 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3838 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3839 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3840 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3841 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3842 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3843 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3844 case ELFOSABI_AROS
: return "AROS";
3845 case ELFOSABI_FENIXOS
: return "FenixOS";
3846 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3847 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3850 switch (filedata
->file_header
.e_machine
)
3855 case ELFOSABI_ARM
: return "ARM";
3856 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3867 case ELFOSABI_STANDALONE
: return _("Standalone App");
3876 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3877 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3886 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3892 get_aarch64_segment_type (unsigned long type
)
3896 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3897 default: return NULL
;
3902 get_arm_segment_type (unsigned long type
)
3906 case PT_ARM_EXIDX
: return "EXIDX";
3907 default: return NULL
;
3912 get_s390_segment_type (unsigned long type
)
3916 case PT_S390_PGSTE
: return "S390_PGSTE";
3917 default: return NULL
;
3922 get_mips_segment_type (unsigned long type
)
3926 case PT_MIPS_REGINFO
: return "REGINFO";
3927 case PT_MIPS_RTPROC
: return "RTPROC";
3928 case PT_MIPS_OPTIONS
: return "OPTIONS";
3929 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3930 default: return NULL
;
3935 get_parisc_segment_type (unsigned long type
)
3939 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3940 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3941 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3942 default: return NULL
;
3947 get_ia64_segment_type (unsigned long type
)
3951 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3952 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3953 default: return NULL
;
3958 get_tic6x_segment_type (unsigned long type
)
3962 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3963 default: return NULL
;
3968 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3970 if (e_machine
== EM_PARISC
)
3973 case PT_HP_TLS
: return "HP_TLS";
3974 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3975 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3976 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3977 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3978 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3979 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3980 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3981 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3982 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3983 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3984 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3985 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3986 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3987 case PT_HP_STACK
: return "HP_STACK";
3988 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3989 default: return NULL
;
3992 if (e_machine
== EM_IA_64
)
3995 case PT_HP_TLS
: return "HP_TLS";
3996 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3997 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3998 case PT_IA_64_HP_STACK
: return "HP_STACK";
3999 default: return NULL
;
4006 get_solaris_segment_type (unsigned long type
)
4010 case 0x6464e550: return "PT_SUNW_UNWIND";
4011 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4012 case 0x6ffffff7: return "PT_LOSUNW";
4013 case 0x6ffffffa: return "PT_SUNWBSS";
4014 case 0x6ffffffb: return "PT_SUNWSTACK";
4015 case 0x6ffffffc: return "PT_SUNWDTRACE";
4016 case 0x6ffffffd: return "PT_SUNWCAP";
4017 case 0x6fffffff: return "PT_HISUNW";
4018 default: return NULL
;
4023 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4025 static char buff
[32];
4029 case PT_NULL
: return "NULL";
4030 case PT_LOAD
: return "LOAD";
4031 case PT_DYNAMIC
: return "DYNAMIC";
4032 case PT_INTERP
: return "INTERP";
4033 case PT_NOTE
: return "NOTE";
4034 case PT_SHLIB
: return "SHLIB";
4035 case PT_PHDR
: return "PHDR";
4036 case PT_TLS
: return "TLS";
4037 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4038 case PT_GNU_STACK
: return "GNU_STACK";
4039 case PT_GNU_RELRO
: return "GNU_RELRO";
4040 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4043 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4045 const char * result
;
4047 switch (filedata
->file_header
.e_machine
)
4050 result
= get_aarch64_segment_type (p_type
);
4053 result
= get_arm_segment_type (p_type
);
4056 case EM_MIPS_RS3_LE
:
4057 result
= get_mips_segment_type (p_type
);
4060 result
= get_parisc_segment_type (p_type
);
4063 result
= get_ia64_segment_type (p_type
);
4066 result
= get_tic6x_segment_type (p_type
);
4070 result
= get_s390_segment_type (p_type
);
4080 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4082 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4084 const char * result
= NULL
;
4086 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4089 case ELFOSABI_FREEBSD
:
4090 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4092 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4097 result
= get_hpux_segment_type (p_type
,
4098 filedata
->file_header
.e_machine
);
4100 case ELFOSABI_SOLARIS
:
4101 result
= get_solaris_segment_type (p_type
);
4109 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4112 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4119 get_arc_section_type_name (unsigned int sh_type
)
4123 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4131 get_mips_section_type_name (unsigned int sh_type
)
4135 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4136 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4137 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4138 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4139 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4140 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4141 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4142 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4143 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4144 case SHT_MIPS_RELD
: return "MIPS_RELD";
4145 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4146 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4147 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4148 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4149 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4150 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4151 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4152 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4153 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4154 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4155 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4156 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4157 case SHT_MIPS_LINE
: return "MIPS_LINE";
4158 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4159 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4160 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4161 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4162 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4163 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4164 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4165 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4166 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4167 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4168 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4169 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4170 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4171 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4172 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4173 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4174 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4175 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4183 get_parisc_section_type_name (unsigned int sh_type
)
4187 case SHT_PARISC_EXT
: return "PARISC_EXT";
4188 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4189 case SHT_PARISC_DOC
: return "PARISC_DOC";
4190 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4191 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4192 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4193 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4194 default: return NULL
;
4199 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4201 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4202 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4203 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4207 case SHT_IA_64_EXT
: return "IA_64_EXT";
4208 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4209 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4210 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4211 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4212 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4213 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4214 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4215 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4216 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4224 get_x86_64_section_type_name (unsigned int sh_type
)
4228 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4229 default: return NULL
;
4234 get_aarch64_section_type_name (unsigned int sh_type
)
4238 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4239 default: return NULL
;
4244 get_arm_section_type_name (unsigned int sh_type
)
4248 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4249 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4250 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4251 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4252 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4253 default: return NULL
;
4258 get_tic6x_section_type_name (unsigned int sh_type
)
4262 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4263 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4264 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4265 case SHT_TI_ICODE
: return "TI_ICODE";
4266 case SHT_TI_XREF
: return "TI_XREF";
4267 case SHT_TI_HANDLER
: return "TI_HANDLER";
4268 case SHT_TI_INITINFO
: return "TI_INITINFO";
4269 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4270 default: return NULL
;
4275 get_msp430x_section_type_name (unsigned int sh_type
)
4279 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4280 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4281 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4282 default: return NULL
;
4287 get_nfp_section_type_name (unsigned int sh_type
)
4291 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4292 case SHT_NFP_INITREG
: return "NFP_INITREG";
4293 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4294 default: return NULL
;
4299 get_v850_section_type_name (unsigned int sh_type
)
4303 case SHT_V850_SCOMMON
: return "V850 Small Common";
4304 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4305 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4306 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4307 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4308 default: return NULL
;
4313 get_riscv_section_type_name (unsigned int sh_type
)
4317 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4318 default: return NULL
;
4323 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4325 static char buff
[32];
4326 const char * result
;
4330 case SHT_NULL
: return "NULL";
4331 case SHT_PROGBITS
: return "PROGBITS";
4332 case SHT_SYMTAB
: return "SYMTAB";
4333 case SHT_STRTAB
: return "STRTAB";
4334 case SHT_RELA
: return "RELA";
4335 case SHT_HASH
: return "HASH";
4336 case SHT_DYNAMIC
: return "DYNAMIC";
4337 case SHT_NOTE
: return "NOTE";
4338 case SHT_NOBITS
: return "NOBITS";
4339 case SHT_REL
: return "REL";
4340 case SHT_SHLIB
: return "SHLIB";
4341 case SHT_DYNSYM
: return "DYNSYM";
4342 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4343 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4344 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4345 case SHT_GNU_HASH
: return "GNU_HASH";
4346 case SHT_GROUP
: return "GROUP";
4347 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4348 case SHT_GNU_verdef
: return "VERDEF";
4349 case SHT_GNU_verneed
: return "VERNEED";
4350 case SHT_GNU_versym
: return "VERSYM";
4351 case 0x6ffffff0: return "VERSYM";
4352 case 0x6ffffffc: return "VERDEF";
4353 case 0x7ffffffd: return "AUXILIARY";
4354 case 0x7fffffff: return "FILTER";
4355 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4358 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4360 switch (filedata
->file_header
.e_machine
)
4363 case EM_ARC_COMPACT
:
4364 case EM_ARC_COMPACT2
:
4365 result
= get_arc_section_type_name (sh_type
);
4368 case EM_MIPS_RS3_LE
:
4369 result
= get_mips_section_type_name (sh_type
);
4372 result
= get_parisc_section_type_name (sh_type
);
4375 result
= get_ia64_section_type_name (filedata
, sh_type
);
4380 result
= get_x86_64_section_type_name (sh_type
);
4383 result
= get_aarch64_section_type_name (sh_type
);
4386 result
= get_arm_section_type_name (sh_type
);
4389 result
= get_tic6x_section_type_name (sh_type
);
4392 result
= get_msp430x_section_type_name (sh_type
);
4395 result
= get_nfp_section_type_name (sh_type
);
4399 case EM_CYGNUS_V850
:
4400 result
= get_v850_section_type_name (sh_type
);
4403 result
= get_riscv_section_type_name (sh_type
);
4413 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4415 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4417 switch (filedata
->file_header
.e_machine
)
4420 result
= get_ia64_section_type_name (filedata
, sh_type
);
4423 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4424 result
= get_solaris_section_type (sh_type
);
4429 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4430 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4431 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4432 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4444 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4446 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4448 switch (filedata
->file_header
.e_machine
)
4452 case EM_CYGNUS_V850
:
4453 result
= get_v850_section_type_name (sh_type
);
4463 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4466 /* This message is probably going to be displayed in a 15
4467 character wide field, so put the hex value first. */
4468 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4474 #define OPTION_DEBUG_DUMP 512
4475 #define OPTION_DYN_SYMS 513
4476 #define OPTION_DWARF_DEPTH 514
4477 #define OPTION_DWARF_START 515
4478 #define OPTION_DWARF_CHECK 516
4479 #define OPTION_CTF_DUMP 517
4480 #define OPTION_CTF_PARENT 518
4481 #define OPTION_CTF_SYMBOLS 519
4482 #define OPTION_CTF_STRINGS 520
4484 static struct option options
[] =
4486 {"all", no_argument
, 0, 'a'},
4487 {"file-header", no_argument
, 0, 'h'},
4488 {"program-headers", no_argument
, 0, 'l'},
4489 {"headers", no_argument
, 0, 'e'},
4490 {"histogram", no_argument
, 0, 'I'},
4491 {"segments", no_argument
, 0, 'l'},
4492 {"sections", no_argument
, 0, 'S'},
4493 {"section-headers", no_argument
, 0, 'S'},
4494 {"section-groups", no_argument
, 0, 'g'},
4495 {"section-details", no_argument
, 0, 't'},
4496 {"full-section-name",no_argument
, 0, 'N'},
4497 {"symbols", no_argument
, 0, 's'},
4498 {"syms", no_argument
, 0, 's'},
4499 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4500 {"relocs", no_argument
, 0, 'r'},
4501 {"notes", no_argument
, 0, 'n'},
4502 {"dynamic", no_argument
, 0, 'd'},
4503 {"lint", no_argument
, 0, 'L'},
4504 {"enable-checks", no_argument
, 0, 'L'},
4505 {"arch-specific", no_argument
, 0, 'A'},
4506 {"version-info", no_argument
, 0, 'V'},
4507 {"use-dynamic", no_argument
, 0, 'D'},
4508 {"unwind", no_argument
, 0, 'u'},
4509 {"archive-index", no_argument
, 0, 'c'},
4510 {"hex-dump", required_argument
, 0, 'x'},
4511 {"relocated-dump", required_argument
, 0, 'R'},
4512 {"string-dump", required_argument
, 0, 'p'},
4513 {"decompress", no_argument
, 0, 'z'},
4514 #ifdef SUPPORT_DISASSEMBLY
4515 {"instruction-dump", required_argument
, 0, 'i'},
4517 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4519 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4520 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4521 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4523 #ifdef ENABLE_LIBCTF
4524 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4526 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4527 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4528 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4531 {"version", no_argument
, 0, 'v'},
4532 {"wide", no_argument
, 0, 'W'},
4533 {"silent-truncation",no_argument
, 0, 'T'},
4534 {"help", no_argument
, 0, 'H'},
4535 {0, no_argument
, 0, 0}
4539 usage (FILE * stream
)
4541 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4542 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4543 fprintf (stream
, _(" Options are:\n\
4544 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4545 -h --file-header Display the ELF file header\n\
4546 -l --program-headers Display the program headers\n\
4547 --segments An alias for --program-headers\n\
4548 -S --section-headers Display the sections' header\n\
4549 --sections An alias for --section-headers\n\
4550 -g --section-groups Display the section groups\n\
4551 -t --section-details Display the section details\n\
4552 -e --headers Equivalent to: -h -l -S\n\
4553 -s --syms Display the symbol table\n\
4554 --symbols An alias for --syms\n\
4555 --dyn-syms Display the dynamic symbol table\n\
4556 -n --notes Display the core notes (if present)\n\
4557 -r --relocs Display the relocations (if present)\n\
4558 -u --unwind Display the unwind info (if present)\n\
4559 -d --dynamic Display the dynamic section (if present)\n\
4560 -V --version-info Display the version sections (if present)\n\
4561 -A --arch-specific Display architecture specific information (if any)\n\
4562 -c --archive-index Display the symbol/file index in an archive\n\
4563 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4564 -L --lint|--enable-checks Display warning messages for possible problems\n\
4565 -x --hex-dump=<number|name>\n\
4566 Dump the contents of section <number|name> as bytes\n\
4567 -p --string-dump=<number|name>\n\
4568 Dump the contents of section <number|name> as strings\n\
4569 -R --relocated-dump=<number|name>\n\
4570 Dump the contents of section <number|name> as relocated bytes\n\
4571 -z --decompress Decompress section before dumping it\n\
4572 -w[lLiaprmfFsoORtUuTgAckK] or\n\
4573 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4574 =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
4575 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4576 =addr,=cu_index,=links,=follow-links]\n\
4577 Display the contents of DWARF debug sections\n"));
4578 fprintf (stream
, _("\
4579 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4580 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4582 #ifdef ENABLE_LIBCTF
4583 fprintf (stream
, _("\
4584 --ctf=<number|name> Display CTF info from section <number|name>\n\
4585 --ctf-parent=<number|name>\n\
4586 Use section <number|name> as the CTF parent\n\n\
4587 --ctf-symbols=<number|name>\n\
4588 Use section <number|name> as the CTF external symtab\n\n\
4589 --ctf-strings=<number|name>\n\
4590 Use section <number|name> as the CTF external strtab\n\n"));
4593 #ifdef SUPPORT_DISASSEMBLY
4594 fprintf (stream
, _("\
4595 -i --instruction-dump=<number|name>\n\
4596 Disassemble the contents of section <number|name>\n"));
4598 fprintf (stream
, _("\
4599 -I --histogram Display histogram of bucket list lengths\n\
4600 -W --wide Allow output width to exceed 80 characters\n\
4601 -T --silent-truncation If a symbol name is truncated, do not add a suffix [...]\n\
4602 @<file> Read options from <file>\n\
4603 -H --help Display this information\n\
4604 -v --version Display the version number of readelf\n"));
4606 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4607 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4609 exit (stream
== stdout
? 0 : 1);
4612 /* Record the fact that the user wants the contents of section number
4613 SECTION to be displayed using the method(s) encoded as flags bits
4614 in TYPE. Note, TYPE can be zero if we are creating the array for
4618 request_dump_bynumber (struct dump_data
*dumpdata
,
4619 unsigned int section
, dump_type type
)
4621 if (section
>= dumpdata
->num_dump_sects
)
4623 dump_type
* new_dump_sects
;
4625 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4626 sizeof (* new_dump_sects
));
4628 if (new_dump_sects
== NULL
)
4629 error (_("Out of memory allocating dump request table.\n"));
4632 if (dumpdata
->dump_sects
)
4634 /* Copy current flag settings. */
4635 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4636 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4638 free (dumpdata
->dump_sects
);
4641 dumpdata
->dump_sects
= new_dump_sects
;
4642 dumpdata
->num_dump_sects
= section
+ 1;
4646 if (dumpdata
->dump_sects
)
4647 dumpdata
->dump_sects
[section
] |= type
;
4650 /* Request a dump by section name. */
4653 request_dump_byname (const char * section
, dump_type type
)
4655 struct dump_list_entry
* new_request
;
4657 new_request
= (struct dump_list_entry
*)
4658 malloc (sizeof (struct dump_list_entry
));
4660 error (_("Out of memory allocating dump request table.\n"));
4662 new_request
->name
= strdup (section
);
4663 if (!new_request
->name
)
4664 error (_("Out of memory allocating dump request table.\n"));
4666 new_request
->type
= type
;
4668 new_request
->next
= dump_sects_byname
;
4669 dump_sects_byname
= new_request
;
4673 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4679 section
= strtoul (optarg
, & cp
, 0);
4681 if (! *cp
&& section
>= 0)
4682 request_dump_bynumber (dumpdata
, section
, type
);
4684 request_dump_byname (optarg
, type
);
4688 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4695 while ((c
= getopt_long
4696 (argc
, argv
, "ADHILNR:STVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4714 do_section_groups
= TRUE
;
4717 do_histogram
= TRUE
;
4722 do_section_groups
= TRUE
;
4727 do_section_details
= TRUE
;
4738 do_using_dynamic
= TRUE
;
4762 do_histogram
= TRUE
;
4768 do_archive_index
= TRUE
;
4774 request_dump (dumpdata
, HEX_DUMP
);
4777 request_dump (dumpdata
, STRING_DUMP
);
4780 request_dump (dumpdata
, RELOC_DUMP
);
4783 decompress_dumps
= TRUE
;
4789 do_debugging
= TRUE
;
4790 dwarf_select_sections_all ();
4794 do_debugging
= FALSE
;
4795 dwarf_select_sections_by_letters (optarg
);
4798 case OPTION_DEBUG_DUMP
:
4801 do_debugging
= TRUE
;
4804 do_debugging
= FALSE
;
4805 dwarf_select_sections_by_names (optarg
);
4808 case OPTION_DWARF_DEPTH
:
4812 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4815 case OPTION_DWARF_START
:
4819 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4822 case OPTION_DWARF_CHECK
:
4825 case OPTION_CTF_DUMP
:
4827 request_dump (dumpdata
, CTF_DUMP
);
4829 case OPTION_CTF_SYMBOLS
:
4830 dump_ctf_symtab_name
= strdup (optarg
);
4832 case OPTION_CTF_STRINGS
:
4833 dump_ctf_strtab_name
= strdup (optarg
);
4835 case OPTION_CTF_PARENT
:
4836 dump_ctf_parent_name
= strdup (optarg
);
4838 case OPTION_DYN_SYMS
:
4841 #ifdef SUPPORT_DISASSEMBLY
4843 request_dump (dumpdata
, DISASS_DUMP
);
4847 print_version (program_name
);
4856 do_not_show_symbol_truncation
= TRUE
;
4859 /* xgettext:c-format */
4860 error (_("Invalid option '-%c'\n"), c
);
4867 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4868 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4869 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4870 && !do_section_groups
&& !do_archive_index
4876 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= TRUE
;
4877 do_segments
= do_header
= do_dump
= do_version
= TRUE
;
4878 do_histogram
= do_debugging
= do_arch
= do_notes
= TRUE
;
4879 do_section_groups
= do_archive_index
= do_dyn_syms
= TRUE
;
4887 get_elf_class (unsigned int elf_class
)
4889 static char buff
[32];
4893 case ELFCLASSNONE
: return _("none");
4894 case ELFCLASS32
: return "ELF32";
4895 case ELFCLASS64
: return "ELF64";
4897 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4903 get_data_encoding (unsigned int encoding
)
4905 static char buff
[32];
4909 case ELFDATANONE
: return _("none");
4910 case ELFDATA2LSB
: return _("2's complement, little endian");
4911 case ELFDATA2MSB
: return _("2's complement, big endian");
4913 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4918 /* Decode the data held in 'filedata->file_header'. */
4921 process_file_header (Filedata
* filedata
)
4923 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4925 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4926 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4927 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4928 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4931 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4935 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4941 printf (_("ELF Header:\n"));
4942 printf (_(" Magic: "));
4943 for (i
= 0; i
< EI_NIDENT
; i
++)
4944 printf ("%2.2x ", header
->e_ident
[i
]);
4946 printf (_(" Class: %s\n"),
4947 get_elf_class (header
->e_ident
[EI_CLASS
]));
4948 printf (_(" Data: %s\n"),
4949 get_data_encoding (header
->e_ident
[EI_DATA
]));
4950 printf (_(" Version: %d%s\n"),
4951 header
->e_ident
[EI_VERSION
],
4952 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4954 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4957 printf (_(" OS/ABI: %s\n"),
4958 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4959 printf (_(" ABI Version: %d\n"),
4960 header
->e_ident
[EI_ABIVERSION
]);
4961 printf (_(" Type: %s\n"),
4962 get_file_type (header
->e_type
));
4963 printf (_(" Machine: %s\n"),
4964 get_machine_name (header
->e_machine
));
4965 printf (_(" Version: 0x%lx\n"),
4968 printf (_(" Entry point address: "));
4969 print_vma (header
->e_entry
, PREFIX_HEX
);
4970 printf (_("\n Start of program headers: "));
4971 print_vma (header
->e_phoff
, DEC
);
4972 printf (_(" (bytes into file)\n Start of section headers: "));
4973 print_vma (header
->e_shoff
, DEC
);
4974 printf (_(" (bytes into file)\n"));
4976 printf (_(" Flags: 0x%lx%s\n"),
4978 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4979 printf (_(" Size of this header: %u (bytes)\n"),
4981 printf (_(" Size of program headers: %u (bytes)\n"),
4982 header
->e_phentsize
);
4983 printf (_(" Number of program headers: %u"),
4985 if (filedata
->section_headers
!= NULL
4986 && header
->e_phnum
== PN_XNUM
4987 && filedata
->section_headers
[0].sh_info
!= 0)
4989 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4990 printf (" (%u)", header
->e_phnum
);
4992 putc ('\n', stdout
);
4993 printf (_(" Size of section headers: %u (bytes)\n"),
4994 header
->e_shentsize
);
4995 printf (_(" Number of section headers: %u"),
4997 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4999 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5000 printf (" (%u)", header
->e_shnum
);
5002 putc ('\n', stdout
);
5003 printf (_(" Section header string table index: %u"),
5004 header
->e_shstrndx
);
5005 if (filedata
->section_headers
!= NULL
5006 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5008 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5009 printf (" (%u)", header
->e_shstrndx
);
5011 if (header
->e_shstrndx
!= SHN_UNDEF
5012 && header
->e_shstrndx
>= header
->e_shnum
)
5014 header
->e_shstrndx
= SHN_UNDEF
;
5015 printf (_(" <corrupt: out of range>"));
5017 putc ('\n', stdout
);
5020 if (filedata
->section_headers
!= NULL
)
5022 if (header
->e_phnum
== PN_XNUM
5023 && filedata
->section_headers
[0].sh_info
!= 0)
5024 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5025 if (header
->e_shnum
== SHN_UNDEF
)
5026 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5027 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5028 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5029 if (header
->e_shstrndx
>= header
->e_shnum
)
5030 header
->e_shstrndx
= SHN_UNDEF
;
5031 free (filedata
->section_headers
);
5032 filedata
->section_headers
= NULL
;
5038 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5039 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5042 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5044 Elf32_External_Phdr
* phdrs
;
5045 Elf32_External_Phdr
* external
;
5046 Elf_Internal_Phdr
* internal
;
5048 unsigned int size
= filedata
->file_header
.e_phentsize
;
5049 unsigned int num
= filedata
->file_header
.e_phnum
;
5051 /* PR binutils/17531: Cope with unexpected section header sizes. */
5052 if (size
== 0 || num
== 0)
5054 if (size
< sizeof * phdrs
)
5056 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5059 if (size
> sizeof * phdrs
)
5060 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5062 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5063 size
, num
, _("program headers"));
5067 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5068 i
< filedata
->file_header
.e_phnum
;
5069 i
++, internal
++, external
++)
5071 internal
->p_type
= BYTE_GET (external
->p_type
);
5072 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5073 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5074 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5075 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5076 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5077 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5078 internal
->p_align
= BYTE_GET (external
->p_align
);
5085 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5086 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5089 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5091 Elf64_External_Phdr
* phdrs
;
5092 Elf64_External_Phdr
* external
;
5093 Elf_Internal_Phdr
* internal
;
5095 unsigned int size
= filedata
->file_header
.e_phentsize
;
5096 unsigned int num
= filedata
->file_header
.e_phnum
;
5098 /* PR binutils/17531: Cope with unexpected section header sizes. */
5099 if (size
== 0 || num
== 0)
5101 if (size
< sizeof * phdrs
)
5103 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5106 if (size
> sizeof * phdrs
)
5107 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5109 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5110 size
, num
, _("program headers"));
5114 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5115 i
< filedata
->file_header
.e_phnum
;
5116 i
++, internal
++, external
++)
5118 internal
->p_type
= BYTE_GET (external
->p_type
);
5119 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5120 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5121 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5122 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5123 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5124 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5125 internal
->p_align
= BYTE_GET (external
->p_align
);
5132 /* Returns TRUE if the program headers were read into `program_headers'. */
5135 get_program_headers (Filedata
* filedata
)
5137 Elf_Internal_Phdr
* phdrs
;
5139 /* Check cache of prior read. */
5140 if (filedata
->program_headers
!= NULL
)
5143 /* Be kind to memory checkers by looking for
5144 e_phnum values which we know must be invalid. */
5145 if (filedata
->file_header
.e_phnum
5146 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5147 >= filedata
->file_size
)
5149 error (_("Too many program headers - %#x - the file is not that big\n"),
5150 filedata
->file_header
.e_phnum
);
5154 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5155 sizeof (Elf_Internal_Phdr
));
5158 error (_("Out of memory reading %u program headers\n"),
5159 filedata
->file_header
.e_phnum
);
5164 ? get_32bit_program_headers (filedata
, phdrs
)
5165 : get_64bit_program_headers (filedata
, phdrs
))
5167 filedata
->program_headers
= phdrs
;
5175 /* Returns TRUE if the program headers were loaded. */
5178 process_program_headers (Filedata
* filedata
)
5180 Elf_Internal_Phdr
* segment
;
5182 Elf_Internal_Phdr
* previous_load
= NULL
;
5184 filedata
->dynamic_addr
= 0;
5185 filedata
->dynamic_size
= 0;
5187 if (filedata
->file_header
.e_phnum
== 0)
5189 /* PR binutils/12467. */
5190 if (filedata
->file_header
.e_phoff
!= 0)
5192 warn (_("possibly corrupt ELF header - it has a non-zero program"
5193 " header offset, but no program headers\n"));
5196 else if (do_segments
)
5197 printf (_("\nThere are no program headers in this file.\n"));
5201 if (do_segments
&& !do_header
)
5203 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5204 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5205 printf (ngettext ("There is %d program header, starting at offset %s\n",
5206 "There are %d program headers, starting at offset %s\n",
5207 filedata
->file_header
.e_phnum
),
5208 filedata
->file_header
.e_phnum
,
5209 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5212 if (! get_program_headers (filedata
))
5217 if (filedata
->file_header
.e_phnum
> 1)
5218 printf (_("\nProgram Headers:\n"));
5220 printf (_("\nProgram Headers:\n"));
5224 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5227 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5231 (_(" Type Offset VirtAddr PhysAddr\n"));
5233 (_(" FileSiz MemSiz Flags Align\n"));
5237 for (i
= 0, segment
= filedata
->program_headers
;
5238 i
< filedata
->file_header
.e_phnum
;
5243 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5247 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5248 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5249 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5250 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5251 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5253 (segment
->p_flags
& PF_R
? 'R' : ' '),
5254 (segment
->p_flags
& PF_W
? 'W' : ' '),
5255 (segment
->p_flags
& PF_X
? 'E' : ' '));
5256 printf ("%#lx", (unsigned long) segment
->p_align
);
5260 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5261 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5264 print_vma (segment
->p_offset
, FULL_HEX
);
5268 print_vma (segment
->p_vaddr
, FULL_HEX
);
5270 print_vma (segment
->p_paddr
, FULL_HEX
);
5273 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5274 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5277 print_vma (segment
->p_filesz
, FULL_HEX
);
5281 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5282 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5285 print_vma (segment
->p_memsz
, FULL_HEX
);
5289 (segment
->p_flags
& PF_R
? 'R' : ' '),
5290 (segment
->p_flags
& PF_W
? 'W' : ' '),
5291 (segment
->p_flags
& PF_X
? 'E' : ' '));
5293 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5294 printf ("%#lx", (unsigned long) segment
->p_align
);
5297 print_vma (segment
->p_align
, PREFIX_HEX
);
5302 print_vma (segment
->p_offset
, FULL_HEX
);
5304 print_vma (segment
->p_vaddr
, FULL_HEX
);
5306 print_vma (segment
->p_paddr
, FULL_HEX
);
5308 print_vma (segment
->p_filesz
, FULL_HEX
);
5310 print_vma (segment
->p_memsz
, FULL_HEX
);
5312 (segment
->p_flags
& PF_R
? 'R' : ' '),
5313 (segment
->p_flags
& PF_W
? 'W' : ' '),
5314 (segment
->p_flags
& PF_X
? 'E' : ' '));
5315 print_vma (segment
->p_align
, PREFIX_HEX
);
5318 putc ('\n', stdout
);
5321 switch (segment
->p_type
)
5324 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5325 required by the ELF standard, several programs, including the Linux
5326 kernel, make use of non-ordered segments. */
5328 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5329 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5331 if (segment
->p_memsz
< segment
->p_filesz
)
5332 error (_("the segment's file size is larger than its memory size\n"));
5333 previous_load
= segment
;
5337 /* PR 20815 - Verify that the program header is loaded into memory. */
5338 if (i
> 0 && previous_load
!= NULL
)
5339 error (_("the PHDR segment must occur before any LOAD segment\n"));
5340 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5344 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5346 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5347 if (load
->p_type
== PT_LOAD
5348 && load
->p_offset
<= segment
->p_offset
5349 && (load
->p_offset
+ load
->p_filesz
5350 >= segment
->p_offset
+ segment
->p_filesz
)
5351 && load
->p_vaddr
<= segment
->p_vaddr
5352 && (load
->p_vaddr
+ load
->p_filesz
5353 >= segment
->p_vaddr
+ segment
->p_filesz
))
5356 if (j
== filedata
->file_header
.e_phnum
)
5357 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5362 if (filedata
->dynamic_addr
)
5363 error (_("more than one dynamic segment\n"));
5365 /* By default, assume that the .dynamic section is the first
5366 section in the DYNAMIC segment. */
5367 filedata
->dynamic_addr
= segment
->p_offset
;
5368 filedata
->dynamic_size
= segment
->p_filesz
;
5370 /* Try to locate the .dynamic section. If there is
5371 a section header table, we can easily locate it. */
5372 if (filedata
->section_headers
!= NULL
)
5374 Elf_Internal_Shdr
* sec
;
5376 sec
= find_section (filedata
, ".dynamic");
5377 if (sec
== NULL
|| sec
->sh_size
== 0)
5379 /* A corresponding .dynamic section is expected, but on
5380 IA-64/OpenVMS it is OK for it to be missing. */
5381 if (!is_ia64_vms (filedata
))
5382 error (_("no .dynamic section in the dynamic segment\n"));
5386 if (sec
->sh_type
== SHT_NOBITS
)
5388 filedata
->dynamic_size
= 0;
5392 filedata
->dynamic_addr
= sec
->sh_offset
;
5393 filedata
->dynamic_size
= sec
->sh_size
;
5395 /* The PT_DYNAMIC segment, which is used by the run-time
5396 loader, should exactly match the .dynamic section. */
5398 && (filedata
->dynamic_addr
!= segment
->p_offset
5399 || filedata
->dynamic_size
!= segment
->p_filesz
))
5401 the .dynamic section is not the same as the dynamic segment\n"));
5404 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5405 segment. Check this after matching against the section headers
5406 so we don't warn on debuginfo file (which have NOBITS .dynamic
5408 if (filedata
->dynamic_addr
> filedata
->file_size
5409 || (filedata
->dynamic_size
5410 > filedata
->file_size
- filedata
->dynamic_addr
))
5412 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5413 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5418 if (fseek (filedata
->handle
,
5419 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5421 error (_("Unable to find program interpreter name\n"));
5425 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5427 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5428 error (_("Internal error: failed to create format string to display program interpreter\n"));
5430 filedata
->program_interpreter
[0] = 0;
5431 if (fscanf (filedata
->handle
, fmt
,
5432 filedata
->program_interpreter
) <= 0)
5433 error (_("Unable to read program interpreter name\n"));
5436 printf (_(" [Requesting program interpreter: %s]\n"),
5437 filedata
->program_interpreter
);
5444 && filedata
->section_headers
!= NULL
5445 && filedata
->string_table
!= NULL
)
5447 printf (_("\n Section to Segment mapping:\n"));
5448 printf (_(" Segment Sections...\n"));
5450 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5453 Elf_Internal_Shdr
* section
;
5455 segment
= filedata
->program_headers
+ i
;
5456 section
= filedata
->section_headers
+ 1;
5458 printf (" %2.2d ", i
);
5460 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5462 if (!ELF_TBSS_SPECIAL (section
, segment
)
5463 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5464 printf ("%s ", printable_section_name (filedata
, section
));
5475 /* Find the file offset corresponding to VMA by using the program headers. */
5478 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5480 Elf_Internal_Phdr
* seg
;
5482 if (! get_program_headers (filedata
))
5484 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5488 for (seg
= filedata
->program_headers
;
5489 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5492 if (seg
->p_type
!= PT_LOAD
)
5495 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5496 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5497 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5500 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5501 (unsigned long) vma
);
5506 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5507 If PROBE is true, this is just a probe and we do not generate any error
5508 messages if the load fails. */
5511 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5513 Elf32_External_Shdr
* shdrs
;
5514 Elf_Internal_Shdr
* internal
;
5516 unsigned int size
= filedata
->file_header
.e_shentsize
;
5517 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5519 /* PR binutils/17531: Cope with unexpected section header sizes. */
5520 if (size
== 0 || num
== 0)
5522 if (size
< sizeof * shdrs
)
5525 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5528 if (!probe
&& size
> sizeof * shdrs
)
5529 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5531 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5533 probe
? NULL
: _("section headers"));
5537 free (filedata
->section_headers
);
5538 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5539 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5540 if (filedata
->section_headers
== NULL
)
5543 error (_("Out of memory reading %u section headers\n"), num
);
5548 for (i
= 0, internal
= filedata
->section_headers
;
5552 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5553 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5554 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5555 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5556 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5557 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5558 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5559 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5560 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5561 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5562 if (!probe
&& internal
->sh_link
> num
)
5563 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5564 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5565 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5572 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5575 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5577 Elf64_External_Shdr
* shdrs
;
5578 Elf_Internal_Shdr
* internal
;
5580 unsigned int size
= filedata
->file_header
.e_shentsize
;
5581 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5583 /* PR binutils/17531: Cope with unexpected section header sizes. */
5584 if (size
== 0 || num
== 0)
5587 if (size
< sizeof * shdrs
)
5590 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5594 if (! probe
&& size
> sizeof * shdrs
)
5595 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5597 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5598 filedata
->file_header
.e_shoff
,
5600 probe
? NULL
: _("section headers"));
5604 free (filedata
->section_headers
);
5605 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5606 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5607 if (filedata
->section_headers
== NULL
)
5610 error (_("Out of memory reading %u section headers\n"), num
);
5615 for (i
= 0, internal
= filedata
->section_headers
;
5619 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5620 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5621 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5622 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5623 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5624 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5625 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5626 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5627 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5628 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5629 if (!probe
&& internal
->sh_link
> num
)
5630 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5631 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5632 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5639 static Elf_Internal_Sym
*
5640 get_32bit_elf_symbols (Filedata
* filedata
,
5641 Elf_Internal_Shdr
* section
,
5642 unsigned long * num_syms_return
)
5644 unsigned long number
= 0;
5645 Elf32_External_Sym
* esyms
= NULL
;
5646 Elf_External_Sym_Shndx
* shndx
= NULL
;
5647 Elf_Internal_Sym
* isyms
= NULL
;
5648 Elf_Internal_Sym
* psym
;
5650 elf_section_list
* entry
;
5652 if (section
->sh_size
== 0)
5654 if (num_syms_return
!= NULL
)
5655 * num_syms_return
= 0;
5659 /* Run some sanity checks first. */
5660 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5662 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5663 printable_section_name (filedata
, section
),
5664 (unsigned long) section
->sh_entsize
);
5668 if (section
->sh_size
> filedata
->file_size
)
5670 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5671 printable_section_name (filedata
, section
),
5672 (unsigned long) section
->sh_size
);
5676 number
= section
->sh_size
/ section
->sh_entsize
;
5678 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5680 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5681 (unsigned long) section
->sh_size
,
5682 printable_section_name (filedata
, section
),
5683 (unsigned long) section
->sh_entsize
);
5687 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5688 section
->sh_size
, _("symbols"));
5693 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5695 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5700 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5704 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5705 entry
->hdr
->sh_offset
,
5706 1, entry
->hdr
->sh_size
,
5707 _("symbol table section indices"));
5711 /* PR17531: file: heap-buffer-overflow */
5712 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5714 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5715 printable_section_name (filedata
, entry
->hdr
),
5716 (unsigned long) entry
->hdr
->sh_size
,
5717 (unsigned long) section
->sh_size
);
5722 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5726 error (_("Out of memory reading %lu symbols\n"),
5727 (unsigned long) number
);
5731 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5733 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5734 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5735 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5736 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5737 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5739 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5740 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5741 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5742 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5743 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5750 if (num_syms_return
!= NULL
)
5751 * num_syms_return
= isyms
== NULL
? 0 : number
;
5756 static Elf_Internal_Sym
*
5757 get_64bit_elf_symbols (Filedata
* filedata
,
5758 Elf_Internal_Shdr
* section
,
5759 unsigned long * num_syms_return
)
5761 unsigned long number
= 0;
5762 Elf64_External_Sym
* esyms
= NULL
;
5763 Elf_External_Sym_Shndx
* shndx
= NULL
;
5764 Elf_Internal_Sym
* isyms
= NULL
;
5765 Elf_Internal_Sym
* psym
;
5767 elf_section_list
* entry
;
5769 if (section
->sh_size
== 0)
5771 if (num_syms_return
!= NULL
)
5772 * num_syms_return
= 0;
5776 /* Run some sanity checks first. */
5777 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5779 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5780 printable_section_name (filedata
, section
),
5781 (unsigned long) section
->sh_entsize
);
5785 if (section
->sh_size
> filedata
->file_size
)
5787 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5788 printable_section_name (filedata
, section
),
5789 (unsigned long) section
->sh_size
);
5793 number
= section
->sh_size
/ section
->sh_entsize
;
5795 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5797 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5798 (unsigned long) section
->sh_size
,
5799 printable_section_name (filedata
, section
),
5800 (unsigned long) section
->sh_entsize
);
5804 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5805 section
->sh_size
, _("symbols"));
5810 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5812 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5817 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5821 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5822 entry
->hdr
->sh_offset
,
5823 1, entry
->hdr
->sh_size
,
5824 _("symbol table section indices"));
5828 /* PR17531: file: heap-buffer-overflow */
5829 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5831 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5832 printable_section_name (filedata
, entry
->hdr
),
5833 (unsigned long) entry
->hdr
->sh_size
,
5834 (unsigned long) section
->sh_size
);
5839 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5843 error (_("Out of memory reading %lu symbols\n"),
5844 (unsigned long) number
);
5848 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5850 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5851 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5852 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5853 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5855 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5857 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5858 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5859 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5861 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5862 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5869 if (num_syms_return
!= NULL
)
5870 * num_syms_return
= isyms
== NULL
? 0 : number
;
5876 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5878 static char buff
[1024];
5880 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5882 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5883 bfd_vma os_flags
= 0;
5884 bfd_vma proc_flags
= 0;
5885 bfd_vma unknown_flags
= 0;
5893 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5894 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5895 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5896 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5897 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5898 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5899 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5900 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5901 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5902 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5903 /* IA-64 specific. */
5904 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5905 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5906 /* IA-64 OpenVMS specific. */
5907 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5908 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5909 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5910 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5911 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5912 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5914 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5915 /* SPARC specific. */
5916 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5917 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5919 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5920 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5921 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5923 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5925 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5928 if (do_section_details
)
5930 sprintf (buff
, "[%*.*lx]: ",
5931 field_size
, field_size
, (unsigned long) sh_flags
);
5932 p
+= field_size
+ 4;
5939 flag
= sh_flags
& - sh_flags
;
5942 if (do_section_details
)
5946 case SHF_WRITE
: sindex
= 0; break;
5947 case SHF_ALLOC
: sindex
= 1; break;
5948 case SHF_EXECINSTR
: sindex
= 2; break;
5949 case SHF_MERGE
: sindex
= 3; break;
5950 case SHF_STRINGS
: sindex
= 4; break;
5951 case SHF_INFO_LINK
: sindex
= 5; break;
5952 case SHF_LINK_ORDER
: sindex
= 6; break;
5953 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5954 case SHF_GROUP
: sindex
= 8; break;
5955 case SHF_TLS
: sindex
= 9; break;
5956 case SHF_EXCLUDE
: sindex
= 18; break;
5957 case SHF_COMPRESSED
: sindex
= 20; break;
5958 case SHF_GNU_MBIND
: sindex
= 24; break;
5962 switch (filedata
->file_header
.e_machine
)
5965 if (flag
== SHF_IA_64_SHORT
)
5967 else if (flag
== SHF_IA_64_NORECOV
)
5970 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5973 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5974 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5975 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5976 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5977 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5978 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5989 case EM_OLD_SPARCV9
:
5990 case EM_SPARC32PLUS
:
5993 if (flag
== SHF_ORDERED
)
6000 case SHF_ENTRYSECT
: sindex
= 21; break;
6001 case SHF_ARM_PURECODE
: sindex
= 22; break;
6002 case SHF_COMDEF
: sindex
= 23; break;
6007 if (flag
== SHF_PPC_VLE
)
6018 if (p
!= buff
+ field_size
+ 4)
6020 if (size
< (10 + 2))
6022 warn (_("Internal error: not enough buffer room for section flag info"));
6023 return _("<unknown>");
6030 size
-= flags
[sindex
].len
;
6031 p
= stpcpy (p
, flags
[sindex
].str
);
6033 else if (flag
& SHF_MASKOS
)
6035 else if (flag
& SHF_MASKPROC
)
6038 unknown_flags
|= flag
;
6044 case SHF_WRITE
: *p
= 'W'; break;
6045 case SHF_ALLOC
: *p
= 'A'; break;
6046 case SHF_EXECINSTR
: *p
= 'X'; break;
6047 case SHF_MERGE
: *p
= 'M'; break;
6048 case SHF_STRINGS
: *p
= 'S'; break;
6049 case SHF_INFO_LINK
: *p
= 'I'; break;
6050 case SHF_LINK_ORDER
: *p
= 'L'; break;
6051 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6052 case SHF_GROUP
: *p
= 'G'; break;
6053 case SHF_TLS
: *p
= 'T'; break;
6054 case SHF_EXCLUDE
: *p
= 'E'; break;
6055 case SHF_COMPRESSED
: *p
= 'C'; break;
6056 case SHF_GNU_MBIND
: *p
= 'D'; break;
6059 if ((filedata
->file_header
.e_machine
== EM_X86_64
6060 || filedata
->file_header
.e_machine
== EM_L1OM
6061 || filedata
->file_header
.e_machine
== EM_K1OM
)
6062 && flag
== SHF_X86_64_LARGE
)
6064 else if (filedata
->file_header
.e_machine
== EM_ARM
6065 && flag
== SHF_ARM_PURECODE
)
6067 else if (filedata
->file_header
.e_machine
== EM_PPC
6068 && flag
== SHF_PPC_VLE
)
6070 else if (flag
& SHF_MASKOS
)
6073 sh_flags
&= ~ SHF_MASKOS
;
6075 else if (flag
& SHF_MASKPROC
)
6078 sh_flags
&= ~ SHF_MASKPROC
;
6088 if (do_section_details
)
6092 size
-= 5 + field_size
;
6093 if (p
!= buff
+ field_size
+ 4)
6097 warn (_("Internal error: not enough buffer room for section flag info"));
6098 return _("<unknown>");
6104 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6105 (unsigned long) os_flags
);
6106 p
+= 5 + field_size
;
6110 size
-= 7 + field_size
;
6111 if (p
!= buff
+ field_size
+ 4)
6115 warn (_("Internal error: not enough buffer room for section flag info"));
6116 return _("<unknown>");
6122 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6123 (unsigned long) proc_flags
);
6124 p
+= 7 + field_size
;
6128 size
-= 10 + field_size
;
6129 if (p
!= buff
+ field_size
+ 4)
6133 warn (_("Internal error: not enough buffer room for section flag info"));
6134 return _("<unknown>");
6140 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6141 (unsigned long) unknown_flags
);
6142 p
+= 10 + field_size
;
6150 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6151 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6155 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6157 if (size
< sizeof (* echdr
))
6159 error (_("Compressed section is too small even for a compression header\n"));
6163 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6164 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6165 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6166 return sizeof (*echdr
);
6170 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6172 if (size
< sizeof (* echdr
))
6174 error (_("Compressed section is too small even for a compression header\n"));
6178 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6179 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6180 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6181 return sizeof (*echdr
);
6186 process_section_headers (Filedata
* filedata
)
6188 Elf_Internal_Shdr
* section
;
6191 free (filedata
->section_headers
);
6192 filedata
->section_headers
= NULL
;
6193 free (filedata
->dynamic_symbols
);
6194 filedata
->dynamic_symbols
= NULL
;
6195 filedata
->num_dynamic_syms
= 0;
6196 free (filedata
->dynamic_strings
);
6197 filedata
->dynamic_strings
= NULL
;
6198 filedata
->dynamic_strings_length
= 0;
6199 free (filedata
->dynamic_syminfo
);
6200 filedata
->dynamic_syminfo
= NULL
;
6201 while (filedata
->symtab_shndx_list
!= NULL
)
6203 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6204 free (filedata
->symtab_shndx_list
);
6205 filedata
->symtab_shndx_list
= next
;
6208 if (filedata
->file_header
.e_shnum
== 0)
6210 /* PR binutils/12467. */
6211 if (filedata
->file_header
.e_shoff
!= 0)
6213 warn (_("possibly corrupt ELF file header - it has a non-zero"
6214 " section header offset, but no section headers\n"));
6217 else if (do_sections
)
6218 printf (_("\nThere are no sections in this file.\n"));
6223 if (do_sections
&& !do_header
)
6224 printf (ngettext ("There is %d section header, "
6225 "starting at offset 0x%lx:\n",
6226 "There are %d section headers, "
6227 "starting at offset 0x%lx:\n",
6228 filedata
->file_header
.e_shnum
),
6229 filedata
->file_header
.e_shnum
,
6230 (unsigned long) filedata
->file_header
.e_shoff
);
6234 if (! get_32bit_section_headers (filedata
, FALSE
))
6239 if (! get_64bit_section_headers (filedata
, FALSE
))
6243 /* Read in the string table, so that we have names to display. */
6244 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6245 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6247 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6249 if (section
->sh_size
!= 0)
6251 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6252 1, section
->sh_size
,
6255 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6259 /* Scan the sections for the dynamic symbol table
6260 and dynamic string table and debug sections. */
6261 eh_addr_size
= is_32bit_elf
? 4 : 8;
6262 switch (filedata
->file_header
.e_machine
)
6265 case EM_MIPS_RS3_LE
:
6266 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6267 FDE addresses. However, the ABI also has a semi-official ILP32
6268 variant for which the normal FDE address size rules apply.
6270 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6271 section, where XX is the size of longs in bits. Unfortunately,
6272 earlier compilers provided no way of distinguishing ILP32 objects
6273 from LP64 objects, so if there's any doubt, we should assume that
6274 the official LP64 form is being used. */
6275 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6276 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6282 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6284 case E_H8_MACH_H8300
:
6285 case E_H8_MACH_H8300HN
:
6286 case E_H8_MACH_H8300SN
:
6287 case E_H8_MACH_H8300SXN
:
6290 case E_H8_MACH_H8300H
:
6291 case E_H8_MACH_H8300S
:
6292 case E_H8_MACH_H8300SX
:
6300 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6302 case EF_M32C_CPU_M16C
:
6309 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6312 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6313 if (section->sh_entsize != expected_entsize) \
6316 sprintf_vma (buf, section->sh_entsize); \
6317 /* Note: coded this way so that there is a single string for \
6319 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6320 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6321 (unsigned) expected_entsize); \
6322 section->sh_entsize = expected_entsize; \
6327 #define CHECK_ENTSIZE(section, i, type) \
6328 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6329 sizeof (Elf64_External_##type))
6331 for (i
= 0, section
= filedata
->section_headers
;
6332 i
< filedata
->file_header
.e_shnum
;
6335 char * name
= SECTION_NAME (section
);
6337 /* Run some sanity checks on the headers and
6338 possibly fill in some file data as well. */
6339 switch (section
->sh_type
)
6342 if (filedata
->dynamic_symbols
!= NULL
)
6344 error (_("File contains multiple dynamic symbol tables\n"));
6348 CHECK_ENTSIZE (section
, i
, Sym
);
6349 filedata
->dynamic_symbols
6350 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6351 filedata
->dynamic_symtab_section
= section
;
6355 if (streq (name
, ".dynstr"))
6357 if (filedata
->dynamic_strings
!= NULL
)
6359 error (_("File contains multiple dynamic string tables\n"));
6363 filedata
->dynamic_strings
6364 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6365 1, section
->sh_size
, _("dynamic strings"));
6366 filedata
->dynamic_strings_length
6367 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6368 filedata
->dynamic_strtab_section
= section
;
6372 case SHT_SYMTAB_SHNDX
:
6374 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6376 entry
->hdr
= section
;
6377 entry
->next
= filedata
->symtab_shndx_list
;
6378 filedata
->symtab_shndx_list
= entry
;
6383 CHECK_ENTSIZE (section
, i
, Sym
);
6387 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6391 CHECK_ENTSIZE (section
, i
, Rel
);
6392 if (do_checks
&& section
->sh_size
== 0)
6393 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6397 CHECK_ENTSIZE (section
, i
, Rela
);
6398 if (do_checks
&& section
->sh_size
== 0)
6399 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6404 /* Having a zero sized section is not illegal according to the
6405 ELF standard, but it might be an indication that something
6406 is wrong. So issue a warning if we are running in lint mode. */
6407 if (do_checks
&& section
->sh_size
== 0)
6408 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6415 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6416 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6417 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6418 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
|| do_debug_ranges
6419 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6420 && (const_strneq (name
, ".debug_")
6421 || const_strneq (name
, ".zdebug_")))
6424 name
+= sizeof (".zdebug_") - 1;
6426 name
+= sizeof (".debug_") - 1;
6429 || (do_debug_info
&& const_strneq (name
, "info"))
6430 || (do_debug_info
&& const_strneq (name
, "types"))
6431 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6432 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6433 || (do_debug_lines
&& const_strneq (name
, "line."))
6434 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6435 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6436 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6437 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6438 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6439 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6440 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6441 || (do_debug_frames
&& const_strneq (name
, "frame"))
6442 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6443 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6444 || (do_debug_str
&& const_strneq (name
, "str"))
6445 || (do_debug_str_offsets
&& const_strneq (name
, "str_offsets"))
6446 || (do_debug_loc
&& const_strneq (name
, "loc"))
6447 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6448 || (do_debug_addr
&& const_strneq (name
, "addr"))
6449 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6450 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6452 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6454 /* Linkonce section to be combined with .debug_info at link time. */
6455 else if ((do_debugging
|| do_debug_info
)
6456 && const_strneq (name
, ".gnu.linkonce.wi."))
6457 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6458 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6459 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6460 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6461 || streq (name
, ".debug_names")))
6462 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6463 /* Trace sections for Itanium VMS. */
6464 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6465 || do_trace_aranges
)
6466 && const_strneq (name
, ".trace_"))
6468 name
+= sizeof (".trace_") - 1;
6471 || (do_trace_info
&& streq (name
, "info"))
6472 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6473 || (do_trace_aranges
&& streq (name
, "aranges"))
6475 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6477 else if ((do_debugging
|| do_debug_links
)
6478 && (const_strneq (name
, ".gnu_debuglink")
6479 || const_strneq (name
, ".gnu_debugaltlink")))
6480 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6486 if (filedata
->file_header
.e_shnum
> 1)
6487 printf (_("\nSection Headers:\n"));
6489 printf (_("\nSection Header:\n"));
6493 if (do_section_details
)
6495 printf (_(" [Nr] Name\n"));
6496 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6500 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6504 if (do_section_details
)
6506 printf (_(" [Nr] Name\n"));
6507 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6511 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6515 if (do_section_details
)
6517 printf (_(" [Nr] Name\n"));
6518 printf (_(" Type Address Offset Link\n"));
6519 printf (_(" Size EntSize Info Align\n"));
6523 printf (_(" [Nr] Name Type Address Offset\n"));
6524 printf (_(" Size EntSize Flags Link Info Align\n"));
6528 if (do_section_details
)
6529 printf (_(" Flags\n"));
6531 for (i
= 0, section
= filedata
->section_headers
;
6532 i
< filedata
->file_header
.e_shnum
;
6535 /* Run some sanity checks on the section header. */
6537 /* Check the sh_link field. */
6538 switch (section
->sh_type
)
6542 if (section
->sh_link
== 0
6543 && (filedata
->file_header
.e_type
== ET_EXEC
6544 || filedata
->file_header
.e_type
== ET_DYN
))
6545 /* A dynamic relocation section where all entries use a
6546 zero symbol index need not specify a symtab section. */
6549 case SHT_SYMTAB_SHNDX
:
6553 case SHT_GNU_versym
:
6554 if (section
->sh_link
== 0
6555 || section
->sh_link
>= filedata
->file_header
.e_shnum
6556 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6557 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6558 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6559 i
, section
->sh_link
);
6565 case SHT_GNU_verneed
:
6566 case SHT_GNU_verdef
:
6567 case SHT_GNU_LIBLIST
:
6568 if (section
->sh_link
== 0
6569 || section
->sh_link
>= filedata
->file_header
.e_shnum
6570 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6571 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6572 i
, section
->sh_link
);
6575 case SHT_INIT_ARRAY
:
6576 case SHT_FINI_ARRAY
:
6577 case SHT_PREINIT_ARRAY
:
6578 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6579 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6580 i
, section
->sh_link
);
6584 /* FIXME: Add support for target specific section types. */
6585 #if 0 /* Currently we do not check other section types as there are too
6586 many special cases. Stab sections for example have a type
6587 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6589 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6590 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6591 i
, section
->sh_link
);
6596 /* Check the sh_info field. */
6597 switch (section
->sh_type
)
6601 if (section
->sh_info
== 0
6602 && (filedata
->file_header
.e_type
== ET_EXEC
6603 || filedata
->file_header
.e_type
== ET_DYN
))
6604 /* Dynamic relocations apply to segments, so they do not
6605 need to specify the section they relocate. */
6607 if (section
->sh_info
== 0
6608 || section
->sh_info
>= filedata
->file_header
.e_shnum
6609 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6610 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6611 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6612 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6613 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6614 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6615 /* FIXME: Are other section types valid ? */
6616 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6617 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6618 i
, section
->sh_info
);
6623 case SHT_SYMTAB_SHNDX
:
6624 case SHT_INIT_ARRAY
:
6625 case SHT_FINI_ARRAY
:
6626 case SHT_PREINIT_ARRAY
:
6627 if (section
->sh_info
!= 0)
6628 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6629 i
, section
->sh_info
);
6635 /* A symbol index - we assume that it is valid. */
6639 /* FIXME: Add support for target specific section types. */
6640 if (section
->sh_type
== SHT_NOBITS
)
6641 /* NOBITS section headers with non-zero sh_info fields can be
6642 created when a binary is stripped of everything but its debug
6643 information. The stripped sections have their headers
6644 preserved but their types set to SHT_NOBITS. So do not check
6645 this type of section. */
6647 else if (section
->sh_flags
& SHF_INFO_LINK
)
6649 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6650 warn (_("[%2u]: Expected link to another section in info field"), i
);
6652 else if (section
->sh_type
< SHT_LOOS
6653 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6654 && section
->sh_info
!= 0)
6655 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6656 i
, section
->sh_info
);
6660 /* Check the sh_size field. */
6661 if (section
->sh_size
> filedata
->file_size
6662 && section
->sh_type
!= SHT_NOBITS
6663 && section
->sh_type
!= SHT_NULL
6664 && section
->sh_type
< SHT_LOOS
)
6665 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6667 printf (" [%2u] ", i
);
6668 if (do_section_details
)
6669 printf ("%s\n ", printable_section_name (filedata
, section
));
6671 print_symbol (-17, SECTION_NAME (section
));
6673 printf (do_wide
? " %-15s " : " %-15.15s ",
6674 get_section_type_name (filedata
, section
->sh_type
));
6678 const char * link_too_big
= NULL
;
6680 print_vma (section
->sh_addr
, LONG_HEX
);
6682 printf ( " %6.6lx %6.6lx %2.2lx",
6683 (unsigned long) section
->sh_offset
,
6684 (unsigned long) section
->sh_size
,
6685 (unsigned long) section
->sh_entsize
);
6687 if (do_section_details
)
6688 fputs (" ", stdout
);
6690 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6692 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6695 /* The sh_link value is out of range. Normally this indicates
6696 an error but it can have special values in Solaris binaries. */
6697 switch (filedata
->file_header
.e_machine
)
6704 case EM_OLD_SPARCV9
:
6705 case EM_SPARC32PLUS
:
6708 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6709 link_too_big
= "BEFORE";
6710 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6711 link_too_big
= "AFTER";
6718 if (do_section_details
)
6720 if (link_too_big
!= NULL
&& * link_too_big
)
6721 printf ("<%s> ", link_too_big
);
6723 printf ("%2u ", section
->sh_link
);
6724 printf ("%3u %2lu\n", section
->sh_info
,
6725 (unsigned long) section
->sh_addralign
);
6728 printf ("%2u %3u %2lu\n",
6731 (unsigned long) section
->sh_addralign
);
6733 if (link_too_big
&& ! * link_too_big
)
6734 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6735 i
, section
->sh_link
);
6739 print_vma (section
->sh_addr
, LONG_HEX
);
6741 if ((long) section
->sh_offset
== section
->sh_offset
)
6742 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6746 print_vma (section
->sh_offset
, LONG_HEX
);
6749 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6750 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6754 print_vma (section
->sh_size
, LONG_HEX
);
6757 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6758 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6762 print_vma (section
->sh_entsize
, LONG_HEX
);
6765 if (do_section_details
)
6766 fputs (" ", stdout
);
6768 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6770 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6772 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6773 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6776 print_vma (section
->sh_addralign
, DEC
);
6780 else if (do_section_details
)
6783 print_vma (section
->sh_addr
, LONG_HEX
);
6784 if ((long) section
->sh_offset
== section
->sh_offset
)
6785 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6789 print_vma (section
->sh_offset
, LONG_HEX
);
6791 printf (" %u\n ", section
->sh_link
);
6792 print_vma (section
->sh_size
, LONG_HEX
);
6794 print_vma (section
->sh_entsize
, LONG_HEX
);
6796 printf (" %-16u %lu\n",
6798 (unsigned long) section
->sh_addralign
);
6803 print_vma (section
->sh_addr
, LONG_HEX
);
6804 if ((long) section
->sh_offset
== section
->sh_offset
)
6805 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6809 print_vma (section
->sh_offset
, LONG_HEX
);
6812 print_vma (section
->sh_size
, LONG_HEX
);
6814 print_vma (section
->sh_entsize
, LONG_HEX
);
6816 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6818 printf (" %2u %3u %lu\n",
6821 (unsigned long) section
->sh_addralign
);
6824 if (do_section_details
)
6826 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6827 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6829 /* Minimum section size is 12 bytes for 32-bit compression
6830 header + 12 bytes for compressed data header. */
6831 unsigned char buf
[24];
6833 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6834 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6835 sizeof (buf
), _("compression header")))
6837 Elf_Internal_Chdr chdr
;
6839 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6840 printf (_(" [<corrupt>]\n"));
6843 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6846 printf (_(" [<unknown>: 0x%x], "),
6848 print_vma (chdr
.ch_size
, LONG_HEX
);
6849 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6856 if (!do_section_details
)
6858 /* The ordering of the letters shown here matches the ordering of the
6859 corresponding SHF_xxx values, and hence the order in which these
6860 letters will be displayed to the user. */
6861 printf (_("Key to Flags:\n\
6862 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6863 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6864 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6865 if (filedata
->file_header
.e_machine
== EM_X86_64
6866 || filedata
->file_header
.e_machine
== EM_L1OM
6867 || filedata
->file_header
.e_machine
== EM_K1OM
)
6868 printf (_("l (large), "));
6869 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6870 printf (_("y (purecode), "));
6871 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6872 printf (_("v (VLE), "));
6873 printf ("p (processor specific)\n");
6880 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6881 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6882 char **strtab
, unsigned long *strtablen
)
6886 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6888 if (*symtab
== NULL
)
6891 if (symsec
->sh_link
!= 0)
6893 Elf_Internal_Shdr
*strsec
;
6895 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6897 error (_("Bad sh_link in symbol table section\n"));
6904 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6906 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6907 1, strsec
->sh_size
, _("string table"));
6908 if (*strtab
== NULL
)
6915 *strtablen
= strsec
->sh_size
;
6921 get_group_flags (unsigned int flags
)
6923 static char buff
[128];
6927 else if (flags
== GRP_COMDAT
)
6930 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6932 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6933 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6934 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6935 ? _("<unknown>") : ""));
6941 process_section_groups (Filedata
* filedata
)
6943 Elf_Internal_Shdr
* section
;
6945 struct group
* group
;
6946 Elf_Internal_Shdr
* symtab_sec
;
6947 Elf_Internal_Shdr
* strtab_sec
;
6948 Elf_Internal_Sym
* symtab
;
6949 unsigned long num_syms
;
6953 /* Don't process section groups unless needed. */
6954 if (!do_unwind
&& !do_section_groups
)
6957 if (filedata
->file_header
.e_shnum
== 0)
6959 if (do_section_groups
)
6960 printf (_("\nThere are no sections to group in this file.\n"));
6965 if (filedata
->section_headers
== NULL
)
6967 error (_("Section headers are not available!\n"));
6968 /* PR 13622: This can happen with a corrupt ELF header. */
6972 filedata
->section_headers_groups
6973 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6974 sizeof (struct group
*));
6976 if (filedata
->section_headers_groups
== NULL
)
6978 error (_("Out of memory reading %u section group headers\n"),
6979 filedata
->file_header
.e_shnum
);
6983 /* Scan the sections for the group section. */
6984 filedata
->group_count
= 0;
6985 for (i
= 0, section
= filedata
->section_headers
;
6986 i
< filedata
->file_header
.e_shnum
;
6988 if (section
->sh_type
== SHT_GROUP
)
6989 filedata
->group_count
++;
6991 if (filedata
->group_count
== 0)
6993 if (do_section_groups
)
6994 printf (_("\nThere are no section groups in this file.\n"));
6999 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7000 sizeof (struct group
));
7002 if (filedata
->section_groups
== NULL
)
7004 error (_("Out of memory reading %lu groups\n"),
7005 (unsigned long) filedata
->group_count
);
7015 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7016 i
< filedata
->file_header
.e_shnum
;
7019 if (section
->sh_type
== SHT_GROUP
)
7021 const char * name
= printable_section_name (filedata
, section
);
7022 const char * group_name
;
7023 unsigned char * start
;
7024 unsigned char * indices
;
7025 unsigned int entry
, j
, size
;
7026 Elf_Internal_Shdr
* sec
;
7027 Elf_Internal_Sym
* sym
;
7029 /* Get the symbol table. */
7030 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7031 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7034 error (_("Bad sh_link in group section `%s'\n"), name
);
7038 if (symtab_sec
!= sec
)
7042 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7047 error (_("Corrupt header in group section `%s'\n"), name
);
7051 if (section
->sh_info
>= num_syms
)
7053 error (_("Bad sh_info in group section `%s'\n"), name
);
7057 sym
= symtab
+ section
->sh_info
;
7059 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7061 if (sym
->st_shndx
== 0
7062 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7064 error (_("Bad sh_info in group section `%s'\n"), name
);
7068 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
7076 /* Get the string table. */
7077 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7085 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7090 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7091 1, strtab_sec
->sh_size
,
7093 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7095 group_name
= sym
->st_name
< strtab_size
7096 ? strtab
+ sym
->st_name
: _("<corrupt>");
7099 /* PR 17531: file: loop. */
7100 if (section
->sh_entsize
> section
->sh_size
)
7102 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7103 printable_section_name (filedata
, section
),
7104 (unsigned long) section
->sh_entsize
,
7105 (unsigned long) section
->sh_size
);
7109 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7110 1, section
->sh_size
,
7116 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7117 entry
= byte_get (indices
, 4);
7120 if (do_section_groups
)
7122 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7123 get_group_flags (entry
), i
, name
, group_name
, size
);
7125 printf (_(" [Index] Name\n"));
7128 group
->group_index
= i
;
7130 for (j
= 0; j
< size
; j
++)
7132 struct group_list
* g
;
7134 entry
= byte_get (indices
, 4);
7137 if (entry
>= filedata
->file_header
.e_shnum
)
7139 static unsigned num_group_errors
= 0;
7141 if (num_group_errors
++ < 10)
7143 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7144 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7145 if (num_group_errors
== 10)
7146 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7151 if (filedata
->section_headers_groups
[entry
] != NULL
)
7155 static unsigned num_errs
= 0;
7157 if (num_errs
++ < 10)
7159 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7161 filedata
->section_headers_groups
[entry
]->group_index
);
7163 warn (_("Further error messages about already contained group sections suppressed\n"));
7169 /* Intel C/C++ compiler may put section 0 in a
7170 section group. We just warn it the first time
7171 and ignore it afterwards. */
7172 static bfd_boolean warned
= FALSE
;
7175 error (_("section 0 in group section [%5u]\n"),
7176 filedata
->section_headers_groups
[entry
]->group_index
);
7182 filedata
->section_headers_groups
[entry
] = group
;
7184 if (do_section_groups
)
7186 sec
= filedata
->section_headers
+ entry
;
7187 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7190 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7191 g
->section_index
= entry
;
7192 g
->next
= group
->root
;
7207 /* Data used to display dynamic fixups. */
7209 struct ia64_vms_dynfixup
7211 bfd_vma needed_ident
; /* Library ident number. */
7212 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7213 bfd_vma fixup_needed
; /* Index of the library. */
7214 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7215 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7218 /* Data used to display dynamic relocations. */
7220 struct ia64_vms_dynimgrela
7222 bfd_vma img_rela_cnt
; /* Number of relocations. */
7223 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7226 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7230 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7231 struct ia64_vms_dynfixup
* fixup
,
7232 const char * strtab
,
7233 unsigned int strtab_sz
)
7235 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7237 const char * lib_name
;
7239 imfs
= get_data (NULL
, filedata
,
7240 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7241 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7242 _("dynamic section image fixups"));
7246 if (fixup
->needed
< strtab_sz
)
7247 lib_name
= strtab
+ fixup
->needed
;
7250 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7251 (unsigned long) fixup
->needed
);
7255 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7256 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7258 (_("Seg Offset Type SymVec DataType\n"));
7260 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7265 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7266 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7267 type
= BYTE_GET (imfs
[i
].type
);
7268 rtype
= elf_ia64_reloc_type (type
);
7270 printf (" 0x%08x ", type
);
7272 printf (" %-32s ", rtype
);
7273 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7274 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7281 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7284 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7286 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7289 imrs
= get_data (NULL
, filedata
,
7290 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7291 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7292 _("dynamic section image relocations"));
7296 printf (_("\nImage relocs\n"));
7298 (_("Seg Offset Type Addend Seg Sym Off\n"));
7300 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7305 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7306 printf ("%08" BFD_VMA_FMT
"x ",
7307 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7308 type
= BYTE_GET (imrs
[i
].type
);
7309 rtype
= elf_ia64_reloc_type (type
);
7311 printf ("0x%08x ", type
);
7313 printf ("%-31s ", rtype
);
7314 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7315 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7316 printf ("%08" BFD_VMA_FMT
"x\n",
7317 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7324 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7327 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7329 struct ia64_vms_dynfixup fixup
;
7330 struct ia64_vms_dynimgrela imgrela
;
7331 Elf_Internal_Dyn
*entry
;
7332 bfd_vma strtab_off
= 0;
7333 bfd_vma strtab_sz
= 0;
7334 char *strtab
= NULL
;
7335 bfd_boolean res
= TRUE
;
7337 memset (&fixup
, 0, sizeof (fixup
));
7338 memset (&imgrela
, 0, sizeof (imgrela
));
7340 /* Note: the order of the entries is specified by the OpenVMS specs. */
7341 for (entry
= filedata
->dynamic_section
;
7342 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7345 switch (entry
->d_tag
)
7347 case DT_IA_64_VMS_STRTAB_OFFSET
:
7348 strtab_off
= entry
->d_un
.d_val
;
7351 strtab_sz
= entry
->d_un
.d_val
;
7353 strtab
= get_data (NULL
, filedata
,
7354 filedata
->dynamic_addr
+ strtab_off
,
7355 1, strtab_sz
, _("dynamic string section"));
7360 case DT_IA_64_VMS_NEEDED_IDENT
:
7361 fixup
.needed_ident
= entry
->d_un
.d_val
;
7364 fixup
.needed
= entry
->d_un
.d_val
;
7366 case DT_IA_64_VMS_FIXUP_NEEDED
:
7367 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7369 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7370 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7372 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7373 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7374 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7377 case DT_IA_64_VMS_IMG_RELA_CNT
:
7378 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7380 case DT_IA_64_VMS_IMG_RELA_OFF
:
7381 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7382 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7403 dynamic_relocations
[] =
7405 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7406 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7407 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7410 /* Process the reloc section. */
7413 process_relocs (Filedata
* filedata
)
7415 unsigned long rel_size
;
7416 unsigned long rel_offset
;
7421 if (do_using_dynamic
)
7425 bfd_boolean has_dynamic_reloc
;
7428 has_dynamic_reloc
= FALSE
;
7430 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7432 is_rela
= dynamic_relocations
[i
].rela
;
7433 name
= dynamic_relocations
[i
].name
;
7434 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7435 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7438 has_dynamic_reloc
= TRUE
;
7440 if (is_rela
== UNKNOWN
)
7442 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7443 switch (filedata
->dynamic_info
[DT_PLTREL
])
7457 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7458 name
, rel_offset
, rel_size
);
7460 dump_relocations (filedata
,
7461 offset_from_vma (filedata
, rel_offset
, rel_size
),
7463 filedata
->dynamic_symbols
,
7464 filedata
->num_dynamic_syms
,
7465 filedata
->dynamic_strings
,
7466 filedata
->dynamic_strings_length
,
7467 is_rela
, TRUE
/* is_dynamic */);
7471 if (is_ia64_vms (filedata
))
7472 if (process_ia64_vms_dynamic_relocs (filedata
))
7473 has_dynamic_reloc
= TRUE
;
7475 if (! has_dynamic_reloc
)
7476 printf (_("\nThere are no dynamic relocations in this file.\n"));
7480 Elf_Internal_Shdr
* section
;
7482 bfd_boolean found
= FALSE
;
7484 for (i
= 0, section
= filedata
->section_headers
;
7485 i
< filedata
->file_header
.e_shnum
;
7488 if ( section
->sh_type
!= SHT_RELA
7489 && section
->sh_type
!= SHT_REL
)
7492 rel_offset
= section
->sh_offset
;
7493 rel_size
= section
->sh_size
;
7498 unsigned long num_rela
;
7500 printf (_("\nRelocation section "));
7502 if (filedata
->string_table
== NULL
)
7503 printf ("%d", section
->sh_name
);
7505 printf ("'%s'", printable_section_name (filedata
, section
));
7507 num_rela
= rel_size
/ section
->sh_entsize
;
7508 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7509 " at offset 0x%lx contains %lu entries:\n",
7511 rel_offset
, num_rela
);
7513 is_rela
= section
->sh_type
== SHT_RELA
;
7515 if (section
->sh_link
!= 0
7516 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7518 Elf_Internal_Shdr
* symsec
;
7519 Elf_Internal_Sym
* symtab
;
7520 unsigned long nsyms
;
7521 unsigned long strtablen
= 0;
7522 char * strtab
= NULL
;
7524 symsec
= filedata
->section_headers
+ section
->sh_link
;
7525 if (symsec
->sh_type
!= SHT_SYMTAB
7526 && symsec
->sh_type
!= SHT_DYNSYM
)
7529 if (!get_symtab (filedata
, symsec
,
7530 &symtab
, &nsyms
, &strtab
, &strtablen
))
7533 dump_relocations (filedata
, rel_offset
, rel_size
,
7534 symtab
, nsyms
, strtab
, strtablen
,
7536 symsec
->sh_type
== SHT_DYNSYM
);
7541 dump_relocations (filedata
, rel_offset
, rel_size
,
7542 NULL
, 0, NULL
, 0, is_rela
,
7543 FALSE
/* is_dynamic */);
7551 /* Users sometimes forget the -D option, so try to be helpful. */
7552 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7554 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7556 printf (_("\nThere are no static relocations in this file."));
7557 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7562 if (i
== ARRAY_SIZE (dynamic_relocations
))
7563 printf (_("\nThere are no relocations in this file.\n"));
7570 /* An absolute address consists of a section and an offset. If the
7571 section is NULL, the offset itself is the address, otherwise, the
7572 address equals to LOAD_ADDRESS(section) + offset. */
7576 unsigned short section
;
7580 /* Find the nearest symbol at or below ADDR. Returns the symbol
7581 name, if found, and the offset from the symbol to ADDR. */
7584 find_symbol_for_address (Filedata
* filedata
,
7585 Elf_Internal_Sym
* symtab
,
7586 unsigned long nsyms
,
7587 const char * strtab
,
7588 unsigned long strtab_size
,
7589 struct absaddr addr
,
7590 const char ** symname
,
7593 bfd_vma dist
= 0x100000;
7594 Elf_Internal_Sym
* sym
;
7595 Elf_Internal_Sym
* beg
;
7596 Elf_Internal_Sym
* end
;
7597 Elf_Internal_Sym
* best
= NULL
;
7599 REMOVE_ARCH_BITS (addr
.offset
);
7601 end
= symtab
+ nsyms
;
7607 sym
= beg
+ (end
- beg
) / 2;
7609 value
= sym
->st_value
;
7610 REMOVE_ARCH_BITS (value
);
7612 if (sym
->st_name
!= 0
7613 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7614 && addr
.offset
>= value
7615 && addr
.offset
- value
< dist
)
7618 dist
= addr
.offset
- value
;
7623 if (addr
.offset
< value
)
7631 *symname
= (best
->st_name
>= strtab_size
7632 ? _("<corrupt>") : strtab
+ best
->st_name
);
7638 *offset
= addr
.offset
;
7641 static /* signed */ int
7642 symcmp (const void *p
, const void *q
)
7644 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7645 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7647 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7650 /* Process the unwind section. */
7652 #include "unwind-ia64.h"
7654 struct ia64_unw_table_entry
7656 struct absaddr start
;
7658 struct absaddr info
;
7661 struct ia64_unw_aux_info
7663 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7664 unsigned long table_len
; /* Length of unwind table. */
7665 unsigned char * info
; /* Unwind info. */
7666 unsigned long info_size
; /* Size of unwind info. */
7667 bfd_vma info_addr
; /* Starting address of unwind info. */
7668 bfd_vma seg_base
; /* Starting address of segment. */
7669 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7670 unsigned long nsyms
; /* Number of symbols. */
7671 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7672 unsigned long nfuns
; /* Number of entries in funtab. */
7673 char * strtab
; /* The string table. */
7674 unsigned long strtab_size
; /* Size of string table. */
7678 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7680 struct ia64_unw_table_entry
* tp
;
7681 unsigned long j
, nfuns
;
7683 bfd_boolean res
= TRUE
;
7685 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7686 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7687 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7688 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7690 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7692 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7696 const unsigned char * dp
;
7697 const unsigned char * head
;
7698 const unsigned char * end
;
7699 const char * procname
;
7701 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7702 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7704 fputs ("\n<", stdout
);
7708 fputs (procname
, stdout
);
7711 printf ("+%lx", (unsigned long) offset
);
7714 fputs (">: [", stdout
);
7715 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7716 fputc ('-', stdout
);
7717 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7718 printf ("], info at +0x%lx\n",
7719 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7721 /* PR 17531: file: 86232b32. */
7722 if (aux
->info
== NULL
)
7725 offset
= tp
->info
.offset
;
7726 if (tp
->info
.section
)
7728 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7730 warn (_("Invalid section %u in table entry %ld\n"),
7731 tp
->info
.section
, (long) (tp
- aux
->table
));
7735 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7737 offset
-= aux
->info_addr
;
7738 /* PR 17531: file: 0997b4d1. */
7739 if (offset
>= aux
->info_size
7740 || aux
->info_size
- offset
< 8)
7742 warn (_("Invalid offset %lx in table entry %ld\n"),
7743 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7748 head
= aux
->info
+ offset
;
7749 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7751 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7752 (unsigned) UNW_VER (stamp
),
7753 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7754 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7755 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7756 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7758 if (UNW_VER (stamp
) != 1)
7760 printf (_("\tUnknown version.\n"));
7765 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7766 /* PR 17531: file: 16ceda89. */
7767 if (end
> aux
->info
+ aux
->info_size
)
7768 end
= aux
->info
+ aux
->info_size
;
7769 for (dp
= head
+ 8; dp
< end
;)
7770 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7779 slurp_ia64_unwind_table (Filedata
* filedata
,
7780 struct ia64_unw_aux_info
* aux
,
7781 Elf_Internal_Shdr
* sec
)
7783 unsigned long size
, nrelas
, i
;
7784 Elf_Internal_Phdr
* seg
;
7785 struct ia64_unw_table_entry
* tep
;
7786 Elf_Internal_Shdr
* relsec
;
7787 Elf_Internal_Rela
* rela
;
7788 Elf_Internal_Rela
* rp
;
7789 unsigned char * table
;
7791 Elf_Internal_Sym
* sym
;
7792 const char * relname
;
7796 /* First, find the starting address of the segment that includes
7799 if (filedata
->file_header
.e_phnum
)
7801 if (! get_program_headers (filedata
))
7804 for (seg
= filedata
->program_headers
;
7805 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7808 if (seg
->p_type
!= PT_LOAD
)
7811 if (sec
->sh_addr
>= seg
->p_vaddr
7812 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7814 aux
->seg_base
= seg
->p_vaddr
;
7820 /* Second, build the unwind table from the contents of the unwind section: */
7821 size
= sec
->sh_size
;
7822 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7827 aux
->table_len
= size
/ (3 * eh_addr_size
);
7828 aux
->table
= (struct ia64_unw_table_entry
*)
7829 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7832 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7834 tep
->start
.section
= SHN_UNDEF
;
7835 tep
->end
.section
= SHN_UNDEF
;
7836 tep
->info
.section
= SHN_UNDEF
;
7837 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7838 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7839 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7840 tep
->start
.offset
+= aux
->seg_base
;
7841 tep
->end
.offset
+= aux
->seg_base
;
7842 tep
->info
.offset
+= aux
->seg_base
;
7846 /* Third, apply any relocations to the unwind table: */
7847 for (relsec
= filedata
->section_headers
;
7848 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7851 if (relsec
->sh_type
!= SHT_RELA
7852 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7853 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7856 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7865 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7867 unsigned int sym_ndx
;
7868 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7869 relname
= elf_ia64_reloc_type (r_type
);
7871 /* PR 17531: file: 9fa67536. */
7872 if (relname
== NULL
)
7874 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7878 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7880 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7884 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7886 /* PR 17531: file: 5bc8d9bf. */
7887 if (i
>= aux
->table_len
)
7889 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7893 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7894 if (sym_ndx
>= aux
->nsyms
)
7896 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7900 sym
= aux
->symtab
+ sym_ndx
;
7902 switch (rp
->r_offset
/ eh_addr_size
% 3)
7905 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7906 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7909 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7910 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7913 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7914 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7928 ia64_process_unwind (Filedata
* filedata
)
7930 Elf_Internal_Shdr
* sec
;
7931 Elf_Internal_Shdr
* unwsec
= NULL
;
7932 unsigned long i
, unwcount
= 0, unwstart
= 0;
7933 struct ia64_unw_aux_info aux
;
7934 bfd_boolean res
= TRUE
;
7936 memset (& aux
, 0, sizeof (aux
));
7938 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7940 if (sec
->sh_type
== SHT_SYMTAB
)
7944 error (_("Multiple symbol tables encountered\n"));
7950 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7951 &aux
.strtab
, &aux
.strtab_size
))
7954 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7959 printf (_("\nThere are no unwind sections in this file.\n"));
7961 while (unwcount
-- > 0)
7966 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7967 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7968 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7973 /* We have already counted the number of SHT_IA64_UNWIND
7974 sections so the loop above should never fail. */
7975 assert (unwsec
!= NULL
);
7978 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7980 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7982 /* We need to find which section group it is in. */
7983 struct group_list
* g
;
7985 if (filedata
->section_headers_groups
== NULL
7986 || filedata
->section_headers_groups
[i
] == NULL
)
7987 i
= filedata
->file_header
.e_shnum
;
7990 g
= filedata
->section_headers_groups
[i
]->root
;
7992 for (; g
!= NULL
; g
= g
->next
)
7994 sec
= filedata
->section_headers
+ g
->section_index
;
7996 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8001 i
= filedata
->file_header
.e_shnum
;
8004 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
8006 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8007 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8008 suffix
= SECTION_NAME (unwsec
) + len
;
8009 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8011 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
8012 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8017 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8018 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8019 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8020 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8022 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
8023 suffix
= SECTION_NAME (unwsec
) + len
;
8024 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8026 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
8027 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8031 if (i
== filedata
->file_header
.e_shnum
)
8033 printf (_("\nCould not find unwind info section for "));
8035 if (filedata
->string_table
== NULL
)
8036 printf ("%d", unwsec
->sh_name
);
8038 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8042 aux
.info_addr
= sec
->sh_addr
;
8043 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8046 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8048 printf (_("\nUnwind section "));
8050 if (filedata
->string_table
== NULL
)
8051 printf ("%d", unwsec
->sh_name
);
8053 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8055 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8056 (unsigned long) unwsec
->sh_offset
,
8057 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8059 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8060 && aux
.table_len
> 0)
8061 dump_ia64_unwind (filedata
, & aux
);
8063 free ((char *) aux
.table
);
8064 free ((char *) aux
.info
);
8071 free ((char *) aux
.strtab
);
8076 struct hppa_unw_table_entry
8078 struct absaddr start
;
8080 unsigned int Cannot_unwind
:1; /* 0 */
8081 unsigned int Millicode
:1; /* 1 */
8082 unsigned int Millicode_save_sr0
:1; /* 2 */
8083 unsigned int Region_description
:2; /* 3..4 */
8084 unsigned int reserved1
:1; /* 5 */
8085 unsigned int Entry_SR
:1; /* 6 */
8086 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8087 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8088 unsigned int Args_stored
:1; /* 16 */
8089 unsigned int Variable_Frame
:1; /* 17 */
8090 unsigned int Separate_Package_Body
:1; /* 18 */
8091 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8092 unsigned int Stack_Overflow_Check
:1; /* 20 */
8093 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8094 unsigned int Ada_Region
:1; /* 22 */
8095 unsigned int cxx_info
:1; /* 23 */
8096 unsigned int cxx_try_catch
:1; /* 24 */
8097 unsigned int sched_entry_seq
:1; /* 25 */
8098 unsigned int reserved2
:1; /* 26 */
8099 unsigned int Save_SP
:1; /* 27 */
8100 unsigned int Save_RP
:1; /* 28 */
8101 unsigned int Save_MRP_in_frame
:1; /* 29 */
8102 unsigned int extn_ptr_defined
:1; /* 30 */
8103 unsigned int Cleanup_defined
:1; /* 31 */
8105 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8106 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8107 unsigned int Large_frame
:1; /* 2 */
8108 unsigned int Pseudo_SP_Set
:1; /* 3 */
8109 unsigned int reserved4
:1; /* 4 */
8110 unsigned int Total_frame_size
:27; /* 5..31 */
8113 struct hppa_unw_aux_info
8115 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8116 unsigned long table_len
; /* Length of unwind table. */
8117 bfd_vma seg_base
; /* Starting address of segment. */
8118 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8119 unsigned long nsyms
; /* Number of symbols. */
8120 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8121 unsigned long nfuns
; /* Number of entries in funtab. */
8122 char * strtab
; /* The string table. */
8123 unsigned long strtab_size
; /* Size of string table. */
8127 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8129 struct hppa_unw_table_entry
* tp
;
8130 unsigned long j
, nfuns
;
8131 bfd_boolean res
= TRUE
;
8133 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8134 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8135 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8136 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8138 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8140 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8143 const char * procname
;
8145 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8146 aux
->strtab_size
, tp
->start
, &procname
,
8149 fputs ("\n<", stdout
);
8153 fputs (procname
, stdout
);
8156 printf ("+%lx", (unsigned long) offset
);
8159 fputs (">: [", stdout
);
8160 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8161 fputc ('-', stdout
);
8162 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8165 #define PF(_m) if (tp->_m) printf (#_m " ");
8166 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8169 PF(Millicode_save_sr0
);
8170 /* PV(Region_description); */
8176 PF(Separate_Package_Body
);
8177 PF(Frame_Extension_Millicode
);
8178 PF(Stack_Overflow_Check
);
8179 PF(Two_Instruction_SP_Increment
);
8183 PF(sched_entry_seq
);
8186 PF(Save_MRP_in_frame
);
8187 PF(extn_ptr_defined
);
8188 PF(Cleanup_defined
);
8189 PF(MPE_XL_interrupt_marker
);
8190 PF(HP_UX_interrupt_marker
);
8193 PV(Total_frame_size
);
8206 slurp_hppa_unwind_table (Filedata
* filedata
,
8207 struct hppa_unw_aux_info
* aux
,
8208 Elf_Internal_Shdr
* sec
)
8210 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8211 Elf_Internal_Phdr
* seg
;
8212 struct hppa_unw_table_entry
* tep
;
8213 Elf_Internal_Shdr
* relsec
;
8214 Elf_Internal_Rela
* rela
;
8215 Elf_Internal_Rela
* rp
;
8216 unsigned char * table
;
8218 Elf_Internal_Sym
* sym
;
8219 const char * relname
;
8221 /* First, find the starting address of the segment that includes
8223 if (filedata
->file_header
.e_phnum
)
8225 if (! get_program_headers (filedata
))
8228 for (seg
= filedata
->program_headers
;
8229 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8232 if (seg
->p_type
!= PT_LOAD
)
8235 if (sec
->sh_addr
>= seg
->p_vaddr
8236 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8238 aux
->seg_base
= seg
->p_vaddr
;
8244 /* Second, build the unwind table from the contents of the unwind
8246 size
= sec
->sh_size
;
8247 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8253 nentries
= size
/ unw_ent_size
;
8254 size
= unw_ent_size
* nentries
;
8256 aux
->table_len
= nentries
;
8257 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8258 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8260 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8262 unsigned int tmp1
, tmp2
;
8264 tep
->start
.section
= SHN_UNDEF
;
8265 tep
->end
.section
= SHN_UNDEF
;
8267 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8268 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8269 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8270 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8272 tep
->start
.offset
+= aux
->seg_base
;
8273 tep
->end
.offset
+= aux
->seg_base
;
8275 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8276 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8277 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8278 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8279 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8280 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8281 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8282 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8283 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8284 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8285 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8286 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8287 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8288 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8289 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8290 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8291 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8292 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8293 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8294 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8295 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8296 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8297 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8298 tep
->Cleanup_defined
= tmp1
& 0x1;
8300 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8301 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8302 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8303 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8304 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8305 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8309 /* Third, apply any relocations to the unwind table. */
8310 for (relsec
= filedata
->section_headers
;
8311 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8314 if (relsec
->sh_type
!= SHT_RELA
8315 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8316 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8319 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8323 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8325 unsigned int sym_ndx
;
8326 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8327 relname
= elf_hppa_reloc_type (r_type
);
8329 if (relname
== NULL
)
8331 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8335 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8336 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8338 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8342 i
= rp
->r_offset
/ unw_ent_size
;
8343 if (i
>= aux
->table_len
)
8345 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8349 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8350 if (sym_ndx
>= aux
->nsyms
)
8352 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8356 sym
= aux
->symtab
+ sym_ndx
;
8358 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8361 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8362 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8365 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8366 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8380 hppa_process_unwind (Filedata
* filedata
)
8382 struct hppa_unw_aux_info aux
;
8383 Elf_Internal_Shdr
* unwsec
= NULL
;
8384 Elf_Internal_Shdr
* sec
;
8386 bfd_boolean res
= TRUE
;
8388 if (filedata
->string_table
== NULL
)
8391 memset (& aux
, 0, sizeof (aux
));
8393 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8395 if (sec
->sh_type
== SHT_SYMTAB
)
8399 error (_("Multiple symbol tables encountered\n"));
8405 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8406 &aux
.strtab
, &aux
.strtab_size
))
8409 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8414 printf (_("\nThere are no unwind sections in this file.\n"));
8416 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8418 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8420 unsigned long num_unwind
= sec
->sh_size
/ 16;
8422 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8423 "contains %lu entry:\n",
8424 "\nUnwind section '%s' at offset 0x%lx "
8425 "contains %lu entries:\n",
8427 printable_section_name (filedata
, sec
),
8428 (unsigned long) sec
->sh_offset
,
8431 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8434 if (res
&& aux
.table_len
> 0)
8436 if (! dump_hppa_unwind (filedata
, &aux
))
8440 free ((char *) aux
.table
);
8446 free ((char *) aux
.strtab
);
8453 unsigned char * data
; /* The unwind data. */
8454 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8455 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8456 unsigned long nrelas
; /* The number of relocations. */
8457 unsigned int rel_type
; /* REL or RELA ? */
8458 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8461 struct arm_unw_aux_info
8463 Filedata
* filedata
; /* The file containing the unwind sections. */
8464 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8465 unsigned long nsyms
; /* Number of symbols. */
8466 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8467 unsigned long nfuns
; /* Number of these symbols. */
8468 char * strtab
; /* The file's string table. */
8469 unsigned long strtab_size
; /* Size of string table. */
8473 arm_print_vma_and_name (Filedata
* filedata
,
8474 struct arm_unw_aux_info
* aux
,
8476 struct absaddr addr
)
8478 const char *procname
;
8481 if (addr
.section
== SHN_UNDEF
)
8484 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8485 aux
->strtab_size
, addr
, &procname
,
8488 print_vma (fn
, PREFIX_HEX
);
8492 fputs (" <", stdout
);
8493 fputs (procname
, stdout
);
8496 printf ("+0x%lx", (unsigned long) sym_offset
);
8497 fputc ('>', stdout
);
8504 arm_free_section (struct arm_section
*arm_sec
)
8506 free (arm_sec
->data
);
8507 free (arm_sec
->rela
);
8510 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8511 cached section and install SEC instead.
8512 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8513 and return its valued in * WORDP, relocating if necessary.
8514 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8515 relocation's offset in ADDR.
8516 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8517 into the string table of the symbol associated with the reloc. If no
8518 reloc was applied store -1 there.
8519 5) Return TRUE upon success, FALSE otherwise. */
8522 get_unwind_section_word (Filedata
* filedata
,
8523 struct arm_unw_aux_info
* aux
,
8524 struct arm_section
* arm_sec
,
8525 Elf_Internal_Shdr
* sec
,
8526 bfd_vma word_offset
,
8527 unsigned int * wordp
,
8528 struct absaddr
* addr
,
8531 Elf_Internal_Rela
*rp
;
8532 Elf_Internal_Sym
*sym
;
8533 const char * relname
;
8535 bfd_boolean wrapped
;
8537 if (sec
== NULL
|| arm_sec
== NULL
)
8540 addr
->section
= SHN_UNDEF
;
8543 if (sym_name
!= NULL
)
8544 *sym_name
= (bfd_vma
) -1;
8546 /* If necessary, update the section cache. */
8547 if (sec
!= arm_sec
->sec
)
8549 Elf_Internal_Shdr
*relsec
;
8551 arm_free_section (arm_sec
);
8554 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8555 sec
->sh_size
, _("unwind data"));
8556 arm_sec
->rela
= NULL
;
8557 arm_sec
->nrelas
= 0;
8559 for (relsec
= filedata
->section_headers
;
8560 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8563 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8564 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8565 /* PR 15745: Check the section type as well. */
8566 || (relsec
->sh_type
!= SHT_REL
8567 && relsec
->sh_type
!= SHT_RELA
))
8570 arm_sec
->rel_type
= relsec
->sh_type
;
8571 if (relsec
->sh_type
== SHT_REL
)
8573 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8575 & arm_sec
->rela
, & arm_sec
->nrelas
))
8578 else /* relsec->sh_type == SHT_RELA */
8580 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8582 & arm_sec
->rela
, & arm_sec
->nrelas
))
8588 arm_sec
->next_rela
= arm_sec
->rela
;
8591 /* If there is no unwind data we can do nothing. */
8592 if (arm_sec
->data
== NULL
)
8595 /* If the offset is invalid then fail. */
8596 if (/* PR 21343 *//* PR 18879 */
8598 || word_offset
> (sec
->sh_size
- 4)
8599 || ((bfd_signed_vma
) word_offset
) < 0)
8602 /* Get the word at the required offset. */
8603 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8605 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8606 if (arm_sec
->rela
== NULL
)
8612 /* Look through the relocs to find the one that applies to the provided offset. */
8614 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8616 bfd_vma prelval
, offset
;
8618 if (rp
->r_offset
> word_offset
&& !wrapped
)
8623 if (rp
->r_offset
> word_offset
)
8626 if (rp
->r_offset
& 3)
8628 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8629 (unsigned long) rp
->r_offset
);
8633 if (rp
->r_offset
< word_offset
)
8636 /* PR 17531: file: 027-161405-0.004 */
8637 if (aux
->symtab
== NULL
)
8640 if (arm_sec
->rel_type
== SHT_REL
)
8642 offset
= word
& 0x7fffffff;
8643 if (offset
& 0x40000000)
8644 offset
|= ~ (bfd_vma
) 0x7fffffff;
8646 else if (arm_sec
->rel_type
== SHT_RELA
)
8647 offset
= rp
->r_addend
;
8650 error (_("Unknown section relocation type %d encountered\n"),
8655 /* PR 17531 file: 027-1241568-0.004. */
8656 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8658 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8659 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8663 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8664 offset
+= sym
->st_value
;
8665 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8667 /* Check that we are processing the expected reloc type. */
8668 if (filedata
->file_header
.e_machine
== EM_ARM
)
8670 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8671 if (relname
== NULL
)
8673 warn (_("Skipping unknown ARM relocation type: %d\n"),
8674 (int) ELF32_R_TYPE (rp
->r_info
));
8678 if (streq (relname
, "R_ARM_NONE"))
8681 if (! streq (relname
, "R_ARM_PREL31"))
8683 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8687 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8689 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8690 if (relname
== NULL
)
8692 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8693 (int) ELF32_R_TYPE (rp
->r_info
));
8697 if (streq (relname
, "R_C6000_NONE"))
8700 if (! streq (relname
, "R_C6000_PREL31"))
8702 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8710 /* This function currently only supports ARM and TI unwinders. */
8711 warn (_("Only TI and ARM unwinders are currently supported\n"));
8715 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8716 addr
->section
= sym
->st_shndx
;
8717 addr
->offset
= offset
;
8720 * sym_name
= sym
->st_name
;
8725 arm_sec
->next_rela
= rp
;
8730 static const char *tic6x_unwind_regnames
[16] =
8732 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8733 "A14", "A13", "A12", "A11", "A10",
8734 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8738 decode_tic6x_unwind_regmask (unsigned int mask
)
8742 for (i
= 12; mask
; mask
>>= 1, i
--)
8746 fputs (tic6x_unwind_regnames
[i
], stdout
);
8748 fputs (", ", stdout
);
8754 if (remaining == 0 && more_words) \
8757 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8758 data_offset, & word, & addr, NULL)) \
8764 #define GET_OP(OP) \
8769 (OP) = word >> 24; \
8774 printf (_("[Truncated opcode]\n")); \
8777 printf ("0x%02x ", OP)
8780 decode_arm_unwind_bytecode (Filedata
* filedata
,
8781 struct arm_unw_aux_info
* aux
,
8783 unsigned int remaining
,
8784 unsigned int more_words
,
8785 bfd_vma data_offset
,
8786 Elf_Internal_Shdr
* data_sec
,
8787 struct arm_section
* data_arm_sec
)
8789 struct absaddr addr
;
8790 bfd_boolean res
= TRUE
;
8792 /* Decode the unwinding instructions. */
8795 unsigned int op
, op2
;
8804 printf (" 0x%02x ", op
);
8806 if ((op
& 0xc0) == 0x00)
8808 int offset
= ((op
& 0x3f) << 2) + 4;
8810 printf (" vsp = vsp + %d", offset
);
8812 else if ((op
& 0xc0) == 0x40)
8814 int offset
= ((op
& 0x3f) << 2) + 4;
8816 printf (" vsp = vsp - %d", offset
);
8818 else if ((op
& 0xf0) == 0x80)
8821 if (op
== 0x80 && op2
== 0)
8822 printf (_("Refuse to unwind"));
8825 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8826 bfd_boolean first
= TRUE
;
8830 for (i
= 0; i
< 12; i
++)
8831 if (mask
& (1 << i
))
8837 printf ("r%d", 4 + i
);
8842 else if ((op
& 0xf0) == 0x90)
8844 if (op
== 0x9d || op
== 0x9f)
8845 printf (_(" [Reserved]"));
8847 printf (" vsp = r%d", op
& 0x0f);
8849 else if ((op
& 0xf0) == 0xa0)
8851 int end
= 4 + (op
& 0x07);
8852 bfd_boolean first
= TRUE
;
8856 for (i
= 4; i
<= end
; i
++)
8872 else if (op
== 0xb0)
8873 printf (_(" finish"));
8874 else if (op
== 0xb1)
8877 if (op2
== 0 || (op2
& 0xf0) != 0)
8878 printf (_("[Spare]"));
8881 unsigned int mask
= op2
& 0x0f;
8882 bfd_boolean first
= TRUE
;
8886 for (i
= 0; i
< 12; i
++)
8887 if (mask
& (1 << i
))
8898 else if (op
== 0xb2)
8900 unsigned char buf
[9];
8901 unsigned int i
, len
;
8902 unsigned long offset
;
8904 for (i
= 0; i
< sizeof (buf
); i
++)
8907 if ((buf
[i
] & 0x80) == 0)
8910 if (i
== sizeof (buf
))
8912 error (_("corrupt change to vsp\n"));
8917 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8918 assert (len
== i
+ 1);
8919 offset
= offset
* 4 + 0x204;
8920 printf ("vsp = vsp + %ld", offset
);
8923 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8925 unsigned int first
, last
;
8932 printf ("pop {D%d", first
);
8934 printf ("-D%d", first
+ last
);
8937 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8939 unsigned int count
= op
& 0x07;
8943 printf ("-D%d", 8 + count
);
8946 else if (op
>= 0xc0 && op
<= 0xc5)
8948 unsigned int count
= op
& 0x07;
8950 printf (" pop {wR10");
8952 printf ("-wR%d", 10 + count
);
8955 else if (op
== 0xc6)
8957 unsigned int first
, last
;
8962 printf ("pop {wR%d", first
);
8964 printf ("-wR%d", first
+ last
);
8967 else if (op
== 0xc7)
8970 if (op2
== 0 || (op2
& 0xf0) != 0)
8971 printf (_("[Spare]"));
8974 unsigned int mask
= op2
& 0x0f;
8975 bfd_boolean first
= TRUE
;
8979 for (i
= 0; i
< 4; i
++)
8980 if (mask
& (1 << i
))
8986 printf ("wCGR%d", i
);
8993 printf (_(" [unsupported opcode]"));
9004 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9005 struct arm_unw_aux_info
* aux
,
9007 unsigned int remaining
,
9008 unsigned int more_words
,
9009 bfd_vma data_offset
,
9010 Elf_Internal_Shdr
* data_sec
,
9011 struct arm_section
* data_arm_sec
)
9013 struct absaddr addr
;
9015 /* Decode the unwinding instructions. */
9018 unsigned int op
, op2
;
9027 printf (" 0x%02x ", op
);
9029 if ((op
& 0xc0) == 0x00)
9031 int offset
= ((op
& 0x3f) << 3) + 8;
9032 printf (" sp = sp + %d", offset
);
9034 else if ((op
& 0xc0) == 0x80)
9037 if (op
== 0x80 && op2
== 0)
9038 printf (_("Refuse to unwind"));
9041 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9043 printf ("pop compact {");
9047 decode_tic6x_unwind_regmask (mask
);
9051 else if ((op
& 0xf0) == 0xc0)
9059 unsigned int offset
;
9063 /* Scan entire instruction first so that GET_OP output is not
9064 interleaved with disassembly. */
9066 for (i
= 0; nregs
< (op
& 0xf); i
++)
9072 regpos
[nregs
].offset
= i
* 2;
9073 regpos
[nregs
].reg
= reg
;
9080 regpos
[nregs
].offset
= i
* 2 + 1;
9081 regpos
[nregs
].reg
= reg
;
9086 printf (_("pop frame {"));
9089 printf (_("*corrupt* - no registers specified"));
9094 for (i
= i
* 2; i
> 0; i
--)
9096 if (regpos
[reg
].offset
== i
- 1)
9098 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9105 fputs (name
, stdout
);
9113 else if (op
== 0xd0)
9114 printf (" MOV FP, SP");
9115 else if (op
== 0xd1)
9116 printf (" __c6xabi_pop_rts");
9117 else if (op
== 0xd2)
9119 unsigned char buf
[9];
9120 unsigned int i
, len
;
9121 unsigned long offset
;
9123 for (i
= 0; i
< sizeof (buf
); i
++)
9126 if ((buf
[i
] & 0x80) == 0)
9129 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9130 if (i
== sizeof (buf
))
9132 warn (_("Corrupt stack pointer adjustment detected\n"));
9136 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9137 assert (len
== i
+ 1);
9138 offset
= offset
* 8 + 0x408;
9139 printf (_("sp = sp + %ld"), offset
);
9141 else if ((op
& 0xf0) == 0xe0)
9143 if ((op
& 0x0f) == 7)
9146 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9150 printf (_(" [unsupported opcode]"));
9159 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9163 offset
= word
& 0x7fffffff;
9164 if (offset
& 0x40000000)
9165 offset
|= ~ (bfd_vma
) 0x7fffffff;
9167 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9170 return offset
+ where
;
9174 decode_arm_unwind (Filedata
* filedata
,
9175 struct arm_unw_aux_info
* aux
,
9177 unsigned int remaining
,
9178 bfd_vma data_offset
,
9179 Elf_Internal_Shdr
* data_sec
,
9180 struct arm_section
* data_arm_sec
)
9183 unsigned int more_words
= 0;
9184 struct absaddr addr
;
9185 bfd_vma sym_name
= (bfd_vma
) -1;
9186 bfd_boolean res
= TRUE
;
9190 /* Fetch the first word.
9191 Note - when decoding an object file the address extracted
9192 here will always be 0. So we also pass in the sym_name
9193 parameter so that we can find the symbol associated with
9194 the personality routine. */
9195 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9196 & word
, & addr
, & sym_name
))
9203 addr
.section
= SHN_UNDEF
;
9207 if ((word
& 0x80000000) == 0)
9209 /* Expand prel31 for personality routine. */
9211 const char *procname
;
9213 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9214 printf (_(" Personality routine: "));
9216 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9217 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9219 procname
= aux
->strtab
+ sym_name
;
9220 print_vma (fn
, PREFIX_HEX
);
9223 fputs (" <", stdout
);
9224 fputs (procname
, stdout
);
9225 fputc ('>', stdout
);
9229 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9230 fputc ('\n', stdout
);
9232 /* The GCC personality routines use the standard compact
9233 encoding, starting with one byte giving the number of
9235 if (procname
!= NULL
9236 && (const_strneq (procname
, "__gcc_personality_v0")
9237 || const_strneq (procname
, "__gxx_personality_v0")
9238 || const_strneq (procname
, "__gcj_personality_v0")
9239 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9246 printf (_(" [Truncated data]\n"));
9249 more_words
= word
>> 24;
9259 /* ARM EHABI Section 6.3:
9261 An exception-handling table entry for the compact model looks like:
9265 1 0 index Data for personalityRoutine[index] */
9267 if (filedata
->file_header
.e_machine
== EM_ARM
9268 && (word
& 0x70000000))
9270 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9274 per_index
= (word
>> 24) & 0x7f;
9275 printf (_(" Compact model index: %d\n"), per_index
);
9282 else if (per_index
< 3)
9284 more_words
= (word
>> 16) & 0xff;
9290 switch (filedata
->file_header
.e_machine
)
9295 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9296 data_offset
, data_sec
, data_arm_sec
))
9301 warn (_("Unknown ARM compact model index encountered\n"));
9302 printf (_(" [reserved]\n"));
9310 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9311 data_offset
, data_sec
, data_arm_sec
))
9314 else if (per_index
< 5)
9316 if (((word
>> 17) & 0x7f) == 0x7f)
9317 printf (_(" Restore stack from frame pointer\n"));
9319 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9320 printf (_(" Registers restored: "));
9322 printf (" (compact) ");
9323 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9325 printf (_(" Return register: %s\n"),
9326 tic6x_unwind_regnames
[word
& 0xf]);
9329 printf (_(" [reserved (%d)]\n"), per_index
);
9333 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9334 filedata
->file_header
.e_machine
);
9338 /* Decode the descriptors. Not implemented. */
9344 dump_arm_unwind (Filedata
* filedata
,
9345 struct arm_unw_aux_info
* aux
,
9346 Elf_Internal_Shdr
* exidx_sec
)
9348 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9349 unsigned int i
, exidx_len
;
9350 unsigned long j
, nfuns
;
9351 bfd_boolean res
= TRUE
;
9353 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9354 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9355 exidx_len
= exidx_sec
->sh_size
/ 8;
9357 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9358 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9359 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9360 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9362 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9364 for (i
= 0; i
< exidx_len
; i
++)
9366 unsigned int exidx_fn
, exidx_entry
;
9367 struct absaddr fn_addr
, entry_addr
;
9370 fputc ('\n', stdout
);
9372 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9373 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9374 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9375 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9378 arm_free_section (& exidx_arm_sec
);
9379 arm_free_section (& extab_arm_sec
);
9383 /* ARM EHABI, Section 5:
9384 An index table entry consists of 2 words.
9385 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9386 if (exidx_fn
& 0x80000000)
9388 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9392 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9394 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9395 fputs (": ", stdout
);
9397 if (exidx_entry
== 1)
9399 print_vma (exidx_entry
, PREFIX_HEX
);
9400 fputs (" [cantunwind]\n", stdout
);
9402 else if (exidx_entry
& 0x80000000)
9404 print_vma (exidx_entry
, PREFIX_HEX
);
9405 fputc ('\n', stdout
);
9406 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9410 bfd_vma table
, table_offset
= 0;
9411 Elf_Internal_Shdr
*table_sec
;
9413 fputs ("@", stdout
);
9414 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9415 print_vma (table
, PREFIX_HEX
);
9418 /* Locate the matching .ARM.extab. */
9419 if (entry_addr
.section
!= SHN_UNDEF
9420 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9422 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9423 table_offset
= entry_addr
.offset
;
9425 if (table_offset
> table_sec
->sh_size
9426 || ((bfd_signed_vma
) table_offset
) < 0)
9428 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9429 (unsigned long) table_offset
,
9430 printable_section_name (filedata
, table_sec
));
9437 table_sec
= find_section_by_address (filedata
, table
);
9438 if (table_sec
!= NULL
)
9439 table_offset
= table
- table_sec
->sh_addr
;
9442 if (table_sec
== NULL
)
9444 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9445 (unsigned long) table
);
9450 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9459 arm_free_section (&exidx_arm_sec
);
9460 arm_free_section (&extab_arm_sec
);
9465 /* Used for both ARM and C6X unwinding tables. */
9468 arm_process_unwind (Filedata
* filedata
)
9470 struct arm_unw_aux_info aux
;
9471 Elf_Internal_Shdr
*unwsec
= NULL
;
9472 Elf_Internal_Shdr
*sec
;
9474 unsigned int sec_type
;
9475 bfd_boolean res
= TRUE
;
9477 switch (filedata
->file_header
.e_machine
)
9480 sec_type
= SHT_ARM_EXIDX
;
9484 sec_type
= SHT_C6000_UNWIND
;
9488 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9489 filedata
->file_header
.e_machine
);
9493 if (filedata
->string_table
== NULL
)
9496 memset (& aux
, 0, sizeof (aux
));
9497 aux
.filedata
= filedata
;
9499 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9501 if (sec
->sh_type
== SHT_SYMTAB
)
9505 error (_("Multiple symbol tables encountered\n"));
9511 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9512 &aux
.strtab
, &aux
.strtab_size
))
9515 else if (sec
->sh_type
== sec_type
)
9520 printf (_("\nThere are no unwind sections in this file.\n"));
9522 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9524 if (sec
->sh_type
== sec_type
)
9526 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9527 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9528 "contains %lu entry:\n",
9529 "\nUnwind section '%s' at offset 0x%lx "
9530 "contains %lu entries:\n",
9532 printable_section_name (filedata
, sec
),
9533 (unsigned long) sec
->sh_offset
,
9536 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9542 free ((char *) aux
.strtab
);
9548 process_unwind (Filedata
* filedata
)
9550 struct unwind_handler
9552 unsigned int machtype
;
9553 bfd_boolean (* handler
)(Filedata
*);
9556 { EM_ARM
, arm_process_unwind
},
9557 { EM_IA_64
, ia64_process_unwind
},
9558 { EM_PARISC
, hppa_process_unwind
},
9559 { EM_TI_C6000
, arm_process_unwind
},
9567 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9568 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9569 return handlers
[i
].handler (filedata
);
9571 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9572 get_machine_name (filedata
->file_header
.e_machine
));
9577 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9579 switch (entry
->d_tag
)
9581 case DT_AARCH64_BTI_PLT
:
9582 case DT_AARCH64_PAC_PLT
:
9585 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9592 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9594 switch (entry
->d_tag
)
9597 if (entry
->d_un
.d_val
== 0)
9601 static const char * opts
[] =
9603 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9604 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9605 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9606 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9610 bfd_boolean first
= TRUE
;
9612 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9613 if (entry
->d_un
.d_val
& (1 << cnt
))
9615 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9621 case DT_MIPS_IVERSION
:
9622 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9623 printf (_("Interface Version: %s"),
9624 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9628 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9629 /* Note: coded this way so that there is a single string for translation. */
9630 printf (_("<corrupt: %s>"), buf
);
9634 case DT_MIPS_TIME_STAMP
:
9638 time_t atime
= entry
->d_un
.d_val
;
9640 tmp
= gmtime (&atime
);
9641 /* PR 17531: file: 6accc532. */
9643 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9645 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9646 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9647 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9648 printf (_("Time Stamp: %s"), timebuf
);
9652 case DT_MIPS_RLD_VERSION
:
9653 case DT_MIPS_LOCAL_GOTNO
:
9654 case DT_MIPS_CONFLICTNO
:
9655 case DT_MIPS_LIBLISTNO
:
9656 case DT_MIPS_SYMTABNO
:
9657 case DT_MIPS_UNREFEXTNO
:
9658 case DT_MIPS_HIPAGENO
:
9659 case DT_MIPS_DELTA_CLASS_NO
:
9660 case DT_MIPS_DELTA_INSTANCE_NO
:
9661 case DT_MIPS_DELTA_RELOC_NO
:
9662 case DT_MIPS_DELTA_SYM_NO
:
9663 case DT_MIPS_DELTA_CLASSSYM_NO
:
9664 case DT_MIPS_COMPACT_SIZE
:
9665 print_vma (entry
->d_un
.d_val
, DEC
);
9669 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9670 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9671 /* Falls through. */
9674 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9680 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9682 switch (entry
->d_tag
)
9684 case DT_HP_DLD_FLAGS
:
9693 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9694 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9695 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9696 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9697 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9698 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9699 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9700 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9701 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9702 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9703 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9704 { DT_HP_GST
, "HP_GST" },
9705 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9706 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9707 { DT_HP_NODELETE
, "HP_NODELETE" },
9708 { DT_HP_GROUP
, "HP_GROUP" },
9709 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9711 bfd_boolean first
= TRUE
;
9713 bfd_vma val
= entry
->d_un
.d_val
;
9715 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9716 if (val
& flags
[cnt
].bit
)
9720 fputs (flags
[cnt
].str
, stdout
);
9722 val
^= flags
[cnt
].bit
;
9725 if (val
!= 0 || first
)
9729 print_vma (val
, HEX
);
9735 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9743 /* VMS vs Unix time offset and factor. */
9745 #define VMS_EPOCH_OFFSET 35067168000000000LL
9746 #define VMS_GRANULARITY_FACTOR 10000000
9748 /* Display a VMS time in a human readable format. */
9751 print_vms_time (bfd_int64_t vmstime
)
9756 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9757 tm
= gmtime (&unxtime
);
9758 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9759 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9760 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9765 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9767 switch (entry
->d_tag
)
9769 case DT_IA_64_PLT_RESERVE
:
9770 /* First 3 slots reserved. */
9771 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9773 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9776 case DT_IA_64_VMS_LINKTIME
:
9778 print_vms_time (entry
->d_un
.d_val
);
9782 case DT_IA_64_VMS_LNKFLAGS
:
9783 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9784 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9785 printf (" CALL_DEBUG");
9786 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9787 printf (" NOP0BUFS");
9788 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9789 printf (" P0IMAGE");
9790 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9791 printf (" MKTHREADS");
9792 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9793 printf (" UPCALLS");
9794 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9796 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9797 printf (" INITIALIZE");
9798 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9800 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9801 printf (" EXE_INIT");
9802 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9803 printf (" TBK_IN_IMG");
9804 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9805 printf (" DBG_IN_IMG");
9806 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9807 printf (" TBK_IN_DSF");
9808 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9809 printf (" DBG_IN_DSF");
9810 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9811 printf (" SIGNATURES");
9812 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9813 printf (" REL_SEG_OFF");
9817 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9824 get_32bit_dynamic_section (Filedata
* filedata
)
9826 Elf32_External_Dyn
* edyn
;
9827 Elf32_External_Dyn
* ext
;
9828 Elf_Internal_Dyn
* entry
;
9830 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9831 filedata
->dynamic_addr
, 1,
9832 filedata
->dynamic_size
,
9833 _("dynamic section"));
9837 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9838 might not have the luxury of section headers. Look for the DT_NULL
9839 terminator to determine the number of entries. */
9840 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9841 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9844 filedata
->dynamic_nent
++;
9845 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9849 filedata
->dynamic_section
9850 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9851 if (filedata
->dynamic_section
== NULL
)
9853 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9854 (unsigned long) filedata
->dynamic_nent
);
9859 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9860 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9863 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9864 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9873 get_64bit_dynamic_section (Filedata
* filedata
)
9875 Elf64_External_Dyn
* edyn
;
9876 Elf64_External_Dyn
* ext
;
9877 Elf_Internal_Dyn
* entry
;
9879 /* Read in the data. */
9880 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9881 filedata
->dynamic_addr
, 1,
9882 filedata
->dynamic_size
,
9883 _("dynamic section"));
9887 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9888 might not have the luxury of section headers. Look for the DT_NULL
9889 terminator to determine the number of entries. */
9890 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9891 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9892 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9895 filedata
->dynamic_nent
++;
9896 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9900 filedata
->dynamic_section
9901 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9902 if (filedata
->dynamic_section
== NULL
)
9904 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9905 (unsigned long) filedata
->dynamic_nent
);
9910 /* Convert from external to internal formats. */
9911 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9912 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9915 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9916 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9925 print_dynamic_flags (bfd_vma flags
)
9927 bfd_boolean first
= TRUE
;
9933 flag
= flags
& - flags
;
9943 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9944 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9945 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9946 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9947 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9948 default: fputs (_("unknown"), stdout
); break;
9955 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9957 unsigned char * e_data
;
9960 /* If the size_t type is smaller than the bfd_size_type, eg because
9961 you are building a 32-bit tool on a 64-bit host, then make sure
9962 that when (number) is cast to (size_t) no information is lost. */
9963 if (sizeof (size_t) < sizeof (bfd_size_type
)
9964 && (bfd_size_type
) ((size_t) number
) != number
)
9966 error (_("Size truncation prevents reading %s elements of size %u\n"),
9967 bfd_vmatoa ("u", number
), ent_size
);
9971 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9972 attempting to allocate memory when the read is bound to fail. */
9973 if (ent_size
* number
> filedata
->file_size
)
9975 error (_("Invalid number of dynamic entries: %s\n"),
9976 bfd_vmatoa ("u", number
));
9980 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9983 error (_("Out of memory reading %s dynamic entries\n"),
9984 bfd_vmatoa ("u", number
));
9988 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9990 error (_("Unable to read in %s bytes of dynamic data\n"),
9991 bfd_vmatoa ("u", number
* ent_size
));
9996 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
9999 error (_("Out of memory allocating space for %s dynamic entries\n"),
10000 bfd_vmatoa ("u", number
));
10006 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10013 static unsigned long
10014 get_num_dynamic_syms (Filedata
* filedata
)
10016 unsigned long num_of_syms
= 0;
10018 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10019 return num_of_syms
;
10021 if (filedata
->dynamic_info
[DT_HASH
])
10023 unsigned char nb
[8];
10024 unsigned char nc
[8];
10025 unsigned int hash_ent_size
= 4;
10027 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10028 || filedata
->file_header
.e_machine
== EM_S390
10029 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10030 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10033 if (fseek (filedata
->handle
,
10034 (filedata
->archive_file_offset
10035 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10036 sizeof nb
+ sizeof nc
)),
10039 error (_("Unable to seek to start of dynamic information\n"));
10043 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10045 error (_("Failed to read in number of buckets\n"));
10049 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10051 error (_("Failed to read in number of chains\n"));
10055 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10056 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10058 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10060 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10062 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10065 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10066 num_of_syms
= filedata
->nchains
;
10069 if (num_of_syms
== 0)
10071 free (filedata
->buckets
);
10072 filedata
->buckets
= NULL
;
10073 free (filedata
->chains
);
10074 filedata
->chains
= NULL
;
10075 filedata
->nbuckets
= 0;
10079 if (filedata
->dynamic_info_DT_GNU_HASH
)
10081 unsigned char nb
[16];
10082 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10083 bfd_vma buckets_vma
;
10086 if (fseek (filedata
->handle
,
10087 (filedata
->archive_file_offset
10088 + offset_from_vma (filedata
,
10089 filedata
->dynamic_info_DT_GNU_HASH
,
10093 error (_("Unable to seek to start of dynamic information\n"));
10097 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10099 error (_("Failed to read in number of buckets\n"));
10103 filedata
->ngnubuckets
= byte_get (nb
, 4);
10104 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10105 bitmaskwords
= byte_get (nb
+ 8, 4);
10106 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10108 buckets_vma
+= bitmaskwords
* 4;
10110 buckets_vma
+= bitmaskwords
* 8;
10112 if (fseek (filedata
->handle
,
10113 (filedata
->archive_file_offset
10114 + offset_from_vma (filedata
, buckets_vma
, 4)),
10117 error (_("Unable to seek to start of dynamic information\n"));
10121 filedata
->gnubuckets
10122 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10124 if (filedata
->gnubuckets
== NULL
)
10127 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10128 if (filedata
->gnubuckets
[i
] != 0)
10130 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10133 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10134 maxchain
= filedata
->gnubuckets
[i
];
10137 if (maxchain
== 0xffffffff)
10140 maxchain
-= filedata
->gnusymidx
;
10142 if (fseek (filedata
->handle
,
10143 (filedata
->archive_file_offset
10144 + offset_from_vma (filedata
,
10145 buckets_vma
+ 4 * (filedata
->ngnubuckets
10150 error (_("Unable to seek to start of dynamic information\n"));
10156 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10158 error (_("Failed to determine last chain length\n"));
10162 if (maxchain
+ 1 == 0)
10167 while ((byte_get (nb
, 4) & 1) == 0);
10169 if (fseek (filedata
->handle
,
10170 (filedata
->archive_file_offset
10171 + offset_from_vma (filedata
, (buckets_vma
10172 + 4 * filedata
->ngnubuckets
),
10176 error (_("Unable to seek to start of dynamic information\n"));
10180 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10181 filedata
->ngnuchains
= maxchain
;
10183 if (filedata
->gnuchains
== NULL
)
10186 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10188 if (fseek (filedata
->handle
,
10189 (filedata
->archive_file_offset
10190 + offset_from_vma (filedata
, (buckets_vma
10191 + 4 * (filedata
->ngnubuckets
10195 error (_("Unable to seek to start of dynamic information\n"));
10199 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10200 if (filedata
->mipsxlat
== NULL
)
10204 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10205 if (filedata
->gnubuckets
[hn
] != 0)
10207 bfd_vma si
= filedata
->gnubuckets
[hn
];
10208 bfd_vma off
= si
- filedata
->gnusymidx
;
10212 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10214 if (off
< filedata
->ngnuchains
10215 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10216 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10220 if (si
>= num_of_syms
)
10221 num_of_syms
= si
+ 1;
10225 while (off
< filedata
->ngnuchains
10226 && (filedata
->gnuchains
[off
++] & 1) == 0);
10229 if (num_of_syms
== 0)
10232 free (filedata
->mipsxlat
);
10233 filedata
->mipsxlat
= NULL
;
10234 free (filedata
->gnuchains
);
10235 filedata
->gnuchains
= NULL
;
10236 free (filedata
->gnubuckets
);
10237 filedata
->gnubuckets
= NULL
;
10238 filedata
->ngnubuckets
= 0;
10239 filedata
->ngnuchains
= 0;
10243 return num_of_syms
;
10246 /* Parse and display the contents of the dynamic section. */
10249 process_dynamic_section (Filedata
* filedata
)
10251 Elf_Internal_Dyn
* entry
;
10253 if (filedata
->dynamic_size
== 0)
10256 printf (_("\nThere is no dynamic section in this file.\n"));
10263 if (! get_32bit_dynamic_section (filedata
))
10268 if (! get_64bit_dynamic_section (filedata
))
10272 /* Find the appropriate symbol table. */
10273 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10275 unsigned long num_of_syms
;
10277 for (entry
= filedata
->dynamic_section
;
10278 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10280 if (entry
->d_tag
== DT_SYMTAB
)
10281 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10282 else if (entry
->d_tag
== DT_SYMENT
)
10283 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10284 else if (entry
->d_tag
== DT_HASH
)
10285 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10286 else if (entry
->d_tag
== DT_GNU_HASH
)
10287 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10288 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10289 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10290 && entry
->d_tag
== DT_MIPS_XHASH
)
10292 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10293 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10296 num_of_syms
= get_num_dynamic_syms (filedata
);
10298 if (num_of_syms
!= 0
10299 && filedata
->dynamic_symbols
== NULL
10300 && filedata
->dynamic_info
[DT_SYMTAB
]
10301 && filedata
->dynamic_info
[DT_SYMENT
])
10303 Elf_Internal_Phdr
*seg
;
10304 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10306 if (! get_program_headers (filedata
))
10308 error (_("Cannot interpret virtual addresses "
10309 "without program headers.\n"));
10313 for (seg
= filedata
->program_headers
;
10314 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10317 if (seg
->p_type
!= PT_LOAD
)
10320 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10322 /* See PR 21379 for a reproducer. */
10323 error (_("Invalid PT_LOAD entry\n"));
10327 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10328 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10330 /* Since we do not know how big the symbol table is,
10331 we default to reading in up to the end of PT_LOAD
10332 segment and processing that. This is overkill, I
10333 know, but it should work. */
10334 Elf_Internal_Shdr section
;
10335 section
.sh_offset
= (vma
- seg
->p_vaddr
10337 section
.sh_size
= (num_of_syms
10338 * filedata
->dynamic_info
[DT_SYMENT
]);
10339 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10342 && filedata
->dynamic_symtab_section
!= NULL
10343 && ((filedata
->dynamic_symtab_section
->sh_offset
10344 != section
.sh_offset
)
10345 || (filedata
->dynamic_symtab_section
->sh_size
10346 != section
.sh_size
)
10347 || (filedata
->dynamic_symtab_section
->sh_entsize
10348 != section
.sh_entsize
)))
10350 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10352 section
.sh_name
= filedata
->string_table_length
;
10353 filedata
->dynamic_symbols
10354 = GET_ELF_SYMBOLS (filedata
, §ion
,
10355 &filedata
->num_dynamic_syms
);
10356 if (filedata
->dynamic_symbols
== NULL
10357 || filedata
->num_dynamic_syms
!= num_of_syms
)
10359 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10368 /* Similarly find a string table. */
10369 if (filedata
->dynamic_strings
== NULL
)
10370 for (entry
= filedata
->dynamic_section
;
10371 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10374 if (entry
->d_tag
== DT_STRTAB
)
10375 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10377 if (entry
->d_tag
== DT_STRSZ
)
10378 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10380 if (filedata
->dynamic_info
[DT_STRTAB
]
10381 && filedata
->dynamic_info
[DT_STRSZ
])
10383 unsigned long offset
;
10384 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10386 offset
= offset_from_vma (filedata
,
10387 filedata
->dynamic_info
[DT_STRTAB
],
10390 && filedata
->dynamic_strtab_section
10391 && ((filedata
->dynamic_strtab_section
->sh_offset
10392 != (file_ptr
) offset
)
10393 || (filedata
->dynamic_strtab_section
->sh_size
10396 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10398 filedata
->dynamic_strings
10399 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10400 _("dynamic string table"));
10401 if (filedata
->dynamic_strings
== NULL
)
10403 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10407 filedata
->dynamic_strings_length
= str_tab_len
;
10412 /* And find the syminfo section if available. */
10413 if (filedata
->dynamic_syminfo
== NULL
)
10415 unsigned long syminsz
= 0;
10417 for (entry
= filedata
->dynamic_section
;
10418 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10421 if (entry
->d_tag
== DT_SYMINENT
)
10423 /* Note: these braces are necessary to avoid a syntax
10424 error from the SunOS4 C compiler. */
10425 /* PR binutils/17531: A corrupt file can trigger this test.
10426 So do not use an assert, instead generate an error message. */
10427 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10428 error (_("Bad value (%d) for SYMINENT entry\n"),
10429 (int) entry
->d_un
.d_val
);
10431 else if (entry
->d_tag
== DT_SYMINSZ
)
10432 syminsz
= entry
->d_un
.d_val
;
10433 else if (entry
->d_tag
== DT_SYMINFO
)
10434 filedata
->dynamic_syminfo_offset
10435 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10438 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10440 Elf_External_Syminfo
* extsyminfo
;
10441 Elf_External_Syminfo
* extsym
;
10442 Elf_Internal_Syminfo
* syminfo
;
10444 /* There is a syminfo section. Read the data. */
10445 extsyminfo
= (Elf_External_Syminfo
*)
10446 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10447 1, syminsz
, _("symbol information"));
10451 if (filedata
->dynamic_syminfo
!= NULL
)
10453 error (_("Multiple dynamic symbol information sections found\n"));
10454 free (filedata
->dynamic_syminfo
);
10456 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10457 if (filedata
->dynamic_syminfo
== NULL
)
10459 error (_("Out of memory allocating %lu bytes "
10460 "for dynamic symbol info\n"),
10461 (unsigned long) syminsz
);
10465 filedata
->dynamic_syminfo_nent
10466 = syminsz
/ sizeof (Elf_External_Syminfo
);
10467 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10468 syminfo
< (filedata
->dynamic_syminfo
10469 + filedata
->dynamic_syminfo_nent
);
10470 ++syminfo
, ++extsym
)
10472 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10473 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10480 if (do_dynamic
&& filedata
->dynamic_addr
)
10481 printf (ngettext ("\nDynamic section at offset 0x%lx "
10482 "contains %lu entry:\n",
10483 "\nDynamic section at offset 0x%lx "
10484 "contains %lu entries:\n",
10485 filedata
->dynamic_nent
),
10486 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10488 printf (_(" Tag Type Name/Value\n"));
10490 for (entry
= filedata
->dynamic_section
;
10491 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10496 const char * dtype
;
10499 print_vma (entry
->d_tag
, FULL_HEX
);
10500 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10501 printf (" (%s)%*s", dtype
,
10502 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10505 switch (entry
->d_tag
)
10509 print_dynamic_flags (entry
->d_un
.d_val
);
10519 switch (entry
->d_tag
)
10522 printf (_("Auxiliary library"));
10526 printf (_("Filter library"));
10530 printf (_("Configuration file"));
10534 printf (_("Dependency audit library"));
10538 printf (_("Audit library"));
10542 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10543 printf (": [%s]\n",
10544 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10548 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10557 printf (_("Flags:"));
10559 if (entry
->d_un
.d_val
== 0)
10560 printf (_(" None\n"));
10563 unsigned long int val
= entry
->d_un
.d_val
;
10565 if (val
& DTF_1_PARINIT
)
10567 printf (" PARINIT");
10568 val
^= DTF_1_PARINIT
;
10570 if (val
& DTF_1_CONFEXP
)
10572 printf (" CONFEXP");
10573 val
^= DTF_1_CONFEXP
;
10576 printf (" %lx", val
);
10585 printf (_("Flags:"));
10587 if (entry
->d_un
.d_val
== 0)
10588 printf (_(" None\n"));
10591 unsigned long int val
= entry
->d_un
.d_val
;
10593 if (val
& DF_P1_LAZYLOAD
)
10595 printf (" LAZYLOAD");
10596 val
^= DF_P1_LAZYLOAD
;
10598 if (val
& DF_P1_GROUPPERM
)
10600 printf (" GROUPPERM");
10601 val
^= DF_P1_GROUPPERM
;
10604 printf (" %lx", val
);
10613 printf (_("Flags:"));
10614 if (entry
->d_un
.d_val
== 0)
10615 printf (_(" None\n"));
10618 unsigned long int val
= entry
->d_un
.d_val
;
10620 if (val
& DF_1_NOW
)
10625 if (val
& DF_1_GLOBAL
)
10627 printf (" GLOBAL");
10628 val
^= DF_1_GLOBAL
;
10630 if (val
& DF_1_GROUP
)
10635 if (val
& DF_1_NODELETE
)
10637 printf (" NODELETE");
10638 val
^= DF_1_NODELETE
;
10640 if (val
& DF_1_LOADFLTR
)
10642 printf (" LOADFLTR");
10643 val
^= DF_1_LOADFLTR
;
10645 if (val
& DF_1_INITFIRST
)
10647 printf (" INITFIRST");
10648 val
^= DF_1_INITFIRST
;
10650 if (val
& DF_1_NOOPEN
)
10652 printf (" NOOPEN");
10653 val
^= DF_1_NOOPEN
;
10655 if (val
& DF_1_ORIGIN
)
10657 printf (" ORIGIN");
10658 val
^= DF_1_ORIGIN
;
10660 if (val
& DF_1_DIRECT
)
10662 printf (" DIRECT");
10663 val
^= DF_1_DIRECT
;
10665 if (val
& DF_1_TRANS
)
10670 if (val
& DF_1_INTERPOSE
)
10672 printf (" INTERPOSE");
10673 val
^= DF_1_INTERPOSE
;
10675 if (val
& DF_1_NODEFLIB
)
10677 printf (" NODEFLIB");
10678 val
^= DF_1_NODEFLIB
;
10680 if (val
& DF_1_NODUMP
)
10682 printf (" NODUMP");
10683 val
^= DF_1_NODUMP
;
10685 if (val
& DF_1_CONFALT
)
10687 printf (" CONFALT");
10688 val
^= DF_1_CONFALT
;
10690 if (val
& DF_1_ENDFILTEE
)
10692 printf (" ENDFILTEE");
10693 val
^= DF_1_ENDFILTEE
;
10695 if (val
& DF_1_DISPRELDNE
)
10697 printf (" DISPRELDNE");
10698 val
^= DF_1_DISPRELDNE
;
10700 if (val
& DF_1_DISPRELPND
)
10702 printf (" DISPRELPND");
10703 val
^= DF_1_DISPRELPND
;
10705 if (val
& DF_1_NODIRECT
)
10707 printf (" NODIRECT");
10708 val
^= DF_1_NODIRECT
;
10710 if (val
& DF_1_IGNMULDEF
)
10712 printf (" IGNMULDEF");
10713 val
^= DF_1_IGNMULDEF
;
10715 if (val
& DF_1_NOKSYMS
)
10717 printf (" NOKSYMS");
10718 val
^= DF_1_NOKSYMS
;
10720 if (val
& DF_1_NOHDR
)
10725 if (val
& DF_1_EDITED
)
10727 printf (" EDITED");
10728 val
^= DF_1_EDITED
;
10730 if (val
& DF_1_NORELOC
)
10732 printf (" NORELOC");
10733 val
^= DF_1_NORELOC
;
10735 if (val
& DF_1_SYMINTPOSE
)
10737 printf (" SYMINTPOSE");
10738 val
^= DF_1_SYMINTPOSE
;
10740 if (val
& DF_1_GLOBAUDIT
)
10742 printf (" GLOBAUDIT");
10743 val
^= DF_1_GLOBAUDIT
;
10745 if (val
& DF_1_SINGLETON
)
10747 printf (" SINGLETON");
10748 val
^= DF_1_SINGLETON
;
10750 if (val
& DF_1_STUB
)
10755 if (val
& DF_1_PIE
)
10760 if (val
& DF_1_KMOD
)
10765 if (val
& DF_1_WEAKFILTER
)
10767 printf (" WEAKFILTER");
10768 val
^= DF_1_WEAKFILTER
;
10770 if (val
& DF_1_NOCOMMON
)
10772 printf (" NOCOMMON");
10773 val
^= DF_1_NOCOMMON
;
10776 printf (" %lx", val
);
10783 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10785 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10805 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10811 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10812 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10818 switch (entry
->d_tag
)
10821 printf (_("Shared library: [%s]"), name
);
10823 if (streq (name
, filedata
->program_interpreter
))
10824 printf (_(" program interpreter"));
10828 printf (_("Library soname: [%s]"), name
);
10832 printf (_("Library rpath: [%s]"), name
);
10836 printf (_("Library runpath: [%s]"), name
);
10840 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10845 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10858 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10859 /* Fall through. */
10863 case DT_INIT_ARRAYSZ
:
10864 case DT_FINI_ARRAYSZ
:
10865 case DT_GNU_CONFLICTSZ
:
10866 case DT_GNU_LIBLISTSZ
:
10869 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10870 printf (_(" (bytes)\n"));
10875 case DT_VERNEEDNUM
:
10880 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10889 case DT_INIT_ARRAY
:
10890 case DT_FINI_ARRAY
:
10893 if (entry
->d_tag
== DT_USED
10894 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10896 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10900 printf (_("Not needed object: [%s]\n"), name
);
10905 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10911 /* The value of this entry is ignored. */
10916 case DT_GNU_PRELINKED
:
10920 time_t atime
= entry
->d_un
.d_val
;
10922 tmp
= gmtime (&atime
);
10923 /* PR 17533 file: 041-1244816-0.004. */
10925 printf (_("<corrupt time val: %lx"),
10926 (unsigned long) atime
);
10928 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10929 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10930 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10936 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10939 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10945 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10946 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10947 = entry
->d_un
.d_val
;
10951 switch (filedata
->file_header
.e_machine
)
10954 dynamic_section_aarch64_val (entry
);
10957 case EM_MIPS_RS3_LE
:
10958 dynamic_section_mips_val (filedata
, entry
);
10961 dynamic_section_parisc_val (entry
);
10964 dynamic_section_ia64_val (entry
);
10967 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10979 get_ver_flags (unsigned int flags
)
10981 static char buff
[128];
10988 if (flags
& VER_FLG_BASE
)
10989 strcat (buff
, "BASE");
10991 if (flags
& VER_FLG_WEAK
)
10993 if (flags
& VER_FLG_BASE
)
10994 strcat (buff
, " | ");
10996 strcat (buff
, "WEAK");
10999 if (flags
& VER_FLG_INFO
)
11001 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11002 strcat (buff
, " | ");
11004 strcat (buff
, "INFO");
11007 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11009 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11010 strcat (buff
, " | ");
11012 strcat (buff
, _("<unknown>"));
11018 /* Display the contents of the version sections. */
11021 process_version_sections (Filedata
* filedata
)
11023 Elf_Internal_Shdr
* section
;
11025 bfd_boolean found
= FALSE
;
11030 for (i
= 0, section
= filedata
->section_headers
;
11031 i
< filedata
->file_header
.e_shnum
;
11034 switch (section
->sh_type
)
11036 case SHT_GNU_verdef
:
11038 Elf_External_Verdef
* edefs
;
11045 printf (ngettext ("\nVersion definition section '%s' "
11046 "contains %u entry:\n",
11047 "\nVersion definition section '%s' "
11048 "contains %u entries:\n",
11050 printable_section_name (filedata
, section
),
11053 printf (_(" Addr: 0x"));
11054 printf_vma (section
->sh_addr
);
11055 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11056 (unsigned long) section
->sh_offset
, section
->sh_link
,
11057 printable_section_name_from_index (filedata
, section
->sh_link
));
11059 edefs
= (Elf_External_Verdef
*)
11060 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11061 _("version definition section"));
11064 endbuf
= (char *) edefs
+ section
->sh_size
;
11066 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11069 Elf_External_Verdef
* edef
;
11070 Elf_Internal_Verdef ent
;
11071 Elf_External_Verdaux
* eaux
;
11072 Elf_Internal_Verdaux aux
;
11073 unsigned long isum
;
11076 vstart
= ((char *) edefs
) + idx
;
11077 if (vstart
+ sizeof (*edef
) > endbuf
)
11080 edef
= (Elf_External_Verdef
*) vstart
;
11082 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11083 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11084 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11085 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11086 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11087 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11088 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11090 printf (_(" %#06lx: Rev: %d Flags: %s"),
11091 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11093 printf (_(" Index: %d Cnt: %d "),
11094 ent
.vd_ndx
, ent
.vd_cnt
);
11096 /* Check for overflow. */
11097 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11100 vstart
+= ent
.vd_aux
;
11102 if (vstart
+ sizeof (*eaux
) > endbuf
)
11104 eaux
= (Elf_External_Verdaux
*) vstart
;
11106 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11107 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11109 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11110 printf (_("Name: %s\n"),
11111 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11113 printf (_("Name index: %ld\n"), aux
.vda_name
);
11115 isum
= idx
+ ent
.vd_aux
;
11117 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11119 if (aux
.vda_next
< sizeof (*eaux
)
11120 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11122 warn (_("Invalid vda_next field of %lx\n"),
11127 /* Check for overflow. */
11128 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11131 isum
+= aux
.vda_next
;
11132 vstart
+= aux
.vda_next
;
11134 if (vstart
+ sizeof (*eaux
) > endbuf
)
11136 eaux
= (Elf_External_Verdaux
*) vstart
;
11138 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11139 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11141 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11142 printf (_(" %#06lx: Parent %d: %s\n"),
11144 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11146 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11147 isum
, j
, aux
.vda_name
);
11150 if (j
< ent
.vd_cnt
)
11151 printf (_(" Version def aux past end of section\n"));
11154 file: id:000001,src:000172+005151,op:splice,rep:2. */
11155 if (ent
.vd_next
< sizeof (*edef
)
11156 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11158 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11159 cnt
= section
->sh_info
;
11162 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11165 idx
+= ent
.vd_next
;
11168 if (cnt
< section
->sh_info
)
11169 printf (_(" Version definition past end of section\n"));
11175 case SHT_GNU_verneed
:
11177 Elf_External_Verneed
* eneed
;
11184 printf (ngettext ("\nVersion needs section '%s' "
11185 "contains %u entry:\n",
11186 "\nVersion needs section '%s' "
11187 "contains %u entries:\n",
11189 printable_section_name (filedata
, section
), section
->sh_info
);
11191 printf (_(" Addr: 0x"));
11192 printf_vma (section
->sh_addr
);
11193 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11194 (unsigned long) section
->sh_offset
, section
->sh_link
,
11195 printable_section_name_from_index (filedata
, section
->sh_link
));
11197 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11198 section
->sh_offset
, 1,
11200 _("Version Needs section"));
11203 endbuf
= (char *) eneed
+ section
->sh_size
;
11205 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11207 Elf_External_Verneed
* entry
;
11208 Elf_Internal_Verneed ent
;
11209 unsigned long isum
;
11213 vstart
= ((char *) eneed
) + idx
;
11214 if (vstart
+ sizeof (*entry
) > endbuf
)
11217 entry
= (Elf_External_Verneed
*) vstart
;
11219 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11220 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11221 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11222 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11223 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11225 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11227 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11228 printf (_(" File: %s"),
11229 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11231 printf (_(" File: %lx"), ent
.vn_file
);
11233 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11235 /* Check for overflow. */
11236 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11238 vstart
+= ent
.vn_aux
;
11240 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11242 Elf_External_Vernaux
* eaux
;
11243 Elf_Internal_Vernaux aux
;
11245 if (vstart
+ sizeof (*eaux
) > endbuf
)
11247 eaux
= (Elf_External_Vernaux
*) vstart
;
11249 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11250 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11251 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11252 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11253 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11255 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11256 printf (_(" %#06lx: Name: %s"),
11257 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11259 printf (_(" %#06lx: Name index: %lx"),
11260 isum
, aux
.vna_name
);
11262 printf (_(" Flags: %s Version: %d\n"),
11263 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11265 if (aux
.vna_next
< sizeof (*eaux
)
11266 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11268 warn (_("Invalid vna_next field of %lx\n"),
11273 /* Check for overflow. */
11274 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11276 isum
+= aux
.vna_next
;
11277 vstart
+= aux
.vna_next
;
11280 if (j
< ent
.vn_cnt
)
11281 warn (_("Missing Version Needs auxillary information\n"));
11283 if (ent
.vn_next
< sizeof (*entry
)
11284 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11286 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11287 cnt
= section
->sh_info
;
11290 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11292 idx
+= ent
.vn_next
;
11295 if (cnt
< section
->sh_info
)
11296 warn (_("Missing Version Needs information\n"));
11302 case SHT_GNU_versym
:
11304 Elf_Internal_Shdr
* link_section
;
11307 unsigned char * edata
;
11308 unsigned short * data
;
11310 Elf_Internal_Sym
* symbols
;
11311 Elf_Internal_Shdr
* string_sec
;
11312 unsigned long num_syms
;
11315 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11318 link_section
= filedata
->section_headers
+ section
->sh_link
;
11319 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11321 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11326 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11327 if (symbols
== NULL
)
11330 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11332 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11333 string_sec
->sh_size
,
11334 _("version string table"));
11341 printf (ngettext ("\nVersion symbols section '%s' "
11342 "contains %lu entry:\n",
11343 "\nVersion symbols section '%s' "
11344 "contains %lu entries:\n",
11346 printable_section_name (filedata
, section
), (unsigned long) total
);
11348 printf (_(" Addr: 0x"));
11349 printf_vma (section
->sh_addr
);
11350 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11351 (unsigned long) section
->sh_offset
, section
->sh_link
,
11352 printable_section_name (filedata
, link_section
));
11354 off
= offset_from_vma (filedata
,
11355 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11356 total
* sizeof (short));
11357 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11358 sizeof (short), total
,
11359 _("version symbol data"));
11367 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11369 for (cnt
= total
; cnt
--;)
11370 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11375 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11379 char *invalid
= _("*invalid*");
11381 printf (" %03x:", cnt
);
11383 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11384 switch (data
[cnt
+ j
])
11387 fputs (_(" 0 (*local*) "), stdout
);
11391 fputs (_(" 1 (*global*) "), stdout
);
11395 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11396 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11398 /* If this index value is greater than the size of the symbols
11399 array, break to avoid an out-of-bounds read. */
11400 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11402 warn (_("invalid index into symbol array\n"));
11407 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11409 Elf_Internal_Verneed ivn
;
11410 unsigned long offset
;
11412 offset
= offset_from_vma
11414 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11415 sizeof (Elf_External_Verneed
));
11419 Elf_Internal_Vernaux ivna
;
11420 Elf_External_Verneed evn
;
11421 Elf_External_Vernaux evna
;
11422 unsigned long a_off
;
11424 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11425 _("version need")) == NULL
)
11428 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11429 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11431 a_off
= offset
+ ivn
.vn_aux
;
11435 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11436 1, _("version need aux (2)")) == NULL
)
11439 ivna
.vna_other
= 0;
11443 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11444 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11447 a_off
+= ivna
.vna_next
;
11449 while (ivna
.vna_other
!= data
[cnt
+ j
]
11450 && ivna
.vna_next
!= 0);
11452 if (ivna
.vna_other
== data
[cnt
+ j
])
11454 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11456 if (ivna
.vna_name
>= string_sec
->sh_size
)
11459 name
= strtab
+ ivna
.vna_name
;
11463 offset
+= ivn
.vn_next
;
11465 while (ivn
.vn_next
);
11468 if (data
[cnt
+ j
] != 0x8001
11469 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11471 Elf_Internal_Verdef ivd
;
11472 Elf_External_Verdef evd
;
11473 unsigned long offset
;
11475 offset
= offset_from_vma
11477 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11482 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11483 _("version def")) == NULL
)
11486 /* PR 17531: file: 046-1082287-0.004. */
11487 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11492 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11493 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11496 offset
+= ivd
.vd_next
;
11498 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11499 && ivd
.vd_next
!= 0);
11501 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11503 Elf_External_Verdaux evda
;
11504 Elf_Internal_Verdaux ivda
;
11506 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11508 if (get_data (&evda
, filedata
,
11509 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11511 _("version def aux")) == NULL
)
11514 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11516 if (ivda
.vda_name
>= string_sec
->sh_size
)
11518 else if (name
!= NULL
&& name
!= invalid
)
11519 name
= _("*both*");
11521 name
= strtab
+ ivda
.vda_name
;
11525 nn
+= printf ("(%s%-*s",
11527 12 - (int) strlen (name
),
11531 printf ("%*c", 18 - nn
, ' ');
11549 printf (_("\nNo version information found in this file.\n"));
11554 static const char *
11555 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11557 static char buff
[64];
11561 case STB_LOCAL
: return "LOCAL";
11562 case STB_GLOBAL
: return "GLOBAL";
11563 case STB_WEAK
: return "WEAK";
11565 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11566 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11568 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11570 if (binding
== STB_GNU_UNIQUE
11571 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11573 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11576 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11581 static const char *
11582 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11584 static char buff
[64];
11588 case STT_NOTYPE
: return "NOTYPE";
11589 case STT_OBJECT
: return "OBJECT";
11590 case STT_FUNC
: return "FUNC";
11591 case STT_SECTION
: return "SECTION";
11592 case STT_FILE
: return "FILE";
11593 case STT_COMMON
: return "COMMON";
11594 case STT_TLS
: return "TLS";
11595 case STT_RELC
: return "RELC";
11596 case STT_SRELC
: return "SRELC";
11598 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11600 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11601 return "THUMB_FUNC";
11603 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11606 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11607 return "PARISC_MILLI";
11609 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11611 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11613 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11615 if (type
== STT_HP_OPAQUE
)
11616 return "HP_OPAQUE";
11617 if (type
== STT_HP_STUB
)
11621 if (type
== STT_GNU_IFUNC
11622 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11623 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11626 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11629 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11634 static const char *
11635 get_symbol_visibility (unsigned int visibility
)
11637 switch (visibility
)
11639 case STV_DEFAULT
: return "DEFAULT";
11640 case STV_INTERNAL
: return "INTERNAL";
11641 case STV_HIDDEN
: return "HIDDEN";
11642 case STV_PROTECTED
: return "PROTECTED";
11644 error (_("Unrecognized visibility value: %u\n"), visibility
);
11645 return _("<unknown>");
11649 static const char *
11650 get_alpha_symbol_other (unsigned int other
)
11654 case STO_ALPHA_NOPV
: return "NOPV";
11655 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11657 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11658 return _("<unknown>");
11662 static const char *
11663 get_solaris_symbol_visibility (unsigned int visibility
)
11665 switch (visibility
)
11667 case 4: return "EXPORTED";
11668 case 5: return "SINGLETON";
11669 case 6: return "ELIMINATE";
11670 default: return get_symbol_visibility (visibility
);
11674 static const char *
11675 get_aarch64_symbol_other (unsigned int other
)
11677 static char buf
[32];
11679 if (other
& STO_AARCH64_VARIANT_PCS
)
11681 other
&= ~STO_AARCH64_VARIANT_PCS
;
11683 return "VARIANT_PCS";
11684 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11690 static const char *
11691 get_mips_symbol_other (unsigned int other
)
11695 case STO_OPTIONAL
: return "OPTIONAL";
11696 case STO_MIPS_PLT
: return "MIPS PLT";
11697 case STO_MIPS_PIC
: return "MIPS PIC";
11698 case STO_MICROMIPS
: return "MICROMIPS";
11699 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11700 case STO_MIPS16
: return "MIPS16";
11701 default: return NULL
;
11705 static const char *
11706 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11708 if (is_ia64_vms (filedata
))
11710 static char res
[32];
11714 /* Function types is for images and .STB files only. */
11715 switch (filedata
->file_header
.e_type
)
11719 switch (VMS_ST_FUNC_TYPE (other
))
11721 case VMS_SFT_CODE_ADDR
:
11722 strcat (res
, " CA");
11724 case VMS_SFT_SYMV_IDX
:
11725 strcat (res
, " VEC");
11728 strcat (res
, " FD");
11730 case VMS_SFT_RESERVE
:
11731 strcat (res
, " RSV");
11734 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11735 VMS_ST_FUNC_TYPE (other
));
11736 strcat (res
, " <unknown>");
11743 switch (VMS_ST_LINKAGE (other
))
11745 case VMS_STL_IGNORE
:
11746 strcat (res
, " IGN");
11748 case VMS_STL_RESERVE
:
11749 strcat (res
, " RSV");
11752 strcat (res
, " STD");
11755 strcat (res
, " LNK");
11758 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11759 VMS_ST_LINKAGE (other
));
11760 strcat (res
, " <unknown>");
11772 static const char *
11773 get_ppc64_symbol_other (unsigned int other
)
11775 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11778 other
>>= STO_PPC64_LOCAL_BIT
;
11781 static char buf
[64];
11783 other
= ppc64_decode_local_entry (other
);
11784 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11790 static const char *
11791 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11793 const char * result
= NULL
;
11794 static char buff
[64];
11799 switch (filedata
->file_header
.e_machine
)
11802 result
= get_alpha_symbol_other (other
);
11805 result
= get_aarch64_symbol_other (other
);
11808 result
= get_mips_symbol_other (other
);
11811 result
= get_ia64_symbol_other (filedata
, other
);
11814 result
= get_ppc64_symbol_other (other
);
11824 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11828 static const char *
11829 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11831 static char buff
[32];
11835 case SHN_UNDEF
: return "UND";
11836 case SHN_ABS
: return "ABS";
11837 case SHN_COMMON
: return "COM";
11839 if (type
== SHN_IA_64_ANSI_COMMON
11840 && filedata
->file_header
.e_machine
== EM_IA_64
11841 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11843 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11844 || filedata
->file_header
.e_machine
== EM_L1OM
11845 || filedata
->file_header
.e_machine
== EM_K1OM
)
11846 && type
== SHN_X86_64_LCOMMON
)
11847 return "LARGE_COM";
11848 else if ((type
== SHN_MIPS_SCOMMON
11849 && filedata
->file_header
.e_machine
== EM_MIPS
)
11850 || (type
== SHN_TIC6X_SCOMMON
11851 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11853 else if (type
== SHN_MIPS_SUNDEFINED
11854 && filedata
->file_header
.e_machine
== EM_MIPS
)
11856 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11857 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11858 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11859 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11860 else if (type
>= SHN_LORESERVE
)
11861 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11862 else if (filedata
->file_header
.e_shnum
!= 0
11863 && type
>= filedata
->file_header
.e_shnum
)
11864 sprintf (buff
, _("bad section index[%3d]"), type
);
11866 sprintf (buff
, "%3d", type
);
11873 static const char *
11874 get_symbol_version_string (Filedata
* filedata
,
11875 bfd_boolean is_dynsym
,
11876 const char * strtab
,
11877 unsigned long int strtab_size
,
11879 Elf_Internal_Sym
* psym
,
11880 enum versioned_symbol_info
* sym_info
,
11881 unsigned short * vna_other
)
11883 unsigned char data
[2];
11884 unsigned short vers_data
;
11885 unsigned long offset
;
11886 unsigned short max_vd_ndx
;
11889 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11892 offset
= offset_from_vma (filedata
,
11893 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11894 sizeof data
+ si
* sizeof (vers_data
));
11896 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11897 sizeof (data
), 1, _("version data")) == NULL
)
11900 vers_data
= byte_get (data
, 2);
11902 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11905 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11908 /* Usually we'd only see verdef for defined symbols, and verneed for
11909 undefined symbols. However, symbols defined by the linker in
11910 .dynbss for variables copied from a shared library in order to
11911 avoid text relocations are defined yet have verneed. We could
11912 use a heuristic to detect the special case, for example, check
11913 for verneed first on symbols defined in SHT_NOBITS sections, but
11914 it is simpler and more reliable to just look for both verdef and
11915 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11917 if (psym
->st_shndx
!= SHN_UNDEF
11918 && vers_data
!= 0x8001
11919 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11921 Elf_Internal_Verdef ivd
;
11922 Elf_Internal_Verdaux ivda
;
11923 Elf_External_Verdaux evda
;
11926 off
= offset_from_vma (filedata
,
11927 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11928 sizeof (Elf_External_Verdef
));
11932 Elf_External_Verdef evd
;
11934 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11935 _("version def")) == NULL
)
11944 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11945 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11946 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11947 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11950 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11951 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11953 off
+= ivd
.vd_next
;
11955 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11957 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11959 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11962 off
-= ivd
.vd_next
;
11965 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11966 _("version def aux")) != NULL
)
11968 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11970 if (psym
->st_name
!= ivda
.vda_name
)
11971 return (ivda
.vda_name
< strtab_size
11972 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11977 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11979 Elf_External_Verneed evn
;
11980 Elf_Internal_Verneed ivn
;
11981 Elf_Internal_Vernaux ivna
;
11983 offset
= offset_from_vma (filedata
,
11984 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11988 unsigned long vna_off
;
11990 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11991 _("version need")) == NULL
)
11994 ivna
.vna_other
= 0;
11999 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12000 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12002 vna_off
= offset
+ ivn
.vn_aux
;
12006 Elf_External_Vernaux evna
;
12008 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12009 _("version need aux (3)")) == NULL
)
12012 ivna
.vna_other
= 0;
12017 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12018 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12019 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12022 vna_off
+= ivna
.vna_next
;
12024 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12026 if (ivna
.vna_other
== vers_data
)
12029 offset
+= ivn
.vn_next
;
12031 while (ivn
.vn_next
!= 0);
12033 if (ivna
.vna_other
== vers_data
)
12035 *sym_info
= symbol_undefined
;
12036 *vna_other
= ivna
.vna_other
;
12037 return (ivna
.vna_name
< strtab_size
12038 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12040 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12041 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12042 return _("<corrupt>");
12048 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12049 Elf_Internal_Sym
*symtab
,
12050 Elf_Internal_Shdr
*section
,
12051 char *strtab
, size_t strtab_size
)
12053 const char *version_string
;
12054 enum versioned_symbol_info sym_info
;
12055 unsigned short vna_other
;
12056 Elf_Internal_Sym
*psym
= symtab
+ si
;
12058 printf ("%6ld: ", si
);
12059 print_vma (psym
->st_value
, LONG_HEX
);
12061 print_vma (psym
->st_size
, DEC_5
);
12062 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12063 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12064 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12065 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12068 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12070 printf (" %-7s", get_symbol_visibility (vis
));
12071 /* Check to see if any other bits in the st_other field are set.
12072 Note - displaying this information disrupts the layout of the
12073 table being generated, but for the moment this case is very rare. */
12074 if (psym
->st_other
^ vis
)
12075 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12077 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12079 bfd_boolean is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
,
12081 const char * sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12084 = get_symbol_version_string (filedata
,
12086 || section
->sh_type
== SHT_DYNSYM
),
12087 strtab
, strtab_size
, si
,
12088 psym
, &sym_info
, &vna_other
);
12090 int len_avail
= 21;
12091 if (! do_wide
&& version_string
!= NULL
)
12095 len_avail
-= 1 + strlen (version_string
);
12097 if (sym_info
== symbol_undefined
)
12098 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12099 else if (sym_info
!= symbol_hidden
)
12103 print_symbol (len_avail
, sstr
);
12105 if (version_string
)
12107 if (sym_info
== symbol_undefined
)
12108 printf ("@%s (%d)", version_string
, vna_other
);
12110 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12116 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12118 && si
>= section
->sh_info
12119 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12120 && filedata
->file_header
.e_machine
!= EM_MIPS
12121 /* Solaris binaries have been found to violate this requirement as
12122 well. Not sure if this is a bug or an ABI requirement. */
12123 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12124 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12125 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12128 /* Dump the symbol table. */
12130 process_symbol_table (Filedata
* filedata
)
12132 Elf_Internal_Shdr
* section
;
12134 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12137 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12139 && do_using_dynamic
12140 && filedata
->dynamic_strings
!= NULL
12141 && filedata
->dynamic_symbols
!= NULL
)
12145 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12146 "\nSymbol table for image contains %lu entries:\n",
12147 filedata
->num_dynamic_syms
),
12148 filedata
->num_dynamic_syms
);
12150 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12152 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12154 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12155 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12156 filedata
->dynamic_strings
,
12157 filedata
->dynamic_strings_length
);
12159 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12160 && filedata
->section_headers
!= NULL
)
12164 for (i
= 0, section
= filedata
->section_headers
;
12165 i
< filedata
->file_header
.e_shnum
;
12168 char * strtab
= NULL
;
12169 unsigned long int strtab_size
= 0;
12170 Elf_Internal_Sym
* symtab
;
12171 unsigned long si
, num_syms
;
12173 if ((section
->sh_type
!= SHT_SYMTAB
12174 && section
->sh_type
!= SHT_DYNSYM
)
12176 && section
->sh_type
== SHT_SYMTAB
))
12179 if (section
->sh_entsize
== 0)
12181 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12182 printable_section_name (filedata
, section
));
12186 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12187 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12188 "\nSymbol table '%s' contains %lu entries:\n",
12190 printable_section_name (filedata
, section
),
12194 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12196 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12198 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12199 if (symtab
== NULL
)
12202 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12204 strtab
= filedata
->string_table
;
12205 strtab_size
= filedata
->string_table_length
;
12207 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12209 Elf_Internal_Shdr
* string_sec
;
12211 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12213 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12214 1, string_sec
->sh_size
,
12215 _("string table"));
12216 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12219 for (si
= 0; si
< num_syms
; si
++)
12220 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12221 strtab
, strtab_size
);
12224 if (strtab
!= filedata
->string_table
)
12230 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12232 if (do_histogram
&& filedata
->buckets
!= NULL
)
12234 unsigned long * lengths
;
12235 unsigned long * counts
;
12238 unsigned long maxlength
= 0;
12239 unsigned long nzero_counts
= 0;
12240 unsigned long nsyms
= 0;
12243 printf (ngettext ("\nHistogram for bucket list length "
12244 "(total of %lu bucket):\n",
12245 "\nHistogram for bucket list length "
12246 "(total of %lu buckets):\n",
12247 (unsigned long) filedata
->nbuckets
),
12248 (unsigned long) filedata
->nbuckets
);
12250 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12251 sizeof (*lengths
));
12252 if (lengths
== NULL
)
12254 error (_("Out of memory allocating space for histogram buckets\n"));
12257 visited
= xcmalloc (filedata
->nchains
, 1);
12258 memset (visited
, 0, filedata
->nchains
);
12260 printf (_(" Length Number %% of total Coverage\n"));
12261 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12263 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12266 if (maxlength
< ++lengths
[hn
])
12268 if (si
>= filedata
->nchains
|| visited
[si
])
12270 error (_("histogram chain is corrupt\n"));
12278 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12279 if (counts
== NULL
)
12282 error (_("Out of memory allocating space for histogram counts\n"));
12286 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12287 ++counts
[lengths
[hn
]];
12289 if (filedata
->nbuckets
> 0)
12292 printf (" 0 %-10lu (%5.1f%%)\n",
12293 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12294 for (i
= 1; i
<= maxlength
; ++i
)
12296 nzero_counts
+= counts
[i
] * i
;
12297 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12298 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12299 (nzero_counts
* 100.0) / nsyms
);
12307 free (filedata
->buckets
);
12308 filedata
->buckets
= NULL
;
12309 filedata
->nbuckets
= 0;
12310 free (filedata
->chains
);
12311 filedata
->chains
= NULL
;
12313 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12315 unsigned long * lengths
;
12316 unsigned long * counts
;
12318 unsigned long maxlength
= 0;
12319 unsigned long nzero_counts
= 0;
12320 unsigned long nsyms
= 0;
12322 printf (ngettext ("\nHistogram for `%s' bucket list length "
12323 "(total of %lu bucket):\n",
12324 "\nHistogram for `%s' bucket list length "
12325 "(total of %lu buckets):\n",
12326 (unsigned long) filedata
->ngnubuckets
),
12327 GNU_HASH_SECTION_NAME (filedata
),
12328 (unsigned long) filedata
->ngnubuckets
);
12330 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12331 sizeof (*lengths
));
12332 if (lengths
== NULL
)
12334 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12338 printf (_(" Length Number %% of total Coverage\n"));
12340 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12341 if (filedata
->gnubuckets
[hn
] != 0)
12343 bfd_vma off
, length
= 1;
12345 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12346 /* PR 17531 file: 010-77222-0.004. */
12347 off
< filedata
->ngnuchains
12348 && (filedata
->gnuchains
[off
] & 1) == 0;
12351 lengths
[hn
] = length
;
12352 if (length
> maxlength
)
12353 maxlength
= length
;
12357 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12358 if (counts
== NULL
)
12361 error (_("Out of memory allocating space for gnu histogram counts\n"));
12365 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12366 ++counts
[lengths
[hn
]];
12368 if (filedata
->ngnubuckets
> 0)
12371 printf (" 0 %-10lu (%5.1f%%)\n",
12372 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12373 for (j
= 1; j
<= maxlength
; ++j
)
12375 nzero_counts
+= counts
[j
] * j
;
12376 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12377 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12378 (nzero_counts
* 100.0) / nsyms
);
12385 free (filedata
->gnubuckets
);
12386 filedata
->gnubuckets
= NULL
;
12387 filedata
->ngnubuckets
= 0;
12388 free (filedata
->gnuchains
);
12389 filedata
->gnuchains
= NULL
;
12390 filedata
->ngnuchains
= 0;
12391 free (filedata
->mipsxlat
);
12392 filedata
->mipsxlat
= NULL
;
12396 free (filedata
->gnubuckets
);
12397 filedata
->gnubuckets
= NULL
;
12398 filedata
->ngnubuckets
= 0;
12399 free (filedata
->gnuchains
);
12400 filedata
->gnuchains
= NULL
;
12401 filedata
->ngnuchains
= 0;
12402 free (filedata
->mipsxlat
);
12403 filedata
->mipsxlat
= NULL
;
12404 free (filedata
->buckets
);
12405 filedata
->buckets
= NULL
;
12406 filedata
->nbuckets
= 0;
12407 free (filedata
->chains
);
12408 filedata
->chains
= NULL
;
12413 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12417 if (filedata
->dynamic_syminfo
== NULL
12419 /* No syminfo, this is ok. */
12422 /* There better should be a dynamic symbol section. */
12423 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12426 if (filedata
->dynamic_addr
)
12427 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12428 "contains %d entry:\n",
12429 "\nDynamic info segment at offset 0x%lx "
12430 "contains %d entries:\n",
12431 filedata
->dynamic_syminfo_nent
),
12432 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12434 printf (_(" Num: Name BoundTo Flags\n"));
12435 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12437 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12439 printf ("%4d: ", i
);
12440 if (i
>= filedata
->num_dynamic_syms
)
12441 printf (_("<corrupt index>"));
12442 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12443 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12444 filedata
->dynamic_symbols
[i
].st_name
));
12446 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12449 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12451 case SYMINFO_BT_SELF
:
12452 fputs ("SELF ", stdout
);
12454 case SYMINFO_BT_PARENT
:
12455 fputs ("PARENT ", stdout
);
12458 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12459 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12460 && VALID_DYNAMIC_NAME (filedata
,
12461 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12463 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12464 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12468 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12472 if (flags
& SYMINFO_FLG_DIRECT
)
12473 printf (" DIRECT");
12474 if (flags
& SYMINFO_FLG_PASSTHRU
)
12475 printf (" PASSTHRU");
12476 if (flags
& SYMINFO_FLG_COPY
)
12478 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12479 printf (" LAZYLOAD");
12487 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12488 is contained by the region START .. END. The types of ADDR, START
12489 and END should all be the same. Note both ADDR + NELEM and END
12490 point to just beyond the end of the regions that are being tested. */
12491 #define IN_RANGE(START,END,ADDR,NELEM) \
12492 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12494 /* Check to see if the given reloc needs to be handled in a target specific
12495 manner. If so then process the reloc and return TRUE otherwise return
12498 If called with reloc == NULL, then this is a signal that reloc processing
12499 for the current section has finished, and any saved state should be
12503 target_specific_reloc_handling (Filedata
* filedata
,
12504 Elf_Internal_Rela
* reloc
,
12505 unsigned char * start
,
12506 unsigned char * end
,
12507 Elf_Internal_Sym
* symtab
,
12508 unsigned long num_syms
)
12510 unsigned int reloc_type
= 0;
12511 unsigned long sym_index
= 0;
12515 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12516 sym_index
= get_reloc_symindex (reloc
->r_info
);
12519 switch (filedata
->file_header
.e_machine
)
12522 case EM_MSP430_OLD
:
12524 static Elf_Internal_Sym
* saved_sym
= NULL
;
12532 switch (reloc_type
)
12534 case 10: /* R_MSP430_SYM_DIFF */
12535 if (uses_msp430x_relocs (filedata
))
12537 /* Fall through. */
12538 case 21: /* R_MSP430X_SYM_DIFF */
12540 if (sym_index
>= num_syms
)
12541 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12544 saved_sym
= symtab
+ sym_index
;
12547 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12548 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12549 goto handle_sym_diff
;
12551 case 5: /* R_MSP430_16_BYTE */
12552 case 9: /* R_MSP430_8 */
12553 if (uses_msp430x_relocs (filedata
))
12555 goto handle_sym_diff
;
12557 case 2: /* R_MSP430_ABS16 */
12558 case 15: /* R_MSP430X_ABS16 */
12559 if (! uses_msp430x_relocs (filedata
))
12561 goto handle_sym_diff
;
12564 if (saved_sym
!= NULL
)
12566 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12569 if (sym_index
>= num_syms
)
12570 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12574 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12575 - saved_sym
->st_value
);
12577 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12578 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12581 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12582 (long) reloc
->r_offset
);
12591 if (saved_sym
!= NULL
)
12592 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12599 case EM_CYGNUS_MN10300
:
12601 static Elf_Internal_Sym
* saved_sym
= NULL
;
12609 switch (reloc_type
)
12611 case 34: /* R_MN10300_ALIGN */
12613 case 33: /* R_MN10300_SYM_DIFF */
12614 if (sym_index
>= num_syms
)
12615 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12618 saved_sym
= symtab
+ sym_index
;
12621 case 1: /* R_MN10300_32 */
12622 case 2: /* R_MN10300_16 */
12623 if (saved_sym
!= NULL
)
12625 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12628 if (sym_index
>= num_syms
)
12629 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12633 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12634 - saved_sym
->st_value
);
12636 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12637 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12639 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12640 (long) reloc
->r_offset
);
12648 if (saved_sym
!= NULL
)
12649 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12657 static bfd_vma saved_sym1
= 0;
12658 static bfd_vma saved_sym2
= 0;
12659 static bfd_vma value
;
12663 saved_sym1
= saved_sym2
= 0;
12667 switch (reloc_type
)
12669 case 0x80: /* R_RL78_SYM. */
12670 saved_sym1
= saved_sym2
;
12671 if (sym_index
>= num_syms
)
12672 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12676 saved_sym2
= symtab
[sym_index
].st_value
;
12677 saved_sym2
+= reloc
->r_addend
;
12681 case 0x83: /* R_RL78_OPsub. */
12682 value
= saved_sym1
- saved_sym2
;
12683 saved_sym2
= saved_sym1
= 0;
12687 case 0x41: /* R_RL78_ABS32. */
12688 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12689 byte_put (start
+ reloc
->r_offset
, value
, 4);
12691 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12692 (long) reloc
->r_offset
);
12696 case 0x43: /* R_RL78_ABS16. */
12697 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12698 byte_put (start
+ reloc
->r_offset
, value
, 2);
12700 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12701 (long) reloc
->r_offset
);
12715 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12716 DWARF debug sections. This is a target specific test. Note - we do not
12717 go through the whole including-target-headers-multiple-times route, (as
12718 we have already done with <elf/h8.h>) because this would become very
12719 messy and even then this function would have to contain target specific
12720 information (the names of the relocs instead of their numeric values).
12721 FIXME: This is not the correct way to solve this problem. The proper way
12722 is to have target specific reloc sizing and typing functions created by
12723 the reloc-macros.h header, in the same way that it already creates the
12724 reloc naming functions. */
12727 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12729 /* Please keep this table alpha-sorted for ease of visual lookup. */
12730 switch (filedata
->file_header
.e_machine
)
12734 return reloc_type
== 1; /* R_386_32. */
12736 return reloc_type
== 1; /* R_68K_32. */
12738 return reloc_type
== 1; /* R_860_32. */
12740 return reloc_type
== 2; /* R_960_32. */
12742 return (reloc_type
== 258
12743 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12745 return reloc_type
== 11; /* R_BPF_DATA_32 */
12746 case EM_ADAPTEVA_EPIPHANY
:
12747 return reloc_type
== 3;
12749 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12751 return reloc_type
== 1; /* R_ARC_32. */
12752 case EM_ARC_COMPACT
:
12753 case EM_ARC_COMPACT2
:
12754 return reloc_type
== 4; /* R_ARC_32. */
12756 return reloc_type
== 2; /* R_ARM_ABS32 */
12759 return reloc_type
== 1;
12761 return reloc_type
== 0x12; /* R_byte4_data. */
12763 return reloc_type
== 3; /* R_CRIS_32. */
12765 return reloc_type
== 3; /* R_CR16_NUM32. */
12767 return reloc_type
== 15; /* R_CRX_NUM32. */
12769 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12770 case EM_CYGNUS_FRV
:
12771 return reloc_type
== 1;
12772 case EM_CYGNUS_D10V
:
12774 return reloc_type
== 6; /* R_D10V_32. */
12775 case EM_CYGNUS_D30V
:
12777 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12779 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12780 case EM_CYGNUS_FR30
:
12782 return reloc_type
== 3; /* R_FR30_32. */
12784 return reloc_type
== 1; /* R_FT32_32. */
12788 return reloc_type
== 1; /* R_H8_DIR32. */
12790 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12791 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12792 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12793 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12796 return reloc_type
== 2; /* R_IP2K_32. */
12798 return reloc_type
== 2; /* R_IQ2000_32. */
12799 case EM_LATTICEMICO32
:
12800 return reloc_type
== 3; /* R_LM32_32. */
12803 return reloc_type
== 3; /* R_M32C_32. */
12805 return reloc_type
== 34; /* R_M32R_32_RELA. */
12808 return reloc_type
== 6; /* R_M68HC11_32. */
12810 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12811 reloc_type
== 6; /* R_S12Z_CW32. */
12813 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12814 case EM_CYGNUS_MEP
:
12815 return reloc_type
== 4; /* R_MEP_32. */
12817 return reloc_type
== 2; /* R_METAG_ADDR32. */
12818 case EM_MICROBLAZE
:
12819 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12821 return reloc_type
== 2; /* R_MIPS_32. */
12823 return reloc_type
== 4; /* R_MMIX_32. */
12824 case EM_CYGNUS_MN10200
:
12826 return reloc_type
== 1; /* R_MN10200_32. */
12827 case EM_CYGNUS_MN10300
:
12829 return reloc_type
== 1; /* R_MN10300_32. */
12831 return reloc_type
== 1; /* R_MOXIE_32. */
12832 case EM_MSP430_OLD
:
12834 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12836 return reloc_type
== 2; /* R_MT_32. */
12838 return reloc_type
== 20; /* R_NDS32_RELA. */
12839 case EM_ALTERA_NIOS2
:
12840 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12842 return reloc_type
== 1; /* R_NIOS_32. */
12844 return reloc_type
== 1; /* R_OR1K_32. */
12846 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12847 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12848 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12851 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12853 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12855 return reloc_type
== 1; /* R_PPC_ADDR32. */
12857 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12859 return reloc_type
== 1; /* R_RISCV_32. */
12861 return reloc_type
== 1; /* R_RL78_DIR32. */
12863 return reloc_type
== 1; /* R_RX_DIR32. */
12865 return reloc_type
== 1; /* R_I370_ADDR31. */
12868 return reloc_type
== 4; /* R_S390_32. */
12870 return reloc_type
== 8; /* R_SCORE_ABS32. */
12872 return reloc_type
== 1; /* R_SH_DIR32. */
12873 case EM_SPARC32PLUS
:
12876 return reloc_type
== 3 /* R_SPARC_32. */
12877 || reloc_type
== 23; /* R_SPARC_UA32. */
12879 return reloc_type
== 6; /* R_SPU_ADDR32 */
12881 return reloc_type
== 1; /* R_C6000_ABS32. */
12883 return reloc_type
== 2; /* R_TILEGX_32. */
12885 return reloc_type
== 1; /* R_TILEPRO_32. */
12886 case EM_CYGNUS_V850
:
12888 return reloc_type
== 6; /* R_V850_ABS32. */
12890 return reloc_type
== 0x33; /* R_V810_WORD. */
12892 return reloc_type
== 1; /* R_VAX_32. */
12894 return reloc_type
== 3; /* R_VISIUM_32. */
12895 case EM_WEBASSEMBLY
:
12896 return reloc_type
== 1; /* R_WASM32_32. */
12900 return reloc_type
== 10; /* R_X86_64_32. */
12903 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12905 return reloc_type
== 4; /* R_XGATE_32. */
12907 return reloc_type
== 1; /* R_XSTROMY16_32. */
12908 case EM_XTENSA_OLD
:
12910 return reloc_type
== 1; /* R_XTENSA_32. */
12912 return reloc_type
== 6; /* R_Z80_32. */
12915 static unsigned int prev_warn
= 0;
12917 /* Avoid repeating the same warning multiple times. */
12918 if (prev_warn
!= filedata
->file_header
.e_machine
)
12919 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12920 filedata
->file_header
.e_machine
);
12921 prev_warn
= filedata
->file_header
.e_machine
;
12927 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12928 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12931 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12933 switch (filedata
->file_header
.e_machine
)
12934 /* Please keep this table alpha-sorted for ease of visual lookup. */
12938 return reloc_type
== 2; /* R_386_PC32. */
12940 return reloc_type
== 4; /* R_68K_PC32. */
12942 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12943 case EM_ADAPTEVA_EPIPHANY
:
12944 return reloc_type
== 6;
12946 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12947 case EM_ARC_COMPACT
:
12948 case EM_ARC_COMPACT2
:
12949 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12951 return reloc_type
== 3; /* R_ARM_REL32 */
12954 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12955 case EM_MICROBLAZE
:
12956 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12958 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12960 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12962 return reloc_type
== 26; /* R_PPC_REL32. */
12964 return reloc_type
== 26; /* R_PPC64_REL32. */
12966 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12969 return reloc_type
== 5; /* R_390_PC32. */
12971 return reloc_type
== 2; /* R_SH_REL32. */
12972 case EM_SPARC32PLUS
:
12975 return reloc_type
== 6; /* R_SPARC_DISP32. */
12977 return reloc_type
== 13; /* R_SPU_REL32. */
12979 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12981 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12983 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12987 return reloc_type
== 2; /* R_X86_64_PC32. */
12989 return reloc_type
== 4; /* R_VAX_PCREL32. */
12990 case EM_XTENSA_OLD
:
12992 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12994 /* Do not abort or issue an error message here. Not all targets use
12995 pc-relative 32-bit relocs in their DWARF debug information and we
12996 have already tested for target coverage in is_32bit_abs_reloc. A
12997 more helpful warning message will be generated by apply_relocations
12998 anyway, so just return. */
13003 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13004 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13007 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13009 switch (filedata
->file_header
.e_machine
)
13012 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13014 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13016 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13017 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13019 return reloc_type
== 80; /* R_PARISC_DIR64. */
13021 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13023 return reloc_type
== 2; /* R_RISCV_64. */
13024 case EM_SPARC32PLUS
:
13027 return reloc_type
== 32 /* R_SPARC_64. */
13028 || reloc_type
== 54; /* R_SPARC_UA64. */
13032 return reloc_type
== 1; /* R_X86_64_64. */
13035 return reloc_type
== 22; /* R_S390_64. */
13037 return reloc_type
== 1; /* R_TILEGX_64. */
13039 return reloc_type
== 18; /* R_MIPS_64. */
13045 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13046 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13049 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13051 switch (filedata
->file_header
.e_machine
)
13054 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13056 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13058 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13059 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13061 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13063 return reloc_type
== 44; /* R_PPC64_REL64. */
13064 case EM_SPARC32PLUS
:
13067 return reloc_type
== 46; /* R_SPARC_DISP64. */
13071 return reloc_type
== 24; /* R_X86_64_PC64. */
13074 return reloc_type
== 23; /* R_S390_PC64. */
13076 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13082 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13083 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13086 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13088 switch (filedata
->file_header
.e_machine
)
13090 case EM_CYGNUS_MN10200
:
13092 return reloc_type
== 4; /* R_MN10200_24. */
13094 return reloc_type
== 5; /* R_FT32_20. */
13096 return reloc_type
== 5; /* R_Z80_24. */
13102 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13103 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13106 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13108 /* Please keep this table alpha-sorted for ease of visual lookup. */
13109 switch (filedata
->file_header
.e_machine
)
13112 case EM_ARC_COMPACT
:
13113 case EM_ARC_COMPACT2
:
13114 return reloc_type
== 2; /* R_ARC_16. */
13115 case EM_ADAPTEVA_EPIPHANY
:
13116 return reloc_type
== 5;
13119 return reloc_type
== 4; /* R_AVR_16. */
13120 case EM_CYGNUS_D10V
:
13122 return reloc_type
== 3; /* R_D10V_16. */
13124 return reloc_type
== 2; /* R_FT32_16. */
13128 return reloc_type
== R_H8_DIR16
;
13131 return reloc_type
== 1; /* R_IP2K_16. */
13134 return reloc_type
== 1; /* R_M32C_16 */
13135 case EM_CYGNUS_MN10200
:
13137 return reloc_type
== 2; /* R_MN10200_16. */
13138 case EM_CYGNUS_MN10300
:
13140 return reloc_type
== 2; /* R_MN10300_16. */
13142 if (uses_msp430x_relocs (filedata
))
13143 return reloc_type
== 2; /* R_MSP430_ABS16. */
13144 /* Fall through. */
13145 case EM_MSP430_OLD
:
13146 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13148 return reloc_type
== 19; /* R_NDS32_RELA. */
13149 case EM_ALTERA_NIOS2
:
13150 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13152 return reloc_type
== 9; /* R_NIOS_16. */
13154 return reloc_type
== 2; /* R_OR1K_16. */
13156 return reloc_type
== 55; /* R_RISCV_SET16. */
13158 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13160 return reloc_type
== 2; /* R_C6000_ABS16. */
13162 return reloc_type
== 2; /* R_VISIUM_16. */
13165 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13167 return reloc_type
== 3; /* R_XGATE_16. */
13169 return reloc_type
== 4; /* R_Z80_16. */
13175 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13176 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13179 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13181 switch (filedata
->file_header
.e_machine
)
13184 return reloc_type
== 54; /* R_RISCV_SET8. */
13186 return reloc_type
== 1; /* R_Z80_8. */
13192 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13193 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13196 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13198 switch (filedata
->file_header
.e_machine
)
13201 return reloc_type
== 53; /* R_RISCV_SET6. */
13207 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13208 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13211 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13213 /* Please keep this table alpha-sorted for ease of visual lookup. */
13214 switch (filedata
->file_header
.e_machine
)
13217 return reloc_type
== 35; /* R_RISCV_ADD32. */
13223 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13224 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13227 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13229 /* Please keep this table alpha-sorted for ease of visual lookup. */
13230 switch (filedata
->file_header
.e_machine
)
13233 return reloc_type
== 39; /* R_RISCV_SUB32. */
13239 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13240 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13243 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13245 /* Please keep this table alpha-sorted for ease of visual lookup. */
13246 switch (filedata
->file_header
.e_machine
)
13249 return reloc_type
== 36; /* R_RISCV_ADD64. */
13255 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13256 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13259 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13261 /* Please keep this table alpha-sorted for ease of visual lookup. */
13262 switch (filedata
->file_header
.e_machine
)
13265 return reloc_type
== 40; /* R_RISCV_SUB64. */
13271 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13272 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13275 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13277 /* Please keep this table alpha-sorted for ease of visual lookup. */
13278 switch (filedata
->file_header
.e_machine
)
13281 return reloc_type
== 34; /* R_RISCV_ADD16. */
13287 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13288 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13291 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13293 /* Please keep this table alpha-sorted for ease of visual lookup. */
13294 switch (filedata
->file_header
.e_machine
)
13297 return reloc_type
== 38; /* R_RISCV_SUB16. */
13303 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13304 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13307 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13309 /* Please keep this table alpha-sorted for ease of visual lookup. */
13310 switch (filedata
->file_header
.e_machine
)
13313 return reloc_type
== 33; /* R_RISCV_ADD8. */
13319 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13320 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13323 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13325 /* Please keep this table alpha-sorted for ease of visual lookup. */
13326 switch (filedata
->file_header
.e_machine
)
13329 return reloc_type
== 37; /* R_RISCV_SUB8. */
13335 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13336 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13339 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13341 switch (filedata
->file_header
.e_machine
)
13344 return reloc_type
== 52; /* R_RISCV_SUB6. */
13350 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13351 relocation entries (possibly formerly used for SHT_GROUP sections). */
13354 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13356 switch (filedata
->file_header
.e_machine
)
13358 case EM_386
: /* R_386_NONE. */
13359 case EM_68K
: /* R_68K_NONE. */
13360 case EM_ADAPTEVA_EPIPHANY
:
13361 case EM_ALPHA
: /* R_ALPHA_NONE. */
13362 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13363 case EM_ARC
: /* R_ARC_NONE. */
13364 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13365 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13366 case EM_ARM
: /* R_ARM_NONE. */
13367 case EM_C166
: /* R_XC16X_NONE. */
13368 case EM_CRIS
: /* R_CRIS_NONE. */
13369 case EM_FT32
: /* R_FT32_NONE. */
13370 case EM_IA_64
: /* R_IA64_NONE. */
13371 case EM_K1OM
: /* R_X86_64_NONE. */
13372 case EM_L1OM
: /* R_X86_64_NONE. */
13373 case EM_M32R
: /* R_M32R_NONE. */
13374 case EM_MIPS
: /* R_MIPS_NONE. */
13375 case EM_MN10300
: /* R_MN10300_NONE. */
13376 case EM_MOXIE
: /* R_MOXIE_NONE. */
13377 case EM_NIOS32
: /* R_NIOS_NONE. */
13378 case EM_OR1K
: /* R_OR1K_NONE. */
13379 case EM_PARISC
: /* R_PARISC_NONE. */
13380 case EM_PPC64
: /* R_PPC64_NONE. */
13381 case EM_PPC
: /* R_PPC_NONE. */
13382 case EM_RISCV
: /* R_RISCV_NONE. */
13383 case EM_S390
: /* R_390_NONE. */
13385 case EM_SH
: /* R_SH_NONE. */
13386 case EM_SPARC32PLUS
:
13387 case EM_SPARC
: /* R_SPARC_NONE. */
13389 case EM_TILEGX
: /* R_TILEGX_NONE. */
13390 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13391 case EM_TI_C6000
:/* R_C6000_NONE. */
13392 case EM_X86_64
: /* R_X86_64_NONE. */
13394 case EM_Z80
: /* R_Z80_NONE. */
13395 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13396 return reloc_type
== 0;
13399 return reloc_type
== 0 || reloc_type
== 256;
13402 return (reloc_type
== 0 /* R_AVR_NONE. */
13403 || reloc_type
== 30 /* R_AVR_DIFF8. */
13404 || reloc_type
== 31 /* R_AVR_DIFF16. */
13405 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13407 return reloc_type
== 3; /* R_METAG_NONE. */
13409 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13410 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13411 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13412 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13413 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13415 return (reloc_type
== 0 /* R_PRU_NONE. */
13416 || reloc_type
== 65 /* R_PRU_DIFF8. */
13417 || reloc_type
== 66 /* R_PRU_DIFF16. */
13418 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13419 case EM_XTENSA_OLD
:
13421 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13422 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13423 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13424 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13425 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13426 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13427 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13428 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13429 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13430 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13435 /* Returns TRUE if there is a relocation against
13436 section NAME at OFFSET bytes. */
13439 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13441 Elf_Internal_Rela
* relocs
;
13442 Elf_Internal_Rela
* rp
;
13444 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13447 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13449 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13450 if (rp
->r_offset
== offset
)
13456 /* Apply relocations to a section.
13457 Returns TRUE upon success, FALSE otherwise.
13458 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13459 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13460 will be set to the number of relocs loaded.
13462 Note: So far support has been added only for those relocations
13463 which can be found in debug sections. FIXME: Add support for
13464 more relocations ? */
13467 apply_relocations (Filedata
* filedata
,
13468 const Elf_Internal_Shdr
* section
,
13469 unsigned char * start
,
13470 bfd_size_type size
,
13471 void ** relocs_return
,
13472 unsigned long * num_relocs_return
)
13474 Elf_Internal_Shdr
* relsec
;
13475 unsigned char * end
= start
+ size
;
13477 if (relocs_return
!= NULL
)
13479 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13480 * num_relocs_return
= 0;
13483 if (filedata
->file_header
.e_type
!= ET_REL
)
13484 /* No relocs to apply. */
13487 /* Find the reloc section associated with the section. */
13488 for (relsec
= filedata
->section_headers
;
13489 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13492 bfd_boolean is_rela
;
13493 unsigned long num_relocs
;
13494 Elf_Internal_Rela
* relocs
;
13495 Elf_Internal_Rela
* rp
;
13496 Elf_Internal_Shdr
* symsec
;
13497 Elf_Internal_Sym
* symtab
;
13498 unsigned long num_syms
;
13499 Elf_Internal_Sym
* sym
;
13501 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13502 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13503 || filedata
->section_headers
+ relsec
->sh_info
!= section
13504 || relsec
->sh_size
== 0
13505 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13508 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13509 if (symsec
->sh_type
!= SHT_SYMTAB
13510 && symsec
->sh_type
!= SHT_DYNSYM
)
13513 is_rela
= relsec
->sh_type
== SHT_RELA
;
13517 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13518 relsec
->sh_size
, & relocs
, & num_relocs
))
13523 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13524 relsec
->sh_size
, & relocs
, & num_relocs
))
13528 /* SH uses RELA but uses in place value instead of the addend field. */
13529 if (filedata
->file_header
.e_machine
== EM_SH
)
13532 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13534 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13537 unsigned int reloc_type
;
13538 unsigned int reloc_size
;
13539 bfd_boolean reloc_inplace
= FALSE
;
13540 bfd_boolean reloc_subtract
= FALSE
;
13541 unsigned char * rloc
;
13542 unsigned long sym_index
;
13544 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13546 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13548 else if (is_none_reloc (filedata
, reloc_type
))
13550 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13551 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13553 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13554 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13556 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13558 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13560 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13561 || is_6bit_abs_reloc (filedata
, reloc_type
))
13563 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13565 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13568 reloc_inplace
= TRUE
;
13570 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13572 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13575 reloc_inplace
= TRUE
;
13577 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13579 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13582 reloc_inplace
= TRUE
;
13584 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13586 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13589 reloc_inplace
= TRUE
;
13591 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13595 reloc_inplace
= TRUE
;
13599 static unsigned int prev_reloc
= 0;
13601 if (reloc_type
!= prev_reloc
)
13602 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13603 reloc_type
, printable_section_name (filedata
, section
));
13604 prev_reloc
= reloc_type
;
13608 rloc
= start
+ rp
->r_offset
;
13609 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13611 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13612 (unsigned long) rp
->r_offset
,
13613 printable_section_name (filedata
, section
));
13617 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13618 if (sym_index
>= num_syms
)
13620 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13621 sym_index
, printable_section_name (filedata
, section
));
13624 sym
= symtab
+ sym_index
;
13626 /* If the reloc has a symbol associated with it,
13627 make sure that it is of an appropriate type.
13629 Relocations against symbols without type can happen.
13630 Gcc -feliminate-dwarf2-dups may generate symbols
13631 without type for debug info.
13633 Icc generates relocations against function symbols
13634 instead of local labels.
13636 Relocations against object symbols can happen, eg when
13637 referencing a global array. For an example of this see
13638 the _clz.o binary in libgcc.a. */
13640 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13641 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13643 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13644 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13645 printable_section_name (filedata
, relsec
),
13646 (long int)(rp
- relocs
));
13652 addend
+= rp
->r_addend
;
13653 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13654 partial_inplace. */
13656 || (filedata
->file_header
.e_machine
== EM_XTENSA
13657 && reloc_type
== 1)
13658 || ((filedata
->file_header
.e_machine
== EM_PJ
13659 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13660 && reloc_type
== 1)
13661 || ((filedata
->file_header
.e_machine
== EM_D30V
13662 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13663 && reloc_type
== 12)
13666 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13667 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13669 addend
+= byte_get (rloc
, reloc_size
);
13672 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13673 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13675 /* On HPPA, all pc-relative relocations are biased by 8. */
13676 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13678 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13681 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13682 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13684 if (reloc_subtract
)
13685 addend
-= sym
->st_value
;
13687 addend
+= sym
->st_value
;
13688 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13689 byte_put (rloc
, addend
, reloc_size
);
13691 else if (reloc_subtract
)
13692 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13694 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13698 /* Let the target specific reloc processing code know that
13699 we have finished with these relocs. */
13700 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13704 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13705 * num_relocs_return
= num_relocs
;
13716 #ifdef SUPPORT_DISASSEMBLY
13718 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13720 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13722 /* FIXME: XXX -- to be done --- XXX */
13728 /* Reads in the contents of SECTION from FILE, returning a pointer
13729 to a malloc'ed buffer or NULL if something went wrong. */
13732 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13734 bfd_size_type num_bytes
= section
->sh_size
;
13736 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13738 printf (_("Section '%s' has no data to dump.\n"),
13739 printable_section_name (filedata
, section
));
13743 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13744 _("section contents"));
13747 /* Uncompresses a section that was compressed using zlib, in place. */
13750 uncompress_section_contents (unsigned char ** buffer
,
13751 dwarf_size_type uncompressed_size
,
13752 dwarf_size_type
* size
)
13754 dwarf_size_type compressed_size
= *size
;
13755 unsigned char * compressed_buffer
= *buffer
;
13756 unsigned char * uncompressed_buffer
;
13760 /* It is possible the section consists of several compressed
13761 buffers concatenated together, so we uncompress in a loop. */
13762 /* PR 18313: The state field in the z_stream structure is supposed
13763 to be invisible to the user (ie us), but some compilers will
13764 still complain about it being used without initialisation. So
13765 we first zero the entire z_stream structure and then set the fields
13767 memset (& strm
, 0, sizeof strm
);
13768 strm
.avail_in
= compressed_size
;
13769 strm
.next_in
= (Bytef
*) compressed_buffer
;
13770 strm
.avail_out
= uncompressed_size
;
13771 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13773 rc
= inflateInit (& strm
);
13774 while (strm
.avail_in
> 0)
13778 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13779 + (uncompressed_size
- strm
.avail_out
));
13780 rc
= inflate (&strm
, Z_FINISH
);
13781 if (rc
!= Z_STREAM_END
)
13783 rc
= inflateReset (& strm
);
13785 rc
= inflateEnd (& strm
);
13787 || strm
.avail_out
!= 0)
13790 *buffer
= uncompressed_buffer
;
13791 *size
= uncompressed_size
;
13795 free (uncompressed_buffer
);
13796 /* Indicate decompression failure. */
13802 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13804 Elf_Internal_Shdr
* relsec
;
13805 bfd_size_type num_bytes
;
13806 unsigned char * data
;
13807 unsigned char * end
;
13808 unsigned char * real_start
;
13809 unsigned char * start
;
13810 bfd_boolean some_strings_shown
;
13812 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13814 /* PR 21820: Do not fail if the section was empty. */
13815 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13817 num_bytes
= section
->sh_size
;
13819 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13821 if (decompress_dumps
)
13823 dwarf_size_type new_size
= num_bytes
;
13824 dwarf_size_type uncompressed_size
= 0;
13826 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13828 Elf_Internal_Chdr chdr
;
13829 unsigned int compression_header_size
13830 = get_compression_header (& chdr
, (unsigned char *) start
,
13832 if (compression_header_size
== 0)
13833 /* An error message will have already been generated
13834 by get_compression_header. */
13837 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13839 warn (_("section '%s' has unsupported compress type: %d\n"),
13840 printable_section_name (filedata
, section
), chdr
.ch_type
);
13843 uncompressed_size
= chdr
.ch_size
;
13844 start
+= compression_header_size
;
13845 new_size
-= compression_header_size
;
13847 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13849 /* Read the zlib header. In this case, it should be "ZLIB"
13850 followed by the uncompressed section size, 8 bytes in
13851 big-endian order. */
13852 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13853 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13854 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13855 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13856 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13857 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13858 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13859 uncompressed_size
+= start
[11];
13864 if (uncompressed_size
)
13866 if (uncompress_section_contents (& start
,
13867 uncompressed_size
, & new_size
))
13868 num_bytes
= new_size
;
13871 error (_("Unable to decompress section %s\n"),
13872 printable_section_name (filedata
, section
));
13877 start
= real_start
;
13880 /* If the section being dumped has relocations against it the user might
13881 be expecting these relocations to have been applied. Check for this
13882 case and issue a warning message in order to avoid confusion.
13883 FIXME: Maybe we ought to have an option that dumps a section with
13884 relocs applied ? */
13885 for (relsec
= filedata
->section_headers
;
13886 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13889 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13890 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13891 || filedata
->section_headers
+ relsec
->sh_info
!= section
13892 || relsec
->sh_size
== 0
13893 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13896 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13901 end
= start
+ num_bytes
;
13902 some_strings_shown
= FALSE
;
13904 #ifdef HAVE_MBSTATE_T
13906 /* Initialise the multibyte conversion state. */
13907 memset (& state
, 0, sizeof (state
));
13910 bfd_boolean continuing
= FALSE
;
13914 while (!ISPRINT (* data
))
13915 if (++ data
>= end
)
13920 size_t maxlen
= end
- data
;
13925 continuing
= FALSE
;
13930 /* PR 11128: Use two separate invocations in order to work
13931 around bugs in the Solaris 8 implementation of printf. */
13932 printf (" [%6tx] ", data
- start
);
13934 printf (" [%6Ix] ", (size_t) (data
- start
));
13949 /* PR 25543: Treat new-lines as string-ending characters. */
13958 /* Do not print control characters directly as they can affect terminal
13959 settings. Such characters usually appear in the names generated
13960 by the assembler for local labels. */
13963 printf ("^%c", c
+ 0x40);
13965 else if (ISPRINT (c
))
13972 #ifdef HAVE_MBSTATE_T
13975 /* Let printf do the hard work of displaying multibyte characters. */
13976 printf ("%.1s", data
- 1);
13977 #ifdef HAVE_MBSTATE_T
13978 /* Try to find out how many bytes made up the character that was
13979 just printed. Advance the symbol pointer past the bytes that
13981 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13985 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13995 printf (_("<corrupt>\n"));
13998 some_strings_shown
= TRUE
;
14002 if (! some_strings_shown
)
14003 printf (_(" No strings found in this section."));
14016 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
14017 Filedata
* filedata
,
14018 bfd_boolean relocate
)
14020 Elf_Internal_Shdr
* relsec
;
14021 bfd_size_type bytes
;
14022 bfd_size_type section_size
;
14024 unsigned char * data
;
14025 unsigned char * real_start
;
14026 unsigned char * start
;
14028 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14030 /* PR 21820: Do not fail if the section was empty. */
14031 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14033 section_size
= section
->sh_size
;
14035 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
14037 if (decompress_dumps
)
14039 dwarf_size_type new_size
= section_size
;
14040 dwarf_size_type uncompressed_size
= 0;
14042 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14044 Elf_Internal_Chdr chdr
;
14045 unsigned int compression_header_size
14046 = get_compression_header (& chdr
, start
, section_size
);
14048 if (compression_header_size
== 0)
14049 /* An error message will have already been generated
14050 by get_compression_header. */
14053 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14055 warn (_("section '%s' has unsupported compress type: %d\n"),
14056 printable_section_name (filedata
, section
), chdr
.ch_type
);
14059 uncompressed_size
= chdr
.ch_size
;
14060 start
+= compression_header_size
;
14061 new_size
-= compression_header_size
;
14063 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14065 /* Read the zlib header. In this case, it should be "ZLIB"
14066 followed by the uncompressed section size, 8 bytes in
14067 big-endian order. */
14068 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14069 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14070 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14071 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14072 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14073 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14074 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14075 uncompressed_size
+= start
[11];
14080 if (uncompressed_size
)
14082 if (uncompress_section_contents (& start
, uncompressed_size
,
14085 section_size
= new_size
;
14089 error (_("Unable to decompress section %s\n"),
14090 printable_section_name (filedata
, section
));
14091 /* FIXME: Print the section anyway ? */
14096 start
= real_start
;
14101 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14106 /* If the section being dumped has relocations against it the user might
14107 be expecting these relocations to have been applied. Check for this
14108 case and issue a warning message in order to avoid confusion.
14109 FIXME: Maybe we ought to have an option that dumps a section with
14110 relocs applied ? */
14111 for (relsec
= filedata
->section_headers
;
14112 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14115 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14116 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14117 || filedata
->section_headers
+ relsec
->sh_info
!= section
14118 || relsec
->sh_size
== 0
14119 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14122 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14127 addr
= section
->sh_addr
;
14128 bytes
= section_size
;
14137 lbytes
= (bytes
> 16 ? 16 : bytes
);
14139 printf (" 0x%8.8lx ", (unsigned long) addr
);
14141 for (j
= 0; j
< 16; j
++)
14144 printf ("%2.2x", data
[j
]);
14152 for (j
= 0; j
< lbytes
; j
++)
14155 if (k
>= ' ' && k
< 0x7f)
14178 #ifdef ENABLE_LIBCTF
14179 static ctf_sect_t
*
14180 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14182 buf
->cts_name
= SECTION_NAME (shdr
);
14183 buf
->cts_size
= shdr
->sh_size
;
14184 buf
->cts_entsize
= shdr
->sh_entsize
;
14189 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14190 it is passed, or a pointer to newly-allocated storage, in which case
14191 dump_ctf() will free it when it no longer needs it. */
14194 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14195 char *s
, void *arg
)
14197 const char *blanks
= arg
;
14200 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14205 /* Dump one CTF archive member. */
14208 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
14210 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
14211 const char *things
[] = {"Header", "Labels", "Data objects",
14212 "Function objects", "Variables", "Types", "Strings",
14214 const char **thing
;
14217 /* Only print out the name of non-default-named archive members.
14218 The name .ctf appears everywhere, even for things that aren't
14219 really archives, so printing it out is liable to be confusing.
14221 The parent, if there is one, is the default-owned archive member:
14222 avoid importing it into itself. (This does no harm, but looks
14225 if (strcmp (name
, ".ctf") != 0)
14227 printf (_("\nCTF archive member: %s:\n"), name
);
14228 ctf_import (ctf
, parent
);
14231 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14233 ctf_dump_state_t
*s
= NULL
;
14236 printf ("\n %s:\n", *thing
);
14237 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14238 (void *) " ")) != NULL
)
14240 printf ("%s\n", item
);
14244 if (ctf_errno (ctf
))
14246 error (_("Iteration failed: %s, %s\n"), *thing
,
14247 ctf_errmsg (ctf_errno (ctf
)));
14255 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14257 Elf_Internal_Shdr
* parent_sec
= NULL
;
14258 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14259 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14260 void * data
= NULL
;
14261 void * symdata
= NULL
;
14262 void * strdata
= NULL
;
14263 void * parentdata
= NULL
;
14264 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14265 ctf_sect_t
* symsectp
= NULL
;
14266 ctf_sect_t
* strsectp
= NULL
;
14267 ctf_archive_t
* ctfa
= NULL
;
14268 ctf_archive_t
* parenta
= NULL
, *lookparent
;
14269 ctf_file_t
* parent
= NULL
;
14272 bfd_boolean ret
= FALSE
;
14274 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14275 data
= get_section_contents (section
, filedata
);
14276 ctfsect
.cts_data
= data
;
14278 if (!dump_ctf_symtab_name
)
14279 dump_ctf_symtab_name
= strdup (".symtab");
14281 if (!dump_ctf_strtab_name
)
14282 dump_ctf_strtab_name
= strdup (".strtab");
14284 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14286 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14288 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14291 if ((symdata
= (void *) get_data (NULL
, filedata
,
14292 symtab_sec
->sh_offset
, 1,
14293 symtab_sec
->sh_size
,
14294 _("symbols"))) == NULL
)
14296 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14297 symsect
.cts_data
= symdata
;
14299 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14301 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14303 error (_("No string table section named %s\n"),
14304 dump_ctf_strtab_name
);
14307 if ((strdata
= (void *) get_data (NULL
, filedata
,
14308 strtab_sec
->sh_offset
, 1,
14309 strtab_sec
->sh_size
,
14310 _("strings"))) == NULL
)
14312 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14313 strsect
.cts_data
= strdata
;
14315 if (dump_ctf_parent_name
)
14317 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14319 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14322 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14323 parent_sec
->sh_offset
, 1,
14324 parent_sec
->sh_size
,
14325 _("CTF parent"))) == NULL
)
14327 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14328 parentsect
.cts_data
= parentdata
;
14331 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
14332 libctf papers over the difference, so we can pretend it is always an
14333 archive. Possibly open the parent as well, if one was specified. */
14335 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14337 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14343 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
14346 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14349 lookparent
= parenta
;
14354 /* Assume that the applicable parent archive member is the default one.
14355 (This is what all known implementations are expected to do, if they
14356 put CTFs and their parents in archives together.) */
14357 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
14359 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14365 printf (_("\nDump of CTF section '%s':\n"),
14366 printable_section_name (filedata
, section
));
14368 if (ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
) != 0)
14372 ctf_file_close (parent
);
14374 ctf_close (parenta
);
14384 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14385 const Elf_Internal_Shdr
* sec
,
14388 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14390 Filedata
* filedata
= (Filedata
*) data
;
14392 if (section
->start
!= NULL
)
14394 /* If it is already loaded, do nothing. */
14395 if (streq (section
->filename
, filedata
->file_name
))
14397 free (section
->start
);
14400 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14401 section
->address
= sec
->sh_addr
;
14402 section
->user_data
= NULL
;
14403 section
->filename
= filedata
->file_name
;
14404 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14406 sec
->sh_size
, buf
);
14407 if (section
->start
== NULL
)
14411 unsigned char *start
= section
->start
;
14412 dwarf_size_type size
= sec
->sh_size
;
14413 dwarf_size_type uncompressed_size
= 0;
14415 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14417 Elf_Internal_Chdr chdr
;
14418 unsigned int compression_header_size
;
14420 if (size
< (is_32bit_elf
14421 ? sizeof (Elf32_External_Chdr
)
14422 : sizeof (Elf64_External_Chdr
)))
14424 warn (_("compressed section %s is too small to contain a compression header\n"),
14429 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14430 if (compression_header_size
== 0)
14431 /* An error message will have already been generated
14432 by get_compression_header. */
14435 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14437 warn (_("section '%s' has unsupported compress type: %d\n"),
14438 section
->name
, chdr
.ch_type
);
14441 uncompressed_size
= chdr
.ch_size
;
14442 start
+= compression_header_size
;
14443 size
-= compression_header_size
;
14445 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14447 /* Read the zlib header. In this case, it should be "ZLIB"
14448 followed by the uncompressed section size, 8 bytes in
14449 big-endian order. */
14450 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14451 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14452 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14453 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14454 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14455 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14456 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14457 uncompressed_size
+= start
[11];
14462 if (uncompressed_size
)
14464 if (uncompress_section_contents (&start
, uncompressed_size
,
14467 /* Free the compressed buffer, update the section buffer
14468 and the section size if uncompress is successful. */
14469 free (section
->start
);
14470 section
->start
= start
;
14474 error (_("Unable to decompress section %s\n"),
14475 printable_section_name (filedata
, sec
));
14480 section
->size
= size
;
14483 if (section
->start
== NULL
)
14486 if (debug_displays
[debug
].relocate
)
14488 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14489 & section
->reloc_info
, & section
->num_relocs
))
14494 section
->reloc_info
= NULL
;
14495 section
->num_relocs
= 0;
14501 #if HAVE_LIBDEBUGINFOD
14502 /* Return a hex string representation of the build-id. */
14504 get_build_id (void * data
)
14506 Filedata
* filedata
= (Filedata
*)data
;
14507 Elf_Internal_Shdr
* shdr
;
14510 /* Iterate through notes to find note.gnu.build-id.
14511 FIXME: Only the first note in any note section is examined. */
14512 for (i
= 0, shdr
= filedata
->section_headers
;
14513 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14516 if (shdr
->sh_type
!= SHT_NOTE
)
14521 size_t data_remaining
;
14523 Elf_External_Note
* enote
;
14524 Elf_Internal_Note inote
;
14526 bfd_vma offset
= shdr
->sh_offset
;
14527 bfd_vma align
= shdr
->sh_addralign
;
14528 bfd_vma length
= shdr
->sh_size
;
14530 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14536 else if (align
!= 4 && align
!= 8)
14542 end
= (char *) enote
+ length
;
14543 data_remaining
= end
- (char *) enote
;
14545 if (!is_ia64_vms (filedata
))
14547 min_notesz
= offsetof (Elf_External_Note
, name
);
14548 if (data_remaining
< min_notesz
)
14551 malformed note encountered in section %s whilst scanning for build-id note\n"),
14552 printable_section_name (filedata
, shdr
));
14556 data_remaining
-= min_notesz
;
14558 inote
.type
= BYTE_GET (enote
->type
);
14559 inote
.namesz
= BYTE_GET (enote
->namesz
);
14560 inote
.namedata
= enote
->name
;
14561 inote
.descsz
= BYTE_GET (enote
->descsz
);
14562 inote
.descdata
= ((char *) enote
14563 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14564 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14565 next
= ((char *) enote
14566 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14570 Elf64_External_VMS_Note
*vms_enote
;
14572 /* PR binutils/15191
14573 Make sure that there is enough data to read. */
14574 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14575 if (data_remaining
< min_notesz
)
14578 malformed note encountered in section %s whilst scanning for build-id note\n"),
14579 printable_section_name (filedata
, shdr
));
14583 data_remaining
-= min_notesz
;
14585 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14586 inote
.type
= BYTE_GET (vms_enote
->type
);
14587 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14588 inote
.namedata
= vms_enote
->name
;
14589 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14590 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14591 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14592 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14595 /* Skip malformed notes. */
14596 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14597 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14598 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14599 || ((size_t) (next
- inote
.descdata
)
14600 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14603 malformed note encountered in section %s whilst scanning for build-id note\n"),
14604 printable_section_name (filedata
, shdr
));
14609 /* Check if this is the build-id note. If so then convert the build-id
14610 bytes to a hex string. */
14611 if (inote
.namesz
> 0
14612 && const_strneq (inote
.namedata
, "GNU")
14613 && inote
.type
== NT_GNU_BUILD_ID
)
14618 build_id
= malloc (inote
.descsz
* 2 + 1);
14619 if (build_id
== NULL
)
14625 for (j
= 0; j
< inote
.descsz
; ++j
)
14626 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14627 build_id
[inote
.descsz
* 2] = '\0';
14630 return (unsigned char *) build_id
;
14637 #endif /* HAVE_LIBDEBUGINFOD */
14639 /* If this is not NULL, load_debug_section will only look for sections
14640 within the list of sections given here. */
14641 static unsigned int * section_subset
= NULL
;
14644 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14646 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14647 Elf_Internal_Shdr
* sec
;
14648 Filedata
* filedata
= (Filedata
*) data
;
14650 /* Without section headers we cannot find any sections. */
14651 if (filedata
->section_headers
== NULL
)
14654 if (filedata
->string_table
== NULL
14655 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14656 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14658 Elf_Internal_Shdr
* strs
;
14660 /* Read in the string table, so that we have section names to scan. */
14661 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14663 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14665 filedata
->string_table
14666 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14667 1, strs
->sh_size
, _("string table"));
14669 filedata
->string_table_length
14670 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14674 /* Locate the debug section. */
14675 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14677 section
->name
= section
->uncompressed_name
;
14680 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14682 section
->name
= section
->compressed_name
;
14687 /* If we're loading from a subset of sections, and we've loaded
14688 a section matching this name before, it's likely that it's a
14690 if (section_subset
!= NULL
)
14691 free_debug_section (debug
);
14693 return load_specific_debug_section (debug
, sec
, data
);
14697 free_debug_section (enum dwarf_section_display_enum debug
)
14699 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14701 if (section
->start
== NULL
)
14704 free ((char *) section
->start
);
14705 section
->start
= NULL
;
14706 section
->address
= 0;
14709 free (section
->reloc_info
);
14710 section
->reloc_info
= NULL
;
14711 section
->num_relocs
= 0;
14715 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14717 char * name
= SECTION_NAME (section
);
14718 const char * print_name
= printable_section_name (filedata
, section
);
14719 bfd_size_type length
;
14720 bfd_boolean result
= TRUE
;
14723 length
= section
->sh_size
;
14726 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14729 if (section
->sh_type
== SHT_NOBITS
)
14731 /* There is no point in dumping the contents of a debugging section
14732 which has the NOBITS type - the bits in the file will be random.
14733 This can happen when a file containing a .eh_frame section is
14734 stripped with the --only-keep-debug command line option. */
14735 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14740 if (const_strneq (name
, ".gnu.linkonce.wi."))
14741 name
= ".debug_info";
14743 /* See if we know how to display the contents of this section. */
14744 for (i
= 0; i
< max
; i
++)
14746 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14747 struct dwarf_section_display
* display
= debug_displays
+ i
;
14748 struct dwarf_section
* sec
= & display
->section
;
14750 if (streq (sec
->uncompressed_name
, name
)
14751 || (id
== line
&& const_strneq (name
, ".debug_line."))
14752 || streq (sec
->compressed_name
, name
))
14754 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14757 free_debug_section (id
);
14759 if (i
== line
&& const_strneq (name
, ".debug_line."))
14761 else if (streq (sec
->uncompressed_name
, name
))
14762 sec
->name
= sec
->uncompressed_name
;
14764 sec
->name
= sec
->compressed_name
;
14766 if (load_specific_debug_section (id
, section
, filedata
))
14768 /* If this debug section is part of a CU/TU set in a .dwp file,
14769 restrict load_debug_section to the sections in that set. */
14770 section_subset
= find_cu_tu_set (filedata
, shndx
);
14772 result
&= display
->display (sec
, filedata
);
14774 section_subset
= NULL
;
14776 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14777 free_debug_section (id
);
14785 printf (_("Unrecognized debug section: %s\n"), print_name
);
14792 /* Set DUMP_SECTS for all sections where dumps were requested
14793 based on section name. */
14796 initialise_dumps_byname (Filedata
* filedata
)
14798 struct dump_list_entry
* cur
;
14800 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14803 bfd_boolean any
= FALSE
;
14805 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14806 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14808 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14813 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14819 process_section_contents (Filedata
* filedata
)
14821 Elf_Internal_Shdr
* section
;
14823 bfd_boolean res
= TRUE
;
14828 initialise_dumps_byname (filedata
);
14830 for (i
= 0, section
= filedata
->section_headers
;
14831 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14834 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14836 #ifdef SUPPORT_DISASSEMBLY
14837 if (dump
& DISASS_DUMP
)
14839 if (! disassemble_section (section
, filedata
))
14843 if (dump
& HEX_DUMP
)
14845 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14849 if (dump
& RELOC_DUMP
)
14851 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14855 if (dump
& STRING_DUMP
)
14857 if (! dump_section_as_strings (section
, filedata
))
14861 if (dump
& DEBUG_DUMP
)
14863 if (! display_debug_section (i
, section
, filedata
))
14867 #ifdef ENABLE_LIBCTF
14868 if (dump
& CTF_DUMP
)
14870 if (! dump_section_as_ctf (section
, filedata
))
14876 /* Check to see if the user requested a
14877 dump of a section that does not exist. */
14878 while (i
< filedata
->dump
.num_dump_sects
)
14880 if (filedata
->dump
.dump_sects
[i
])
14882 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14892 process_mips_fpe_exception (int mask
)
14896 bfd_boolean first
= TRUE
;
14898 if (mask
& OEX_FPU_INEX
)
14899 fputs ("INEX", stdout
), first
= FALSE
;
14900 if (mask
& OEX_FPU_UFLO
)
14901 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14902 if (mask
& OEX_FPU_OFLO
)
14903 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14904 if (mask
& OEX_FPU_DIV0
)
14905 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14906 if (mask
& OEX_FPU_INVAL
)
14907 printf ("%sINVAL", first
? "" : "|");
14910 fputs ("0", stdout
);
14913 /* Display's the value of TAG at location P. If TAG is
14914 greater than 0 it is assumed to be an unknown tag, and
14915 a message is printed to this effect. Otherwise it is
14916 assumed that a message has already been printed.
14918 If the bottom bit of TAG is set it assumed to have a
14919 string value, otherwise it is assumed to have an integer
14922 Returns an updated P pointing to the first unread byte
14923 beyond the end of TAG's value.
14925 Reads at or beyond END will not be made. */
14927 static unsigned char *
14928 display_tag_value (signed int tag
,
14930 const unsigned char * const end
)
14935 printf (" Tag_unknown_%d: ", tag
);
14939 warn (_("<corrupt tag>\n"));
14943 /* PR 17531 file: 027-19978-0.004. */
14944 size_t maxlen
= (end
- p
) - 1;
14949 print_symbol ((int) maxlen
, (const char *) p
);
14950 p
+= strnlen ((char *) p
, maxlen
) + 1;
14954 printf (_("<corrupt string tag>"));
14955 p
= (unsigned char *) end
;
14961 READ_ULEB (val
, p
, end
);
14962 printf ("%ld (0x%lx)\n", val
, val
);
14969 /* ARC ABI attributes section. */
14971 static unsigned char *
14972 display_arc_attribute (unsigned char * p
,
14973 const unsigned char * const end
)
14978 READ_ULEB (tag
, p
, end
);
14982 case Tag_ARC_PCS_config
:
14983 READ_ULEB (val
, p
, end
);
14984 printf (" Tag_ARC_PCS_config: ");
14988 printf (_("Absent/Non standard\n"));
14991 printf (_("Bare metal/mwdt\n"));
14994 printf (_("Bare metal/newlib\n"));
14997 printf (_("Linux/uclibc\n"));
15000 printf (_("Linux/glibc\n"));
15003 printf (_("Unknown\n"));
15008 case Tag_ARC_CPU_base
:
15009 READ_ULEB (val
, p
, end
);
15010 printf (" Tag_ARC_CPU_base: ");
15015 printf (_("Absent\n"));
15017 case TAG_CPU_ARC6xx
:
15018 printf ("ARC6xx\n");
15020 case TAG_CPU_ARC7xx
:
15021 printf ("ARC7xx\n");
15023 case TAG_CPU_ARCEM
:
15024 printf ("ARCEM\n");
15026 case TAG_CPU_ARCHS
:
15027 printf ("ARCHS\n");
15032 case Tag_ARC_CPU_variation
:
15033 READ_ULEB (val
, p
, end
);
15034 printf (" Tag_ARC_CPU_variation: ");
15038 if (val
> 0 && val
< 16)
15039 printf ("Core%d\n", val
);
15041 printf ("Unknown\n");
15045 printf (_("Absent\n"));
15050 case Tag_ARC_CPU_name
:
15051 printf (" Tag_ARC_CPU_name: ");
15052 p
= display_tag_value (-1, p
, end
);
15055 case Tag_ARC_ABI_rf16
:
15056 READ_ULEB (val
, p
, end
);
15057 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15060 case Tag_ARC_ABI_osver
:
15061 READ_ULEB (val
, p
, end
);
15062 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15065 case Tag_ARC_ABI_pic
:
15066 case Tag_ARC_ABI_sda
:
15067 READ_ULEB (val
, p
, end
);
15068 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15069 : " Tag_ARC_ABI_pic: ");
15073 printf (_("Absent\n"));
15082 printf (_("Unknown\n"));
15087 case Tag_ARC_ABI_tls
:
15088 READ_ULEB (val
, p
, end
);
15089 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15092 case Tag_ARC_ABI_enumsize
:
15093 READ_ULEB (val
, p
, end
);
15094 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15098 case Tag_ARC_ABI_exceptions
:
15099 READ_ULEB (val
, p
, end
);
15100 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15104 case Tag_ARC_ABI_double_size
:
15105 READ_ULEB (val
, p
, end
);
15106 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15109 case Tag_ARC_ISA_config
:
15110 printf (" Tag_ARC_ISA_config: ");
15111 p
= display_tag_value (-1, p
, end
);
15114 case Tag_ARC_ISA_apex
:
15115 printf (" Tag_ARC_ISA_apex: ");
15116 p
= display_tag_value (-1, p
, end
);
15119 case Tag_ARC_ISA_mpy_option
:
15120 READ_ULEB (val
, p
, end
);
15121 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15124 case Tag_ARC_ATR_version
:
15125 READ_ULEB (val
, p
, end
);
15126 printf (" Tag_ARC_ATR_version: %d\n", val
);
15130 return display_tag_value (tag
& 1, p
, end
);
15136 /* ARM EABI attributes section. */
15141 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15143 const char ** table
;
15144 } arm_attr_public_tag
;
15146 static const char * arm_attr_tag_CPU_arch
[] =
15147 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15148 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15149 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15150 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15151 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15152 {"No", "Thumb-1", "Thumb-2", "Yes"};
15153 static const char * arm_attr_tag_FP_arch
[] =
15154 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15155 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15156 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15157 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15158 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15159 "NEON for ARMv8.1"};
15160 static const char * arm_attr_tag_PCS_config
[] =
15161 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15162 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15163 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15164 {"V6", "SB", "TLS", "Unused"};
15165 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15166 {"Absolute", "PC-relative", "SB-relative", "None"};
15167 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15168 {"Absolute", "PC-relative", "None"};
15169 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15170 {"None", "direct", "GOT-indirect"};
15171 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15172 {"None", "??? 1", "2", "??? 3", "4"};
15173 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15174 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15175 {"Unused", "Needed", "Sign only"};
15176 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15177 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15178 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15179 {"Unused", "Finite", "RTABI", "IEEE 754"};
15180 static const char * arm_attr_tag_ABI_enum_size
[] =
15181 {"Unused", "small", "int", "forced to int"};
15182 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15183 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15184 static const char * arm_attr_tag_ABI_VFP_args
[] =
15185 {"AAPCS", "VFP registers", "custom", "compatible"};
15186 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15187 {"AAPCS", "WMMX registers", "custom"};
15188 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15189 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15190 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15191 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15192 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15193 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15194 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15195 static const char * arm_attr_tag_FP_HP_extension
[] =
15196 {"Not Allowed", "Allowed"};
15197 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15198 {"None", "IEEE 754", "Alternative Format"};
15199 static const char * arm_attr_tag_DSP_extension
[] =
15200 {"Follow architecture", "Allowed"};
15201 static const char * arm_attr_tag_MPextension_use
[] =
15202 {"Not Allowed", "Allowed"};
15203 static const char * arm_attr_tag_DIV_use
[] =
15204 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15205 "Allowed in v7-A with integer division extension"};
15206 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15207 static const char * arm_attr_tag_Virtualization_use
[] =
15208 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15209 "TrustZone and Virtualization Extensions"};
15210 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15211 {"Not Allowed", "Allowed"};
15213 static const char * arm_attr_tag_MVE_arch
[] =
15214 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15216 #define LOOKUP(id, name) \
15217 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15218 static arm_attr_public_tag arm_attr_public_tags
[] =
15220 {4, "CPU_raw_name", 1, NULL
},
15221 {5, "CPU_name", 1, NULL
},
15222 LOOKUP(6, CPU_arch
),
15223 {7, "CPU_arch_profile", 0, NULL
},
15224 LOOKUP(8, ARM_ISA_use
),
15225 LOOKUP(9, THUMB_ISA_use
),
15226 LOOKUP(10, FP_arch
),
15227 LOOKUP(11, WMMX_arch
),
15228 LOOKUP(12, Advanced_SIMD_arch
),
15229 LOOKUP(13, PCS_config
),
15230 LOOKUP(14, ABI_PCS_R9_use
),
15231 LOOKUP(15, ABI_PCS_RW_data
),
15232 LOOKUP(16, ABI_PCS_RO_data
),
15233 LOOKUP(17, ABI_PCS_GOT_use
),
15234 LOOKUP(18, ABI_PCS_wchar_t
),
15235 LOOKUP(19, ABI_FP_rounding
),
15236 LOOKUP(20, ABI_FP_denormal
),
15237 LOOKUP(21, ABI_FP_exceptions
),
15238 LOOKUP(22, ABI_FP_user_exceptions
),
15239 LOOKUP(23, ABI_FP_number_model
),
15240 {24, "ABI_align_needed", 0, NULL
},
15241 {25, "ABI_align_preserved", 0, NULL
},
15242 LOOKUP(26, ABI_enum_size
),
15243 LOOKUP(27, ABI_HardFP_use
),
15244 LOOKUP(28, ABI_VFP_args
),
15245 LOOKUP(29, ABI_WMMX_args
),
15246 LOOKUP(30, ABI_optimization_goals
),
15247 LOOKUP(31, ABI_FP_optimization_goals
),
15248 {32, "compatibility", 0, NULL
},
15249 LOOKUP(34, CPU_unaligned_access
),
15250 LOOKUP(36, FP_HP_extension
),
15251 LOOKUP(38, ABI_FP_16bit_format
),
15252 LOOKUP(42, MPextension_use
),
15253 LOOKUP(44, DIV_use
),
15254 LOOKUP(46, DSP_extension
),
15255 LOOKUP(48, MVE_arch
),
15256 {64, "nodefaults", 0, NULL
},
15257 {65, "also_compatible_with", 0, NULL
},
15258 LOOKUP(66, T2EE_use
),
15259 {67, "conformance", 1, NULL
},
15260 LOOKUP(68, Virtualization_use
),
15261 LOOKUP(70, MPextension_use_legacy
)
15265 static unsigned char *
15266 display_arm_attribute (unsigned char * p
,
15267 const unsigned char * const end
)
15271 arm_attr_public_tag
* attr
;
15275 READ_ULEB (tag
, p
, end
);
15277 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15279 if (arm_attr_public_tags
[i
].tag
== tag
)
15281 attr
= &arm_attr_public_tags
[i
];
15288 printf (" Tag_%s: ", attr
->name
);
15289 switch (attr
->type
)
15294 case 7: /* Tag_CPU_arch_profile. */
15295 READ_ULEB (val
, p
, end
);
15298 case 0: printf (_("None\n")); break;
15299 case 'A': printf (_("Application\n")); break;
15300 case 'R': printf (_("Realtime\n")); break;
15301 case 'M': printf (_("Microcontroller\n")); break;
15302 case 'S': printf (_("Application or Realtime\n")); break;
15303 default: printf ("??? (%d)\n", val
); break;
15307 case 24: /* Tag_align_needed. */
15308 READ_ULEB (val
, p
, end
);
15311 case 0: printf (_("None\n")); break;
15312 case 1: printf (_("8-byte\n")); break;
15313 case 2: printf (_("4-byte\n")); break;
15314 case 3: printf ("??? 3\n"); break;
15317 printf (_("8-byte and up to %d-byte extended\n"),
15320 printf ("??? (%d)\n", val
);
15325 case 25: /* Tag_align_preserved. */
15326 READ_ULEB (val
, p
, end
);
15329 case 0: printf (_("None\n")); break;
15330 case 1: printf (_("8-byte, except leaf SP\n")); break;
15331 case 2: printf (_("8-byte\n")); break;
15332 case 3: printf ("??? 3\n"); break;
15335 printf (_("8-byte and up to %d-byte extended\n"),
15338 printf ("??? (%d)\n", val
);
15343 case 32: /* Tag_compatibility. */
15345 READ_ULEB (val
, p
, end
);
15346 printf (_("flag = %d, vendor = "), val
);
15349 size_t maxlen
= (end
- p
) - 1;
15351 print_symbol ((int) maxlen
, (const char *) p
);
15352 p
+= strnlen ((char *) p
, maxlen
) + 1;
15356 printf (_("<corrupt>"));
15357 p
= (unsigned char *) end
;
15363 case 64: /* Tag_nodefaults. */
15364 /* PR 17531: file: 001-505008-0.01. */
15367 printf (_("True\n"));
15370 case 65: /* Tag_also_compatible_with. */
15371 READ_ULEB (val
, p
, end
);
15372 if (val
== 6 /* Tag_CPU_arch. */)
15374 READ_ULEB (val
, p
, end
);
15375 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15376 printf ("??? (%d)\n", val
);
15378 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15382 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15387 printf (_("<unknown: %d>\n"), tag
);
15393 return display_tag_value (-1, p
, end
);
15395 return display_tag_value (0, p
, end
);
15398 assert (attr
->type
& 0x80);
15399 READ_ULEB (val
, p
, end
);
15400 type
= attr
->type
& 0x7f;
15402 printf ("??? (%d)\n", val
);
15404 printf ("%s\n", attr
->table
[val
]);
15409 return display_tag_value (tag
, p
, end
);
15412 static unsigned char *
15413 display_gnu_attribute (unsigned char * p
,
15414 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15415 const unsigned char * const end
)
15420 READ_ULEB (tag
, p
, end
);
15422 /* Tag_compatibility is the only generic GNU attribute defined at
15426 READ_ULEB (val
, p
, end
);
15428 printf (_("flag = %d, vendor = "), val
);
15431 printf (_("<corrupt>\n"));
15432 warn (_("corrupt vendor attribute\n"));
15438 size_t maxlen
= (end
- p
) - 1;
15440 print_symbol ((int) maxlen
, (const char *) p
);
15441 p
+= strnlen ((char *) p
, maxlen
) + 1;
15445 printf (_("<corrupt>"));
15446 p
= (unsigned char *) end
;
15453 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15454 return display_proc_gnu_attribute (p
, tag
, end
);
15456 return display_tag_value (tag
, p
, end
);
15459 static unsigned char *
15460 display_m68k_gnu_attribute (unsigned char * p
,
15462 const unsigned char * const end
)
15466 if (tag
== Tag_GNU_M68K_ABI_FP
)
15468 printf (" Tag_GNU_M68K_ABI_FP: ");
15471 printf (_("<corrupt>\n"));
15474 READ_ULEB (val
, p
, end
);
15477 printf ("(%#x), ", val
);
15482 printf (_("unspecified hard/soft float\n"));
15485 printf (_("hard float\n"));
15488 printf (_("soft float\n"));
15494 return display_tag_value (tag
& 1, p
, end
);
15497 static unsigned char *
15498 display_power_gnu_attribute (unsigned char * p
,
15500 const unsigned char * const end
)
15504 if (tag
== Tag_GNU_Power_ABI_FP
)
15506 printf (" Tag_GNU_Power_ABI_FP: ");
15509 printf (_("<corrupt>\n"));
15512 READ_ULEB (val
, p
, end
);
15515 printf ("(%#x), ", val
);
15520 printf (_("unspecified hard/soft float, "));
15523 printf (_("hard float, "));
15526 printf (_("soft float, "));
15529 printf (_("single-precision hard float, "));
15536 printf (_("unspecified long double\n"));
15539 printf (_("128-bit IBM long double\n"));
15542 printf (_("64-bit long double\n"));
15545 printf (_("128-bit IEEE long double\n"));
15551 if (tag
== Tag_GNU_Power_ABI_Vector
)
15553 printf (" Tag_GNU_Power_ABI_Vector: ");
15556 printf (_("<corrupt>\n"));
15559 READ_ULEB (val
, p
, end
);
15562 printf ("(%#x), ", val
);
15567 printf (_("unspecified\n"));
15570 printf (_("generic\n"));
15573 printf ("AltiVec\n");
15582 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15584 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15587 printf (_("<corrupt>\n"));
15590 READ_ULEB (val
, p
, end
);
15593 printf ("(%#x), ", val
);
15598 printf (_("unspecified\n"));
15601 printf ("r3/r4\n");
15604 printf (_("memory\n"));
15613 return display_tag_value (tag
& 1, p
, end
);
15616 static unsigned char *
15617 display_s390_gnu_attribute (unsigned char * p
,
15619 const unsigned char * const end
)
15623 if (tag
== Tag_GNU_S390_ABI_Vector
)
15625 printf (" Tag_GNU_S390_ABI_Vector: ");
15626 READ_ULEB (val
, p
, end
);
15631 printf (_("any\n"));
15634 printf (_("software\n"));
15637 printf (_("hardware\n"));
15640 printf ("??? (%d)\n", val
);
15646 return display_tag_value (tag
& 1, p
, end
);
15650 display_sparc_hwcaps (unsigned int mask
)
15654 bfd_boolean first
= TRUE
;
15656 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15657 fputs ("mul32", stdout
), first
= FALSE
;
15658 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15659 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15660 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15661 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15662 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15663 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15664 if (mask
& ELF_SPARC_HWCAP_POPC
)
15665 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15666 if (mask
& ELF_SPARC_HWCAP_VIS
)
15667 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15668 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15669 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15670 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15671 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15672 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15673 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15674 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15675 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15676 if (mask
& ELF_SPARC_HWCAP_HPC
)
15677 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15678 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15679 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15680 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15681 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15682 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15683 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15684 if (mask
& ELF_SPARC_HWCAP_IMA
)
15685 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15686 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15687 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15690 fputc ('0', stdout
);
15691 fputc ('\n', stdout
);
15695 display_sparc_hwcaps2 (unsigned int mask
)
15699 bfd_boolean first
= TRUE
;
15701 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15702 fputs ("fjathplus", stdout
), first
= FALSE
;
15703 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15704 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15705 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15706 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15707 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15708 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15709 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15710 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15711 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15712 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15713 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15714 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15715 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15716 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15717 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15718 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15719 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15720 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15721 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15722 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15725 fputc ('0', stdout
);
15726 fputc ('\n', stdout
);
15729 static unsigned char *
15730 display_sparc_gnu_attribute (unsigned char * p
,
15732 const unsigned char * const end
)
15736 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15738 READ_ULEB (val
, p
, end
);
15739 printf (" Tag_GNU_Sparc_HWCAPS: ");
15740 display_sparc_hwcaps (val
);
15743 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15745 READ_ULEB (val
, p
, end
);
15746 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15747 display_sparc_hwcaps2 (val
);
15751 return display_tag_value (tag
, p
, end
);
15755 print_mips_fp_abi_value (unsigned int val
)
15759 case Val_GNU_MIPS_ABI_FP_ANY
:
15760 printf (_("Hard or soft float\n"));
15762 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15763 printf (_("Hard float (double precision)\n"));
15765 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15766 printf (_("Hard float (single precision)\n"));
15768 case Val_GNU_MIPS_ABI_FP_SOFT
:
15769 printf (_("Soft float\n"));
15771 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15772 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15774 case Val_GNU_MIPS_ABI_FP_XX
:
15775 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15777 case Val_GNU_MIPS_ABI_FP_64
:
15778 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15780 case Val_GNU_MIPS_ABI_FP_64A
:
15781 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15783 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15784 printf (_("NaN 2008 compatibility\n"));
15787 printf ("??? (%d)\n", val
);
15792 static unsigned char *
15793 display_mips_gnu_attribute (unsigned char * p
,
15795 const unsigned char * const end
)
15797 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15801 printf (" Tag_GNU_MIPS_ABI_FP: ");
15802 READ_ULEB (val
, p
, end
);
15803 print_mips_fp_abi_value (val
);
15807 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15811 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15812 READ_ULEB (val
, p
, end
);
15816 case Val_GNU_MIPS_ABI_MSA_ANY
:
15817 printf (_("Any MSA or not\n"));
15819 case Val_GNU_MIPS_ABI_MSA_128
:
15820 printf (_("128-bit MSA\n"));
15823 printf ("??? (%d)\n", val
);
15829 return display_tag_value (tag
& 1, p
, end
);
15832 static unsigned char *
15833 display_tic6x_attribute (unsigned char * p
,
15834 const unsigned char * const end
)
15839 READ_ULEB (tag
, p
, end
);
15844 printf (" Tag_ISA: ");
15845 READ_ULEB (val
, p
, end
);
15849 case C6XABI_Tag_ISA_none
:
15850 printf (_("None\n"));
15852 case C6XABI_Tag_ISA_C62X
:
15855 case C6XABI_Tag_ISA_C67X
:
15858 case C6XABI_Tag_ISA_C67XP
:
15859 printf ("C67x+\n");
15861 case C6XABI_Tag_ISA_C64X
:
15864 case C6XABI_Tag_ISA_C64XP
:
15865 printf ("C64x+\n");
15867 case C6XABI_Tag_ISA_C674X
:
15868 printf ("C674x\n");
15871 printf ("??? (%d)\n", val
);
15876 case Tag_ABI_wchar_t
:
15877 printf (" Tag_ABI_wchar_t: ");
15878 READ_ULEB (val
, p
, end
);
15882 printf (_("Not used\n"));
15885 printf (_("2 bytes\n"));
15888 printf (_("4 bytes\n"));
15891 printf ("??? (%d)\n", val
);
15896 case Tag_ABI_stack_align_needed
:
15897 printf (" Tag_ABI_stack_align_needed: ");
15898 READ_ULEB (val
, p
, end
);
15902 printf (_("8-byte\n"));
15905 printf (_("16-byte\n"));
15908 printf ("??? (%d)\n", val
);
15913 case Tag_ABI_stack_align_preserved
:
15914 READ_ULEB (val
, p
, end
);
15915 printf (" Tag_ABI_stack_align_preserved: ");
15919 printf (_("8-byte\n"));
15922 printf (_("16-byte\n"));
15925 printf ("??? (%d)\n", val
);
15931 READ_ULEB (val
, p
, end
);
15932 printf (" Tag_ABI_DSBT: ");
15936 printf (_("DSBT addressing not used\n"));
15939 printf (_("DSBT addressing used\n"));
15942 printf ("??? (%d)\n", val
);
15948 READ_ULEB (val
, p
, end
);
15949 printf (" Tag_ABI_PID: ");
15953 printf (_("Data addressing position-dependent\n"));
15956 printf (_("Data addressing position-independent, GOT near DP\n"));
15959 printf (_("Data addressing position-independent, GOT far from DP\n"));
15962 printf ("??? (%d)\n", val
);
15968 READ_ULEB (val
, p
, end
);
15969 printf (" Tag_ABI_PIC: ");
15973 printf (_("Code addressing position-dependent\n"));
15976 printf (_("Code addressing position-independent\n"));
15979 printf ("??? (%d)\n", val
);
15984 case Tag_ABI_array_object_alignment
:
15985 READ_ULEB (val
, p
, end
);
15986 printf (" Tag_ABI_array_object_alignment: ");
15990 printf (_("8-byte\n"));
15993 printf (_("4-byte\n"));
15996 printf (_("16-byte\n"));
15999 printf ("??? (%d)\n", val
);
16004 case Tag_ABI_array_object_align_expected
:
16005 READ_ULEB (val
, p
, end
);
16006 printf (" Tag_ABI_array_object_align_expected: ");
16010 printf (_("8-byte\n"));
16013 printf (_("4-byte\n"));
16016 printf (_("16-byte\n"));
16019 printf ("??? (%d)\n", val
);
16024 case Tag_ABI_compatibility
:
16026 READ_ULEB (val
, p
, end
);
16027 printf (" Tag_ABI_compatibility: ");
16028 printf (_("flag = %d, vendor = "), val
);
16031 size_t maxlen
= (end
- p
) - 1;
16033 print_symbol ((int) maxlen
, (const char *) p
);
16034 p
+= strnlen ((char *) p
, maxlen
) + 1;
16038 printf (_("<corrupt>"));
16039 p
= (unsigned char *) end
;
16045 case Tag_ABI_conformance
:
16047 printf (" Tag_ABI_conformance: \"");
16050 size_t maxlen
= (end
- p
) - 1;
16052 print_symbol ((int) maxlen
, (const char *) p
);
16053 p
+= strnlen ((char *) p
, maxlen
) + 1;
16057 printf (_("<corrupt>"));
16058 p
= (unsigned char *) end
;
16065 return display_tag_value (tag
, p
, end
);
16069 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16071 unsigned long addr
= 0;
16072 size_t bytes
= end
- p
;
16079 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16081 printf (" 0x%8.8lx ", addr
);
16083 for (j
= 0; j
< 16; j
++)
16086 printf ("%2.2x", p
[j
]);
16094 for (j
= 0; j
< lbytes
; j
++)
16097 if (k
>= ' ' && k
< 0x7f)
16113 static unsigned char *
16114 display_msp430x_attribute (unsigned char * p
,
16115 const unsigned char * const end
)
16120 READ_ULEB (tag
, p
, end
);
16124 case OFBA_MSPABI_Tag_ISA
:
16125 printf (" Tag_ISA: ");
16126 READ_ULEB (val
, p
, end
);
16129 case 0: printf (_("None\n")); break;
16130 case 1: printf (_("MSP430\n")); break;
16131 case 2: printf (_("MSP430X\n")); break;
16132 default: printf ("??? (%d)\n", val
); break;
16136 case OFBA_MSPABI_Tag_Code_Model
:
16137 printf (" Tag_Code_Model: ");
16138 READ_ULEB (val
, p
, end
);
16141 case 0: printf (_("None\n")); break;
16142 case 1: printf (_("Small\n")); break;
16143 case 2: printf (_("Large\n")); break;
16144 default: printf ("??? (%d)\n", val
); break;
16148 case OFBA_MSPABI_Tag_Data_Model
:
16149 printf (" Tag_Data_Model: ");
16150 READ_ULEB (val
, p
, end
);
16153 case 0: printf (_("None\n")); break;
16154 case 1: printf (_("Small\n")); break;
16155 case 2: printf (_("Large\n")); break;
16156 case 3: printf (_("Restricted Large\n")); break;
16157 default: printf ("??? (%d)\n", val
); break;
16162 printf (_(" <unknown tag %d>: "), tag
);
16169 size_t maxlen
= (end
- p
) - 1;
16171 print_symbol ((int) maxlen
, (const char *) p
);
16172 p
+= strnlen ((char *) p
, maxlen
) + 1;
16176 printf (_("<corrupt>"));
16177 p
= (unsigned char *) end
;
16183 READ_ULEB (val
, p
, end
);
16184 printf ("%d (0x%x)\n", val
, val
);
16193 static unsigned char *
16194 display_msp430_gnu_attribute (unsigned char * p
,
16196 const unsigned char * const end
)
16198 if (tag
== Tag_GNU_MSP430_Data_Region
)
16202 printf (" Tag_GNU_MSP430_Data_Region: ");
16203 READ_ULEB (val
, p
, end
);
16207 case Val_GNU_MSP430_Data_Region_Any
:
16208 printf (_("Any Region\n"));
16210 case Val_GNU_MSP430_Data_Region_Lower
:
16211 printf (_("Lower Region Only\n"));
16214 printf ("??? (%u)\n", val
);
16218 return display_tag_value (tag
& 1, p
, end
);
16221 struct riscv_attr_tag_t
{
16226 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16228 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16231 T(priv_spec_minor
),
16232 T(priv_spec_revision
),
16233 T(unaligned_access
),
16238 static unsigned char *
16239 display_riscv_attribute (unsigned char *p
,
16240 const unsigned char * const end
)
16244 struct riscv_attr_tag_t
*attr
= NULL
;
16247 READ_ULEB (tag
, p
, end
);
16249 /* Find the name of attribute. */
16250 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16252 if (riscv_attr_tag
[i
].tag
== tag
)
16254 attr
= &riscv_attr_tag
[i
];
16260 printf (" %s: ", attr
->name
);
16262 return display_tag_value (tag
, p
, end
);
16266 case Tag_RISCV_priv_spec
:
16267 case Tag_RISCV_priv_spec_minor
:
16268 case Tag_RISCV_priv_spec_revision
:
16269 READ_ULEB (val
, p
, end
);
16270 printf (_("%u\n"), val
);
16272 case Tag_RISCV_unaligned_access
:
16273 READ_ULEB (val
, p
, end
);
16277 printf (_("No unaligned access\n"));
16280 printf (_("Unaligned access\n"));
16284 case Tag_RISCV_stack_align
:
16285 READ_ULEB (val
, p
, end
);
16286 printf (_("%u-bytes\n"), val
);
16288 case Tag_RISCV_arch
:
16289 p
= display_tag_value (-1, p
, end
);
16292 return display_tag_value (tag
, p
, end
);
16299 process_attributes (Filedata
* filedata
,
16300 const char * public_name
,
16301 unsigned int proc_type
,
16302 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16303 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16305 Elf_Internal_Shdr
* sect
;
16307 bfd_boolean res
= TRUE
;
16309 /* Find the section header so that we get the size. */
16310 for (i
= 0, sect
= filedata
->section_headers
;
16311 i
< filedata
->file_header
.e_shnum
;
16314 unsigned char * contents
;
16317 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16320 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16321 sect
->sh_size
, _("attributes"));
16322 if (contents
== NULL
)
16329 /* The first character is the version of the attributes.
16330 Currently only version 1, (aka 'A') is recognised here. */
16333 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16338 bfd_vma section_len
;
16340 section_len
= sect
->sh_size
- 1;
16343 while (section_len
> 0)
16346 unsigned int namelen
;
16347 bfd_boolean public_section
;
16348 bfd_boolean gnu_section
;
16350 if (section_len
<= 4)
16352 error (_("Tag section ends prematurely\n"));
16356 attr_len
= byte_get (p
, 4);
16359 if (attr_len
> section_len
)
16361 error (_("Bad attribute length (%u > %u)\n"),
16362 (unsigned) attr_len
, (unsigned) section_len
);
16363 attr_len
= section_len
;
16366 /* PR 17531: file: 001-101425-0.004 */
16367 else if (attr_len
< 5)
16369 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16374 section_len
-= attr_len
;
16377 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16378 if (namelen
== 0 || namelen
>= attr_len
)
16380 error (_("Corrupt attribute section name\n"));
16385 printf (_("Attribute Section: "));
16386 print_symbol (INT_MAX
, (const char *) p
);
16389 if (public_name
&& streq ((char *) p
, public_name
))
16390 public_section
= TRUE
;
16392 public_section
= FALSE
;
16394 if (streq ((char *) p
, "gnu"))
16395 gnu_section
= TRUE
;
16397 gnu_section
= FALSE
;
16400 attr_len
-= namelen
;
16402 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16407 unsigned char * end
;
16409 /* PR binutils/17531: Safe handling of corrupt files. */
16412 error (_("Unused bytes at end of section\n"));
16419 size
= byte_get (p
, 4);
16420 if (size
> attr_len
)
16422 error (_("Bad subsection length (%u > %u)\n"),
16423 (unsigned) size
, (unsigned) attr_len
);
16427 /* PR binutils/17531: Safe handling of corrupt files. */
16430 error (_("Bad subsection length (%u < 6)\n"),
16438 end
= p
+ size
- 1;
16439 assert (end
<= contents
+ sect
->sh_size
);
16445 printf (_("File Attributes\n"));
16448 printf (_("Section Attributes:"));
16451 printf (_("Symbol Attributes:"));
16452 /* Fall through. */
16456 READ_ULEB (val
, p
, end
);
16459 printf (" %d", val
);
16464 printf (_("Unknown tag: %d\n"), tag
);
16465 public_section
= FALSE
;
16469 if (public_section
&& display_pub_attribute
!= NULL
)
16472 p
= display_pub_attribute (p
, end
);
16475 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16478 p
= display_gnu_attribute (p
,
16479 display_proc_gnu_attribute
,
16485 printf (_(" Unknown attribute:\n"));
16486 display_raw_attribute (p
, end
);
16501 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16502 Print the Address, Access and Initial fields of an entry at VMA ADDR
16503 and return the VMA of the next entry, or -1 if there was a problem.
16504 Does not read from DATA_END or beyond. */
16507 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16508 unsigned char * data_end
)
16511 print_vma (addr
, LONG_HEX
);
16513 if (addr
< pltgot
+ 0xfff0)
16514 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16516 printf ("%10s", "");
16519 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16523 unsigned char * from
= data
+ addr
- pltgot
;
16525 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16527 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16528 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16529 return (bfd_vma
) -1;
16533 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16534 print_vma (entry
, LONG_HEX
);
16537 return addr
+ (is_32bit_elf
? 4 : 8);
16540 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16541 PLTGOT. Print the Address and Initial fields of an entry at VMA
16542 ADDR and return the VMA of the next entry. */
16545 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16548 print_vma (addr
, LONG_HEX
);
16551 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16556 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16557 print_vma (entry
, LONG_HEX
);
16559 return addr
+ (is_32bit_elf
? 4 : 8);
16563 print_mips_ases (unsigned int mask
)
16565 if (mask
& AFL_ASE_DSP
)
16566 fputs ("\n\tDSP ASE", stdout
);
16567 if (mask
& AFL_ASE_DSPR2
)
16568 fputs ("\n\tDSP R2 ASE", stdout
);
16569 if (mask
& AFL_ASE_DSPR3
)
16570 fputs ("\n\tDSP R3 ASE", stdout
);
16571 if (mask
& AFL_ASE_EVA
)
16572 fputs ("\n\tEnhanced VA Scheme", stdout
);
16573 if (mask
& AFL_ASE_MCU
)
16574 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16575 if (mask
& AFL_ASE_MDMX
)
16576 fputs ("\n\tMDMX ASE", stdout
);
16577 if (mask
& AFL_ASE_MIPS3D
)
16578 fputs ("\n\tMIPS-3D ASE", stdout
);
16579 if (mask
& AFL_ASE_MT
)
16580 fputs ("\n\tMT ASE", stdout
);
16581 if (mask
& AFL_ASE_SMARTMIPS
)
16582 fputs ("\n\tSmartMIPS ASE", stdout
);
16583 if (mask
& AFL_ASE_VIRT
)
16584 fputs ("\n\tVZ ASE", stdout
);
16585 if (mask
& AFL_ASE_MSA
)
16586 fputs ("\n\tMSA ASE", stdout
);
16587 if (mask
& AFL_ASE_MIPS16
)
16588 fputs ("\n\tMIPS16 ASE", stdout
);
16589 if (mask
& AFL_ASE_MICROMIPS
)
16590 fputs ("\n\tMICROMIPS ASE", stdout
);
16591 if (mask
& AFL_ASE_XPA
)
16592 fputs ("\n\tXPA ASE", stdout
);
16593 if (mask
& AFL_ASE_MIPS16E2
)
16594 fputs ("\n\tMIPS16e2 ASE", stdout
);
16595 if (mask
& AFL_ASE_CRC
)
16596 fputs ("\n\tCRC ASE", stdout
);
16597 if (mask
& AFL_ASE_GINV
)
16598 fputs ("\n\tGINV ASE", stdout
);
16599 if (mask
& AFL_ASE_LOONGSON_MMI
)
16600 fputs ("\n\tLoongson MMI ASE", stdout
);
16601 if (mask
& AFL_ASE_LOONGSON_CAM
)
16602 fputs ("\n\tLoongson CAM ASE", stdout
);
16603 if (mask
& AFL_ASE_LOONGSON_EXT
)
16604 fputs ("\n\tLoongson EXT ASE", stdout
);
16605 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16606 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16608 fprintf (stdout
, "\n\t%s", _("None"));
16609 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16610 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16614 print_mips_isa_ext (unsigned int isa_ext
)
16619 fputs (_("None"), stdout
);
16622 fputs ("RMI XLR", stdout
);
16624 case AFL_EXT_OCTEON3
:
16625 fputs ("Cavium Networks Octeon3", stdout
);
16627 case AFL_EXT_OCTEON2
:
16628 fputs ("Cavium Networks Octeon2", stdout
);
16630 case AFL_EXT_OCTEONP
:
16631 fputs ("Cavium Networks OcteonP", stdout
);
16633 case AFL_EXT_OCTEON
:
16634 fputs ("Cavium Networks Octeon", stdout
);
16637 fputs ("Toshiba R5900", stdout
);
16640 fputs ("MIPS R4650", stdout
);
16643 fputs ("LSI R4010", stdout
);
16646 fputs ("NEC VR4100", stdout
);
16649 fputs ("Toshiba R3900", stdout
);
16651 case AFL_EXT_10000
:
16652 fputs ("MIPS R10000", stdout
);
16655 fputs ("Broadcom SB-1", stdout
);
16658 fputs ("NEC VR4111/VR4181", stdout
);
16661 fputs ("NEC VR4120", stdout
);
16664 fputs ("NEC VR5400", stdout
);
16667 fputs ("NEC VR5500", stdout
);
16669 case AFL_EXT_LOONGSON_2E
:
16670 fputs ("ST Microelectronics Loongson 2E", stdout
);
16672 case AFL_EXT_LOONGSON_2F
:
16673 fputs ("ST Microelectronics Loongson 2F", stdout
);
16675 case AFL_EXT_INTERAPTIV_MR2
:
16676 fputs ("Imagination interAptiv MR2", stdout
);
16679 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16684 get_mips_reg_size (int reg_size
)
16686 return (reg_size
== AFL_REG_NONE
) ? 0
16687 : (reg_size
== AFL_REG_32
) ? 32
16688 : (reg_size
== AFL_REG_64
) ? 64
16689 : (reg_size
== AFL_REG_128
) ? 128
16694 process_mips_specific (Filedata
* filedata
)
16696 Elf_Internal_Dyn
* entry
;
16697 Elf_Internal_Shdr
*sect
= NULL
;
16698 size_t liblist_offset
= 0;
16699 size_t liblistno
= 0;
16700 size_t conflictsno
= 0;
16701 size_t options_offset
= 0;
16702 size_t conflicts_offset
= 0;
16703 size_t pltrelsz
= 0;
16705 bfd_vma pltgot
= 0;
16706 bfd_vma mips_pltgot
= 0;
16707 bfd_vma jmprel
= 0;
16708 bfd_vma local_gotno
= 0;
16709 bfd_vma gotsym
= 0;
16710 bfd_vma symtabno
= 0;
16711 bfd_boolean res
= TRUE
;
16713 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16714 display_mips_gnu_attribute
))
16717 sect
= find_section (filedata
, ".MIPS.abiflags");
16721 Elf_External_ABIFlags_v0
*abiflags_ext
;
16722 Elf_Internal_ABIFlags_v0 abiflags_in
;
16724 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16726 error (_("Corrupt MIPS ABI Flags section.\n"));
16731 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16732 sect
->sh_size
, _("MIPS ABI Flags section"));
16735 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16736 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16737 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16738 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16739 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16740 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16741 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16742 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16743 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16744 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16745 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16747 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16748 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16749 if (abiflags_in
.isa_rev
> 1)
16750 printf ("r%d", abiflags_in
.isa_rev
);
16751 printf ("\nGPR size: %d",
16752 get_mips_reg_size (abiflags_in
.gpr_size
));
16753 printf ("\nCPR1 size: %d",
16754 get_mips_reg_size (abiflags_in
.cpr1_size
));
16755 printf ("\nCPR2 size: %d",
16756 get_mips_reg_size (abiflags_in
.cpr2_size
));
16757 fputs ("\nFP ABI: ", stdout
);
16758 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16759 fputs ("ISA Extension: ", stdout
);
16760 print_mips_isa_ext (abiflags_in
.isa_ext
);
16761 fputs ("\nASEs:", stdout
);
16762 print_mips_ases (abiflags_in
.ases
);
16763 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16764 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16765 fputc ('\n', stdout
);
16766 free (abiflags_ext
);
16771 /* We have a lot of special sections. Thanks SGI! */
16772 if (filedata
->dynamic_section
== NULL
)
16774 /* No dynamic information available. See if there is static GOT. */
16775 sect
= find_section (filedata
, ".got");
16778 unsigned char *data_end
;
16779 unsigned char *data
;
16783 pltgot
= sect
->sh_addr
;
16786 addr_size
= (is_32bit_elf
? 4 : 8);
16787 end
= pltgot
+ sect
->sh_size
;
16789 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16791 _("Global Offset Table data"));
16792 /* PR 12855: Null data is handled gracefully throughout. */
16793 data_end
= data
+ (end
- pltgot
);
16795 printf (_("\nStatic GOT:\n"));
16796 printf (_(" Canonical gp value: "));
16797 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16800 /* In a dynamic binary GOT[0] is reserved for the dynamic
16801 loader to store the lazy resolver pointer, however in
16802 a static binary it may well have been omitted and GOT
16803 reduced to a table of addresses.
16804 PR 21344: Check for the entry being fully available
16805 before fetching it. */
16807 && data
+ ent
- pltgot
+ addr_size
<= data_end
16808 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16810 printf (_(" Reserved entries:\n"));
16811 printf (_(" %*s %10s %*s\n"),
16812 addr_size
* 2, _("Address"), _("Access"),
16813 addr_size
* 2, _("Value"));
16814 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16816 if (ent
== (bfd_vma
) -1)
16817 goto sgot_print_fail
;
16819 /* Check for the MSB of GOT[1] being set, identifying a
16820 GNU object. This entry will be used by some runtime
16821 loaders, to store the module pointer. Otherwise this
16822 is an ordinary local entry.
16823 PR 21344: Check for the entry being fully available
16824 before fetching it. */
16826 && data
+ ent
- pltgot
+ addr_size
<= data_end
16827 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16828 >> (addr_size
* 8 - 1)) != 0)
16830 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16832 if (ent
== (bfd_vma
) -1)
16833 goto sgot_print_fail
;
16838 if (data
!= NULL
&& ent
< end
)
16840 printf (_(" Local entries:\n"));
16841 printf (" %*s %10s %*s\n",
16842 addr_size
* 2, _("Address"), _("Access"),
16843 addr_size
* 2, _("Value"));
16846 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16848 if (ent
== (bfd_vma
) -1)
16849 goto sgot_print_fail
;
16860 for (entry
= filedata
->dynamic_section
;
16861 /* PR 17531 file: 012-50589-0.004. */
16862 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16863 && entry
->d_tag
!= DT_NULL
);
16865 switch (entry
->d_tag
)
16867 case DT_MIPS_LIBLIST
:
16869 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16870 liblistno
* sizeof (Elf32_External_Lib
));
16872 case DT_MIPS_LIBLISTNO
:
16873 liblistno
= entry
->d_un
.d_val
;
16875 case DT_MIPS_OPTIONS
:
16876 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16878 case DT_MIPS_CONFLICT
:
16880 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16881 conflictsno
* sizeof (Elf32_External_Conflict
));
16883 case DT_MIPS_CONFLICTNO
:
16884 conflictsno
= entry
->d_un
.d_val
;
16887 pltgot
= entry
->d_un
.d_ptr
;
16889 case DT_MIPS_LOCAL_GOTNO
:
16890 local_gotno
= entry
->d_un
.d_val
;
16892 case DT_MIPS_GOTSYM
:
16893 gotsym
= entry
->d_un
.d_val
;
16895 case DT_MIPS_SYMTABNO
:
16896 symtabno
= entry
->d_un
.d_val
;
16898 case DT_MIPS_PLTGOT
:
16899 mips_pltgot
= entry
->d_un
.d_ptr
;
16902 pltrel
= entry
->d_un
.d_val
;
16905 pltrelsz
= entry
->d_un
.d_val
;
16908 jmprel
= entry
->d_un
.d_ptr
;
16914 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16916 Elf32_External_Lib
* elib
;
16919 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16920 sizeof (Elf32_External_Lib
),
16922 _("liblist section data"));
16925 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16926 "\nSection '.liblist' contains %lu entries:\n",
16927 (unsigned long) liblistno
),
16928 (unsigned long) liblistno
);
16929 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16932 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16939 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16940 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16941 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16942 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16943 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16945 tmp
= gmtime (&atime
);
16946 snprintf (timebuf
, sizeof (timebuf
),
16947 "%04u-%02u-%02uT%02u:%02u:%02u",
16948 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16949 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16951 printf ("%3lu: ", (unsigned long) cnt
);
16952 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
16953 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
16955 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16956 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16957 liblist
.l_version
);
16959 if (liblist
.l_flags
== 0)
16963 static const struct
16970 { " EXACT_MATCH", LL_EXACT_MATCH
},
16971 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16972 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16973 { " EXPORTS", LL_EXPORTS
},
16974 { " DELAY_LOAD", LL_DELAY_LOAD
},
16975 { " DELTA", LL_DELTA
}
16977 int flags
= liblist
.l_flags
;
16980 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16981 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16983 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16984 flags
^= l_flags_vals
[fcnt
].bit
;
16987 printf (" %#x", (unsigned int) flags
);
16999 if (options_offset
!= 0)
17001 Elf_External_Options
* eopt
;
17004 sect
= filedata
->section_headers
;
17006 /* Find the section header so that we get the size. */
17007 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17008 /* PR 17533 file: 012-277276-0.004. */
17011 error (_("No MIPS_OPTIONS header found\n"));
17015 if (sect
->sh_size
< sizeof (* eopt
))
17017 error (_("The MIPS options section is too small.\n"));
17021 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17022 sect
->sh_size
, _("options"));
17025 Elf_Internal_Options option
;
17028 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17030 Elf_External_Options
* eoption
;
17031 unsigned int optsize
;
17033 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17035 optsize
= BYTE_GET (eoption
->size
);
17037 /* PR 17531: file: ffa0fa3b. */
17038 if (optsize
< sizeof (* eopt
)
17039 || optsize
> sect
->sh_size
- offset
)
17041 error (_("Invalid size (%u) for MIPS option\n"),
17050 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17051 "\nSection '%s' contains %d entries:\n",
17053 printable_section_name (filedata
, sect
), cnt
);
17059 Elf_External_Options
* eoption
;
17061 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17063 option
.kind
= BYTE_GET (eoption
->kind
);
17064 option
.size
= BYTE_GET (eoption
->size
);
17065 option
.section
= BYTE_GET (eoption
->section
);
17066 option
.info
= BYTE_GET (eoption
->info
);
17068 switch (option
.kind
)
17071 /* This shouldn't happen. */
17072 printf (" NULL %" PRId16
" %" PRIx32
,
17073 option
.section
, option
.info
);
17077 printf (" REGINFO ");
17078 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17080 Elf32_External_RegInfo
* ereg
;
17081 Elf32_RegInfo reginfo
;
17084 if (option
.size
< (sizeof (Elf_External_Options
)
17085 + sizeof (Elf32_External_RegInfo
)))
17087 printf (_("<corrupt>\n"));
17088 error (_("Truncated MIPS REGINFO option\n"));
17093 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17095 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17096 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17097 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17098 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17099 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17100 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17102 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17103 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17105 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17106 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17107 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17108 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17113 Elf64_External_RegInfo
* ereg
;
17114 Elf64_Internal_RegInfo reginfo
;
17116 if (option
.size
< (sizeof (Elf_External_Options
)
17117 + sizeof (Elf64_External_RegInfo
)))
17119 printf (_("<corrupt>\n"));
17120 error (_("Truncated MIPS REGINFO option\n"));
17125 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
17126 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17127 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17128 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17129 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17130 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17131 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17133 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
17134 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17136 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17137 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17138 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17139 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17141 offset
+= option
.size
;
17144 case ODK_EXCEPTIONS
:
17145 fputs (" EXCEPTIONS fpe_min(", stdout
);
17146 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
17147 fputs (") fpe_max(", stdout
);
17148 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
17149 fputs (")", stdout
);
17151 if (option
.info
& OEX_PAGE0
)
17152 fputs (" PAGE0", stdout
);
17153 if (option
.info
& OEX_SMM
)
17154 fputs (" SMM", stdout
);
17155 if (option
.info
& OEX_FPDBUG
)
17156 fputs (" FPDBUG", stdout
);
17157 if (option
.info
& OEX_DISMISS
)
17158 fputs (" DISMISS", stdout
);
17162 fputs (" PAD ", stdout
);
17163 if (option
.info
& OPAD_PREFIX
)
17164 fputs (" PREFIX", stdout
);
17165 if (option
.info
& OPAD_POSTFIX
)
17166 fputs (" POSTFIX", stdout
);
17167 if (option
.info
& OPAD_SYMBOL
)
17168 fputs (" SYMBOL", stdout
);
17172 fputs (" HWPATCH ", stdout
);
17173 if (option
.info
& OHW_R4KEOP
)
17174 fputs (" R4KEOP", stdout
);
17175 if (option
.info
& OHW_R8KPFETCH
)
17176 fputs (" R8KPFETCH", stdout
);
17177 if (option
.info
& OHW_R5KEOP
)
17178 fputs (" R5KEOP", stdout
);
17179 if (option
.info
& OHW_R5KCVTL
)
17180 fputs (" R5KCVTL", stdout
);
17184 fputs (" FILL ", stdout
);
17185 /* XXX Print content of info word? */
17189 fputs (" TAGS ", stdout
);
17190 /* XXX Print content of info word? */
17194 fputs (" HWAND ", stdout
);
17195 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17196 fputs (" R4KEOP_CHECKED", stdout
);
17197 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17198 fputs (" R4KEOP_CLEAN", stdout
);
17202 fputs (" HWOR ", stdout
);
17203 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17204 fputs (" R4KEOP_CHECKED", stdout
);
17205 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17206 fputs (" R4KEOP_CLEAN", stdout
);
17210 printf (" GP_GROUP %#06x self-contained %#06x",
17211 option
.info
& OGP_GROUP
,
17212 (option
.info
& OGP_SELF
) >> 16);
17216 printf (" IDENT %#06x self-contained %#06x",
17217 option
.info
& OGP_GROUP
,
17218 (option
.info
& OGP_SELF
) >> 16);
17222 /* This shouldn't happen. */
17223 printf (" %3d ??? %" PRId16
" %" PRIx32
,
17224 option
.kind
, option
.section
, option
.info
);
17228 len
= sizeof (* eopt
);
17229 while (len
< option
.size
)
17231 unsigned char datum
= *((unsigned char *) eoption
+ len
);
17233 if (ISPRINT (datum
))
17234 printf ("%c", datum
);
17236 printf ("\\%03o", datum
);
17239 fputs ("\n", stdout
);
17241 offset
+= option
.size
;
17249 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17251 Elf32_Conflict
* iconf
;
17254 if (filedata
->dynamic_symbols
== NULL
)
17256 error (_("conflict list found without a dynamic symbol table\n"));
17260 /* PR 21345 - print a slightly more helpful error message
17261 if we are sure that the cmalloc will fail. */
17262 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17264 error (_("Overlarge number of conflicts detected: %lx\n"),
17265 (long) conflictsno
);
17269 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17272 error (_("Out of memory allocating space for dynamic conflicts\n"));
17278 Elf32_External_Conflict
* econf32
;
17280 econf32
= (Elf32_External_Conflict
*)
17281 get_data (NULL
, filedata
, conflicts_offset
,
17282 sizeof (*econf32
), conflictsno
, _("conflict"));
17289 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17290 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17296 Elf64_External_Conflict
* econf64
;
17298 econf64
= (Elf64_External_Conflict
*)
17299 get_data (NULL
, filedata
, conflicts_offset
,
17300 sizeof (*econf64
), conflictsno
, _("conflict"));
17307 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17308 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17313 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17314 "\nSection '.conflict' contains %lu entries:\n",
17315 (unsigned long) conflictsno
),
17316 (unsigned long) conflictsno
);
17317 puts (_(" Num: Index Value Name"));
17319 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17321 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17323 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17324 printf (_("<corrupt symbol index>"));
17327 Elf_Internal_Sym
* psym
;
17329 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17330 print_vma (psym
->st_value
, FULL_HEX
);
17332 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17333 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17335 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17343 if (pltgot
!= 0 && local_gotno
!= 0)
17345 bfd_vma ent
, local_end
, global_end
;
17347 unsigned char * data
;
17348 unsigned char * data_end
;
17352 addr_size
= (is_32bit_elf
? 4 : 8);
17353 local_end
= pltgot
+ local_gotno
* addr_size
;
17355 /* PR binutils/17533 file: 012-111227-0.004 */
17356 if (symtabno
< gotsym
)
17358 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17359 (unsigned long) gotsym
, (unsigned long) symtabno
);
17363 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17364 /* PR 17531: file: 54c91a34. */
17365 if (global_end
< local_end
)
17367 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17371 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17372 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17373 global_end
- pltgot
, 1,
17374 _("Global Offset Table data"));
17375 /* PR 12855: Null data is handled gracefully throughout. */
17376 data_end
= data
+ (global_end
- pltgot
);
17378 printf (_("\nPrimary GOT:\n"));
17379 printf (_(" Canonical gp value: "));
17380 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17383 printf (_(" Reserved entries:\n"));
17384 printf (_(" %*s %10s %*s Purpose\n"),
17385 addr_size
* 2, _("Address"), _("Access"),
17386 addr_size
* 2, _("Initial"));
17387 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17388 printf (_(" Lazy resolver\n"));
17389 if (ent
== (bfd_vma
) -1)
17390 goto got_print_fail
;
17392 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17393 This entry will be used by some runtime loaders, to store the
17394 module pointer. Otherwise this is an ordinary local entry.
17395 PR 21344: Check for the entry being fully available before
17398 && data
+ ent
- pltgot
+ addr_size
<= data_end
17399 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17400 >> (addr_size
* 8 - 1)) != 0)
17402 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17403 printf (_(" Module pointer (GNU extension)\n"));
17404 if (ent
== (bfd_vma
) -1)
17405 goto got_print_fail
;
17409 if (data
!= NULL
&& ent
< local_end
)
17411 printf (_(" Local entries:\n"));
17412 printf (" %*s %10s %*s\n",
17413 addr_size
* 2, _("Address"), _("Access"),
17414 addr_size
* 2, _("Initial"));
17415 while (ent
< local_end
)
17417 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17419 if (ent
== (bfd_vma
) -1)
17420 goto got_print_fail
;
17425 if (data
!= NULL
&& gotsym
< symtabno
)
17429 printf (_(" Global entries:\n"));
17430 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17431 addr_size
* 2, _("Address"),
17433 addr_size
* 2, _("Initial"),
17434 addr_size
* 2, _("Sym.Val."),
17436 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17437 _("Ndx"), _("Name"));
17439 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17441 for (i
= gotsym
; i
< symtabno
; i
++)
17443 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17446 if (filedata
->dynamic_symbols
== NULL
)
17447 printf (_("<no dynamic symbols>"));
17448 else if (i
< filedata
->num_dynamic_syms
)
17450 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17452 print_vma (psym
->st_value
, LONG_HEX
);
17453 printf (" %-7s %3s ",
17454 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17455 get_symbol_index_type (filedata
, psym
->st_shndx
));
17457 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17458 print_symbol (sym_width
,
17459 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17461 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17464 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17465 (unsigned long) i
);
17468 if (ent
== (bfd_vma
) -1)
17478 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17481 size_t offset
, rel_offset
;
17482 unsigned long count
, i
;
17483 unsigned char * data
;
17484 int addr_size
, sym_width
;
17485 Elf_Internal_Rela
* rels
;
17487 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17488 if (pltrel
== DT_RELA
)
17490 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17495 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17500 addr_size
= (is_32bit_elf
? 4 : 8);
17501 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17503 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17504 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17505 1, _("Procedure Linkage Table data"));
17509 printf ("\nPLT GOT:\n\n");
17510 printf (_(" Reserved entries:\n"));
17511 printf (_(" %*s %*s Purpose\n"),
17512 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17513 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17514 printf (_(" PLT lazy resolver\n"));
17515 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17516 printf (_(" Module pointer\n"));
17519 printf (_(" Entries:\n"));
17520 printf (" %*s %*s %*s %-7s %3s %s\n",
17521 addr_size
* 2, _("Address"),
17522 addr_size
* 2, _("Initial"),
17523 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17524 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17525 for (i
= 0; i
< count
; i
++)
17527 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17529 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17532 if (idx
>= filedata
->num_dynamic_syms
)
17533 printf (_("<corrupt symbol index: %lu>"), idx
);
17536 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17538 print_vma (psym
->st_value
, LONG_HEX
);
17539 printf (" %-7s %3s ",
17540 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17541 get_symbol_index_type (filedata
, psym
->st_shndx
));
17542 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17543 print_symbol (sym_width
,
17544 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17546 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17560 process_nds32_specific (Filedata
* filedata
)
17562 Elf_Internal_Shdr
*sect
= NULL
;
17564 sect
= find_section (filedata
, ".nds32_e_flags");
17565 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17567 unsigned char *buf
;
17570 printf ("\nNDS32 elf flags section:\n");
17571 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17572 _("NDS32 elf flags section"));
17577 flag
= byte_get (buf
, 4);
17579 switch (flag
& 0x3)
17582 printf ("(VEC_SIZE):\tNo entry.\n");
17585 printf ("(VEC_SIZE):\t4 bytes\n");
17588 printf ("(VEC_SIZE):\t16 bytes\n");
17591 printf ("(VEC_SIZE):\treserved\n");
17600 process_gnu_liblist (Filedata
* filedata
)
17602 Elf_Internal_Shdr
* section
;
17603 Elf_Internal_Shdr
* string_sec
;
17604 Elf32_External_Lib
* elib
;
17606 size_t strtab_size
;
17608 unsigned long num_liblist
;
17610 bfd_boolean res
= TRUE
;
17615 for (i
= 0, section
= filedata
->section_headers
;
17616 i
< filedata
->file_header
.e_shnum
;
17619 switch (section
->sh_type
)
17621 case SHT_GNU_LIBLIST
:
17622 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17625 elib
= (Elf32_External_Lib
*)
17626 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17627 _("liblist section data"));
17635 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17636 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17637 string_sec
->sh_size
,
17638 _("liblist string table"));
17640 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17647 strtab_size
= string_sec
->sh_size
;
17649 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17650 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17651 "\nLibrary list section '%s' contains %lu entries:\n",
17653 printable_section_name (filedata
, section
),
17656 puts (_(" Library Time Stamp Checksum Version Flags"));
17658 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17666 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17667 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17668 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17669 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17670 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17672 tmp
= gmtime (&atime
);
17673 snprintf (timebuf
, sizeof (timebuf
),
17674 "%04u-%02u-%02uT%02u:%02u:%02u",
17675 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17676 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17678 printf ("%3lu: ", (unsigned long) cnt
);
17680 printf ("%-20s", liblist
.l_name
< strtab_size
17681 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17683 printf ("%-20.20s", liblist
.l_name
< strtab_size
17684 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17685 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17686 liblist
.l_version
, liblist
.l_flags
);
17697 static const char *
17698 get_note_type (Filedata
* filedata
, unsigned e_type
)
17700 static char buff
[64];
17702 if (filedata
->file_header
.e_type
== ET_CORE
)
17706 return _("NT_AUXV (auxiliary vector)");
17708 return _("NT_PRSTATUS (prstatus structure)");
17710 return _("NT_FPREGSET (floating point registers)");
17712 return _("NT_PRPSINFO (prpsinfo structure)");
17713 case NT_TASKSTRUCT
:
17714 return _("NT_TASKSTRUCT (task structure)");
17716 return _("NT_PRXFPREG (user_xfpregs structure)");
17718 return _("NT_PPC_VMX (ppc Altivec registers)");
17720 return _("NT_PPC_VSX (ppc VSX registers)");
17722 return _("NT_PPC_TAR (ppc TAR register)");
17724 return _("NT_PPC_PPR (ppc PPR register)");
17726 return _("NT_PPC_DSCR (ppc DSCR register)");
17728 return _("NT_PPC_EBB (ppc EBB registers)");
17730 return _("NT_PPC_PMU (ppc PMU registers)");
17731 case NT_PPC_TM_CGPR
:
17732 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17733 case NT_PPC_TM_CFPR
:
17734 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17735 case NT_PPC_TM_CVMX
:
17736 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17737 case NT_PPC_TM_CVSX
:
17738 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17739 case NT_PPC_TM_SPR
:
17740 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17741 case NT_PPC_TM_CTAR
:
17742 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17743 case NT_PPC_TM_CPPR
:
17744 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17745 case NT_PPC_TM_CDSCR
:
17746 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17748 return _("NT_386_TLS (x86 TLS information)");
17749 case NT_386_IOPERM
:
17750 return _("NT_386_IOPERM (x86 I/O permissions)");
17751 case NT_X86_XSTATE
:
17752 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17753 case NT_S390_HIGH_GPRS
:
17754 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17755 case NT_S390_TIMER
:
17756 return _("NT_S390_TIMER (s390 timer register)");
17757 case NT_S390_TODCMP
:
17758 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17759 case NT_S390_TODPREG
:
17760 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17762 return _("NT_S390_CTRS (s390 control registers)");
17763 case NT_S390_PREFIX
:
17764 return _("NT_S390_PREFIX (s390 prefix register)");
17765 case NT_S390_LAST_BREAK
:
17766 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17767 case NT_S390_SYSTEM_CALL
:
17768 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17770 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17771 case NT_S390_VXRS_LOW
:
17772 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17773 case NT_S390_VXRS_HIGH
:
17774 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17775 case NT_S390_GS_CB
:
17776 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17777 case NT_S390_GS_BC
:
17778 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17780 return _("NT_ARM_VFP (arm VFP registers)");
17782 return _("NT_ARM_TLS (AArch TLS registers)");
17783 case NT_ARM_HW_BREAK
:
17784 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17785 case NT_ARM_HW_WATCH
:
17786 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17788 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17790 return _("NT_PSTATUS (pstatus structure)");
17792 return _("NT_FPREGS (floating point registers)");
17794 return _("NT_PSINFO (psinfo structure)");
17796 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17798 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17799 case NT_WIN32PSTATUS
:
17800 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17802 return _("NT_SIGINFO (siginfo_t data)");
17804 return _("NT_FILE (mapped files)");
17812 return _("NT_VERSION (version)");
17814 return _("NT_ARCH (architecture)");
17815 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17817 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17823 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17828 print_core_note (Elf_Internal_Note
*pnote
)
17830 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17831 bfd_vma count
, page_size
;
17832 unsigned char *descdata
, *filenames
, *descend
;
17834 if (pnote
->type
!= NT_FILE
)
17844 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17845 /* Still "successful". */
17850 if (pnote
->descsz
< 2 * addr_size
)
17852 error (_(" Malformed note - too short for header\n"));
17856 descdata
= (unsigned char *) pnote
->descdata
;
17857 descend
= descdata
+ pnote
->descsz
;
17859 if (descdata
[pnote
->descsz
- 1] != '\0')
17861 error (_(" Malformed note - does not end with \\0\n"));
17865 count
= byte_get (descdata
, addr_size
);
17866 descdata
+= addr_size
;
17868 page_size
= byte_get (descdata
, addr_size
);
17869 descdata
+= addr_size
;
17871 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17872 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17874 error (_(" Malformed note - too short for supplied file count\n"));
17878 printf (_(" Page size: "));
17879 print_vma (page_size
, DEC
);
17882 printf (_(" %*s%*s%*s\n"),
17883 (int) (2 + 2 * addr_size
), _("Start"),
17884 (int) (4 + 2 * addr_size
), _("End"),
17885 (int) (4 + 2 * addr_size
), _("Page Offset"));
17886 filenames
= descdata
+ count
* 3 * addr_size
;
17887 while (count
-- > 0)
17889 bfd_vma start
, end
, file_ofs
;
17891 if (filenames
== descend
)
17893 error (_(" Malformed note - filenames end too early\n"));
17897 start
= byte_get (descdata
, addr_size
);
17898 descdata
+= addr_size
;
17899 end
= byte_get (descdata
, addr_size
);
17900 descdata
+= addr_size
;
17901 file_ofs
= byte_get (descdata
, addr_size
);
17902 descdata
+= addr_size
;
17905 print_vma (start
, FULL_HEX
);
17907 print_vma (end
, FULL_HEX
);
17909 print_vma (file_ofs
, FULL_HEX
);
17910 printf ("\n %s\n", filenames
);
17912 filenames
+= 1 + strlen ((char *) filenames
);
17918 static const char *
17919 get_gnu_elf_note_type (unsigned e_type
)
17921 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17924 case NT_GNU_ABI_TAG
:
17925 return _("NT_GNU_ABI_TAG (ABI version tag)");
17927 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17928 case NT_GNU_BUILD_ID
:
17929 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17930 case NT_GNU_GOLD_VERSION
:
17931 return _("NT_GNU_GOLD_VERSION (gold version)");
17932 case NT_GNU_PROPERTY_TYPE_0
:
17933 return _("NT_GNU_PROPERTY_TYPE_0");
17934 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17935 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17936 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17937 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17940 static char buff
[64];
17942 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17949 decode_x86_compat_isa (unsigned int bitmask
)
17953 unsigned int bit
= bitmask
& (- bitmask
);
17958 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17961 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17964 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17967 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17970 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17973 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17976 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17979 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17982 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17985 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17988 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17991 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17992 printf ("AVX512F");
17994 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17995 printf ("AVX512CD");
17997 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17998 printf ("AVX512ER");
18000 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18001 printf ("AVX512PF");
18003 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18004 printf ("AVX512VL");
18006 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18007 printf ("AVX512DQ");
18009 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18010 printf ("AVX512BW");
18013 printf (_("<unknown: %x>"), bit
);
18022 decode_x86_isa (unsigned int bitmask
)
18026 printf (_("<None>"));
18032 unsigned int bit
= bitmask
& (- bitmask
);
18037 case GNU_PROPERTY_X86_ISA_1_CMOV
:
18040 case GNU_PROPERTY_X86_ISA_1_SSE
:
18043 case GNU_PROPERTY_X86_ISA_1_SSE2
:
18046 case GNU_PROPERTY_X86_ISA_1_SSE3
:
18049 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
18052 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
18055 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
18058 case GNU_PROPERTY_X86_ISA_1_AVX
:
18061 case GNU_PROPERTY_X86_ISA_1_AVX2
:
18064 case GNU_PROPERTY_X86_ISA_1_FMA
:
18067 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
18068 printf ("AVX512F");
18070 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
18071 printf ("AVX512CD");
18073 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
18074 printf ("AVX512ER");
18076 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
18077 printf ("AVX512PF");
18079 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
18080 printf ("AVX512VL");
18082 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
18083 printf ("AVX512DQ");
18085 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
18086 printf ("AVX512BW");
18088 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
18089 printf ("AVX512_4FMAPS");
18091 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
18092 printf ("AVX512_4VNNIW");
18094 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
18095 printf ("AVX512_BITALG");
18097 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
18098 printf ("AVX512_IFMA");
18100 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
18101 printf ("AVX512_VBMI");
18103 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
18104 printf ("AVX512_VBMI2");
18106 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
18107 printf ("AVX512_VNNI");
18109 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
18110 printf ("AVX512_BF16");
18113 printf (_("<unknown: %x>"), bit
);
18122 decode_x86_feature_1 (unsigned int bitmask
)
18126 printf (_("<None>"));
18132 unsigned int bit
= bitmask
& (- bitmask
);
18137 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18140 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18144 printf (_("<unknown: %x>"), bit
);
18153 decode_x86_feature_2 (unsigned int bitmask
)
18157 printf (_("<None>"));
18163 unsigned int bit
= bitmask
& (- bitmask
);
18168 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18171 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18174 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18177 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18180 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18183 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18186 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18189 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18192 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18193 printf ("XSAVEOPT");
18195 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18199 printf (_("<unknown: %x>"), bit
);
18208 decode_aarch64_feature_1_and (unsigned int bitmask
)
18212 unsigned int bit
= bitmask
& (- bitmask
);
18217 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18221 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18226 printf (_("<unknown: %x>"), bit
);
18235 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18237 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18238 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18239 unsigned int size
= is_32bit_elf
? 4 : 8;
18241 printf (_(" Properties: "));
18243 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18245 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18249 while (ptr
< ptr_end
)
18253 unsigned int datasz
;
18255 if ((size_t) (ptr_end
- ptr
) < 8)
18257 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18261 type
= byte_get (ptr
, 4);
18262 datasz
= byte_get (ptr
+ 4, 4);
18266 if (datasz
> (size_t) (ptr_end
- ptr
))
18268 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18273 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18275 if (filedata
->file_header
.e_machine
== EM_X86_64
18276 || filedata
->file_header
.e_machine
== EM_IAMCU
18277 || filedata
->file_header
.e_machine
== EM_386
)
18279 unsigned int bitmask
;
18282 bitmask
= byte_get (ptr
, 4);
18288 case GNU_PROPERTY_X86_ISA_1_USED
:
18290 printf (_("x86 ISA used: <corrupt length: %#x> "),
18294 printf ("x86 ISA used: ");
18295 decode_x86_isa (bitmask
);
18299 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18301 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18305 printf ("x86 ISA needed: ");
18306 decode_x86_isa (bitmask
);
18310 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18312 printf (_("x86 feature: <corrupt length: %#x> "),
18316 printf ("x86 feature: ");
18317 decode_x86_feature_1 (bitmask
);
18321 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18323 printf (_("x86 feature used: <corrupt length: %#x> "),
18327 printf ("x86 feature used: ");
18328 decode_x86_feature_2 (bitmask
);
18332 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18334 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18337 printf ("x86 feature needed: ");
18338 decode_x86_feature_2 (bitmask
);
18342 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18344 printf (_("x86 ISA used: <corrupt length: %#x> "),
18348 printf ("x86 ISA used: ");
18349 decode_x86_compat_isa (bitmask
);
18353 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18355 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18359 printf ("x86 ISA needed: ");
18360 decode_x86_compat_isa (bitmask
);
18368 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18370 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18372 printf ("AArch64 feature: ");
18374 printf (_("<corrupt length: %#x> "), datasz
);
18376 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18385 case GNU_PROPERTY_STACK_SIZE
:
18386 printf (_("stack size: "));
18387 if (datasz
!= size
)
18388 printf (_("<corrupt length: %#x> "), datasz
);
18390 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18393 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18394 printf ("no copy on protected ");
18396 printf (_("<corrupt length: %#x> "), datasz
);
18404 if (type
< GNU_PROPERTY_LOPROC
)
18405 printf (_("<unknown type %#x data: "), type
);
18406 else if (type
< GNU_PROPERTY_LOUSER
)
18407 printf (_("<procesor-specific type %#x data: "), type
);
18409 printf (_("<application-specific type %#x data: "), type
);
18410 for (j
= 0; j
< datasz
; ++j
)
18411 printf ("%02x ", ptr
[j
] & 0xff);
18415 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18416 if (ptr
== ptr_end
)
18429 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18431 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18432 switch (pnote
->type
)
18434 case NT_GNU_BUILD_ID
:
18438 printf (_(" Build ID: "));
18439 for (i
= 0; i
< pnote
->descsz
; ++i
)
18440 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18445 case NT_GNU_ABI_TAG
:
18447 unsigned long os
, major
, minor
, subminor
;
18448 const char *osname
;
18450 /* PR 17531: file: 030-599401-0.004. */
18451 if (pnote
->descsz
< 16)
18453 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18457 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18458 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18459 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18460 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18464 case GNU_ABI_TAG_LINUX
:
18467 case GNU_ABI_TAG_HURD
:
18470 case GNU_ABI_TAG_SOLARIS
:
18471 osname
= "Solaris";
18473 case GNU_ABI_TAG_FREEBSD
:
18474 osname
= "FreeBSD";
18476 case GNU_ABI_TAG_NETBSD
:
18479 case GNU_ABI_TAG_SYLLABLE
:
18480 osname
= "Syllable";
18482 case GNU_ABI_TAG_NACL
:
18486 osname
= "Unknown";
18490 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18491 major
, minor
, subminor
);
18495 case NT_GNU_GOLD_VERSION
:
18499 printf (_(" Version: "));
18500 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18501 printf ("%c", pnote
->descdata
[i
]);
18508 unsigned long num_entries
, mask
;
18510 /* Hardware capabilities information. Word 0 is the number of entries.
18511 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18512 is a series of entries, where each entry is a single byte followed
18513 by a nul terminated string. The byte gives the bit number to test
18514 if enabled in the bitmask. */
18515 printf (_(" Hardware Capabilities: "));
18516 if (pnote
->descsz
< 8)
18518 error (_("<corrupt GNU_HWCAP>\n"));
18521 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18522 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18523 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18524 /* FIXME: Add code to display the entries... */
18528 case NT_GNU_PROPERTY_TYPE_0
:
18529 print_gnu_property_note (filedata
, pnote
);
18533 /* Handle unrecognised types. An error message should have already been
18534 created by get_gnu_elf_note_type(), so all that we need to do is to
18535 display the data. */
18539 printf (_(" Description data: "));
18540 for (i
= 0; i
< pnote
->descsz
; ++i
)
18541 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18550 static const char *
18551 get_v850_elf_note_type (enum v850_notes n_type
)
18553 static char buff
[64];
18557 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18558 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18559 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18560 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18561 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18562 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18564 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18570 print_v850_note (Elf_Internal_Note
* pnote
)
18574 if (pnote
->descsz
!= 4)
18577 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18581 printf (_("not set\n"));
18585 switch (pnote
->type
)
18587 case V850_NOTE_ALIGNMENT
:
18590 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18591 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18595 case V850_NOTE_DATA_SIZE
:
18598 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18599 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18603 case V850_NOTE_FPU_INFO
:
18606 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18607 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18611 case V850_NOTE_MMU_INFO
:
18612 case V850_NOTE_CACHE_INFO
:
18613 case V850_NOTE_SIMD_INFO
:
18614 if (val
== EF_RH850_SIMD
)
18616 printf (_("yes\n"));
18622 /* An 'unknown note type' message will already have been displayed. */
18626 printf (_("unknown value: %x\n"), val
);
18631 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18633 unsigned int version
;
18635 switch (pnote
->type
)
18637 case NT_NETBSD_IDENT
:
18638 if (pnote
->descsz
< 1)
18640 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18641 if ((version
/ 10000) % 100)
18642 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18643 version
, version
/ 100000000, (version
/ 1000000) % 100,
18644 (version
/ 10000) % 100 > 26 ? "Z" : "",
18645 'A' + (version
/ 10000) % 26);
18647 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18648 version
, version
/ 100000000, (version
/ 1000000) % 100,
18649 (version
/ 100) % 100);
18652 case NT_NETBSD_MARCH
:
18653 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18657 #ifdef NT_NETBSD_PAX
18658 case NT_NETBSD_PAX
:
18659 if (pnote
->descsz
< 1)
18661 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18662 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18663 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18664 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18665 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18666 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18667 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18668 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18673 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18674 pnote
->descsz
, pnote
->type
);
18678 static const char *
18679 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18683 case NT_FREEBSD_THRMISC
:
18684 return _("NT_THRMISC (thrmisc structure)");
18685 case NT_FREEBSD_PROCSTAT_PROC
:
18686 return _("NT_PROCSTAT_PROC (proc data)");
18687 case NT_FREEBSD_PROCSTAT_FILES
:
18688 return _("NT_PROCSTAT_FILES (files data)");
18689 case NT_FREEBSD_PROCSTAT_VMMAP
:
18690 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18691 case NT_FREEBSD_PROCSTAT_GROUPS
:
18692 return _("NT_PROCSTAT_GROUPS (groups data)");
18693 case NT_FREEBSD_PROCSTAT_UMASK
:
18694 return _("NT_PROCSTAT_UMASK (umask data)");
18695 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18696 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18697 case NT_FREEBSD_PROCSTAT_OSREL
:
18698 return _("NT_PROCSTAT_OSREL (osreldate data)");
18699 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18700 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18701 case NT_FREEBSD_PROCSTAT_AUXV
:
18702 return _("NT_PROCSTAT_AUXV (auxv data)");
18703 case NT_FREEBSD_PTLWPINFO
:
18704 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18706 return get_note_type (filedata
, e_type
);
18709 static const char *
18710 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18712 static char buff
[64];
18716 case NT_NETBSDCORE_PROCINFO
:
18717 /* NetBSD core "procinfo" structure. */
18718 return _("NetBSD procinfo structure");
18720 #ifdef NT_NETBSDCORE_AUXV
18721 case NT_NETBSDCORE_AUXV
:
18722 return _("NetBSD ELF auxiliary vector data");
18725 #ifdef NT_NETBSDCORE_LWPSTATUS
18726 case NT_NETBSDCORE_LWPSTATUS
:
18727 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18731 /* As of Jan 2020 there are no other machine-independent notes
18732 defined for NetBSD core files. If the note type is less
18733 than the start of the machine-dependent note types, we don't
18736 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18738 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18744 switch (filedata
->file_header
.e_machine
)
18746 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18747 and PT_GETFPREGS == mach+2. */
18752 case EM_SPARC32PLUS
:
18756 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18757 return _("PT_GETREGS (reg structure)");
18758 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18759 return _("PT_GETFPREGS (fpreg structure)");
18765 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18766 There's also old PT___GETREGS40 == mach + 1 for old reg
18767 structure which lacks GBR. */
18771 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18772 return _("PT___GETREGS40 (old reg structure)");
18773 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18774 return _("PT_GETREGS (reg structure)");
18775 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18776 return _("PT_GETFPREGS (fpreg structure)");
18782 /* On all other arch's, PT_GETREGS == mach+1 and
18783 PT_GETFPREGS == mach+3. */
18787 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18788 return _("PT_GETREGS (reg structure)");
18789 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18790 return _("PT_GETFPREGS (fpreg structure)");
18796 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18797 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18801 static const char *
18802 get_stapsdt_note_type (unsigned e_type
)
18804 static char buff
[64];
18809 return _("NT_STAPSDT (SystemTap probe descriptors)");
18815 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18820 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18822 size_t len
, maxlen
;
18823 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18824 char *data
= pnote
->descdata
;
18825 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18826 bfd_vma pc
, base_addr
, semaphore
;
18827 char *provider
, *probe
, *arg_fmt
;
18829 if (pnote
->descsz
< (addr_size
* 3))
18830 goto stapdt_note_too_small
;
18832 pc
= byte_get ((unsigned char *) data
, addr_size
);
18835 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18838 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18841 if (data
>= data_end
)
18842 goto stapdt_note_too_small
;
18843 maxlen
= data_end
- data
;
18844 len
= strnlen (data
, maxlen
);
18851 goto stapdt_note_too_small
;
18853 if (data
>= data_end
)
18854 goto stapdt_note_too_small
;
18855 maxlen
= data_end
- data
;
18856 len
= strnlen (data
, maxlen
);
18863 goto stapdt_note_too_small
;
18865 if (data
>= data_end
)
18866 goto stapdt_note_too_small
;
18867 maxlen
= data_end
- data
;
18868 len
= strnlen (data
, maxlen
);
18875 goto stapdt_note_too_small
;
18877 printf (_(" Provider: %s\n"), provider
);
18878 printf (_(" Name: %s\n"), probe
);
18879 printf (_(" Location: "));
18880 print_vma (pc
, FULL_HEX
);
18881 printf (_(", Base: "));
18882 print_vma (base_addr
, FULL_HEX
);
18883 printf (_(", Semaphore: "));
18884 print_vma (semaphore
, FULL_HEX
);
18886 printf (_(" Arguments: %s\n"), arg_fmt
);
18888 return data
== data_end
;
18890 stapdt_note_too_small
:
18891 printf (_(" <corrupt - note is too small>\n"));
18892 error (_("corrupt stapdt note - the data size is too small\n"));
18896 static const char *
18897 get_ia64_vms_note_type (unsigned e_type
)
18899 static char buff
[64];
18904 return _("NT_VMS_MHD (module header)");
18906 return _("NT_VMS_LNM (language name)");
18908 return _("NT_VMS_SRC (source files)");
18910 return "NT_VMS_TITLE";
18912 return _("NT_VMS_EIDC (consistency check)");
18913 case NT_VMS_FPMODE
:
18914 return _("NT_VMS_FPMODE (FP mode)");
18915 case NT_VMS_LINKTIME
:
18916 return "NT_VMS_LINKTIME";
18917 case NT_VMS_IMGNAM
:
18918 return _("NT_VMS_IMGNAM (image name)");
18920 return _("NT_VMS_IMGID (image id)");
18921 case NT_VMS_LINKID
:
18922 return _("NT_VMS_LINKID (link id)");
18923 case NT_VMS_IMGBID
:
18924 return _("NT_VMS_IMGBID (build id)");
18925 case NT_VMS_GSTNAM
:
18926 return _("NT_VMS_GSTNAM (sym table name)");
18927 case NT_VMS_ORIG_DYN
:
18928 return "NT_VMS_ORIG_DYN";
18929 case NT_VMS_PATCHTIME
:
18930 return "NT_VMS_PATCHTIME";
18932 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18938 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18940 int maxlen
= pnote
->descsz
;
18942 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18943 goto desc_size_fail
;
18945 switch (pnote
->type
)
18949 goto desc_size_fail
;
18951 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18953 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18954 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18955 if (l
+ 34 < maxlen
)
18957 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18958 if (l
+ 35 < maxlen
)
18959 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18961 printf (_(" Module version : <missing>\n"));
18965 printf (_(" Module name : <missing>\n"));
18966 printf (_(" Module version : <missing>\n"));
18971 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18975 case NT_VMS_FPMODE
:
18976 printf (_(" Floating Point mode: "));
18978 goto desc_size_fail
;
18979 /* FIXME: Generate an error if descsz > 8 ? */
18981 printf ("0x%016" BFD_VMA_FMT
"x\n",
18982 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18985 case NT_VMS_LINKTIME
:
18986 printf (_(" Link time: "));
18988 goto desc_size_fail
;
18989 /* FIXME: Generate an error if descsz > 8 ? */
18992 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18996 case NT_VMS_PATCHTIME
:
18997 printf (_(" Patch time: "));
18999 goto desc_size_fail
;
19000 /* FIXME: Generate an error if descsz > 8 ? */
19003 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19007 case NT_VMS_ORIG_DYN
:
19009 goto desc_size_fail
;
19011 printf (_(" Major id: %u, minor id: %u\n"),
19012 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
19013 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
19014 printf (_(" Last modified : "));
19016 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
19017 printf (_("\n Link flags : "));
19018 printf ("0x%016" BFD_VMA_FMT
"x\n",
19019 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
19020 printf (_(" Header flags: 0x%08x\n"),
19021 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
19022 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
19026 case NT_VMS_IMGNAM
:
19027 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
19030 case NT_VMS_GSTNAM
:
19031 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
19035 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
19038 case NT_VMS_LINKID
:
19039 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
19049 printf (_(" <corrupt - data size is too small>\n"));
19050 error (_("corrupt IA64 note: data size is too small\n"));
19054 struct build_attr_cache
{
19055 Filedata
*filedata
;
19057 unsigned long strtablen
;
19058 Elf_Internal_Sym
*symtab
;
19059 unsigned long nsyms
;
19062 /* Find the symbol associated with a build attribute that is attached
19063 to address OFFSET. If PNAME is non-NULL then store the name of
19064 the symbol (if found) in the provided pointer, Returns NULL if a
19065 symbol could not be found. */
19067 static Elf_Internal_Sym
*
19068 get_symbol_for_build_attribute (Filedata
* filedata
,
19069 unsigned long offset
,
19070 bfd_boolean is_open_attr
,
19071 const char ** pname
)
19073 Elf_Internal_Sym
*saved_sym
= NULL
;
19074 Elf_Internal_Sym
*sym
;
19076 if (filedata
->section_headers
!= NULL
19077 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
19079 Elf_Internal_Shdr
* symsec
;
19081 free (ba_cache
.strtab
);
19082 ba_cache
.strtab
= NULL
;
19083 free (ba_cache
.symtab
);
19084 ba_cache
.symtab
= NULL
;
19086 /* Load the symbol and string sections. */
19087 for (symsec
= filedata
->section_headers
;
19088 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19091 if (symsec
->sh_type
== SHT_SYMTAB
19092 && get_symtab (filedata
, symsec
,
19093 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19094 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19097 ba_cache
.filedata
= filedata
;
19100 if (ba_cache
.symtab
== NULL
)
19103 /* Find a symbol whose value matches offset. */
19104 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19105 if (sym
->st_value
== offset
)
19107 if (sym
->st_name
>= ba_cache
.strtablen
)
19108 /* Huh ? This should not happen. */
19111 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19114 /* The AArch64 and ARM architectures define mapping symbols
19115 (eg $d, $x, $t) which we want to ignore. */
19116 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19117 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19118 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19123 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19124 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19125 FUNC symbols entirely. */
19126 switch (ELF_ST_TYPE (sym
->st_info
))
19133 /* If the symbol has a size associated
19134 with it then we can stop searching. */
19135 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19140 /* Ignore function symbols. */
19147 switch (ELF_ST_BIND (sym
->st_info
))
19150 if (saved_sym
== NULL
19151 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19156 if (saved_sym
== NULL
)
19166 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19174 if (saved_sym
&& pname
)
19175 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19180 /* Returns true iff addr1 and addr2 are in the same section. */
19183 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19185 Elf_Internal_Shdr
* a1
;
19186 Elf_Internal_Shdr
* a2
;
19188 a1
= find_section_by_address (filedata
, addr1
);
19189 a2
= find_section_by_address (filedata
, addr2
);
19191 return a1
== a2
&& a1
!= NULL
;
19195 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19196 Filedata
* filedata
)
19198 static unsigned long global_offset
= 0;
19199 static unsigned long global_end
= 0;
19200 static unsigned long func_offset
= 0;
19201 static unsigned long func_end
= 0;
19203 Elf_Internal_Sym
* sym
;
19205 unsigned long start
;
19207 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19209 switch (pnote
->descsz
)
19212 /* A zero-length description means that the range of
19213 the previous note of the same type should be used. */
19216 if (global_end
> global_offset
)
19217 printf (_(" Applies to region from %#lx to %#lx\n"),
19218 global_offset
, global_end
);
19220 printf (_(" Applies to region from %#lx\n"), global_offset
);
19224 if (func_end
> func_offset
)
19225 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19227 printf (_(" Applies to region from %#lx\n"), func_offset
);
19232 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19239 /* FIXME: We should check that version 3+ notes are being used here... */
19240 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19241 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19245 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19251 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19252 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19256 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19257 printf (_(" <invalid descsz>"));
19262 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19263 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19264 in order to avoid them being confused with the start address of the
19265 first function in the file... */
19266 if (sym
== NULL
&& is_open_attr
)
19267 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19270 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19271 end
= start
+ sym
->st_size
;
19275 /* FIXME: Need to properly allow for section alignment.
19276 16 is just the alignment used on x86_64. */
19278 && start
> BFD_ALIGN (global_end
, 16)
19279 /* Build notes are not guaranteed to be organised in order of
19280 increasing address, but we should find the all of the notes
19281 for one section in the same place. */
19282 && same_section (filedata
, start
, global_end
))
19283 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19284 global_end
+ 1, start
- 1);
19286 printf (_(" Applies to region from %#lx"), start
);
19287 global_offset
= start
;
19291 printf (_(" to %#lx"), end
);
19297 printf (_(" Applies to region from %#lx"), start
);
19298 func_offset
= start
;
19302 printf (_(" to %#lx"), end
);
19308 printf (_(" (%s)"), name
);
19315 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19317 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19318 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19319 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19321 char name_attribute
;
19322 const char * expected_types
;
19323 const char * name
= pnote
->namedata
;
19327 if (name
== NULL
|| pnote
->namesz
< 2)
19329 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19330 print_symbol (-20, _(" <corrupt name>"));
19339 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19340 if (name
[0] == 'G' && name
[1] == 'A')
19342 if (pnote
->namesz
< 4)
19344 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19345 print_symbol (-20, _(" <corrupt name>"));
19354 switch ((name_type
= * name
))
19356 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19357 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19358 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19359 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19360 printf ("%c", * name
);
19364 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19365 print_symbol (-20, _("<unknown name type>"));
19372 switch ((name_attribute
= * name
))
19374 case GNU_BUILD_ATTRIBUTE_VERSION
:
19375 text
= _("<version>");
19376 expected_types
= string_expected
;
19379 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19380 text
= _("<stack prot>");
19381 expected_types
= "!+*";
19384 case GNU_BUILD_ATTRIBUTE_RELRO
:
19385 text
= _("<relro>");
19386 expected_types
= bool_expected
;
19389 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19390 text
= _("<stack size>");
19391 expected_types
= number_expected
;
19394 case GNU_BUILD_ATTRIBUTE_TOOL
:
19395 text
= _("<tool>");
19396 expected_types
= string_expected
;
19399 case GNU_BUILD_ATTRIBUTE_ABI
:
19401 expected_types
= "$*";
19404 case GNU_BUILD_ATTRIBUTE_PIC
:
19406 expected_types
= number_expected
;
19409 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19410 text
= _("<short enum>");
19411 expected_types
= bool_expected
;
19415 if (ISPRINT (* name
))
19417 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19419 if (len
> left
&& ! do_wide
)
19421 printf ("%.*s:", len
, name
);
19427 static char tmpbuf
[128];
19429 error (_("unrecognised byte in name field: %d\n"), * name
);
19430 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19434 expected_types
= "*$!+";
19439 left
-= printf ("%s", text
);
19441 if (strchr (expected_types
, name_type
) == NULL
)
19442 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19444 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19446 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19447 (unsigned long) pnote
->namesz
,
19448 (long) (name
- pnote
->namedata
));
19452 if (left
< 1 && ! do_wide
)
19457 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19459 unsigned int bytes
;
19460 unsigned long long val
= 0;
19461 unsigned int shift
= 0;
19462 char * decoded
= NULL
;
19464 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19466 /* The -1 is because the name field is always 0 terminated, and we
19467 want to be able to ensure that the shift in the while loop below
19468 will not overflow. */
19471 if (bytes
> sizeof (val
))
19473 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19475 bytes
= sizeof (val
);
19477 /* We do not bother to warn if bytes == 0 as this can
19478 happen with some early versions of the gcc plugin. */
19482 unsigned long byte
= (* name
++) & 0xff;
19484 val
|= byte
<< shift
;
19488 switch (name_attribute
)
19490 case GNU_BUILD_ATTRIBUTE_PIC
:
19493 case 0: decoded
= "static"; break;
19494 case 1: decoded
= "pic"; break;
19495 case 2: decoded
= "PIC"; break;
19496 case 3: decoded
= "pie"; break;
19497 case 4: decoded
= "PIE"; break;
19501 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19504 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19505 case 0: decoded
= "off"; break;
19506 case 1: decoded
= "on"; break;
19507 case 2: decoded
= "all"; break;
19508 case 3: decoded
= "strong"; break;
19509 case 4: decoded
= "explicit"; break;
19517 if (decoded
!= NULL
)
19519 print_symbol (-left
, decoded
);
19530 left
-= printf ("0x%llx", val
);
19532 left
-= printf ("0x%-.*llx", left
, val
);
19536 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19537 left
-= print_symbol (- left
, name
);
19539 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19540 left
-= print_symbol (- left
, "true");
19542 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19543 left
-= print_symbol (- left
, "false");
19547 if (do_wide
&& left
> 0)
19548 printf ("%-*s", left
, " ");
19553 /* Note that by the ELF standard, the name field is already null byte
19554 terminated, and namesz includes the terminating null byte.
19555 I.E. the value of namesz for the name "FSF" is 4.
19557 If the value of namesz is zero, there is no name present. */
19560 process_note (Elf_Internal_Note
* pnote
,
19561 Filedata
* filedata
)
19563 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19566 if (pnote
->namesz
== 0)
19567 /* If there is no note name, then use the default set of
19568 note type strings. */
19569 nt
= get_note_type (filedata
, pnote
->type
);
19571 else if (const_strneq (pnote
->namedata
, "GNU"))
19572 /* GNU-specific object file notes. */
19573 nt
= get_gnu_elf_note_type (pnote
->type
);
19575 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19576 /* FreeBSD-specific core file notes. */
19577 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19579 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19580 /* NetBSD-specific core file notes. */
19581 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19583 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19584 /* NetBSD-specific core file notes. */
19585 return process_netbsd_elf_note (pnote
);
19587 else if (const_strneq (pnote
->namedata
, "PaX"))
19588 /* NetBSD-specific core file notes. */
19589 return process_netbsd_elf_note (pnote
);
19591 else if (strneq (pnote
->namedata
, "SPU/", 4))
19593 /* SPU-specific core file notes. */
19594 nt
= pnote
->namedata
+ 4;
19598 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19599 /* VMS/ia64-specific file notes. */
19600 nt
= get_ia64_vms_note_type (pnote
->type
);
19602 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19603 nt
= get_stapsdt_note_type (pnote
->type
);
19606 /* Don't recognize this note name; just use the default set of
19607 note type strings. */
19608 nt
= get_note_type (filedata
, pnote
->type
);
19612 if (((const_strneq (pnote
->namedata
, "GA")
19613 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19614 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19615 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19616 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19617 print_gnu_build_attribute_name (pnote
);
19619 print_symbol (-20, name
);
19622 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19624 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19626 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19627 return print_ia64_vms_note (pnote
);
19628 else if (const_strneq (pnote
->namedata
, "GNU"))
19629 return print_gnu_note (filedata
, pnote
);
19630 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19631 return print_stapsdt_note (pnote
);
19632 else if (const_strneq (pnote
->namedata
, "CORE"))
19633 return print_core_note (pnote
);
19634 else if (((const_strneq (pnote
->namedata
, "GA")
19635 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19636 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19637 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19638 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19639 return print_gnu_build_attribute_description (pnote
, filedata
);
19645 printf (_(" description data: "));
19646 for (i
= 0; i
< pnote
->descsz
; i
++)
19647 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19659 process_notes_at (Filedata
* filedata
,
19660 Elf_Internal_Shdr
* section
,
19665 Elf_External_Note
* pnotes
;
19666 Elf_External_Note
* external
;
19668 bfd_boolean res
= TRUE
;
19675 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19678 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19686 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19689 if (pnotes
== NULL
)
19695 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19697 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19698 (unsigned long) offset
, (unsigned long) length
);
19700 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19701 specifies that notes should be aligned to 4 bytes in 32-bit
19702 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19703 we also support 4 byte alignment in 64-bit objects. If section
19704 alignment is less than 4, we treate alignment as 4 bytes. */
19707 else if (align
!= 4 && align
!= 8)
19709 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19715 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19717 end
= (char *) pnotes
+ length
;
19718 while ((char *) external
< end
)
19720 Elf_Internal_Note inote
;
19723 char * temp
= NULL
;
19724 size_t data_remaining
= end
- (char *) external
;
19726 if (!is_ia64_vms (filedata
))
19728 /* PR binutils/15191
19729 Make sure that there is enough data to read. */
19730 min_notesz
= offsetof (Elf_External_Note
, name
);
19731 if (data_remaining
< min_notesz
)
19733 warn (ngettext ("Corrupt note: only %ld byte remains, "
19734 "not enough for a full note\n",
19735 "Corrupt note: only %ld bytes remain, "
19736 "not enough for a full note\n",
19738 (long) data_remaining
);
19741 data_remaining
-= min_notesz
;
19743 inote
.type
= BYTE_GET (external
->type
);
19744 inote
.namesz
= BYTE_GET (external
->namesz
);
19745 inote
.namedata
= external
->name
;
19746 inote
.descsz
= BYTE_GET (external
->descsz
);
19747 inote
.descdata
= ((char *) external
19748 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19749 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19750 next
= ((char *) external
19751 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19755 Elf64_External_VMS_Note
*vms_external
;
19757 /* PR binutils/15191
19758 Make sure that there is enough data to read. */
19759 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19760 if (data_remaining
< min_notesz
)
19762 warn (ngettext ("Corrupt note: only %ld byte remains, "
19763 "not enough for a full note\n",
19764 "Corrupt note: only %ld bytes remain, "
19765 "not enough for a full note\n",
19767 (long) data_remaining
);
19770 data_remaining
-= min_notesz
;
19772 vms_external
= (Elf64_External_VMS_Note
*) external
;
19773 inote
.type
= BYTE_GET (vms_external
->type
);
19774 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19775 inote
.namedata
= vms_external
->name
;
19776 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19777 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19778 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19779 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19782 /* PR 17531: file: 3443835e. */
19783 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19784 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19785 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19786 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19787 || ((size_t) (next
- inote
.descdata
)
19788 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19790 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19791 (unsigned long) ((char *) external
- (char *) pnotes
));
19792 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19793 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19797 external
= (Elf_External_Note
*) next
;
19799 /* Verify that name is null terminated. It appears that at least
19800 one version of Linux (RedHat 6.0) generates corefiles that don't
19801 comply with the ELF spec by failing to include the null byte in
19803 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19805 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19807 temp
= (char *) malloc (inote
.namesz
+ 1);
19810 error (_("Out of memory allocating space for inote name\n"));
19815 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19816 inote
.namedata
= temp
;
19818 inote
.namedata
[inote
.namesz
] = 0;
19821 if (! process_note (& inote
, filedata
))
19834 process_corefile_note_segments (Filedata
* filedata
)
19836 Elf_Internal_Phdr
* segment
;
19838 bfd_boolean res
= TRUE
;
19840 if (! get_program_headers (filedata
))
19843 for (i
= 0, segment
= filedata
->program_headers
;
19844 i
< filedata
->file_header
.e_phnum
;
19847 if (segment
->p_type
== PT_NOTE
)
19848 if (! process_notes_at (filedata
, NULL
,
19849 (bfd_vma
) segment
->p_offset
,
19850 (bfd_vma
) segment
->p_filesz
,
19851 (bfd_vma
) segment
->p_align
))
19859 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19861 Elf_External_Note
* pnotes
;
19862 Elf_External_Note
* external
;
19864 bfd_boolean res
= TRUE
;
19869 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19871 if (pnotes
== NULL
)
19875 end
= (char*) pnotes
+ length
;
19877 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19878 (unsigned long) offset
, (unsigned long) length
);
19880 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19882 Elf_External_Note
* next
;
19883 Elf_Internal_Note inote
;
19885 inote
.type
= BYTE_GET (external
->type
);
19886 inote
.namesz
= BYTE_GET (external
->namesz
);
19887 inote
.namedata
= external
->name
;
19888 inote
.descsz
= BYTE_GET (external
->descsz
);
19889 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19890 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19892 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19894 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19895 inote
.descdata
= inote
.namedata
;
19899 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19901 if ( ((char *) next
> end
)
19902 || ((char *) next
< (char *) pnotes
))
19904 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19905 (unsigned long) ((char *) external
- (char *) pnotes
));
19906 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19907 inote
.type
, inote
.namesz
, inote
.descsz
);
19913 /* Prevent out-of-bounds indexing. */
19914 if ( inote
.namedata
+ inote
.namesz
> end
19915 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19917 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19918 (unsigned long) ((char *) external
- (char *) pnotes
));
19919 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19920 inote
.type
, inote
.namesz
, inote
.descsz
);
19924 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19926 if (! print_v850_note (& inote
))
19929 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19930 inote
.namesz
, inote
.descsz
);
19940 process_note_sections (Filedata
* filedata
)
19942 Elf_Internal_Shdr
* section
;
19944 unsigned int n
= 0;
19945 bfd_boolean res
= TRUE
;
19947 for (i
= 0, section
= filedata
->section_headers
;
19948 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19951 if (section
->sh_type
== SHT_NOTE
)
19953 if (! process_notes_at (filedata
, section
,
19954 (bfd_vma
) section
->sh_offset
,
19955 (bfd_vma
) section
->sh_size
,
19956 (bfd_vma
) section
->sh_addralign
))
19961 if (( filedata
->file_header
.e_machine
== EM_V800
19962 || filedata
->file_header
.e_machine
== EM_V850
19963 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19964 && section
->sh_type
== SHT_RENESAS_INFO
)
19966 if (! process_v850_notes (filedata
,
19967 (bfd_vma
) section
->sh_offset
,
19968 (bfd_vma
) section
->sh_size
))
19975 /* Try processing NOTE segments instead. */
19976 return process_corefile_note_segments (filedata
);
19982 process_notes (Filedata
* filedata
)
19984 /* If we have not been asked to display the notes then do nothing. */
19988 if (filedata
->file_header
.e_type
!= ET_CORE
)
19989 return process_note_sections (filedata
);
19991 /* No program headers means no NOTE segment. */
19992 if (filedata
->file_header
.e_phnum
> 0)
19993 return process_corefile_note_segments (filedata
);
19995 printf (_("No note segments present in the core file.\n"));
19999 static unsigned char *
20000 display_public_gnu_attributes (unsigned char * start
,
20001 const unsigned char * const end
)
20003 printf (_(" Unknown GNU attribute: %s\n"), start
);
20005 start
+= strnlen ((char *) start
, end
- start
);
20006 display_raw_attribute (start
, end
);
20008 return (unsigned char *) end
;
20011 static unsigned char *
20012 display_generic_attribute (unsigned char * start
,
20014 const unsigned char * const end
)
20017 return (unsigned char *) end
;
20019 return display_tag_value (tag
, start
, end
);
20023 process_arch_specific (Filedata
* filedata
)
20028 switch (filedata
->file_header
.e_machine
)
20031 case EM_ARC_COMPACT
:
20032 case EM_ARC_COMPACT2
:
20033 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
20034 display_arc_attribute
,
20035 display_generic_attribute
);
20037 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
20038 display_arm_attribute
,
20039 display_generic_attribute
);
20042 case EM_MIPS_RS3_LE
:
20043 return process_mips_specific (filedata
);
20046 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
20047 display_msp430x_attribute
,
20048 display_msp430_gnu_attribute
);
20051 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
20052 display_riscv_attribute
,
20053 display_generic_attribute
);
20056 return process_nds32_specific (filedata
);
20059 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20060 display_m68k_gnu_attribute
);
20064 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20065 display_power_gnu_attribute
);
20069 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20070 display_s390_gnu_attribute
);
20073 case EM_SPARC32PLUS
:
20075 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20076 display_sparc_gnu_attribute
);
20079 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
20080 display_tic6x_attribute
,
20081 display_generic_attribute
);
20084 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20085 display_public_gnu_attributes
,
20086 display_generic_attribute
);
20091 get_file_header (Filedata
* filedata
)
20093 /* Read in the identity array. */
20094 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20097 /* Determine how to read the rest of the header. */
20098 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20103 byte_get
= byte_get_little_endian
;
20104 byte_put
= byte_put_little_endian
;
20107 byte_get
= byte_get_big_endian
;
20108 byte_put
= byte_put_big_endian
;
20112 /* For now we only support 32 bit and 64 bit ELF files. */
20113 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20115 /* Read in the rest of the header. */
20118 Elf32_External_Ehdr ehdr32
;
20120 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20123 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20124 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20125 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20126 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20127 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20128 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20129 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20130 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20131 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20132 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20133 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20134 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20135 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20139 Elf64_External_Ehdr ehdr64
;
20141 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20142 we will not be able to cope with the 64bit data found in
20143 64 ELF files. Detect this now and abort before we start
20144 overwriting things. */
20145 if (sizeof (bfd_vma
) < 8)
20147 error (_("This instance of readelf has been built without support for a\n\
20148 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20152 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20155 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20156 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20157 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20158 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20159 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20160 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20161 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20162 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20163 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20164 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20165 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20166 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20167 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20170 if (filedata
->file_header
.e_shoff
)
20172 /* There may be some extensions in the first section header. Don't
20173 bomb if we can't read it. */
20175 get_32bit_section_headers (filedata
, TRUE
);
20177 get_64bit_section_headers (filedata
, TRUE
);
20184 close_file (Filedata
* filedata
)
20188 if (filedata
->handle
)
20189 fclose (filedata
->handle
);
20195 close_debug_file (void * data
)
20197 close_file ((Filedata
*) data
);
20201 open_file (const char * pathname
)
20203 struct stat statbuf
;
20204 Filedata
* filedata
= NULL
;
20206 if (stat (pathname
, & statbuf
) < 0
20207 || ! S_ISREG (statbuf
.st_mode
))
20210 filedata
= calloc (1, sizeof * filedata
);
20211 if (filedata
== NULL
)
20214 filedata
->handle
= fopen (pathname
, "rb");
20215 if (filedata
->handle
== NULL
)
20218 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20219 filedata
->file_name
= pathname
;
20221 if (! get_file_header (filedata
))
20224 if (filedata
->file_header
.e_shoff
)
20228 /* Read the section headers again, this time for real. */
20230 res
= get_32bit_section_headers (filedata
, FALSE
);
20232 res
= get_64bit_section_headers (filedata
, FALSE
);
20243 if (filedata
->handle
)
20244 fclose (filedata
->handle
);
20251 open_debug_file (const char * pathname
)
20253 return open_file (pathname
);
20256 /* Process one ELF object file according to the command line options.
20257 This file may actually be stored in an archive. The file is
20258 positioned at the start of the ELF object. Returns TRUE if no
20259 problems were encountered, FALSE otherwise. */
20262 process_object (Filedata
* filedata
)
20264 bfd_boolean have_separate_files
;
20268 if (! get_file_header (filedata
))
20270 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20274 /* Initialise per file variables. */
20275 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20276 filedata
->version_info
[i
] = 0;
20278 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20279 filedata
->dynamic_info
[i
] = 0;
20280 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20281 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20283 /* Process the file. */
20285 printf (_("\nFile: %s\n"), filedata
->file_name
);
20287 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20288 Note we do this even if cmdline_dump_sects is empty because we
20289 must make sure that the dump_sets array is zeroed out before each
20290 object file is processed. */
20291 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20292 memset (filedata
->dump
.dump_sects
, 0,
20293 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20295 if (cmdline
.num_dump_sects
> 0)
20297 if (filedata
->dump
.num_dump_sects
== 0)
20298 /* A sneaky way of allocating the dump_sects array. */
20299 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20301 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20302 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20303 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20306 if (! process_file_header (filedata
))
20309 if (! process_section_headers (filedata
))
20311 /* Without loaded section headers we cannot process lots of things. */
20312 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20314 if (! do_using_dynamic
)
20315 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20318 if (! process_section_groups (filedata
))
20319 /* Without loaded section groups we cannot process unwind. */
20322 res
= process_program_headers (filedata
);
20324 res
= process_dynamic_section (filedata
);
20326 if (! process_relocs (filedata
))
20329 if (! process_unwind (filedata
))
20332 if (! process_symbol_table (filedata
))
20335 if (! process_syminfo (filedata
))
20338 if (! process_version_sections (filedata
))
20341 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20342 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20344 have_separate_files
= FALSE
;
20346 if (! process_section_contents (filedata
))
20349 if (have_separate_files
)
20353 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20355 if (! process_section_headers (d
->handle
))
20357 else if (! process_section_contents (d
->handle
))
20361 /* The file handles are closed by the call to free_debug_memory() below. */
20364 if (! process_notes (filedata
))
20367 if (! process_gnu_liblist (filedata
))
20370 if (! process_arch_specific (filedata
))
20373 free (filedata
->program_headers
);
20374 filedata
->program_headers
= NULL
;
20376 free (filedata
->section_headers
);
20377 filedata
->section_headers
= NULL
;
20379 free (filedata
->string_table
);
20380 filedata
->string_table
= NULL
;
20381 filedata
->string_table_length
= 0;
20383 free (filedata
->dump
.dump_sects
);
20384 filedata
->dump
.dump_sects
= NULL
;
20385 filedata
->dump
.num_dump_sects
= 0;
20387 free (filedata
->dynamic_strings
);
20388 filedata
->dynamic_strings
= NULL
;
20389 filedata
->dynamic_strings_length
= 0;
20391 free (filedata
->dynamic_symbols
);
20392 filedata
->dynamic_symbols
= NULL
;
20393 filedata
->num_dynamic_syms
= 0;
20395 free (filedata
->dynamic_syminfo
);
20396 filedata
->dynamic_syminfo
= NULL
;
20398 free (filedata
->dynamic_section
);
20399 filedata
->dynamic_section
= NULL
;
20401 while (filedata
->symtab_shndx_list
!= NULL
)
20403 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20404 free (filedata
->symtab_shndx_list
);
20405 filedata
->symtab_shndx_list
= next
;
20408 free (filedata
->section_headers_groups
);
20409 filedata
->section_headers_groups
= NULL
;
20411 if (filedata
->section_groups
)
20413 struct group_list
* g
;
20414 struct group_list
* next
;
20416 for (i
= 0; i
< filedata
->group_count
; i
++)
20418 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20425 free (filedata
->section_groups
);
20426 filedata
->section_groups
= NULL
;
20429 free_debug_memory ();
20434 /* Process an ELF archive.
20435 On entry the file is positioned just after the ARMAG string.
20436 Returns TRUE upon success, FALSE otherwise. */
20439 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20441 struct archive_info arch
;
20442 struct archive_info nested_arch
;
20444 bfd_boolean ret
= TRUE
;
20448 /* The ARCH structure is used to hold information about this archive. */
20449 arch
.file_name
= NULL
;
20451 arch
.index_array
= NULL
;
20452 arch
.sym_table
= NULL
;
20453 arch
.longnames
= NULL
;
20455 /* The NESTED_ARCH structure is used as a single-item cache of information
20456 about a nested archive (when members of a thin archive reside within
20457 another regular archive file). */
20458 nested_arch
.file_name
= NULL
;
20459 nested_arch
.file
= NULL
;
20460 nested_arch
.index_array
= NULL
;
20461 nested_arch
.sym_table
= NULL
;
20462 nested_arch
.longnames
= NULL
;
20464 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20465 filedata
->file_size
, is_thin_archive
,
20466 do_archive_index
) != 0)
20472 if (do_archive_index
)
20474 if (arch
.sym_table
== NULL
)
20475 error (_("%s: unable to dump the index as none was found\n"),
20476 filedata
->file_name
);
20479 unsigned long i
, l
;
20480 unsigned long current_pos
;
20482 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20483 "in the symbol table)\n"),
20484 filedata
->file_name
, (unsigned long) arch
.index_num
,
20487 current_pos
= ftell (filedata
->handle
);
20489 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20492 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20495 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20498 if (member_name
!= NULL
)
20500 char * qualified_name
20501 = make_qualified_name (&arch
, &nested_arch
,
20504 if (qualified_name
!= NULL
)
20506 printf (_("Contents of binary %s at offset "),
20508 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20510 free (qualified_name
);
20512 free (member_name
);
20516 if (l
>= arch
.sym_size
)
20518 error (_("%s: end of the symbol table reached "
20519 "before the end of the index\n"),
20520 filedata
->file_name
);
20524 /* PR 17531: file: 0b6630b2. */
20525 printf ("\t%.*s\n",
20526 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20527 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20530 if (arch
.uses_64bit_indices
)
20535 if (l
< arch
.sym_size
)
20537 error (ngettext ("%s: %ld byte remains in the symbol table, "
20538 "but without corresponding entries in "
20539 "the index table\n",
20540 "%s: %ld bytes remain in the symbol table, "
20541 "but without corresponding entries in "
20542 "the index table\n",
20543 arch
.sym_size
- l
),
20544 filedata
->file_name
, arch
.sym_size
- l
);
20548 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20550 error (_("%s: failed to seek back to start of object files "
20551 "in the archive\n"),
20552 filedata
->file_name
);
20558 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20559 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20560 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20561 && !do_section_groups
&& !do_dyn_syms
)
20563 ret
= TRUE
; /* Archive index only. */
20572 char * qualified_name
;
20574 /* Read the next archive header. */
20575 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20577 error (_("%s: failed to seek to next archive header\n"),
20582 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20583 if (got
!= sizeof arch
.arhdr
)
20587 /* PR 24049 - we cannot use filedata->file_name as this will
20588 have already been freed. */
20589 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20594 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20596 error (_("%s: did not find a valid archive header\n"),
20602 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20604 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20605 if (filedata
->archive_file_size
& 01)
20606 ++filedata
->archive_file_size
;
20608 name
= get_archive_member_name (&arch
, &nested_arch
);
20611 error (_("%s: bad archive file name\n"), arch
.file_name
);
20615 namelen
= strlen (name
);
20617 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20618 if (qualified_name
== NULL
)
20620 error (_("%s: bad archive file name\n"), arch
.file_name
);
20626 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20628 /* This is a proxy for an external member of a thin archive. */
20629 Filedata
* member_filedata
;
20630 char * member_file_name
= adjust_relative_path
20631 (filedata
->file_name
, name
, namelen
);
20634 if (member_file_name
== NULL
)
20636 free (qualified_name
);
20641 member_filedata
= open_file (member_file_name
);
20642 if (member_filedata
== NULL
)
20644 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20645 free (member_file_name
);
20646 free (qualified_name
);
20651 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20652 member_filedata
->file_name
= qualified_name
;
20654 if (! process_object (member_filedata
))
20657 close_file (member_filedata
);
20658 free (member_file_name
);
20660 else if (is_thin_archive
)
20662 Filedata thin_filedata
;
20664 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20666 /* PR 15140: Allow for corrupt thin archives. */
20667 if (nested_arch
.file
== NULL
)
20669 error (_("%s: contains corrupt thin archive: %s\n"),
20670 qualified_name
, name
);
20671 free (qualified_name
);
20678 /* This is a proxy for a member of a nested archive. */
20679 filedata
->archive_file_offset
20680 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20682 /* The nested archive file will have been opened and setup by
20683 get_archive_member_name. */
20684 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20687 error (_("%s: failed to seek to archive member.\n"),
20688 nested_arch
.file_name
);
20689 free (qualified_name
);
20694 thin_filedata
.handle
= nested_arch
.file
;
20695 thin_filedata
.file_name
= qualified_name
;
20697 if (! process_object (& thin_filedata
))
20703 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20704 filedata
->file_name
= qualified_name
;
20705 if (! process_object (filedata
))
20707 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20708 /* Stop looping with "negative" archive_file_size. */
20709 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20710 arch
.next_arhdr_offset
= -1ul;
20713 free (qualified_name
);
20717 if (nested_arch
.file
!= NULL
)
20718 fclose (nested_arch
.file
);
20719 release_archive (&nested_arch
);
20720 release_archive (&arch
);
20726 process_file (char * file_name
)
20728 Filedata
* filedata
= NULL
;
20729 struct stat statbuf
;
20730 char armag
[SARMAG
];
20731 bfd_boolean ret
= TRUE
;
20733 if (stat (file_name
, &statbuf
) < 0)
20735 if (errno
== ENOENT
)
20736 error (_("'%s': No such file\n"), file_name
);
20738 error (_("Could not locate '%s'. System error message: %s\n"),
20739 file_name
, strerror (errno
));
20743 if (! S_ISREG (statbuf
.st_mode
))
20745 error (_("'%s' is not an ordinary file\n"), file_name
);
20749 filedata
= calloc (1, sizeof * filedata
);
20750 if (filedata
== NULL
)
20752 error (_("Out of memory allocating file data structure\n"));
20756 filedata
->file_name
= file_name
;
20757 filedata
->handle
= fopen (file_name
, "rb");
20758 if (filedata
->handle
== NULL
)
20760 error (_("Input file '%s' is not readable.\n"), file_name
);
20765 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20767 error (_("%s: Failed to read file's magic number\n"), file_name
);
20768 fclose (filedata
->handle
);
20773 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20775 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20777 if (! process_archive (filedata
, FALSE
))
20780 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20782 if ( ! process_archive (filedata
, TRUE
))
20787 if (do_archive_index
&& !check_all
)
20788 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20791 rewind (filedata
->handle
);
20792 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20794 if (! process_object (filedata
))
20798 fclose (filedata
->handle
);
20799 free (filedata
->section_headers
);
20800 free (filedata
->program_headers
);
20801 free (filedata
->string_table
);
20802 free (filedata
->dump
.dump_sects
);
20805 free (ba_cache
.strtab
);
20806 ba_cache
.strtab
= NULL
;
20807 free (ba_cache
.symtab
);
20808 ba_cache
.symtab
= NULL
;
20809 ba_cache
.filedata
= NULL
;
20814 #ifdef SUPPORT_DISASSEMBLY
20815 /* Needed by the i386 disassembler. For extra credit, someone could
20816 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20820 print_address (unsigned int addr
, FILE * outfile
)
20822 fprintf (outfile
,"0x%8.8x", addr
);
20825 /* Needed by the i386 disassembler. */
20828 db_task_printsym (unsigned int addr
)
20830 print_address (addr
, stderr
);
20835 main (int argc
, char ** argv
)
20839 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20840 setlocale (LC_MESSAGES
, "");
20842 #if defined (HAVE_SETLOCALE)
20843 setlocale (LC_CTYPE
, "");
20845 bindtextdomain (PACKAGE
, LOCALEDIR
);
20846 textdomain (PACKAGE
);
20848 expandargv (&argc
, &argv
);
20850 parse_args (& cmdline
, argc
, argv
);
20852 if (optind
< (argc
- 1))
20853 /* When displaying information for more than one file,
20854 prefix the information with the file name. */
20856 else if (optind
>= argc
)
20858 /* Ensure that the warning is always displayed. */
20861 warn (_("Nothing to do.\n"));
20866 while (optind
< argc
)
20867 if (! process_file (argv
[optind
++]))
20870 free (cmdline
.dump_sects
);
20872 free (dump_ctf_symtab_name
);
20873 free (dump_ctf_strtab_name
);
20874 free (dump_ctf_parent_name
);
20876 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;