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 free (dump_ctf_symtab_name
);
4831 dump_ctf_symtab_name
= strdup (optarg
);
4833 case OPTION_CTF_STRINGS
:
4834 free (dump_ctf_strtab_name
);
4835 dump_ctf_strtab_name
= strdup (optarg
);
4837 case OPTION_CTF_PARENT
:
4838 free (dump_ctf_parent_name
);
4839 dump_ctf_parent_name
= strdup (optarg
);
4841 case OPTION_DYN_SYMS
:
4844 #ifdef SUPPORT_DISASSEMBLY
4846 request_dump (dumpdata
, DISASS_DUMP
);
4850 print_version (program_name
);
4859 do_not_show_symbol_truncation
= TRUE
;
4862 /* xgettext:c-format */
4863 error (_("Invalid option '-%c'\n"), c
);
4870 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4871 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4872 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4873 && !do_section_groups
&& !do_archive_index
4879 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= TRUE
;
4880 do_segments
= do_header
= do_dump
= do_version
= TRUE
;
4881 do_histogram
= do_debugging
= do_arch
= do_notes
= TRUE
;
4882 do_section_groups
= do_archive_index
= do_dyn_syms
= TRUE
;
4890 get_elf_class (unsigned int elf_class
)
4892 static char buff
[32];
4896 case ELFCLASSNONE
: return _("none");
4897 case ELFCLASS32
: return "ELF32";
4898 case ELFCLASS64
: return "ELF64";
4900 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4906 get_data_encoding (unsigned int encoding
)
4908 static char buff
[32];
4912 case ELFDATANONE
: return _("none");
4913 case ELFDATA2LSB
: return _("2's complement, little endian");
4914 case ELFDATA2MSB
: return _("2's complement, big endian");
4916 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4921 /* Decode the data held in 'filedata->file_header'. */
4924 process_file_header (Filedata
* filedata
)
4926 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4928 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4929 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4930 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4931 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4934 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4938 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4944 printf (_("ELF Header:\n"));
4945 printf (_(" Magic: "));
4946 for (i
= 0; i
< EI_NIDENT
; i
++)
4947 printf ("%2.2x ", header
->e_ident
[i
]);
4949 printf (_(" Class: %s\n"),
4950 get_elf_class (header
->e_ident
[EI_CLASS
]));
4951 printf (_(" Data: %s\n"),
4952 get_data_encoding (header
->e_ident
[EI_DATA
]));
4953 printf (_(" Version: %d%s\n"),
4954 header
->e_ident
[EI_VERSION
],
4955 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4957 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4960 printf (_(" OS/ABI: %s\n"),
4961 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4962 printf (_(" ABI Version: %d\n"),
4963 header
->e_ident
[EI_ABIVERSION
]);
4964 printf (_(" Type: %s\n"),
4965 get_file_type (header
->e_type
));
4966 printf (_(" Machine: %s\n"),
4967 get_machine_name (header
->e_machine
));
4968 printf (_(" Version: 0x%lx\n"),
4971 printf (_(" Entry point address: "));
4972 print_vma (header
->e_entry
, PREFIX_HEX
);
4973 printf (_("\n Start of program headers: "));
4974 print_vma (header
->e_phoff
, DEC
);
4975 printf (_(" (bytes into file)\n Start of section headers: "));
4976 print_vma (header
->e_shoff
, DEC
);
4977 printf (_(" (bytes into file)\n"));
4979 printf (_(" Flags: 0x%lx%s\n"),
4981 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4982 printf (_(" Size of this header: %u (bytes)\n"),
4984 printf (_(" Size of program headers: %u (bytes)\n"),
4985 header
->e_phentsize
);
4986 printf (_(" Number of program headers: %u"),
4988 if (filedata
->section_headers
!= NULL
4989 && header
->e_phnum
== PN_XNUM
4990 && filedata
->section_headers
[0].sh_info
!= 0)
4992 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4993 printf (" (%u)", header
->e_phnum
);
4995 putc ('\n', stdout
);
4996 printf (_(" Size of section headers: %u (bytes)\n"),
4997 header
->e_shentsize
);
4998 printf (_(" Number of section headers: %u"),
5000 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5002 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5003 printf (" (%u)", header
->e_shnum
);
5005 putc ('\n', stdout
);
5006 printf (_(" Section header string table index: %u"),
5007 header
->e_shstrndx
);
5008 if (filedata
->section_headers
!= NULL
5009 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5011 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5012 printf (" (%u)", header
->e_shstrndx
);
5014 if (header
->e_shstrndx
!= SHN_UNDEF
5015 && header
->e_shstrndx
>= header
->e_shnum
)
5017 header
->e_shstrndx
= SHN_UNDEF
;
5018 printf (_(" <corrupt: out of range>"));
5020 putc ('\n', stdout
);
5023 if (filedata
->section_headers
!= NULL
)
5025 if (header
->e_phnum
== PN_XNUM
5026 && filedata
->section_headers
[0].sh_info
!= 0)
5027 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5028 if (header
->e_shnum
== SHN_UNDEF
)
5029 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5030 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5031 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5032 if (header
->e_shstrndx
>= header
->e_shnum
)
5033 header
->e_shstrndx
= SHN_UNDEF
;
5034 free (filedata
->section_headers
);
5035 filedata
->section_headers
= NULL
;
5041 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5042 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5045 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5047 Elf32_External_Phdr
* phdrs
;
5048 Elf32_External_Phdr
* external
;
5049 Elf_Internal_Phdr
* internal
;
5051 unsigned int size
= filedata
->file_header
.e_phentsize
;
5052 unsigned int num
= filedata
->file_header
.e_phnum
;
5054 /* PR binutils/17531: Cope with unexpected section header sizes. */
5055 if (size
== 0 || num
== 0)
5057 if (size
< sizeof * phdrs
)
5059 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5062 if (size
> sizeof * phdrs
)
5063 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5065 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5066 size
, num
, _("program headers"));
5070 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5071 i
< filedata
->file_header
.e_phnum
;
5072 i
++, internal
++, external
++)
5074 internal
->p_type
= BYTE_GET (external
->p_type
);
5075 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5076 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5077 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5078 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5079 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5080 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5081 internal
->p_align
= BYTE_GET (external
->p_align
);
5088 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5089 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5092 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5094 Elf64_External_Phdr
* phdrs
;
5095 Elf64_External_Phdr
* external
;
5096 Elf_Internal_Phdr
* internal
;
5098 unsigned int size
= filedata
->file_header
.e_phentsize
;
5099 unsigned int num
= filedata
->file_header
.e_phnum
;
5101 /* PR binutils/17531: Cope with unexpected section header sizes. */
5102 if (size
== 0 || num
== 0)
5104 if (size
< sizeof * phdrs
)
5106 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5109 if (size
> sizeof * phdrs
)
5110 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5112 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5113 size
, num
, _("program headers"));
5117 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5118 i
< filedata
->file_header
.e_phnum
;
5119 i
++, internal
++, external
++)
5121 internal
->p_type
= BYTE_GET (external
->p_type
);
5122 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5123 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5124 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5125 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5126 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5127 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5128 internal
->p_align
= BYTE_GET (external
->p_align
);
5135 /* Returns TRUE if the program headers were read into `program_headers'. */
5138 get_program_headers (Filedata
* filedata
)
5140 Elf_Internal_Phdr
* phdrs
;
5142 /* Check cache of prior read. */
5143 if (filedata
->program_headers
!= NULL
)
5146 /* Be kind to memory checkers by looking for
5147 e_phnum values which we know must be invalid. */
5148 if (filedata
->file_header
.e_phnum
5149 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5150 >= filedata
->file_size
)
5152 error (_("Too many program headers - %#x - the file is not that big\n"),
5153 filedata
->file_header
.e_phnum
);
5157 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5158 sizeof (Elf_Internal_Phdr
));
5161 error (_("Out of memory reading %u program headers\n"),
5162 filedata
->file_header
.e_phnum
);
5167 ? get_32bit_program_headers (filedata
, phdrs
)
5168 : get_64bit_program_headers (filedata
, phdrs
))
5170 filedata
->program_headers
= phdrs
;
5178 /* Returns TRUE if the program headers were loaded. */
5181 process_program_headers (Filedata
* filedata
)
5183 Elf_Internal_Phdr
* segment
;
5185 Elf_Internal_Phdr
* previous_load
= NULL
;
5187 filedata
->dynamic_addr
= 0;
5188 filedata
->dynamic_size
= 0;
5190 if (filedata
->file_header
.e_phnum
== 0)
5192 /* PR binutils/12467. */
5193 if (filedata
->file_header
.e_phoff
!= 0)
5195 warn (_("possibly corrupt ELF header - it has a non-zero program"
5196 " header offset, but no program headers\n"));
5199 else if (do_segments
)
5200 printf (_("\nThere are no program headers in this file.\n"));
5204 if (do_segments
&& !do_header
)
5206 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5207 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5208 printf (ngettext ("There is %d program header, starting at offset %s\n",
5209 "There are %d program headers, starting at offset %s\n",
5210 filedata
->file_header
.e_phnum
),
5211 filedata
->file_header
.e_phnum
,
5212 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5215 if (! get_program_headers (filedata
))
5220 if (filedata
->file_header
.e_phnum
> 1)
5221 printf (_("\nProgram Headers:\n"));
5223 printf (_("\nProgram Headers:\n"));
5227 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5230 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5234 (_(" Type Offset VirtAddr PhysAddr\n"));
5236 (_(" FileSiz MemSiz Flags Align\n"));
5240 for (i
= 0, segment
= filedata
->program_headers
;
5241 i
< filedata
->file_header
.e_phnum
;
5246 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5250 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5251 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5252 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5253 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5254 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5256 (segment
->p_flags
& PF_R
? 'R' : ' '),
5257 (segment
->p_flags
& PF_W
? 'W' : ' '),
5258 (segment
->p_flags
& PF_X
? 'E' : ' '));
5259 printf ("%#lx", (unsigned long) segment
->p_align
);
5263 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5264 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5267 print_vma (segment
->p_offset
, FULL_HEX
);
5271 print_vma (segment
->p_vaddr
, FULL_HEX
);
5273 print_vma (segment
->p_paddr
, FULL_HEX
);
5276 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5277 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5280 print_vma (segment
->p_filesz
, FULL_HEX
);
5284 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5285 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5288 print_vma (segment
->p_memsz
, FULL_HEX
);
5292 (segment
->p_flags
& PF_R
? 'R' : ' '),
5293 (segment
->p_flags
& PF_W
? 'W' : ' '),
5294 (segment
->p_flags
& PF_X
? 'E' : ' '));
5296 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5297 printf ("%#lx", (unsigned long) segment
->p_align
);
5300 print_vma (segment
->p_align
, PREFIX_HEX
);
5305 print_vma (segment
->p_offset
, FULL_HEX
);
5307 print_vma (segment
->p_vaddr
, FULL_HEX
);
5309 print_vma (segment
->p_paddr
, FULL_HEX
);
5311 print_vma (segment
->p_filesz
, FULL_HEX
);
5313 print_vma (segment
->p_memsz
, FULL_HEX
);
5315 (segment
->p_flags
& PF_R
? 'R' : ' '),
5316 (segment
->p_flags
& PF_W
? 'W' : ' '),
5317 (segment
->p_flags
& PF_X
? 'E' : ' '));
5318 print_vma (segment
->p_align
, PREFIX_HEX
);
5321 putc ('\n', stdout
);
5324 switch (segment
->p_type
)
5327 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5328 required by the ELF standard, several programs, including the Linux
5329 kernel, make use of non-ordered segments. */
5331 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5332 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5334 if (segment
->p_memsz
< segment
->p_filesz
)
5335 error (_("the segment's file size is larger than its memory size\n"));
5336 previous_load
= segment
;
5340 /* PR 20815 - Verify that the program header is loaded into memory. */
5341 if (i
> 0 && previous_load
!= NULL
)
5342 error (_("the PHDR segment must occur before any LOAD segment\n"));
5343 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5347 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5349 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5350 if (load
->p_type
== PT_LOAD
5351 && load
->p_offset
<= segment
->p_offset
5352 && (load
->p_offset
+ load
->p_filesz
5353 >= segment
->p_offset
+ segment
->p_filesz
)
5354 && load
->p_vaddr
<= segment
->p_vaddr
5355 && (load
->p_vaddr
+ load
->p_filesz
5356 >= segment
->p_vaddr
+ segment
->p_filesz
))
5359 if (j
== filedata
->file_header
.e_phnum
)
5360 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5365 if (filedata
->dynamic_addr
)
5366 error (_("more than one dynamic segment\n"));
5368 /* By default, assume that the .dynamic section is the first
5369 section in the DYNAMIC segment. */
5370 filedata
->dynamic_addr
= segment
->p_offset
;
5371 filedata
->dynamic_size
= segment
->p_filesz
;
5373 /* Try to locate the .dynamic section. If there is
5374 a section header table, we can easily locate it. */
5375 if (filedata
->section_headers
!= NULL
)
5377 Elf_Internal_Shdr
* sec
;
5379 sec
= find_section (filedata
, ".dynamic");
5380 if (sec
== NULL
|| sec
->sh_size
== 0)
5382 /* A corresponding .dynamic section is expected, but on
5383 IA-64/OpenVMS it is OK for it to be missing. */
5384 if (!is_ia64_vms (filedata
))
5385 error (_("no .dynamic section in the dynamic segment\n"));
5389 if (sec
->sh_type
== SHT_NOBITS
)
5391 filedata
->dynamic_size
= 0;
5395 filedata
->dynamic_addr
= sec
->sh_offset
;
5396 filedata
->dynamic_size
= sec
->sh_size
;
5398 /* The PT_DYNAMIC segment, which is used by the run-time
5399 loader, should exactly match the .dynamic section. */
5401 && (filedata
->dynamic_addr
!= segment
->p_offset
5402 || filedata
->dynamic_size
!= segment
->p_filesz
))
5404 the .dynamic section is not the same as the dynamic segment\n"));
5407 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5408 segment. Check this after matching against the section headers
5409 so we don't warn on debuginfo file (which have NOBITS .dynamic
5411 if (filedata
->dynamic_addr
> filedata
->file_size
5412 || (filedata
->dynamic_size
5413 > filedata
->file_size
- filedata
->dynamic_addr
))
5415 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5416 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5421 if (fseek (filedata
->handle
,
5422 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5424 error (_("Unable to find program interpreter name\n"));
5428 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5430 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5431 error (_("Internal error: failed to create format string to display program interpreter\n"));
5433 filedata
->program_interpreter
[0] = 0;
5434 if (fscanf (filedata
->handle
, fmt
,
5435 filedata
->program_interpreter
) <= 0)
5436 error (_("Unable to read program interpreter name\n"));
5439 printf (_(" [Requesting program interpreter: %s]\n"),
5440 filedata
->program_interpreter
);
5447 && filedata
->section_headers
!= NULL
5448 && filedata
->string_table
!= NULL
)
5450 printf (_("\n Section to Segment mapping:\n"));
5451 printf (_(" Segment Sections...\n"));
5453 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5456 Elf_Internal_Shdr
* section
;
5458 segment
= filedata
->program_headers
+ i
;
5459 section
= filedata
->section_headers
+ 1;
5461 printf (" %2.2d ", i
);
5463 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5465 if (!ELF_TBSS_SPECIAL (section
, segment
)
5466 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5467 printf ("%s ", printable_section_name (filedata
, section
));
5478 /* Find the file offset corresponding to VMA by using the program headers. */
5481 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5483 Elf_Internal_Phdr
* seg
;
5485 if (! get_program_headers (filedata
))
5487 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5491 for (seg
= filedata
->program_headers
;
5492 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5495 if (seg
->p_type
!= PT_LOAD
)
5498 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5499 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5500 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5503 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5504 (unsigned long) vma
);
5509 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5510 If PROBE is true, this is just a probe and we do not generate any error
5511 messages if the load fails. */
5514 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5516 Elf32_External_Shdr
* shdrs
;
5517 Elf_Internal_Shdr
* internal
;
5519 unsigned int size
= filedata
->file_header
.e_shentsize
;
5520 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5522 /* PR binutils/17531: Cope with unexpected section header sizes. */
5523 if (size
== 0 || num
== 0)
5525 if (size
< sizeof * shdrs
)
5528 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5531 if (!probe
&& size
> sizeof * shdrs
)
5532 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5534 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5536 probe
? NULL
: _("section headers"));
5540 free (filedata
->section_headers
);
5541 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5542 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5543 if (filedata
->section_headers
== NULL
)
5546 error (_("Out of memory reading %u section headers\n"), num
);
5551 for (i
= 0, internal
= filedata
->section_headers
;
5555 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5556 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5557 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5558 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5559 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5560 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5561 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5562 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5563 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5564 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5565 if (!probe
&& internal
->sh_link
> num
)
5566 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5567 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5568 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5575 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5578 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5580 Elf64_External_Shdr
* shdrs
;
5581 Elf_Internal_Shdr
* internal
;
5583 unsigned int size
= filedata
->file_header
.e_shentsize
;
5584 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5586 /* PR binutils/17531: Cope with unexpected section header sizes. */
5587 if (size
== 0 || num
== 0)
5590 if (size
< sizeof * shdrs
)
5593 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5597 if (! probe
&& size
> sizeof * shdrs
)
5598 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5600 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5601 filedata
->file_header
.e_shoff
,
5603 probe
? NULL
: _("section headers"));
5607 free (filedata
->section_headers
);
5608 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5609 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5610 if (filedata
->section_headers
== NULL
)
5613 error (_("Out of memory reading %u section headers\n"), num
);
5618 for (i
= 0, internal
= filedata
->section_headers
;
5622 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5623 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5624 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5625 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5626 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5627 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5628 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5629 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5630 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5631 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5632 if (!probe
&& internal
->sh_link
> num
)
5633 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5634 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5635 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5642 static Elf_Internal_Sym
*
5643 get_32bit_elf_symbols (Filedata
* filedata
,
5644 Elf_Internal_Shdr
* section
,
5645 unsigned long * num_syms_return
)
5647 unsigned long number
= 0;
5648 Elf32_External_Sym
* esyms
= NULL
;
5649 Elf_External_Sym_Shndx
* shndx
= NULL
;
5650 Elf_Internal_Sym
* isyms
= NULL
;
5651 Elf_Internal_Sym
* psym
;
5653 elf_section_list
* entry
;
5655 if (section
->sh_size
== 0)
5657 if (num_syms_return
!= NULL
)
5658 * num_syms_return
= 0;
5662 /* Run some sanity checks first. */
5663 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5665 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5666 printable_section_name (filedata
, section
),
5667 (unsigned long) section
->sh_entsize
);
5671 if (section
->sh_size
> filedata
->file_size
)
5673 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5674 printable_section_name (filedata
, section
),
5675 (unsigned long) section
->sh_size
);
5679 number
= section
->sh_size
/ section
->sh_entsize
;
5681 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5683 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5684 (unsigned long) section
->sh_size
,
5685 printable_section_name (filedata
, section
),
5686 (unsigned long) section
->sh_entsize
);
5690 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5691 section
->sh_size
, _("symbols"));
5696 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5698 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5703 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5707 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5708 entry
->hdr
->sh_offset
,
5709 1, entry
->hdr
->sh_size
,
5710 _("symbol table section indices"));
5714 /* PR17531: file: heap-buffer-overflow */
5715 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5717 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5718 printable_section_name (filedata
, entry
->hdr
),
5719 (unsigned long) entry
->hdr
->sh_size
,
5720 (unsigned long) section
->sh_size
);
5725 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5729 error (_("Out of memory reading %lu symbols\n"),
5730 (unsigned long) number
);
5734 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5736 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5737 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5738 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5739 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5740 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5742 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5743 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5744 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5745 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5746 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5753 if (num_syms_return
!= NULL
)
5754 * num_syms_return
= isyms
== NULL
? 0 : number
;
5759 static Elf_Internal_Sym
*
5760 get_64bit_elf_symbols (Filedata
* filedata
,
5761 Elf_Internal_Shdr
* section
,
5762 unsigned long * num_syms_return
)
5764 unsigned long number
= 0;
5765 Elf64_External_Sym
* esyms
= NULL
;
5766 Elf_External_Sym_Shndx
* shndx
= NULL
;
5767 Elf_Internal_Sym
* isyms
= NULL
;
5768 Elf_Internal_Sym
* psym
;
5770 elf_section_list
* entry
;
5772 if (section
->sh_size
== 0)
5774 if (num_syms_return
!= NULL
)
5775 * num_syms_return
= 0;
5779 /* Run some sanity checks first. */
5780 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5782 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5783 printable_section_name (filedata
, section
),
5784 (unsigned long) section
->sh_entsize
);
5788 if (section
->sh_size
> filedata
->file_size
)
5790 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5791 printable_section_name (filedata
, section
),
5792 (unsigned long) section
->sh_size
);
5796 number
= section
->sh_size
/ section
->sh_entsize
;
5798 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5800 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5801 (unsigned long) section
->sh_size
,
5802 printable_section_name (filedata
, section
),
5803 (unsigned long) section
->sh_entsize
);
5807 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5808 section
->sh_size
, _("symbols"));
5813 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5815 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5820 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5824 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5825 entry
->hdr
->sh_offset
,
5826 1, entry
->hdr
->sh_size
,
5827 _("symbol table section indices"));
5831 /* PR17531: file: heap-buffer-overflow */
5832 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5834 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5835 printable_section_name (filedata
, entry
->hdr
),
5836 (unsigned long) entry
->hdr
->sh_size
,
5837 (unsigned long) section
->sh_size
);
5842 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5846 error (_("Out of memory reading %lu symbols\n"),
5847 (unsigned long) number
);
5851 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5853 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5854 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5855 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5856 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5858 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5860 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5861 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5862 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5864 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5865 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5872 if (num_syms_return
!= NULL
)
5873 * num_syms_return
= isyms
== NULL
? 0 : number
;
5879 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5881 static char buff
[1024];
5883 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5885 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5886 bfd_vma os_flags
= 0;
5887 bfd_vma proc_flags
= 0;
5888 bfd_vma unknown_flags
= 0;
5896 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5897 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5898 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5899 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5900 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5901 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5902 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5903 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5904 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5905 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5906 /* IA-64 specific. */
5907 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5908 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5909 /* IA-64 OpenVMS specific. */
5910 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5911 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5912 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5913 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5914 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5915 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5917 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5918 /* SPARC specific. */
5919 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5920 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5922 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5923 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5924 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5926 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5928 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5931 if (do_section_details
)
5933 sprintf (buff
, "[%*.*lx]: ",
5934 field_size
, field_size
, (unsigned long) sh_flags
);
5935 p
+= field_size
+ 4;
5942 flag
= sh_flags
& - sh_flags
;
5945 if (do_section_details
)
5949 case SHF_WRITE
: sindex
= 0; break;
5950 case SHF_ALLOC
: sindex
= 1; break;
5951 case SHF_EXECINSTR
: sindex
= 2; break;
5952 case SHF_MERGE
: sindex
= 3; break;
5953 case SHF_STRINGS
: sindex
= 4; break;
5954 case SHF_INFO_LINK
: sindex
= 5; break;
5955 case SHF_LINK_ORDER
: sindex
= 6; break;
5956 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5957 case SHF_GROUP
: sindex
= 8; break;
5958 case SHF_TLS
: sindex
= 9; break;
5959 case SHF_EXCLUDE
: sindex
= 18; break;
5960 case SHF_COMPRESSED
: sindex
= 20; break;
5961 case SHF_GNU_MBIND
: sindex
= 24; break;
5965 switch (filedata
->file_header
.e_machine
)
5968 if (flag
== SHF_IA_64_SHORT
)
5970 else if (flag
== SHF_IA_64_NORECOV
)
5973 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5976 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5977 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5978 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5979 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5980 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5981 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5992 case EM_OLD_SPARCV9
:
5993 case EM_SPARC32PLUS
:
5996 if (flag
== SHF_ORDERED
)
6003 case SHF_ENTRYSECT
: sindex
= 21; break;
6004 case SHF_ARM_PURECODE
: sindex
= 22; break;
6005 case SHF_COMDEF
: sindex
= 23; break;
6010 if (flag
== SHF_PPC_VLE
)
6021 if (p
!= buff
+ field_size
+ 4)
6023 if (size
< (10 + 2))
6025 warn (_("Internal error: not enough buffer room for section flag info"));
6026 return _("<unknown>");
6033 size
-= flags
[sindex
].len
;
6034 p
= stpcpy (p
, flags
[sindex
].str
);
6036 else if (flag
& SHF_MASKOS
)
6038 else if (flag
& SHF_MASKPROC
)
6041 unknown_flags
|= flag
;
6047 case SHF_WRITE
: *p
= 'W'; break;
6048 case SHF_ALLOC
: *p
= 'A'; break;
6049 case SHF_EXECINSTR
: *p
= 'X'; break;
6050 case SHF_MERGE
: *p
= 'M'; break;
6051 case SHF_STRINGS
: *p
= 'S'; break;
6052 case SHF_INFO_LINK
: *p
= 'I'; break;
6053 case SHF_LINK_ORDER
: *p
= 'L'; break;
6054 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6055 case SHF_GROUP
: *p
= 'G'; break;
6056 case SHF_TLS
: *p
= 'T'; break;
6057 case SHF_EXCLUDE
: *p
= 'E'; break;
6058 case SHF_COMPRESSED
: *p
= 'C'; break;
6059 case SHF_GNU_MBIND
: *p
= 'D'; break;
6062 if ((filedata
->file_header
.e_machine
== EM_X86_64
6063 || filedata
->file_header
.e_machine
== EM_L1OM
6064 || filedata
->file_header
.e_machine
== EM_K1OM
)
6065 && flag
== SHF_X86_64_LARGE
)
6067 else if (filedata
->file_header
.e_machine
== EM_ARM
6068 && flag
== SHF_ARM_PURECODE
)
6070 else if (filedata
->file_header
.e_machine
== EM_PPC
6071 && flag
== SHF_PPC_VLE
)
6073 else if (flag
& SHF_MASKOS
)
6076 sh_flags
&= ~ SHF_MASKOS
;
6078 else if (flag
& SHF_MASKPROC
)
6081 sh_flags
&= ~ SHF_MASKPROC
;
6091 if (do_section_details
)
6095 size
-= 5 + field_size
;
6096 if (p
!= buff
+ field_size
+ 4)
6100 warn (_("Internal error: not enough buffer room for section flag info"));
6101 return _("<unknown>");
6107 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6108 (unsigned long) os_flags
);
6109 p
+= 5 + field_size
;
6113 size
-= 7 + field_size
;
6114 if (p
!= buff
+ field_size
+ 4)
6118 warn (_("Internal error: not enough buffer room for section flag info"));
6119 return _("<unknown>");
6125 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6126 (unsigned long) proc_flags
);
6127 p
+= 7 + field_size
;
6131 size
-= 10 + field_size
;
6132 if (p
!= buff
+ field_size
+ 4)
6136 warn (_("Internal error: not enough buffer room for section flag info"));
6137 return _("<unknown>");
6143 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6144 (unsigned long) unknown_flags
);
6145 p
+= 10 + field_size
;
6153 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6154 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6158 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6160 if (size
< sizeof (* echdr
))
6162 error (_("Compressed section is too small even for a compression header\n"));
6166 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6167 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6168 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6169 return sizeof (*echdr
);
6173 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6175 if (size
< sizeof (* echdr
))
6177 error (_("Compressed section is too small even for a compression header\n"));
6181 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6182 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6183 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6184 return sizeof (*echdr
);
6189 process_section_headers (Filedata
* filedata
)
6191 Elf_Internal_Shdr
* section
;
6194 free (filedata
->section_headers
);
6195 filedata
->section_headers
= NULL
;
6196 free (filedata
->dynamic_symbols
);
6197 filedata
->dynamic_symbols
= NULL
;
6198 filedata
->num_dynamic_syms
= 0;
6199 free (filedata
->dynamic_strings
);
6200 filedata
->dynamic_strings
= NULL
;
6201 filedata
->dynamic_strings_length
= 0;
6202 free (filedata
->dynamic_syminfo
);
6203 filedata
->dynamic_syminfo
= NULL
;
6204 while (filedata
->symtab_shndx_list
!= NULL
)
6206 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6207 free (filedata
->symtab_shndx_list
);
6208 filedata
->symtab_shndx_list
= next
;
6211 if (filedata
->file_header
.e_shnum
== 0)
6213 /* PR binutils/12467. */
6214 if (filedata
->file_header
.e_shoff
!= 0)
6216 warn (_("possibly corrupt ELF file header - it has a non-zero"
6217 " section header offset, but no section headers\n"));
6220 else if (do_sections
)
6221 printf (_("\nThere are no sections in this file.\n"));
6226 if (do_sections
&& !do_header
)
6227 printf (ngettext ("There is %d section header, "
6228 "starting at offset 0x%lx:\n",
6229 "There are %d section headers, "
6230 "starting at offset 0x%lx:\n",
6231 filedata
->file_header
.e_shnum
),
6232 filedata
->file_header
.e_shnum
,
6233 (unsigned long) filedata
->file_header
.e_shoff
);
6237 if (! get_32bit_section_headers (filedata
, FALSE
))
6242 if (! get_64bit_section_headers (filedata
, FALSE
))
6246 /* Read in the string table, so that we have names to display. */
6247 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6248 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6250 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6252 if (section
->sh_size
!= 0)
6254 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6255 1, section
->sh_size
,
6258 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6262 /* Scan the sections for the dynamic symbol table
6263 and dynamic string table and debug sections. */
6264 eh_addr_size
= is_32bit_elf
? 4 : 8;
6265 switch (filedata
->file_header
.e_machine
)
6268 case EM_MIPS_RS3_LE
:
6269 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6270 FDE addresses. However, the ABI also has a semi-official ILP32
6271 variant for which the normal FDE address size rules apply.
6273 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6274 section, where XX is the size of longs in bits. Unfortunately,
6275 earlier compilers provided no way of distinguishing ILP32 objects
6276 from LP64 objects, so if there's any doubt, we should assume that
6277 the official LP64 form is being used. */
6278 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6279 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6285 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6287 case E_H8_MACH_H8300
:
6288 case E_H8_MACH_H8300HN
:
6289 case E_H8_MACH_H8300SN
:
6290 case E_H8_MACH_H8300SXN
:
6293 case E_H8_MACH_H8300H
:
6294 case E_H8_MACH_H8300S
:
6295 case E_H8_MACH_H8300SX
:
6303 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6305 case EF_M32C_CPU_M16C
:
6312 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6315 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6316 if (section->sh_entsize != expected_entsize) \
6319 sprintf_vma (buf, section->sh_entsize); \
6320 /* Note: coded this way so that there is a single string for \
6322 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6323 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6324 (unsigned) expected_entsize); \
6325 section->sh_entsize = expected_entsize; \
6330 #define CHECK_ENTSIZE(section, i, type) \
6331 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6332 sizeof (Elf64_External_##type))
6334 for (i
= 0, section
= filedata
->section_headers
;
6335 i
< filedata
->file_header
.e_shnum
;
6338 char * name
= SECTION_NAME (section
);
6340 /* Run some sanity checks on the headers and
6341 possibly fill in some file data as well. */
6342 switch (section
->sh_type
)
6345 if (filedata
->dynamic_symbols
!= NULL
)
6347 error (_("File contains multiple dynamic symbol tables\n"));
6351 CHECK_ENTSIZE (section
, i
, Sym
);
6352 filedata
->dynamic_symbols
6353 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6354 filedata
->dynamic_symtab_section
= section
;
6358 if (streq (name
, ".dynstr"))
6360 if (filedata
->dynamic_strings
!= NULL
)
6362 error (_("File contains multiple dynamic string tables\n"));
6366 filedata
->dynamic_strings
6367 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6368 1, section
->sh_size
, _("dynamic strings"));
6369 filedata
->dynamic_strings_length
6370 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6371 filedata
->dynamic_strtab_section
= section
;
6375 case SHT_SYMTAB_SHNDX
:
6377 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6379 entry
->hdr
= section
;
6380 entry
->next
= filedata
->symtab_shndx_list
;
6381 filedata
->symtab_shndx_list
= entry
;
6386 CHECK_ENTSIZE (section
, i
, Sym
);
6390 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6394 CHECK_ENTSIZE (section
, i
, Rel
);
6395 if (do_checks
&& section
->sh_size
== 0)
6396 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6400 CHECK_ENTSIZE (section
, i
, Rela
);
6401 if (do_checks
&& section
->sh_size
== 0)
6402 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6407 /* Having a zero sized section is not illegal according to the
6408 ELF standard, but it might be an indication that something
6409 is wrong. So issue a warning if we are running in lint mode. */
6410 if (do_checks
&& section
->sh_size
== 0)
6411 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6418 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6419 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6420 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6421 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
|| do_debug_ranges
6422 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6423 && (const_strneq (name
, ".debug_")
6424 || const_strneq (name
, ".zdebug_")))
6427 name
+= sizeof (".zdebug_") - 1;
6429 name
+= sizeof (".debug_") - 1;
6432 || (do_debug_info
&& const_strneq (name
, "info"))
6433 || (do_debug_info
&& const_strneq (name
, "types"))
6434 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6435 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6436 || (do_debug_lines
&& const_strneq (name
, "line."))
6437 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6438 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6439 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6440 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6441 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6442 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6443 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6444 || (do_debug_frames
&& const_strneq (name
, "frame"))
6445 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6446 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6447 || (do_debug_str
&& const_strneq (name
, "str"))
6448 || (do_debug_str_offsets
&& const_strneq (name
, "str_offsets"))
6449 || (do_debug_loc
&& const_strneq (name
, "loc"))
6450 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6451 || (do_debug_addr
&& const_strneq (name
, "addr"))
6452 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6453 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6455 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6457 /* Linkonce section to be combined with .debug_info at link time. */
6458 else if ((do_debugging
|| do_debug_info
)
6459 && const_strneq (name
, ".gnu.linkonce.wi."))
6460 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6461 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6462 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6463 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6464 || streq (name
, ".debug_names")))
6465 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6466 /* Trace sections for Itanium VMS. */
6467 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6468 || do_trace_aranges
)
6469 && const_strneq (name
, ".trace_"))
6471 name
+= sizeof (".trace_") - 1;
6474 || (do_trace_info
&& streq (name
, "info"))
6475 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6476 || (do_trace_aranges
&& streq (name
, "aranges"))
6478 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6480 else if ((do_debugging
|| do_debug_links
)
6481 && (const_strneq (name
, ".gnu_debuglink")
6482 || const_strneq (name
, ".gnu_debugaltlink")))
6483 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6489 if (filedata
->file_header
.e_shnum
> 1)
6490 printf (_("\nSection Headers:\n"));
6492 printf (_("\nSection Header:\n"));
6496 if (do_section_details
)
6498 printf (_(" [Nr] Name\n"));
6499 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6503 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6507 if (do_section_details
)
6509 printf (_(" [Nr] Name\n"));
6510 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6514 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6518 if (do_section_details
)
6520 printf (_(" [Nr] Name\n"));
6521 printf (_(" Type Address Offset Link\n"));
6522 printf (_(" Size EntSize Info Align\n"));
6526 printf (_(" [Nr] Name Type Address Offset\n"));
6527 printf (_(" Size EntSize Flags Link Info Align\n"));
6531 if (do_section_details
)
6532 printf (_(" Flags\n"));
6534 for (i
= 0, section
= filedata
->section_headers
;
6535 i
< filedata
->file_header
.e_shnum
;
6538 /* Run some sanity checks on the section header. */
6540 /* Check the sh_link field. */
6541 switch (section
->sh_type
)
6545 if (section
->sh_link
== 0
6546 && (filedata
->file_header
.e_type
== ET_EXEC
6547 || filedata
->file_header
.e_type
== ET_DYN
))
6548 /* A dynamic relocation section where all entries use a
6549 zero symbol index need not specify a symtab section. */
6552 case SHT_SYMTAB_SHNDX
:
6556 case SHT_GNU_versym
:
6557 if (section
->sh_link
== 0
6558 || section
->sh_link
>= filedata
->file_header
.e_shnum
6559 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6560 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6561 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6562 i
, section
->sh_link
);
6568 case SHT_GNU_verneed
:
6569 case SHT_GNU_verdef
:
6570 case SHT_GNU_LIBLIST
:
6571 if (section
->sh_link
== 0
6572 || section
->sh_link
>= filedata
->file_header
.e_shnum
6573 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6574 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6575 i
, section
->sh_link
);
6578 case SHT_INIT_ARRAY
:
6579 case SHT_FINI_ARRAY
:
6580 case SHT_PREINIT_ARRAY
:
6581 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6582 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6583 i
, section
->sh_link
);
6587 /* FIXME: Add support for target specific section types. */
6588 #if 0 /* Currently we do not check other section types as there are too
6589 many special cases. Stab sections for example have a type
6590 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6592 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6593 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6594 i
, section
->sh_link
);
6599 /* Check the sh_info field. */
6600 switch (section
->sh_type
)
6604 if (section
->sh_info
== 0
6605 && (filedata
->file_header
.e_type
== ET_EXEC
6606 || filedata
->file_header
.e_type
== ET_DYN
))
6607 /* Dynamic relocations apply to segments, so they do not
6608 need to specify the section they relocate. */
6610 if (section
->sh_info
== 0
6611 || section
->sh_info
>= filedata
->file_header
.e_shnum
6612 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6613 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6614 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6615 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6616 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6617 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6618 /* FIXME: Are other section types valid ? */
6619 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6620 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6621 i
, section
->sh_info
);
6626 case SHT_SYMTAB_SHNDX
:
6627 case SHT_INIT_ARRAY
:
6628 case SHT_FINI_ARRAY
:
6629 case SHT_PREINIT_ARRAY
:
6630 if (section
->sh_info
!= 0)
6631 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6632 i
, section
->sh_info
);
6638 /* A symbol index - we assume that it is valid. */
6642 /* FIXME: Add support for target specific section types. */
6643 if (section
->sh_type
== SHT_NOBITS
)
6644 /* NOBITS section headers with non-zero sh_info fields can be
6645 created when a binary is stripped of everything but its debug
6646 information. The stripped sections have their headers
6647 preserved but their types set to SHT_NOBITS. So do not check
6648 this type of section. */
6650 else if (section
->sh_flags
& SHF_INFO_LINK
)
6652 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6653 warn (_("[%2u]: Expected link to another section in info field"), i
);
6655 else if (section
->sh_type
< SHT_LOOS
6656 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6657 && section
->sh_info
!= 0)
6658 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6659 i
, section
->sh_info
);
6663 /* Check the sh_size field. */
6664 if (section
->sh_size
> filedata
->file_size
6665 && section
->sh_type
!= SHT_NOBITS
6666 && section
->sh_type
!= SHT_NULL
6667 && section
->sh_type
< SHT_LOOS
)
6668 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6670 printf (" [%2u] ", i
);
6671 if (do_section_details
)
6672 printf ("%s\n ", printable_section_name (filedata
, section
));
6674 print_symbol (-17, SECTION_NAME (section
));
6676 printf (do_wide
? " %-15s " : " %-15.15s ",
6677 get_section_type_name (filedata
, section
->sh_type
));
6681 const char * link_too_big
= NULL
;
6683 print_vma (section
->sh_addr
, LONG_HEX
);
6685 printf ( " %6.6lx %6.6lx %2.2lx",
6686 (unsigned long) section
->sh_offset
,
6687 (unsigned long) section
->sh_size
,
6688 (unsigned long) section
->sh_entsize
);
6690 if (do_section_details
)
6691 fputs (" ", stdout
);
6693 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6695 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6698 /* The sh_link value is out of range. Normally this indicates
6699 an error but it can have special values in Solaris binaries. */
6700 switch (filedata
->file_header
.e_machine
)
6707 case EM_OLD_SPARCV9
:
6708 case EM_SPARC32PLUS
:
6711 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6712 link_too_big
= "BEFORE";
6713 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6714 link_too_big
= "AFTER";
6721 if (do_section_details
)
6723 if (link_too_big
!= NULL
&& * link_too_big
)
6724 printf ("<%s> ", link_too_big
);
6726 printf ("%2u ", section
->sh_link
);
6727 printf ("%3u %2lu\n", section
->sh_info
,
6728 (unsigned long) section
->sh_addralign
);
6731 printf ("%2u %3u %2lu\n",
6734 (unsigned long) section
->sh_addralign
);
6736 if (link_too_big
&& ! * link_too_big
)
6737 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6738 i
, section
->sh_link
);
6742 print_vma (section
->sh_addr
, LONG_HEX
);
6744 if ((long) section
->sh_offset
== section
->sh_offset
)
6745 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6749 print_vma (section
->sh_offset
, LONG_HEX
);
6752 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6753 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6757 print_vma (section
->sh_size
, LONG_HEX
);
6760 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6761 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6765 print_vma (section
->sh_entsize
, LONG_HEX
);
6768 if (do_section_details
)
6769 fputs (" ", stdout
);
6771 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6773 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6775 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6776 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6779 print_vma (section
->sh_addralign
, DEC
);
6783 else if (do_section_details
)
6786 print_vma (section
->sh_addr
, LONG_HEX
);
6787 if ((long) section
->sh_offset
== section
->sh_offset
)
6788 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6792 print_vma (section
->sh_offset
, LONG_HEX
);
6794 printf (" %u\n ", section
->sh_link
);
6795 print_vma (section
->sh_size
, LONG_HEX
);
6797 print_vma (section
->sh_entsize
, LONG_HEX
);
6799 printf (" %-16u %lu\n",
6801 (unsigned long) section
->sh_addralign
);
6806 print_vma (section
->sh_addr
, LONG_HEX
);
6807 if ((long) section
->sh_offset
== section
->sh_offset
)
6808 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6812 print_vma (section
->sh_offset
, LONG_HEX
);
6815 print_vma (section
->sh_size
, LONG_HEX
);
6817 print_vma (section
->sh_entsize
, LONG_HEX
);
6819 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6821 printf (" %2u %3u %lu\n",
6824 (unsigned long) section
->sh_addralign
);
6827 if (do_section_details
)
6829 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6830 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6832 /* Minimum section size is 12 bytes for 32-bit compression
6833 header + 12 bytes for compressed data header. */
6834 unsigned char buf
[24];
6836 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6837 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6838 sizeof (buf
), _("compression header")))
6840 Elf_Internal_Chdr chdr
;
6842 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6843 printf (_(" [<corrupt>]\n"));
6846 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6849 printf (_(" [<unknown>: 0x%x], "),
6851 print_vma (chdr
.ch_size
, LONG_HEX
);
6852 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6859 if (!do_section_details
)
6861 /* The ordering of the letters shown here matches the ordering of the
6862 corresponding SHF_xxx values, and hence the order in which these
6863 letters will be displayed to the user. */
6864 printf (_("Key to Flags:\n\
6865 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6866 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6867 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6868 if (filedata
->file_header
.e_machine
== EM_X86_64
6869 || filedata
->file_header
.e_machine
== EM_L1OM
6870 || filedata
->file_header
.e_machine
== EM_K1OM
)
6871 printf (_("l (large), "));
6872 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6873 printf (_("y (purecode), "));
6874 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6875 printf (_("v (VLE), "));
6876 printf ("p (processor specific)\n");
6883 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6884 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6885 char **strtab
, unsigned long *strtablen
)
6889 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6891 if (*symtab
== NULL
)
6894 if (symsec
->sh_link
!= 0)
6896 Elf_Internal_Shdr
*strsec
;
6898 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6900 error (_("Bad sh_link in symbol table section\n"));
6907 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6909 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6910 1, strsec
->sh_size
, _("string table"));
6911 if (*strtab
== NULL
)
6918 *strtablen
= strsec
->sh_size
;
6924 get_group_flags (unsigned int flags
)
6926 static char buff
[128];
6930 else if (flags
== GRP_COMDAT
)
6933 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6935 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6936 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6937 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6938 ? _("<unknown>") : ""));
6944 process_section_groups (Filedata
* filedata
)
6946 Elf_Internal_Shdr
* section
;
6948 struct group
* group
;
6949 Elf_Internal_Shdr
* symtab_sec
;
6950 Elf_Internal_Shdr
* strtab_sec
;
6951 Elf_Internal_Sym
* symtab
;
6952 unsigned long num_syms
;
6956 /* Don't process section groups unless needed. */
6957 if (!do_unwind
&& !do_section_groups
)
6960 if (filedata
->file_header
.e_shnum
== 0)
6962 if (do_section_groups
)
6963 printf (_("\nThere are no sections to group in this file.\n"));
6968 if (filedata
->section_headers
== NULL
)
6970 error (_("Section headers are not available!\n"));
6971 /* PR 13622: This can happen with a corrupt ELF header. */
6975 filedata
->section_headers_groups
6976 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6977 sizeof (struct group
*));
6979 if (filedata
->section_headers_groups
== NULL
)
6981 error (_("Out of memory reading %u section group headers\n"),
6982 filedata
->file_header
.e_shnum
);
6986 /* Scan the sections for the group section. */
6987 filedata
->group_count
= 0;
6988 for (i
= 0, section
= filedata
->section_headers
;
6989 i
< filedata
->file_header
.e_shnum
;
6991 if (section
->sh_type
== SHT_GROUP
)
6992 filedata
->group_count
++;
6994 if (filedata
->group_count
== 0)
6996 if (do_section_groups
)
6997 printf (_("\nThere are no section groups in this file.\n"));
7002 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7003 sizeof (struct group
));
7005 if (filedata
->section_groups
== NULL
)
7007 error (_("Out of memory reading %lu groups\n"),
7008 (unsigned long) filedata
->group_count
);
7018 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7019 i
< filedata
->file_header
.e_shnum
;
7022 if (section
->sh_type
== SHT_GROUP
)
7024 const char * name
= printable_section_name (filedata
, section
);
7025 const char * group_name
;
7026 unsigned char * start
;
7027 unsigned char * indices
;
7028 unsigned int entry
, j
, size
;
7029 Elf_Internal_Shdr
* sec
;
7030 Elf_Internal_Sym
* sym
;
7032 /* Get the symbol table. */
7033 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7034 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7037 error (_("Bad sh_link in group section `%s'\n"), name
);
7041 if (symtab_sec
!= sec
)
7045 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7050 error (_("Corrupt header in group section `%s'\n"), name
);
7054 if (section
->sh_info
>= num_syms
)
7056 error (_("Bad sh_info in group section `%s'\n"), name
);
7060 sym
= symtab
+ section
->sh_info
;
7062 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7064 if (sym
->st_shndx
== 0
7065 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7067 error (_("Bad sh_info in group section `%s'\n"), name
);
7071 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
7079 /* Get the string table. */
7080 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7088 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7093 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7094 1, strtab_sec
->sh_size
,
7096 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7098 group_name
= sym
->st_name
< strtab_size
7099 ? strtab
+ sym
->st_name
: _("<corrupt>");
7102 /* PR 17531: file: loop. */
7103 if (section
->sh_entsize
> section
->sh_size
)
7105 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7106 printable_section_name (filedata
, section
),
7107 (unsigned long) section
->sh_entsize
,
7108 (unsigned long) section
->sh_size
);
7112 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7113 1, section
->sh_size
,
7119 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7120 entry
= byte_get (indices
, 4);
7123 if (do_section_groups
)
7125 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7126 get_group_flags (entry
), i
, name
, group_name
, size
);
7128 printf (_(" [Index] Name\n"));
7131 group
->group_index
= i
;
7133 for (j
= 0; j
< size
; j
++)
7135 struct group_list
* g
;
7137 entry
= byte_get (indices
, 4);
7140 if (entry
>= filedata
->file_header
.e_shnum
)
7142 static unsigned num_group_errors
= 0;
7144 if (num_group_errors
++ < 10)
7146 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7147 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7148 if (num_group_errors
== 10)
7149 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7154 if (filedata
->section_headers_groups
[entry
] != NULL
)
7158 static unsigned num_errs
= 0;
7160 if (num_errs
++ < 10)
7162 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7164 filedata
->section_headers_groups
[entry
]->group_index
);
7166 warn (_("Further error messages about already contained group sections suppressed\n"));
7172 /* Intel C/C++ compiler may put section 0 in a
7173 section group. We just warn it the first time
7174 and ignore it afterwards. */
7175 static bfd_boolean warned
= FALSE
;
7178 error (_("section 0 in group section [%5u]\n"),
7179 filedata
->section_headers_groups
[entry
]->group_index
);
7185 filedata
->section_headers_groups
[entry
] = group
;
7187 if (do_section_groups
)
7189 sec
= filedata
->section_headers
+ entry
;
7190 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7193 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7194 g
->section_index
= entry
;
7195 g
->next
= group
->root
;
7210 /* Data used to display dynamic fixups. */
7212 struct ia64_vms_dynfixup
7214 bfd_vma needed_ident
; /* Library ident number. */
7215 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7216 bfd_vma fixup_needed
; /* Index of the library. */
7217 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7218 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7221 /* Data used to display dynamic relocations. */
7223 struct ia64_vms_dynimgrela
7225 bfd_vma img_rela_cnt
; /* Number of relocations. */
7226 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7229 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7233 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7234 struct ia64_vms_dynfixup
* fixup
,
7235 const char * strtab
,
7236 unsigned int strtab_sz
)
7238 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7240 const char * lib_name
;
7242 imfs
= get_data (NULL
, filedata
,
7243 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7244 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7245 _("dynamic section image fixups"));
7249 if (fixup
->needed
< strtab_sz
)
7250 lib_name
= strtab
+ fixup
->needed
;
7253 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7254 (unsigned long) fixup
->needed
);
7258 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7259 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7261 (_("Seg Offset Type SymVec DataType\n"));
7263 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7268 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7269 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7270 type
= BYTE_GET (imfs
[i
].type
);
7271 rtype
= elf_ia64_reloc_type (type
);
7273 printf (" 0x%08x ", type
);
7275 printf (" %-32s ", rtype
);
7276 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7277 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7284 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7287 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7289 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7292 imrs
= get_data (NULL
, filedata
,
7293 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7294 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7295 _("dynamic section image relocations"));
7299 printf (_("\nImage relocs\n"));
7301 (_("Seg Offset Type Addend Seg Sym Off\n"));
7303 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7308 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7309 printf ("%08" BFD_VMA_FMT
"x ",
7310 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7311 type
= BYTE_GET (imrs
[i
].type
);
7312 rtype
= elf_ia64_reloc_type (type
);
7314 printf ("0x%08x ", type
);
7316 printf ("%-31s ", rtype
);
7317 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7318 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7319 printf ("%08" BFD_VMA_FMT
"x\n",
7320 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7327 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7330 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7332 struct ia64_vms_dynfixup fixup
;
7333 struct ia64_vms_dynimgrela imgrela
;
7334 Elf_Internal_Dyn
*entry
;
7335 bfd_vma strtab_off
= 0;
7336 bfd_vma strtab_sz
= 0;
7337 char *strtab
= NULL
;
7338 bfd_boolean res
= TRUE
;
7340 memset (&fixup
, 0, sizeof (fixup
));
7341 memset (&imgrela
, 0, sizeof (imgrela
));
7343 /* Note: the order of the entries is specified by the OpenVMS specs. */
7344 for (entry
= filedata
->dynamic_section
;
7345 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7348 switch (entry
->d_tag
)
7350 case DT_IA_64_VMS_STRTAB_OFFSET
:
7351 strtab_off
= entry
->d_un
.d_val
;
7354 strtab_sz
= entry
->d_un
.d_val
;
7356 strtab
= get_data (NULL
, filedata
,
7357 filedata
->dynamic_addr
+ strtab_off
,
7358 1, strtab_sz
, _("dynamic string section"));
7363 case DT_IA_64_VMS_NEEDED_IDENT
:
7364 fixup
.needed_ident
= entry
->d_un
.d_val
;
7367 fixup
.needed
= entry
->d_un
.d_val
;
7369 case DT_IA_64_VMS_FIXUP_NEEDED
:
7370 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7372 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7373 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7375 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7376 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7377 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7380 case DT_IA_64_VMS_IMG_RELA_CNT
:
7381 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7383 case DT_IA_64_VMS_IMG_RELA_OFF
:
7384 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7385 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7406 dynamic_relocations
[] =
7408 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7409 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7410 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7413 /* Process the reloc section. */
7416 process_relocs (Filedata
* filedata
)
7418 unsigned long rel_size
;
7419 unsigned long rel_offset
;
7424 if (do_using_dynamic
)
7428 bfd_boolean has_dynamic_reloc
;
7431 has_dynamic_reloc
= FALSE
;
7433 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7435 is_rela
= dynamic_relocations
[i
].rela
;
7436 name
= dynamic_relocations
[i
].name
;
7437 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7438 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7441 has_dynamic_reloc
= TRUE
;
7443 if (is_rela
== UNKNOWN
)
7445 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7446 switch (filedata
->dynamic_info
[DT_PLTREL
])
7460 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7461 name
, rel_offset
, rel_size
);
7463 dump_relocations (filedata
,
7464 offset_from_vma (filedata
, rel_offset
, rel_size
),
7466 filedata
->dynamic_symbols
,
7467 filedata
->num_dynamic_syms
,
7468 filedata
->dynamic_strings
,
7469 filedata
->dynamic_strings_length
,
7470 is_rela
, TRUE
/* is_dynamic */);
7474 if (is_ia64_vms (filedata
))
7475 if (process_ia64_vms_dynamic_relocs (filedata
))
7476 has_dynamic_reloc
= TRUE
;
7478 if (! has_dynamic_reloc
)
7479 printf (_("\nThere are no dynamic relocations in this file.\n"));
7483 Elf_Internal_Shdr
* section
;
7485 bfd_boolean found
= FALSE
;
7487 for (i
= 0, section
= filedata
->section_headers
;
7488 i
< filedata
->file_header
.e_shnum
;
7491 if ( section
->sh_type
!= SHT_RELA
7492 && section
->sh_type
!= SHT_REL
)
7495 rel_offset
= section
->sh_offset
;
7496 rel_size
= section
->sh_size
;
7501 unsigned long num_rela
;
7503 printf (_("\nRelocation section "));
7505 if (filedata
->string_table
== NULL
)
7506 printf ("%d", section
->sh_name
);
7508 printf ("'%s'", printable_section_name (filedata
, section
));
7510 num_rela
= rel_size
/ section
->sh_entsize
;
7511 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7512 " at offset 0x%lx contains %lu entries:\n",
7514 rel_offset
, num_rela
);
7516 is_rela
= section
->sh_type
== SHT_RELA
;
7518 if (section
->sh_link
!= 0
7519 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7521 Elf_Internal_Shdr
* symsec
;
7522 Elf_Internal_Sym
* symtab
;
7523 unsigned long nsyms
;
7524 unsigned long strtablen
= 0;
7525 char * strtab
= NULL
;
7527 symsec
= filedata
->section_headers
+ section
->sh_link
;
7528 if (symsec
->sh_type
!= SHT_SYMTAB
7529 && symsec
->sh_type
!= SHT_DYNSYM
)
7532 if (!get_symtab (filedata
, symsec
,
7533 &symtab
, &nsyms
, &strtab
, &strtablen
))
7536 dump_relocations (filedata
, rel_offset
, rel_size
,
7537 symtab
, nsyms
, strtab
, strtablen
,
7539 symsec
->sh_type
== SHT_DYNSYM
);
7544 dump_relocations (filedata
, rel_offset
, rel_size
,
7545 NULL
, 0, NULL
, 0, is_rela
,
7546 FALSE
/* is_dynamic */);
7554 /* Users sometimes forget the -D option, so try to be helpful. */
7555 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7557 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7559 printf (_("\nThere are no static relocations in this file."));
7560 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7565 if (i
== ARRAY_SIZE (dynamic_relocations
))
7566 printf (_("\nThere are no relocations in this file.\n"));
7573 /* An absolute address consists of a section and an offset. If the
7574 section is NULL, the offset itself is the address, otherwise, the
7575 address equals to LOAD_ADDRESS(section) + offset. */
7579 unsigned short section
;
7583 /* Find the nearest symbol at or below ADDR. Returns the symbol
7584 name, if found, and the offset from the symbol to ADDR. */
7587 find_symbol_for_address (Filedata
* filedata
,
7588 Elf_Internal_Sym
* symtab
,
7589 unsigned long nsyms
,
7590 const char * strtab
,
7591 unsigned long strtab_size
,
7592 struct absaddr addr
,
7593 const char ** symname
,
7596 bfd_vma dist
= 0x100000;
7597 Elf_Internal_Sym
* sym
;
7598 Elf_Internal_Sym
* beg
;
7599 Elf_Internal_Sym
* end
;
7600 Elf_Internal_Sym
* best
= NULL
;
7602 REMOVE_ARCH_BITS (addr
.offset
);
7604 end
= symtab
+ nsyms
;
7610 sym
= beg
+ (end
- beg
) / 2;
7612 value
= sym
->st_value
;
7613 REMOVE_ARCH_BITS (value
);
7615 if (sym
->st_name
!= 0
7616 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7617 && addr
.offset
>= value
7618 && addr
.offset
- value
< dist
)
7621 dist
= addr
.offset
- value
;
7626 if (addr
.offset
< value
)
7634 *symname
= (best
->st_name
>= strtab_size
7635 ? _("<corrupt>") : strtab
+ best
->st_name
);
7641 *offset
= addr
.offset
;
7644 static /* signed */ int
7645 symcmp (const void *p
, const void *q
)
7647 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7648 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7650 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7653 /* Process the unwind section. */
7655 #include "unwind-ia64.h"
7657 struct ia64_unw_table_entry
7659 struct absaddr start
;
7661 struct absaddr info
;
7664 struct ia64_unw_aux_info
7666 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7667 unsigned long table_len
; /* Length of unwind table. */
7668 unsigned char * info
; /* Unwind info. */
7669 unsigned long info_size
; /* Size of unwind info. */
7670 bfd_vma info_addr
; /* Starting address of unwind info. */
7671 bfd_vma seg_base
; /* Starting address of segment. */
7672 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7673 unsigned long nsyms
; /* Number of symbols. */
7674 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7675 unsigned long nfuns
; /* Number of entries in funtab. */
7676 char * strtab
; /* The string table. */
7677 unsigned long strtab_size
; /* Size of string table. */
7681 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7683 struct ia64_unw_table_entry
* tp
;
7684 unsigned long j
, nfuns
;
7686 bfd_boolean res
= TRUE
;
7688 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7689 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7690 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7691 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7693 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7695 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7699 const unsigned char * dp
;
7700 const unsigned char * head
;
7701 const unsigned char * end
;
7702 const char * procname
;
7704 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7705 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7707 fputs ("\n<", stdout
);
7711 fputs (procname
, stdout
);
7714 printf ("+%lx", (unsigned long) offset
);
7717 fputs (">: [", stdout
);
7718 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7719 fputc ('-', stdout
);
7720 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7721 printf ("], info at +0x%lx\n",
7722 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7724 /* PR 17531: file: 86232b32. */
7725 if (aux
->info
== NULL
)
7728 offset
= tp
->info
.offset
;
7729 if (tp
->info
.section
)
7731 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7733 warn (_("Invalid section %u in table entry %ld\n"),
7734 tp
->info
.section
, (long) (tp
- aux
->table
));
7738 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7740 offset
-= aux
->info_addr
;
7741 /* PR 17531: file: 0997b4d1. */
7742 if (offset
>= aux
->info_size
7743 || aux
->info_size
- offset
< 8)
7745 warn (_("Invalid offset %lx in table entry %ld\n"),
7746 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7751 head
= aux
->info
+ offset
;
7752 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7754 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7755 (unsigned) UNW_VER (stamp
),
7756 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7757 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7758 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7759 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7761 if (UNW_VER (stamp
) != 1)
7763 printf (_("\tUnknown version.\n"));
7768 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7769 /* PR 17531: file: 16ceda89. */
7770 if (end
> aux
->info
+ aux
->info_size
)
7771 end
= aux
->info
+ aux
->info_size
;
7772 for (dp
= head
+ 8; dp
< end
;)
7773 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7782 slurp_ia64_unwind_table (Filedata
* filedata
,
7783 struct ia64_unw_aux_info
* aux
,
7784 Elf_Internal_Shdr
* sec
)
7786 unsigned long size
, nrelas
, i
;
7787 Elf_Internal_Phdr
* seg
;
7788 struct ia64_unw_table_entry
* tep
;
7789 Elf_Internal_Shdr
* relsec
;
7790 Elf_Internal_Rela
* rela
;
7791 Elf_Internal_Rela
* rp
;
7792 unsigned char * table
;
7794 Elf_Internal_Sym
* sym
;
7795 const char * relname
;
7799 /* First, find the starting address of the segment that includes
7802 if (filedata
->file_header
.e_phnum
)
7804 if (! get_program_headers (filedata
))
7807 for (seg
= filedata
->program_headers
;
7808 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7811 if (seg
->p_type
!= PT_LOAD
)
7814 if (sec
->sh_addr
>= seg
->p_vaddr
7815 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7817 aux
->seg_base
= seg
->p_vaddr
;
7823 /* Second, build the unwind table from the contents of the unwind section: */
7824 size
= sec
->sh_size
;
7825 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7830 aux
->table_len
= size
/ (3 * eh_addr_size
);
7831 aux
->table
= (struct ia64_unw_table_entry
*)
7832 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7835 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7837 tep
->start
.section
= SHN_UNDEF
;
7838 tep
->end
.section
= SHN_UNDEF
;
7839 tep
->info
.section
= SHN_UNDEF
;
7840 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7841 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7842 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7843 tep
->start
.offset
+= aux
->seg_base
;
7844 tep
->end
.offset
+= aux
->seg_base
;
7845 tep
->info
.offset
+= aux
->seg_base
;
7849 /* Third, apply any relocations to the unwind table: */
7850 for (relsec
= filedata
->section_headers
;
7851 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7854 if (relsec
->sh_type
!= SHT_RELA
7855 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7856 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7859 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7868 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7870 unsigned int sym_ndx
;
7871 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7872 relname
= elf_ia64_reloc_type (r_type
);
7874 /* PR 17531: file: 9fa67536. */
7875 if (relname
== NULL
)
7877 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7881 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7883 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7887 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7889 /* PR 17531: file: 5bc8d9bf. */
7890 if (i
>= aux
->table_len
)
7892 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7896 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7897 if (sym_ndx
>= aux
->nsyms
)
7899 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7903 sym
= aux
->symtab
+ sym_ndx
;
7905 switch (rp
->r_offset
/ eh_addr_size
% 3)
7908 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7909 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7912 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7913 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7916 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7917 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7931 ia64_process_unwind (Filedata
* filedata
)
7933 Elf_Internal_Shdr
* sec
;
7934 Elf_Internal_Shdr
* unwsec
= NULL
;
7935 unsigned long i
, unwcount
= 0, unwstart
= 0;
7936 struct ia64_unw_aux_info aux
;
7937 bfd_boolean res
= TRUE
;
7939 memset (& aux
, 0, sizeof (aux
));
7941 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7943 if (sec
->sh_type
== SHT_SYMTAB
)
7947 error (_("Multiple symbol tables encountered\n"));
7953 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7954 &aux
.strtab
, &aux
.strtab_size
))
7957 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7962 printf (_("\nThere are no unwind sections in this file.\n"));
7964 while (unwcount
-- > 0)
7969 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7970 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7971 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7976 /* We have already counted the number of SHT_IA64_UNWIND
7977 sections so the loop above should never fail. */
7978 assert (unwsec
!= NULL
);
7981 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7983 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7985 /* We need to find which section group it is in. */
7986 struct group_list
* g
;
7988 if (filedata
->section_headers_groups
== NULL
7989 || filedata
->section_headers_groups
[i
] == NULL
)
7990 i
= filedata
->file_header
.e_shnum
;
7993 g
= filedata
->section_headers_groups
[i
]->root
;
7995 for (; g
!= NULL
; g
= g
->next
)
7997 sec
= filedata
->section_headers
+ g
->section_index
;
7999 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8004 i
= filedata
->file_header
.e_shnum
;
8007 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
8009 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8010 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8011 suffix
= SECTION_NAME (unwsec
) + len
;
8012 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8014 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
8015 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8020 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8021 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8022 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8023 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8025 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
8026 suffix
= SECTION_NAME (unwsec
) + len
;
8027 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8029 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
8030 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8034 if (i
== filedata
->file_header
.e_shnum
)
8036 printf (_("\nCould not find unwind info section for "));
8038 if (filedata
->string_table
== NULL
)
8039 printf ("%d", unwsec
->sh_name
);
8041 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8045 aux
.info_addr
= sec
->sh_addr
;
8046 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8049 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8051 printf (_("\nUnwind section "));
8053 if (filedata
->string_table
== NULL
)
8054 printf ("%d", unwsec
->sh_name
);
8056 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8058 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8059 (unsigned long) unwsec
->sh_offset
,
8060 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8062 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8063 && aux
.table_len
> 0)
8064 dump_ia64_unwind (filedata
, & aux
);
8066 free ((char *) aux
.table
);
8067 free ((char *) aux
.info
);
8074 free ((char *) aux
.strtab
);
8079 struct hppa_unw_table_entry
8081 struct absaddr start
;
8083 unsigned int Cannot_unwind
:1; /* 0 */
8084 unsigned int Millicode
:1; /* 1 */
8085 unsigned int Millicode_save_sr0
:1; /* 2 */
8086 unsigned int Region_description
:2; /* 3..4 */
8087 unsigned int reserved1
:1; /* 5 */
8088 unsigned int Entry_SR
:1; /* 6 */
8089 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8090 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8091 unsigned int Args_stored
:1; /* 16 */
8092 unsigned int Variable_Frame
:1; /* 17 */
8093 unsigned int Separate_Package_Body
:1; /* 18 */
8094 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8095 unsigned int Stack_Overflow_Check
:1; /* 20 */
8096 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8097 unsigned int Ada_Region
:1; /* 22 */
8098 unsigned int cxx_info
:1; /* 23 */
8099 unsigned int cxx_try_catch
:1; /* 24 */
8100 unsigned int sched_entry_seq
:1; /* 25 */
8101 unsigned int reserved2
:1; /* 26 */
8102 unsigned int Save_SP
:1; /* 27 */
8103 unsigned int Save_RP
:1; /* 28 */
8104 unsigned int Save_MRP_in_frame
:1; /* 29 */
8105 unsigned int extn_ptr_defined
:1; /* 30 */
8106 unsigned int Cleanup_defined
:1; /* 31 */
8108 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8109 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8110 unsigned int Large_frame
:1; /* 2 */
8111 unsigned int Pseudo_SP_Set
:1; /* 3 */
8112 unsigned int reserved4
:1; /* 4 */
8113 unsigned int Total_frame_size
:27; /* 5..31 */
8116 struct hppa_unw_aux_info
8118 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8119 unsigned long table_len
; /* Length of unwind table. */
8120 bfd_vma seg_base
; /* Starting address of segment. */
8121 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8122 unsigned long nsyms
; /* Number of symbols. */
8123 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8124 unsigned long nfuns
; /* Number of entries in funtab. */
8125 char * strtab
; /* The string table. */
8126 unsigned long strtab_size
; /* Size of string table. */
8130 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8132 struct hppa_unw_table_entry
* tp
;
8133 unsigned long j
, nfuns
;
8134 bfd_boolean res
= TRUE
;
8136 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8137 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8138 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8139 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8141 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8143 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8146 const char * procname
;
8148 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8149 aux
->strtab_size
, tp
->start
, &procname
,
8152 fputs ("\n<", stdout
);
8156 fputs (procname
, stdout
);
8159 printf ("+%lx", (unsigned long) offset
);
8162 fputs (">: [", stdout
);
8163 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8164 fputc ('-', stdout
);
8165 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8168 #define PF(_m) if (tp->_m) printf (#_m " ");
8169 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8172 PF(Millicode_save_sr0
);
8173 /* PV(Region_description); */
8179 PF(Separate_Package_Body
);
8180 PF(Frame_Extension_Millicode
);
8181 PF(Stack_Overflow_Check
);
8182 PF(Two_Instruction_SP_Increment
);
8186 PF(sched_entry_seq
);
8189 PF(Save_MRP_in_frame
);
8190 PF(extn_ptr_defined
);
8191 PF(Cleanup_defined
);
8192 PF(MPE_XL_interrupt_marker
);
8193 PF(HP_UX_interrupt_marker
);
8196 PV(Total_frame_size
);
8209 slurp_hppa_unwind_table (Filedata
* filedata
,
8210 struct hppa_unw_aux_info
* aux
,
8211 Elf_Internal_Shdr
* sec
)
8213 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8214 Elf_Internal_Phdr
* seg
;
8215 struct hppa_unw_table_entry
* tep
;
8216 Elf_Internal_Shdr
* relsec
;
8217 Elf_Internal_Rela
* rela
;
8218 Elf_Internal_Rela
* rp
;
8219 unsigned char * table
;
8221 Elf_Internal_Sym
* sym
;
8222 const char * relname
;
8224 /* First, find the starting address of the segment that includes
8226 if (filedata
->file_header
.e_phnum
)
8228 if (! get_program_headers (filedata
))
8231 for (seg
= filedata
->program_headers
;
8232 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8235 if (seg
->p_type
!= PT_LOAD
)
8238 if (sec
->sh_addr
>= seg
->p_vaddr
8239 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8241 aux
->seg_base
= seg
->p_vaddr
;
8247 /* Second, build the unwind table from the contents of the unwind
8249 size
= sec
->sh_size
;
8250 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8256 nentries
= size
/ unw_ent_size
;
8257 size
= unw_ent_size
* nentries
;
8259 aux
->table_len
= nentries
;
8260 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8261 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8263 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8265 unsigned int tmp1
, tmp2
;
8267 tep
->start
.section
= SHN_UNDEF
;
8268 tep
->end
.section
= SHN_UNDEF
;
8270 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8271 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8272 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8273 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8275 tep
->start
.offset
+= aux
->seg_base
;
8276 tep
->end
.offset
+= aux
->seg_base
;
8278 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8279 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8280 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8281 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8282 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8283 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8284 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8285 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8286 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8287 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8288 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8289 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8290 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8291 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8292 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8293 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8294 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8295 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8296 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8297 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8298 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8299 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8300 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8301 tep
->Cleanup_defined
= tmp1
& 0x1;
8303 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8304 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8305 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8306 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8307 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8308 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8312 /* Third, apply any relocations to the unwind table. */
8313 for (relsec
= filedata
->section_headers
;
8314 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8317 if (relsec
->sh_type
!= SHT_RELA
8318 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8319 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8322 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8326 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8328 unsigned int sym_ndx
;
8329 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8330 relname
= elf_hppa_reloc_type (r_type
);
8332 if (relname
== NULL
)
8334 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8338 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8339 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8341 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8345 i
= rp
->r_offset
/ unw_ent_size
;
8346 if (i
>= aux
->table_len
)
8348 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8352 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8353 if (sym_ndx
>= aux
->nsyms
)
8355 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8359 sym
= aux
->symtab
+ sym_ndx
;
8361 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8364 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8365 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8368 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8369 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8383 hppa_process_unwind (Filedata
* filedata
)
8385 struct hppa_unw_aux_info aux
;
8386 Elf_Internal_Shdr
* unwsec
= NULL
;
8387 Elf_Internal_Shdr
* sec
;
8389 bfd_boolean res
= TRUE
;
8391 if (filedata
->string_table
== NULL
)
8394 memset (& aux
, 0, sizeof (aux
));
8396 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8398 if (sec
->sh_type
== SHT_SYMTAB
)
8402 error (_("Multiple symbol tables encountered\n"));
8408 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8409 &aux
.strtab
, &aux
.strtab_size
))
8412 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8417 printf (_("\nThere are no unwind sections in this file.\n"));
8419 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8421 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8423 unsigned long num_unwind
= sec
->sh_size
/ 16;
8425 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8426 "contains %lu entry:\n",
8427 "\nUnwind section '%s' at offset 0x%lx "
8428 "contains %lu entries:\n",
8430 printable_section_name (filedata
, sec
),
8431 (unsigned long) sec
->sh_offset
,
8434 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8437 if (res
&& aux
.table_len
> 0)
8439 if (! dump_hppa_unwind (filedata
, &aux
))
8443 free ((char *) aux
.table
);
8449 free ((char *) aux
.strtab
);
8456 unsigned char * data
; /* The unwind data. */
8457 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8458 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8459 unsigned long nrelas
; /* The number of relocations. */
8460 unsigned int rel_type
; /* REL or RELA ? */
8461 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8464 struct arm_unw_aux_info
8466 Filedata
* filedata
; /* The file containing the unwind sections. */
8467 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8468 unsigned long nsyms
; /* Number of symbols. */
8469 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8470 unsigned long nfuns
; /* Number of these symbols. */
8471 char * strtab
; /* The file's string table. */
8472 unsigned long strtab_size
; /* Size of string table. */
8476 arm_print_vma_and_name (Filedata
* filedata
,
8477 struct arm_unw_aux_info
* aux
,
8479 struct absaddr addr
)
8481 const char *procname
;
8484 if (addr
.section
== SHN_UNDEF
)
8487 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8488 aux
->strtab_size
, addr
, &procname
,
8491 print_vma (fn
, PREFIX_HEX
);
8495 fputs (" <", stdout
);
8496 fputs (procname
, stdout
);
8499 printf ("+0x%lx", (unsigned long) sym_offset
);
8500 fputc ('>', stdout
);
8507 arm_free_section (struct arm_section
*arm_sec
)
8509 free (arm_sec
->data
);
8510 free (arm_sec
->rela
);
8513 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8514 cached section and install SEC instead.
8515 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8516 and return its valued in * WORDP, relocating if necessary.
8517 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8518 relocation's offset in ADDR.
8519 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8520 into the string table of the symbol associated with the reloc. If no
8521 reloc was applied store -1 there.
8522 5) Return TRUE upon success, FALSE otherwise. */
8525 get_unwind_section_word (Filedata
* filedata
,
8526 struct arm_unw_aux_info
* aux
,
8527 struct arm_section
* arm_sec
,
8528 Elf_Internal_Shdr
* sec
,
8529 bfd_vma word_offset
,
8530 unsigned int * wordp
,
8531 struct absaddr
* addr
,
8534 Elf_Internal_Rela
*rp
;
8535 Elf_Internal_Sym
*sym
;
8536 const char * relname
;
8538 bfd_boolean wrapped
;
8540 if (sec
== NULL
|| arm_sec
== NULL
)
8543 addr
->section
= SHN_UNDEF
;
8546 if (sym_name
!= NULL
)
8547 *sym_name
= (bfd_vma
) -1;
8549 /* If necessary, update the section cache. */
8550 if (sec
!= arm_sec
->sec
)
8552 Elf_Internal_Shdr
*relsec
;
8554 arm_free_section (arm_sec
);
8557 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8558 sec
->sh_size
, _("unwind data"));
8559 arm_sec
->rela
= NULL
;
8560 arm_sec
->nrelas
= 0;
8562 for (relsec
= filedata
->section_headers
;
8563 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8566 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8567 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8568 /* PR 15745: Check the section type as well. */
8569 || (relsec
->sh_type
!= SHT_REL
8570 && relsec
->sh_type
!= SHT_RELA
))
8573 arm_sec
->rel_type
= relsec
->sh_type
;
8574 if (relsec
->sh_type
== SHT_REL
)
8576 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8578 & arm_sec
->rela
, & arm_sec
->nrelas
))
8581 else /* relsec->sh_type == SHT_RELA */
8583 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8585 & arm_sec
->rela
, & arm_sec
->nrelas
))
8591 arm_sec
->next_rela
= arm_sec
->rela
;
8594 /* If there is no unwind data we can do nothing. */
8595 if (arm_sec
->data
== NULL
)
8598 /* If the offset is invalid then fail. */
8599 if (/* PR 21343 *//* PR 18879 */
8601 || word_offset
> (sec
->sh_size
- 4)
8602 || ((bfd_signed_vma
) word_offset
) < 0)
8605 /* Get the word at the required offset. */
8606 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8608 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8609 if (arm_sec
->rela
== NULL
)
8615 /* Look through the relocs to find the one that applies to the provided offset. */
8617 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8619 bfd_vma prelval
, offset
;
8621 if (rp
->r_offset
> word_offset
&& !wrapped
)
8626 if (rp
->r_offset
> word_offset
)
8629 if (rp
->r_offset
& 3)
8631 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8632 (unsigned long) rp
->r_offset
);
8636 if (rp
->r_offset
< word_offset
)
8639 /* PR 17531: file: 027-161405-0.004 */
8640 if (aux
->symtab
== NULL
)
8643 if (arm_sec
->rel_type
== SHT_REL
)
8645 offset
= word
& 0x7fffffff;
8646 if (offset
& 0x40000000)
8647 offset
|= ~ (bfd_vma
) 0x7fffffff;
8649 else if (arm_sec
->rel_type
== SHT_RELA
)
8650 offset
= rp
->r_addend
;
8653 error (_("Unknown section relocation type %d encountered\n"),
8658 /* PR 17531 file: 027-1241568-0.004. */
8659 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8661 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8662 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8666 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8667 offset
+= sym
->st_value
;
8668 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8670 /* Check that we are processing the expected reloc type. */
8671 if (filedata
->file_header
.e_machine
== EM_ARM
)
8673 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8674 if (relname
== NULL
)
8676 warn (_("Skipping unknown ARM relocation type: %d\n"),
8677 (int) ELF32_R_TYPE (rp
->r_info
));
8681 if (streq (relname
, "R_ARM_NONE"))
8684 if (! streq (relname
, "R_ARM_PREL31"))
8686 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8690 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8692 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8693 if (relname
== NULL
)
8695 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8696 (int) ELF32_R_TYPE (rp
->r_info
));
8700 if (streq (relname
, "R_C6000_NONE"))
8703 if (! streq (relname
, "R_C6000_PREL31"))
8705 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8713 /* This function currently only supports ARM and TI unwinders. */
8714 warn (_("Only TI and ARM unwinders are currently supported\n"));
8718 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8719 addr
->section
= sym
->st_shndx
;
8720 addr
->offset
= offset
;
8723 * sym_name
= sym
->st_name
;
8728 arm_sec
->next_rela
= rp
;
8733 static const char *tic6x_unwind_regnames
[16] =
8735 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8736 "A14", "A13", "A12", "A11", "A10",
8737 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8741 decode_tic6x_unwind_regmask (unsigned int mask
)
8745 for (i
= 12; mask
; mask
>>= 1, i
--)
8749 fputs (tic6x_unwind_regnames
[i
], stdout
);
8751 fputs (", ", stdout
);
8757 if (remaining == 0 && more_words) \
8760 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8761 data_offset, & word, & addr, NULL)) \
8767 #define GET_OP(OP) \
8772 (OP) = word >> 24; \
8777 printf (_("[Truncated opcode]\n")); \
8780 printf ("0x%02x ", OP)
8783 decode_arm_unwind_bytecode (Filedata
* filedata
,
8784 struct arm_unw_aux_info
* aux
,
8786 unsigned int remaining
,
8787 unsigned int more_words
,
8788 bfd_vma data_offset
,
8789 Elf_Internal_Shdr
* data_sec
,
8790 struct arm_section
* data_arm_sec
)
8792 struct absaddr addr
;
8793 bfd_boolean res
= TRUE
;
8795 /* Decode the unwinding instructions. */
8798 unsigned int op
, op2
;
8807 printf (" 0x%02x ", op
);
8809 if ((op
& 0xc0) == 0x00)
8811 int offset
= ((op
& 0x3f) << 2) + 4;
8813 printf (" vsp = vsp + %d", offset
);
8815 else if ((op
& 0xc0) == 0x40)
8817 int offset
= ((op
& 0x3f) << 2) + 4;
8819 printf (" vsp = vsp - %d", offset
);
8821 else if ((op
& 0xf0) == 0x80)
8824 if (op
== 0x80 && op2
== 0)
8825 printf (_("Refuse to unwind"));
8828 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8829 bfd_boolean first
= TRUE
;
8833 for (i
= 0; i
< 12; i
++)
8834 if (mask
& (1 << i
))
8840 printf ("r%d", 4 + i
);
8845 else if ((op
& 0xf0) == 0x90)
8847 if (op
== 0x9d || op
== 0x9f)
8848 printf (_(" [Reserved]"));
8850 printf (" vsp = r%d", op
& 0x0f);
8852 else if ((op
& 0xf0) == 0xa0)
8854 int end
= 4 + (op
& 0x07);
8855 bfd_boolean first
= TRUE
;
8859 for (i
= 4; i
<= end
; i
++)
8875 else if (op
== 0xb0)
8876 printf (_(" finish"));
8877 else if (op
== 0xb1)
8880 if (op2
== 0 || (op2
& 0xf0) != 0)
8881 printf (_("[Spare]"));
8884 unsigned int mask
= op2
& 0x0f;
8885 bfd_boolean first
= TRUE
;
8889 for (i
= 0; i
< 12; i
++)
8890 if (mask
& (1 << i
))
8901 else if (op
== 0xb2)
8903 unsigned char buf
[9];
8904 unsigned int i
, len
;
8905 unsigned long offset
;
8907 for (i
= 0; i
< sizeof (buf
); i
++)
8910 if ((buf
[i
] & 0x80) == 0)
8913 if (i
== sizeof (buf
))
8915 error (_("corrupt change to vsp\n"));
8920 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8921 assert (len
== i
+ 1);
8922 offset
= offset
* 4 + 0x204;
8923 printf ("vsp = vsp + %ld", offset
);
8926 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8928 unsigned int first
, last
;
8935 printf ("pop {D%d", first
);
8937 printf ("-D%d", first
+ last
);
8940 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8942 unsigned int count
= op
& 0x07;
8946 printf ("-D%d", 8 + count
);
8949 else if (op
>= 0xc0 && op
<= 0xc5)
8951 unsigned int count
= op
& 0x07;
8953 printf (" pop {wR10");
8955 printf ("-wR%d", 10 + count
);
8958 else if (op
== 0xc6)
8960 unsigned int first
, last
;
8965 printf ("pop {wR%d", first
);
8967 printf ("-wR%d", first
+ last
);
8970 else if (op
== 0xc7)
8973 if (op2
== 0 || (op2
& 0xf0) != 0)
8974 printf (_("[Spare]"));
8977 unsigned int mask
= op2
& 0x0f;
8978 bfd_boolean first
= TRUE
;
8982 for (i
= 0; i
< 4; i
++)
8983 if (mask
& (1 << i
))
8989 printf ("wCGR%d", i
);
8996 printf (_(" [unsupported opcode]"));
9007 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9008 struct arm_unw_aux_info
* aux
,
9010 unsigned int remaining
,
9011 unsigned int more_words
,
9012 bfd_vma data_offset
,
9013 Elf_Internal_Shdr
* data_sec
,
9014 struct arm_section
* data_arm_sec
)
9016 struct absaddr addr
;
9018 /* Decode the unwinding instructions. */
9021 unsigned int op
, op2
;
9030 printf (" 0x%02x ", op
);
9032 if ((op
& 0xc0) == 0x00)
9034 int offset
= ((op
& 0x3f) << 3) + 8;
9035 printf (" sp = sp + %d", offset
);
9037 else if ((op
& 0xc0) == 0x80)
9040 if (op
== 0x80 && op2
== 0)
9041 printf (_("Refuse to unwind"));
9044 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9046 printf ("pop compact {");
9050 decode_tic6x_unwind_regmask (mask
);
9054 else if ((op
& 0xf0) == 0xc0)
9062 unsigned int offset
;
9066 /* Scan entire instruction first so that GET_OP output is not
9067 interleaved with disassembly. */
9069 for (i
= 0; nregs
< (op
& 0xf); i
++)
9075 regpos
[nregs
].offset
= i
* 2;
9076 regpos
[nregs
].reg
= reg
;
9083 regpos
[nregs
].offset
= i
* 2 + 1;
9084 regpos
[nregs
].reg
= reg
;
9089 printf (_("pop frame {"));
9092 printf (_("*corrupt* - no registers specified"));
9097 for (i
= i
* 2; i
> 0; i
--)
9099 if (regpos
[reg
].offset
== i
- 1)
9101 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9108 fputs (name
, stdout
);
9116 else if (op
== 0xd0)
9117 printf (" MOV FP, SP");
9118 else if (op
== 0xd1)
9119 printf (" __c6xabi_pop_rts");
9120 else if (op
== 0xd2)
9122 unsigned char buf
[9];
9123 unsigned int i
, len
;
9124 unsigned long offset
;
9126 for (i
= 0; i
< sizeof (buf
); i
++)
9129 if ((buf
[i
] & 0x80) == 0)
9132 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9133 if (i
== sizeof (buf
))
9135 warn (_("Corrupt stack pointer adjustment detected\n"));
9139 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9140 assert (len
== i
+ 1);
9141 offset
= offset
* 8 + 0x408;
9142 printf (_("sp = sp + %ld"), offset
);
9144 else if ((op
& 0xf0) == 0xe0)
9146 if ((op
& 0x0f) == 7)
9149 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9153 printf (_(" [unsupported opcode]"));
9162 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9166 offset
= word
& 0x7fffffff;
9167 if (offset
& 0x40000000)
9168 offset
|= ~ (bfd_vma
) 0x7fffffff;
9170 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9173 return offset
+ where
;
9177 decode_arm_unwind (Filedata
* filedata
,
9178 struct arm_unw_aux_info
* aux
,
9180 unsigned int remaining
,
9181 bfd_vma data_offset
,
9182 Elf_Internal_Shdr
* data_sec
,
9183 struct arm_section
* data_arm_sec
)
9186 unsigned int more_words
= 0;
9187 struct absaddr addr
;
9188 bfd_vma sym_name
= (bfd_vma
) -1;
9189 bfd_boolean res
= TRUE
;
9193 /* Fetch the first word.
9194 Note - when decoding an object file the address extracted
9195 here will always be 0. So we also pass in the sym_name
9196 parameter so that we can find the symbol associated with
9197 the personality routine. */
9198 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9199 & word
, & addr
, & sym_name
))
9206 addr
.section
= SHN_UNDEF
;
9210 if ((word
& 0x80000000) == 0)
9212 /* Expand prel31 for personality routine. */
9214 const char *procname
;
9216 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9217 printf (_(" Personality routine: "));
9219 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9220 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9222 procname
= aux
->strtab
+ sym_name
;
9223 print_vma (fn
, PREFIX_HEX
);
9226 fputs (" <", stdout
);
9227 fputs (procname
, stdout
);
9228 fputc ('>', stdout
);
9232 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9233 fputc ('\n', stdout
);
9235 /* The GCC personality routines use the standard compact
9236 encoding, starting with one byte giving the number of
9238 if (procname
!= NULL
9239 && (const_strneq (procname
, "__gcc_personality_v0")
9240 || const_strneq (procname
, "__gxx_personality_v0")
9241 || const_strneq (procname
, "__gcj_personality_v0")
9242 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9249 printf (_(" [Truncated data]\n"));
9252 more_words
= word
>> 24;
9262 /* ARM EHABI Section 6.3:
9264 An exception-handling table entry for the compact model looks like:
9268 1 0 index Data for personalityRoutine[index] */
9270 if (filedata
->file_header
.e_machine
== EM_ARM
9271 && (word
& 0x70000000))
9273 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9277 per_index
= (word
>> 24) & 0x7f;
9278 printf (_(" Compact model index: %d\n"), per_index
);
9285 else if (per_index
< 3)
9287 more_words
= (word
>> 16) & 0xff;
9293 switch (filedata
->file_header
.e_machine
)
9298 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9299 data_offset
, data_sec
, data_arm_sec
))
9304 warn (_("Unknown ARM compact model index encountered\n"));
9305 printf (_(" [reserved]\n"));
9313 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9314 data_offset
, data_sec
, data_arm_sec
))
9317 else if (per_index
< 5)
9319 if (((word
>> 17) & 0x7f) == 0x7f)
9320 printf (_(" Restore stack from frame pointer\n"));
9322 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9323 printf (_(" Registers restored: "));
9325 printf (" (compact) ");
9326 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9328 printf (_(" Return register: %s\n"),
9329 tic6x_unwind_regnames
[word
& 0xf]);
9332 printf (_(" [reserved (%d)]\n"), per_index
);
9336 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9337 filedata
->file_header
.e_machine
);
9341 /* Decode the descriptors. Not implemented. */
9347 dump_arm_unwind (Filedata
* filedata
,
9348 struct arm_unw_aux_info
* aux
,
9349 Elf_Internal_Shdr
* exidx_sec
)
9351 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9352 unsigned int i
, exidx_len
;
9353 unsigned long j
, nfuns
;
9354 bfd_boolean res
= TRUE
;
9356 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9357 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9358 exidx_len
= exidx_sec
->sh_size
/ 8;
9360 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9361 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9362 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9363 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9365 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9367 for (i
= 0; i
< exidx_len
; i
++)
9369 unsigned int exidx_fn
, exidx_entry
;
9370 struct absaddr fn_addr
, entry_addr
;
9373 fputc ('\n', stdout
);
9375 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9376 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9377 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9378 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9381 arm_free_section (& exidx_arm_sec
);
9382 arm_free_section (& extab_arm_sec
);
9386 /* ARM EHABI, Section 5:
9387 An index table entry consists of 2 words.
9388 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9389 if (exidx_fn
& 0x80000000)
9391 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9395 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9397 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9398 fputs (": ", stdout
);
9400 if (exidx_entry
== 1)
9402 print_vma (exidx_entry
, PREFIX_HEX
);
9403 fputs (" [cantunwind]\n", stdout
);
9405 else if (exidx_entry
& 0x80000000)
9407 print_vma (exidx_entry
, PREFIX_HEX
);
9408 fputc ('\n', stdout
);
9409 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9413 bfd_vma table
, table_offset
= 0;
9414 Elf_Internal_Shdr
*table_sec
;
9416 fputs ("@", stdout
);
9417 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9418 print_vma (table
, PREFIX_HEX
);
9421 /* Locate the matching .ARM.extab. */
9422 if (entry_addr
.section
!= SHN_UNDEF
9423 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9425 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9426 table_offset
= entry_addr
.offset
;
9428 if (table_offset
> table_sec
->sh_size
9429 || ((bfd_signed_vma
) table_offset
) < 0)
9431 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9432 (unsigned long) table_offset
,
9433 printable_section_name (filedata
, table_sec
));
9440 table_sec
= find_section_by_address (filedata
, table
);
9441 if (table_sec
!= NULL
)
9442 table_offset
= table
- table_sec
->sh_addr
;
9445 if (table_sec
== NULL
)
9447 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9448 (unsigned long) table
);
9453 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9462 arm_free_section (&exidx_arm_sec
);
9463 arm_free_section (&extab_arm_sec
);
9468 /* Used for both ARM and C6X unwinding tables. */
9471 arm_process_unwind (Filedata
* filedata
)
9473 struct arm_unw_aux_info aux
;
9474 Elf_Internal_Shdr
*unwsec
= NULL
;
9475 Elf_Internal_Shdr
*sec
;
9477 unsigned int sec_type
;
9478 bfd_boolean res
= TRUE
;
9480 switch (filedata
->file_header
.e_machine
)
9483 sec_type
= SHT_ARM_EXIDX
;
9487 sec_type
= SHT_C6000_UNWIND
;
9491 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9492 filedata
->file_header
.e_machine
);
9496 if (filedata
->string_table
== NULL
)
9499 memset (& aux
, 0, sizeof (aux
));
9500 aux
.filedata
= filedata
;
9502 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9504 if (sec
->sh_type
== SHT_SYMTAB
)
9508 error (_("Multiple symbol tables encountered\n"));
9514 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9515 &aux
.strtab
, &aux
.strtab_size
))
9518 else if (sec
->sh_type
== sec_type
)
9523 printf (_("\nThere are no unwind sections in this file.\n"));
9525 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9527 if (sec
->sh_type
== sec_type
)
9529 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9530 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9531 "contains %lu entry:\n",
9532 "\nUnwind section '%s' at offset 0x%lx "
9533 "contains %lu entries:\n",
9535 printable_section_name (filedata
, sec
),
9536 (unsigned long) sec
->sh_offset
,
9539 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9545 free ((char *) aux
.strtab
);
9551 process_unwind (Filedata
* filedata
)
9553 struct unwind_handler
9555 unsigned int machtype
;
9556 bfd_boolean (* handler
)(Filedata
*);
9559 { EM_ARM
, arm_process_unwind
},
9560 { EM_IA_64
, ia64_process_unwind
},
9561 { EM_PARISC
, hppa_process_unwind
},
9562 { EM_TI_C6000
, arm_process_unwind
},
9570 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9571 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9572 return handlers
[i
].handler (filedata
);
9574 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9575 get_machine_name (filedata
->file_header
.e_machine
));
9580 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9582 switch (entry
->d_tag
)
9584 case DT_AARCH64_BTI_PLT
:
9585 case DT_AARCH64_PAC_PLT
:
9588 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9595 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9597 switch (entry
->d_tag
)
9600 if (entry
->d_un
.d_val
== 0)
9604 static const char * opts
[] =
9606 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9607 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9608 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9609 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9613 bfd_boolean first
= TRUE
;
9615 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9616 if (entry
->d_un
.d_val
& (1 << cnt
))
9618 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9624 case DT_MIPS_IVERSION
:
9625 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9626 printf (_("Interface Version: %s"),
9627 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9631 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9632 /* Note: coded this way so that there is a single string for translation. */
9633 printf (_("<corrupt: %s>"), buf
);
9637 case DT_MIPS_TIME_STAMP
:
9641 time_t atime
= entry
->d_un
.d_val
;
9643 tmp
= gmtime (&atime
);
9644 /* PR 17531: file: 6accc532. */
9646 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9648 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9649 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9650 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9651 printf (_("Time Stamp: %s"), timebuf
);
9655 case DT_MIPS_RLD_VERSION
:
9656 case DT_MIPS_LOCAL_GOTNO
:
9657 case DT_MIPS_CONFLICTNO
:
9658 case DT_MIPS_LIBLISTNO
:
9659 case DT_MIPS_SYMTABNO
:
9660 case DT_MIPS_UNREFEXTNO
:
9661 case DT_MIPS_HIPAGENO
:
9662 case DT_MIPS_DELTA_CLASS_NO
:
9663 case DT_MIPS_DELTA_INSTANCE_NO
:
9664 case DT_MIPS_DELTA_RELOC_NO
:
9665 case DT_MIPS_DELTA_SYM_NO
:
9666 case DT_MIPS_DELTA_CLASSSYM_NO
:
9667 case DT_MIPS_COMPACT_SIZE
:
9668 print_vma (entry
->d_un
.d_val
, DEC
);
9672 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9673 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9674 /* Falls through. */
9677 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9683 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9685 switch (entry
->d_tag
)
9687 case DT_HP_DLD_FLAGS
:
9696 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9697 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9698 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9699 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9700 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9701 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9702 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9703 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9704 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9705 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9706 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9707 { DT_HP_GST
, "HP_GST" },
9708 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9709 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9710 { DT_HP_NODELETE
, "HP_NODELETE" },
9711 { DT_HP_GROUP
, "HP_GROUP" },
9712 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9714 bfd_boolean first
= TRUE
;
9716 bfd_vma val
= entry
->d_un
.d_val
;
9718 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9719 if (val
& flags
[cnt
].bit
)
9723 fputs (flags
[cnt
].str
, stdout
);
9725 val
^= flags
[cnt
].bit
;
9728 if (val
!= 0 || first
)
9732 print_vma (val
, HEX
);
9738 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9746 /* VMS vs Unix time offset and factor. */
9748 #define VMS_EPOCH_OFFSET 35067168000000000LL
9749 #define VMS_GRANULARITY_FACTOR 10000000
9751 /* Display a VMS time in a human readable format. */
9754 print_vms_time (bfd_int64_t vmstime
)
9759 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9760 tm
= gmtime (&unxtime
);
9761 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9762 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9763 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9768 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9770 switch (entry
->d_tag
)
9772 case DT_IA_64_PLT_RESERVE
:
9773 /* First 3 slots reserved. */
9774 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9776 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9779 case DT_IA_64_VMS_LINKTIME
:
9781 print_vms_time (entry
->d_un
.d_val
);
9785 case DT_IA_64_VMS_LNKFLAGS
:
9786 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9787 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9788 printf (" CALL_DEBUG");
9789 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9790 printf (" NOP0BUFS");
9791 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9792 printf (" P0IMAGE");
9793 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9794 printf (" MKTHREADS");
9795 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9796 printf (" UPCALLS");
9797 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9799 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9800 printf (" INITIALIZE");
9801 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9803 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9804 printf (" EXE_INIT");
9805 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9806 printf (" TBK_IN_IMG");
9807 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9808 printf (" DBG_IN_IMG");
9809 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9810 printf (" TBK_IN_DSF");
9811 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9812 printf (" DBG_IN_DSF");
9813 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9814 printf (" SIGNATURES");
9815 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9816 printf (" REL_SEG_OFF");
9820 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9827 get_32bit_dynamic_section (Filedata
* filedata
)
9829 Elf32_External_Dyn
* edyn
;
9830 Elf32_External_Dyn
* ext
;
9831 Elf_Internal_Dyn
* entry
;
9833 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9834 filedata
->dynamic_addr
, 1,
9835 filedata
->dynamic_size
,
9836 _("dynamic section"));
9840 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9841 might not have the luxury of section headers. Look for the DT_NULL
9842 terminator to determine the number of entries. */
9843 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9844 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9847 filedata
->dynamic_nent
++;
9848 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9852 filedata
->dynamic_section
9853 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9854 if (filedata
->dynamic_section
== NULL
)
9856 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9857 (unsigned long) filedata
->dynamic_nent
);
9862 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9863 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9866 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9867 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9876 get_64bit_dynamic_section (Filedata
* filedata
)
9878 Elf64_External_Dyn
* edyn
;
9879 Elf64_External_Dyn
* ext
;
9880 Elf_Internal_Dyn
* entry
;
9882 /* Read in the data. */
9883 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9884 filedata
->dynamic_addr
, 1,
9885 filedata
->dynamic_size
,
9886 _("dynamic section"));
9890 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9891 might not have the luxury of section headers. Look for the DT_NULL
9892 terminator to determine the number of entries. */
9893 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9894 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9895 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9898 filedata
->dynamic_nent
++;
9899 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9903 filedata
->dynamic_section
9904 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9905 if (filedata
->dynamic_section
== NULL
)
9907 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9908 (unsigned long) filedata
->dynamic_nent
);
9913 /* Convert from external to internal formats. */
9914 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9915 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9918 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9919 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9928 print_dynamic_flags (bfd_vma flags
)
9930 bfd_boolean first
= TRUE
;
9936 flag
= flags
& - flags
;
9946 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9947 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9948 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9949 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9950 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9951 default: fputs (_("unknown"), stdout
); break;
9958 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9960 unsigned char * e_data
;
9963 /* If the size_t type is smaller than the bfd_size_type, eg because
9964 you are building a 32-bit tool on a 64-bit host, then make sure
9965 that when (number) is cast to (size_t) no information is lost. */
9966 if (sizeof (size_t) < sizeof (bfd_size_type
)
9967 && (bfd_size_type
) ((size_t) number
) != number
)
9969 error (_("Size truncation prevents reading %s elements of size %u\n"),
9970 bfd_vmatoa ("u", number
), ent_size
);
9974 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9975 attempting to allocate memory when the read is bound to fail. */
9976 if (ent_size
* number
> filedata
->file_size
)
9978 error (_("Invalid number of dynamic entries: %s\n"),
9979 bfd_vmatoa ("u", number
));
9983 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9986 error (_("Out of memory reading %s dynamic entries\n"),
9987 bfd_vmatoa ("u", number
));
9991 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9993 error (_("Unable to read in %s bytes of dynamic data\n"),
9994 bfd_vmatoa ("u", number
* ent_size
));
9999 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10000 if (i_data
== NULL
)
10002 error (_("Out of memory allocating space for %s dynamic entries\n"),
10003 bfd_vmatoa ("u", number
));
10009 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10016 static unsigned long
10017 get_num_dynamic_syms (Filedata
* filedata
)
10019 unsigned long num_of_syms
= 0;
10021 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10022 return num_of_syms
;
10024 if (filedata
->dynamic_info
[DT_HASH
])
10026 unsigned char nb
[8];
10027 unsigned char nc
[8];
10028 unsigned int hash_ent_size
= 4;
10030 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10031 || filedata
->file_header
.e_machine
== EM_S390
10032 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10033 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10036 if (fseek (filedata
->handle
,
10037 (filedata
->archive_file_offset
10038 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10039 sizeof nb
+ sizeof nc
)),
10042 error (_("Unable to seek to start of dynamic information\n"));
10046 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10048 error (_("Failed to read in number of buckets\n"));
10052 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10054 error (_("Failed to read in number of chains\n"));
10058 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10059 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10061 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10063 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10065 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10068 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10069 num_of_syms
= filedata
->nchains
;
10072 if (num_of_syms
== 0)
10074 free (filedata
->buckets
);
10075 filedata
->buckets
= NULL
;
10076 free (filedata
->chains
);
10077 filedata
->chains
= NULL
;
10078 filedata
->nbuckets
= 0;
10082 if (filedata
->dynamic_info_DT_GNU_HASH
)
10084 unsigned char nb
[16];
10085 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10086 bfd_vma buckets_vma
;
10089 if (fseek (filedata
->handle
,
10090 (filedata
->archive_file_offset
10091 + offset_from_vma (filedata
,
10092 filedata
->dynamic_info_DT_GNU_HASH
,
10096 error (_("Unable to seek to start of dynamic information\n"));
10100 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10102 error (_("Failed to read in number of buckets\n"));
10106 filedata
->ngnubuckets
= byte_get (nb
, 4);
10107 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10108 bitmaskwords
= byte_get (nb
+ 8, 4);
10109 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10111 buckets_vma
+= bitmaskwords
* 4;
10113 buckets_vma
+= bitmaskwords
* 8;
10115 if (fseek (filedata
->handle
,
10116 (filedata
->archive_file_offset
10117 + offset_from_vma (filedata
, buckets_vma
, 4)),
10120 error (_("Unable to seek to start of dynamic information\n"));
10124 filedata
->gnubuckets
10125 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10127 if (filedata
->gnubuckets
== NULL
)
10130 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10131 if (filedata
->gnubuckets
[i
] != 0)
10133 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10136 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10137 maxchain
= filedata
->gnubuckets
[i
];
10140 if (maxchain
== 0xffffffff)
10143 maxchain
-= filedata
->gnusymidx
;
10145 if (fseek (filedata
->handle
,
10146 (filedata
->archive_file_offset
10147 + offset_from_vma (filedata
,
10148 buckets_vma
+ 4 * (filedata
->ngnubuckets
10153 error (_("Unable to seek to start of dynamic information\n"));
10159 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10161 error (_("Failed to determine last chain length\n"));
10165 if (maxchain
+ 1 == 0)
10170 while ((byte_get (nb
, 4) & 1) == 0);
10172 if (fseek (filedata
->handle
,
10173 (filedata
->archive_file_offset
10174 + offset_from_vma (filedata
, (buckets_vma
10175 + 4 * filedata
->ngnubuckets
),
10179 error (_("Unable to seek to start of dynamic information\n"));
10183 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10184 filedata
->ngnuchains
= maxchain
;
10186 if (filedata
->gnuchains
== NULL
)
10189 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10191 if (fseek (filedata
->handle
,
10192 (filedata
->archive_file_offset
10193 + offset_from_vma (filedata
, (buckets_vma
10194 + 4 * (filedata
->ngnubuckets
10198 error (_("Unable to seek to start of dynamic information\n"));
10202 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10203 if (filedata
->mipsxlat
== NULL
)
10207 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10208 if (filedata
->gnubuckets
[hn
] != 0)
10210 bfd_vma si
= filedata
->gnubuckets
[hn
];
10211 bfd_vma off
= si
- filedata
->gnusymidx
;
10215 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10217 if (off
< filedata
->ngnuchains
10218 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10219 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10223 if (si
>= num_of_syms
)
10224 num_of_syms
= si
+ 1;
10228 while (off
< filedata
->ngnuchains
10229 && (filedata
->gnuchains
[off
++] & 1) == 0);
10232 if (num_of_syms
== 0)
10235 free (filedata
->mipsxlat
);
10236 filedata
->mipsxlat
= NULL
;
10237 free (filedata
->gnuchains
);
10238 filedata
->gnuchains
= NULL
;
10239 free (filedata
->gnubuckets
);
10240 filedata
->gnubuckets
= NULL
;
10241 filedata
->ngnubuckets
= 0;
10242 filedata
->ngnuchains
= 0;
10246 return num_of_syms
;
10249 /* Parse and display the contents of the dynamic section. */
10252 process_dynamic_section (Filedata
* filedata
)
10254 Elf_Internal_Dyn
* entry
;
10256 if (filedata
->dynamic_size
== 0)
10259 printf (_("\nThere is no dynamic section in this file.\n"));
10266 if (! get_32bit_dynamic_section (filedata
))
10271 if (! get_64bit_dynamic_section (filedata
))
10275 /* Find the appropriate symbol table. */
10276 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10278 unsigned long num_of_syms
;
10280 for (entry
= filedata
->dynamic_section
;
10281 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10283 if (entry
->d_tag
== DT_SYMTAB
)
10284 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10285 else if (entry
->d_tag
== DT_SYMENT
)
10286 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10287 else if (entry
->d_tag
== DT_HASH
)
10288 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10289 else if (entry
->d_tag
== DT_GNU_HASH
)
10290 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10291 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10292 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10293 && entry
->d_tag
== DT_MIPS_XHASH
)
10295 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10296 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10299 num_of_syms
= get_num_dynamic_syms (filedata
);
10301 if (num_of_syms
!= 0
10302 && filedata
->dynamic_symbols
== NULL
10303 && filedata
->dynamic_info
[DT_SYMTAB
]
10304 && filedata
->dynamic_info
[DT_SYMENT
])
10306 Elf_Internal_Phdr
*seg
;
10307 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10309 if (! get_program_headers (filedata
))
10311 error (_("Cannot interpret virtual addresses "
10312 "without program headers.\n"));
10316 for (seg
= filedata
->program_headers
;
10317 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10320 if (seg
->p_type
!= PT_LOAD
)
10323 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10325 /* See PR 21379 for a reproducer. */
10326 error (_("Invalid PT_LOAD entry\n"));
10330 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10331 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10333 /* Since we do not know how big the symbol table is,
10334 we default to reading in up to the end of PT_LOAD
10335 segment and processing that. This is overkill, I
10336 know, but it should work. */
10337 Elf_Internal_Shdr section
;
10338 section
.sh_offset
= (vma
- seg
->p_vaddr
10340 section
.sh_size
= (num_of_syms
10341 * filedata
->dynamic_info
[DT_SYMENT
]);
10342 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10345 && filedata
->dynamic_symtab_section
!= NULL
10346 && ((filedata
->dynamic_symtab_section
->sh_offset
10347 != section
.sh_offset
)
10348 || (filedata
->dynamic_symtab_section
->sh_size
10349 != section
.sh_size
)
10350 || (filedata
->dynamic_symtab_section
->sh_entsize
10351 != section
.sh_entsize
)))
10353 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10355 section
.sh_name
= filedata
->string_table_length
;
10356 filedata
->dynamic_symbols
10357 = GET_ELF_SYMBOLS (filedata
, §ion
,
10358 &filedata
->num_dynamic_syms
);
10359 if (filedata
->dynamic_symbols
== NULL
10360 || filedata
->num_dynamic_syms
!= num_of_syms
)
10362 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10371 /* Similarly find a string table. */
10372 if (filedata
->dynamic_strings
== NULL
)
10373 for (entry
= filedata
->dynamic_section
;
10374 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10377 if (entry
->d_tag
== DT_STRTAB
)
10378 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10380 if (entry
->d_tag
== DT_STRSZ
)
10381 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10383 if (filedata
->dynamic_info
[DT_STRTAB
]
10384 && filedata
->dynamic_info
[DT_STRSZ
])
10386 unsigned long offset
;
10387 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10389 offset
= offset_from_vma (filedata
,
10390 filedata
->dynamic_info
[DT_STRTAB
],
10393 && filedata
->dynamic_strtab_section
10394 && ((filedata
->dynamic_strtab_section
->sh_offset
10395 != (file_ptr
) offset
)
10396 || (filedata
->dynamic_strtab_section
->sh_size
10399 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10401 filedata
->dynamic_strings
10402 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10403 _("dynamic string table"));
10404 if (filedata
->dynamic_strings
== NULL
)
10406 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10410 filedata
->dynamic_strings_length
= str_tab_len
;
10415 /* And find the syminfo section if available. */
10416 if (filedata
->dynamic_syminfo
== NULL
)
10418 unsigned long syminsz
= 0;
10420 for (entry
= filedata
->dynamic_section
;
10421 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10424 if (entry
->d_tag
== DT_SYMINENT
)
10426 /* Note: these braces are necessary to avoid a syntax
10427 error from the SunOS4 C compiler. */
10428 /* PR binutils/17531: A corrupt file can trigger this test.
10429 So do not use an assert, instead generate an error message. */
10430 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10431 error (_("Bad value (%d) for SYMINENT entry\n"),
10432 (int) entry
->d_un
.d_val
);
10434 else if (entry
->d_tag
== DT_SYMINSZ
)
10435 syminsz
= entry
->d_un
.d_val
;
10436 else if (entry
->d_tag
== DT_SYMINFO
)
10437 filedata
->dynamic_syminfo_offset
10438 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10441 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10443 Elf_External_Syminfo
* extsyminfo
;
10444 Elf_External_Syminfo
* extsym
;
10445 Elf_Internal_Syminfo
* syminfo
;
10447 /* There is a syminfo section. Read the data. */
10448 extsyminfo
= (Elf_External_Syminfo
*)
10449 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10450 1, syminsz
, _("symbol information"));
10454 if (filedata
->dynamic_syminfo
!= NULL
)
10456 error (_("Multiple dynamic symbol information sections found\n"));
10457 free (filedata
->dynamic_syminfo
);
10459 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10460 if (filedata
->dynamic_syminfo
== NULL
)
10462 error (_("Out of memory allocating %lu bytes "
10463 "for dynamic symbol info\n"),
10464 (unsigned long) syminsz
);
10468 filedata
->dynamic_syminfo_nent
10469 = syminsz
/ sizeof (Elf_External_Syminfo
);
10470 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10471 syminfo
< (filedata
->dynamic_syminfo
10472 + filedata
->dynamic_syminfo_nent
);
10473 ++syminfo
, ++extsym
)
10475 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10476 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10483 if (do_dynamic
&& filedata
->dynamic_addr
)
10484 printf (ngettext ("\nDynamic section at offset 0x%lx "
10485 "contains %lu entry:\n",
10486 "\nDynamic section at offset 0x%lx "
10487 "contains %lu entries:\n",
10488 filedata
->dynamic_nent
),
10489 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10491 printf (_(" Tag Type Name/Value\n"));
10493 for (entry
= filedata
->dynamic_section
;
10494 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10499 const char * dtype
;
10502 print_vma (entry
->d_tag
, FULL_HEX
);
10503 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10504 printf (" (%s)%*s", dtype
,
10505 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10508 switch (entry
->d_tag
)
10512 print_dynamic_flags (entry
->d_un
.d_val
);
10522 switch (entry
->d_tag
)
10525 printf (_("Auxiliary library"));
10529 printf (_("Filter library"));
10533 printf (_("Configuration file"));
10537 printf (_("Dependency audit library"));
10541 printf (_("Audit library"));
10545 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10546 printf (": [%s]\n",
10547 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10551 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10560 printf (_("Flags:"));
10562 if (entry
->d_un
.d_val
== 0)
10563 printf (_(" None\n"));
10566 unsigned long int val
= entry
->d_un
.d_val
;
10568 if (val
& DTF_1_PARINIT
)
10570 printf (" PARINIT");
10571 val
^= DTF_1_PARINIT
;
10573 if (val
& DTF_1_CONFEXP
)
10575 printf (" CONFEXP");
10576 val
^= DTF_1_CONFEXP
;
10579 printf (" %lx", val
);
10588 printf (_("Flags:"));
10590 if (entry
->d_un
.d_val
== 0)
10591 printf (_(" None\n"));
10594 unsigned long int val
= entry
->d_un
.d_val
;
10596 if (val
& DF_P1_LAZYLOAD
)
10598 printf (" LAZYLOAD");
10599 val
^= DF_P1_LAZYLOAD
;
10601 if (val
& DF_P1_GROUPPERM
)
10603 printf (" GROUPPERM");
10604 val
^= DF_P1_GROUPPERM
;
10607 printf (" %lx", val
);
10616 printf (_("Flags:"));
10617 if (entry
->d_un
.d_val
== 0)
10618 printf (_(" None\n"));
10621 unsigned long int val
= entry
->d_un
.d_val
;
10623 if (val
& DF_1_NOW
)
10628 if (val
& DF_1_GLOBAL
)
10630 printf (" GLOBAL");
10631 val
^= DF_1_GLOBAL
;
10633 if (val
& DF_1_GROUP
)
10638 if (val
& DF_1_NODELETE
)
10640 printf (" NODELETE");
10641 val
^= DF_1_NODELETE
;
10643 if (val
& DF_1_LOADFLTR
)
10645 printf (" LOADFLTR");
10646 val
^= DF_1_LOADFLTR
;
10648 if (val
& DF_1_INITFIRST
)
10650 printf (" INITFIRST");
10651 val
^= DF_1_INITFIRST
;
10653 if (val
& DF_1_NOOPEN
)
10655 printf (" NOOPEN");
10656 val
^= DF_1_NOOPEN
;
10658 if (val
& DF_1_ORIGIN
)
10660 printf (" ORIGIN");
10661 val
^= DF_1_ORIGIN
;
10663 if (val
& DF_1_DIRECT
)
10665 printf (" DIRECT");
10666 val
^= DF_1_DIRECT
;
10668 if (val
& DF_1_TRANS
)
10673 if (val
& DF_1_INTERPOSE
)
10675 printf (" INTERPOSE");
10676 val
^= DF_1_INTERPOSE
;
10678 if (val
& DF_1_NODEFLIB
)
10680 printf (" NODEFLIB");
10681 val
^= DF_1_NODEFLIB
;
10683 if (val
& DF_1_NODUMP
)
10685 printf (" NODUMP");
10686 val
^= DF_1_NODUMP
;
10688 if (val
& DF_1_CONFALT
)
10690 printf (" CONFALT");
10691 val
^= DF_1_CONFALT
;
10693 if (val
& DF_1_ENDFILTEE
)
10695 printf (" ENDFILTEE");
10696 val
^= DF_1_ENDFILTEE
;
10698 if (val
& DF_1_DISPRELDNE
)
10700 printf (" DISPRELDNE");
10701 val
^= DF_1_DISPRELDNE
;
10703 if (val
& DF_1_DISPRELPND
)
10705 printf (" DISPRELPND");
10706 val
^= DF_1_DISPRELPND
;
10708 if (val
& DF_1_NODIRECT
)
10710 printf (" NODIRECT");
10711 val
^= DF_1_NODIRECT
;
10713 if (val
& DF_1_IGNMULDEF
)
10715 printf (" IGNMULDEF");
10716 val
^= DF_1_IGNMULDEF
;
10718 if (val
& DF_1_NOKSYMS
)
10720 printf (" NOKSYMS");
10721 val
^= DF_1_NOKSYMS
;
10723 if (val
& DF_1_NOHDR
)
10728 if (val
& DF_1_EDITED
)
10730 printf (" EDITED");
10731 val
^= DF_1_EDITED
;
10733 if (val
& DF_1_NORELOC
)
10735 printf (" NORELOC");
10736 val
^= DF_1_NORELOC
;
10738 if (val
& DF_1_SYMINTPOSE
)
10740 printf (" SYMINTPOSE");
10741 val
^= DF_1_SYMINTPOSE
;
10743 if (val
& DF_1_GLOBAUDIT
)
10745 printf (" GLOBAUDIT");
10746 val
^= DF_1_GLOBAUDIT
;
10748 if (val
& DF_1_SINGLETON
)
10750 printf (" SINGLETON");
10751 val
^= DF_1_SINGLETON
;
10753 if (val
& DF_1_STUB
)
10758 if (val
& DF_1_PIE
)
10763 if (val
& DF_1_KMOD
)
10768 if (val
& DF_1_WEAKFILTER
)
10770 printf (" WEAKFILTER");
10771 val
^= DF_1_WEAKFILTER
;
10773 if (val
& DF_1_NOCOMMON
)
10775 printf (" NOCOMMON");
10776 val
^= DF_1_NOCOMMON
;
10779 printf (" %lx", val
);
10786 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10788 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10808 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10814 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10815 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10821 switch (entry
->d_tag
)
10824 printf (_("Shared library: [%s]"), name
);
10826 if (streq (name
, filedata
->program_interpreter
))
10827 printf (_(" program interpreter"));
10831 printf (_("Library soname: [%s]"), name
);
10835 printf (_("Library rpath: [%s]"), name
);
10839 printf (_("Library runpath: [%s]"), name
);
10843 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10848 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10861 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10862 /* Fall through. */
10866 case DT_INIT_ARRAYSZ
:
10867 case DT_FINI_ARRAYSZ
:
10868 case DT_GNU_CONFLICTSZ
:
10869 case DT_GNU_LIBLISTSZ
:
10872 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10873 printf (_(" (bytes)\n"));
10878 case DT_VERNEEDNUM
:
10883 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10892 case DT_INIT_ARRAY
:
10893 case DT_FINI_ARRAY
:
10896 if (entry
->d_tag
== DT_USED
10897 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10899 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10903 printf (_("Not needed object: [%s]\n"), name
);
10908 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10914 /* The value of this entry is ignored. */
10919 case DT_GNU_PRELINKED
:
10923 time_t atime
= entry
->d_un
.d_val
;
10925 tmp
= gmtime (&atime
);
10926 /* PR 17533 file: 041-1244816-0.004. */
10928 printf (_("<corrupt time val: %lx"),
10929 (unsigned long) atime
);
10931 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10932 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10933 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10939 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10942 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10948 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10949 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10950 = entry
->d_un
.d_val
;
10954 switch (filedata
->file_header
.e_machine
)
10957 dynamic_section_aarch64_val (entry
);
10960 case EM_MIPS_RS3_LE
:
10961 dynamic_section_mips_val (filedata
, entry
);
10964 dynamic_section_parisc_val (entry
);
10967 dynamic_section_ia64_val (entry
);
10970 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10982 get_ver_flags (unsigned int flags
)
10984 static char buff
[128];
10991 if (flags
& VER_FLG_BASE
)
10992 strcat (buff
, "BASE");
10994 if (flags
& VER_FLG_WEAK
)
10996 if (flags
& VER_FLG_BASE
)
10997 strcat (buff
, " | ");
10999 strcat (buff
, "WEAK");
11002 if (flags
& VER_FLG_INFO
)
11004 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11005 strcat (buff
, " | ");
11007 strcat (buff
, "INFO");
11010 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11012 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11013 strcat (buff
, " | ");
11015 strcat (buff
, _("<unknown>"));
11021 /* Display the contents of the version sections. */
11024 process_version_sections (Filedata
* filedata
)
11026 Elf_Internal_Shdr
* section
;
11028 bfd_boolean found
= FALSE
;
11033 for (i
= 0, section
= filedata
->section_headers
;
11034 i
< filedata
->file_header
.e_shnum
;
11037 switch (section
->sh_type
)
11039 case SHT_GNU_verdef
:
11041 Elf_External_Verdef
* edefs
;
11048 printf (ngettext ("\nVersion definition section '%s' "
11049 "contains %u entry:\n",
11050 "\nVersion definition section '%s' "
11051 "contains %u entries:\n",
11053 printable_section_name (filedata
, section
),
11056 printf (_(" Addr: 0x"));
11057 printf_vma (section
->sh_addr
);
11058 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11059 (unsigned long) section
->sh_offset
, section
->sh_link
,
11060 printable_section_name_from_index (filedata
, section
->sh_link
));
11062 edefs
= (Elf_External_Verdef
*)
11063 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11064 _("version definition section"));
11067 endbuf
= (char *) edefs
+ section
->sh_size
;
11069 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11072 Elf_External_Verdef
* edef
;
11073 Elf_Internal_Verdef ent
;
11074 Elf_External_Verdaux
* eaux
;
11075 Elf_Internal_Verdaux aux
;
11076 unsigned long isum
;
11079 vstart
= ((char *) edefs
) + idx
;
11080 if (vstart
+ sizeof (*edef
) > endbuf
)
11083 edef
= (Elf_External_Verdef
*) vstart
;
11085 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11086 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11087 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11088 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11089 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11090 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11091 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11093 printf (_(" %#06lx: Rev: %d Flags: %s"),
11094 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11096 printf (_(" Index: %d Cnt: %d "),
11097 ent
.vd_ndx
, ent
.vd_cnt
);
11099 /* Check for overflow. */
11100 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11103 vstart
+= ent
.vd_aux
;
11105 if (vstart
+ sizeof (*eaux
) > endbuf
)
11107 eaux
= (Elf_External_Verdaux
*) vstart
;
11109 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11110 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11112 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11113 printf (_("Name: %s\n"),
11114 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11116 printf (_("Name index: %ld\n"), aux
.vda_name
);
11118 isum
= idx
+ ent
.vd_aux
;
11120 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11122 if (aux
.vda_next
< sizeof (*eaux
)
11123 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11125 warn (_("Invalid vda_next field of %lx\n"),
11130 /* Check for overflow. */
11131 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11134 isum
+= aux
.vda_next
;
11135 vstart
+= aux
.vda_next
;
11137 if (vstart
+ sizeof (*eaux
) > endbuf
)
11139 eaux
= (Elf_External_Verdaux
*) vstart
;
11141 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11142 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11144 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11145 printf (_(" %#06lx: Parent %d: %s\n"),
11147 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11149 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11150 isum
, j
, aux
.vda_name
);
11153 if (j
< ent
.vd_cnt
)
11154 printf (_(" Version def aux past end of section\n"));
11157 file: id:000001,src:000172+005151,op:splice,rep:2. */
11158 if (ent
.vd_next
< sizeof (*edef
)
11159 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11161 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11162 cnt
= section
->sh_info
;
11165 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11168 idx
+= ent
.vd_next
;
11171 if (cnt
< section
->sh_info
)
11172 printf (_(" Version definition past end of section\n"));
11178 case SHT_GNU_verneed
:
11180 Elf_External_Verneed
* eneed
;
11187 printf (ngettext ("\nVersion needs section '%s' "
11188 "contains %u entry:\n",
11189 "\nVersion needs section '%s' "
11190 "contains %u entries:\n",
11192 printable_section_name (filedata
, section
), section
->sh_info
);
11194 printf (_(" Addr: 0x"));
11195 printf_vma (section
->sh_addr
);
11196 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11197 (unsigned long) section
->sh_offset
, section
->sh_link
,
11198 printable_section_name_from_index (filedata
, section
->sh_link
));
11200 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11201 section
->sh_offset
, 1,
11203 _("Version Needs section"));
11206 endbuf
= (char *) eneed
+ section
->sh_size
;
11208 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11210 Elf_External_Verneed
* entry
;
11211 Elf_Internal_Verneed ent
;
11212 unsigned long isum
;
11216 vstart
= ((char *) eneed
) + idx
;
11217 if (vstart
+ sizeof (*entry
) > endbuf
)
11220 entry
= (Elf_External_Verneed
*) vstart
;
11222 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11223 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11224 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11225 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11226 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11228 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11230 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11231 printf (_(" File: %s"),
11232 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11234 printf (_(" File: %lx"), ent
.vn_file
);
11236 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11238 /* Check for overflow. */
11239 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11241 vstart
+= ent
.vn_aux
;
11243 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11245 Elf_External_Vernaux
* eaux
;
11246 Elf_Internal_Vernaux aux
;
11248 if (vstart
+ sizeof (*eaux
) > endbuf
)
11250 eaux
= (Elf_External_Vernaux
*) vstart
;
11252 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11253 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11254 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11255 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11256 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11258 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11259 printf (_(" %#06lx: Name: %s"),
11260 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11262 printf (_(" %#06lx: Name index: %lx"),
11263 isum
, aux
.vna_name
);
11265 printf (_(" Flags: %s Version: %d\n"),
11266 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11268 if (aux
.vna_next
< sizeof (*eaux
)
11269 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11271 warn (_("Invalid vna_next field of %lx\n"),
11276 /* Check for overflow. */
11277 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11279 isum
+= aux
.vna_next
;
11280 vstart
+= aux
.vna_next
;
11283 if (j
< ent
.vn_cnt
)
11284 warn (_("Missing Version Needs auxillary information\n"));
11286 if (ent
.vn_next
< sizeof (*entry
)
11287 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11289 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11290 cnt
= section
->sh_info
;
11293 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11295 idx
+= ent
.vn_next
;
11298 if (cnt
< section
->sh_info
)
11299 warn (_("Missing Version Needs information\n"));
11305 case SHT_GNU_versym
:
11307 Elf_Internal_Shdr
* link_section
;
11310 unsigned char * edata
;
11311 unsigned short * data
;
11313 Elf_Internal_Sym
* symbols
;
11314 Elf_Internal_Shdr
* string_sec
;
11315 unsigned long num_syms
;
11318 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11321 link_section
= filedata
->section_headers
+ section
->sh_link
;
11322 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11324 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11329 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11330 if (symbols
== NULL
)
11333 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11335 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11336 string_sec
->sh_size
,
11337 _("version string table"));
11344 printf (ngettext ("\nVersion symbols section '%s' "
11345 "contains %lu entry:\n",
11346 "\nVersion symbols section '%s' "
11347 "contains %lu entries:\n",
11349 printable_section_name (filedata
, section
), (unsigned long) total
);
11351 printf (_(" Addr: 0x"));
11352 printf_vma (section
->sh_addr
);
11353 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11354 (unsigned long) section
->sh_offset
, section
->sh_link
,
11355 printable_section_name (filedata
, link_section
));
11357 off
= offset_from_vma (filedata
,
11358 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11359 total
* sizeof (short));
11360 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11361 sizeof (short), total
,
11362 _("version symbol data"));
11370 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11372 for (cnt
= total
; cnt
--;)
11373 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11378 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11382 char *invalid
= _("*invalid*");
11384 printf (" %03x:", cnt
);
11386 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11387 switch (data
[cnt
+ j
])
11390 fputs (_(" 0 (*local*) "), stdout
);
11394 fputs (_(" 1 (*global*) "), stdout
);
11398 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11399 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11401 /* If this index value is greater than the size of the symbols
11402 array, break to avoid an out-of-bounds read. */
11403 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11405 warn (_("invalid index into symbol array\n"));
11410 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11412 Elf_Internal_Verneed ivn
;
11413 unsigned long offset
;
11415 offset
= offset_from_vma
11417 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11418 sizeof (Elf_External_Verneed
));
11422 Elf_Internal_Vernaux ivna
;
11423 Elf_External_Verneed evn
;
11424 Elf_External_Vernaux evna
;
11425 unsigned long a_off
;
11427 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11428 _("version need")) == NULL
)
11431 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11432 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11434 a_off
= offset
+ ivn
.vn_aux
;
11438 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11439 1, _("version need aux (2)")) == NULL
)
11442 ivna
.vna_other
= 0;
11446 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11447 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11450 a_off
+= ivna
.vna_next
;
11452 while (ivna
.vna_other
!= data
[cnt
+ j
]
11453 && ivna
.vna_next
!= 0);
11455 if (ivna
.vna_other
== data
[cnt
+ j
])
11457 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11459 if (ivna
.vna_name
>= string_sec
->sh_size
)
11462 name
= strtab
+ ivna
.vna_name
;
11466 offset
+= ivn
.vn_next
;
11468 while (ivn
.vn_next
);
11471 if (data
[cnt
+ j
] != 0x8001
11472 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11474 Elf_Internal_Verdef ivd
;
11475 Elf_External_Verdef evd
;
11476 unsigned long offset
;
11478 offset
= offset_from_vma
11480 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11485 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11486 _("version def")) == NULL
)
11489 /* PR 17531: file: 046-1082287-0.004. */
11490 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11495 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11496 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11499 offset
+= ivd
.vd_next
;
11501 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11502 && ivd
.vd_next
!= 0);
11504 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11506 Elf_External_Verdaux evda
;
11507 Elf_Internal_Verdaux ivda
;
11509 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11511 if (get_data (&evda
, filedata
,
11512 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11514 _("version def aux")) == NULL
)
11517 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11519 if (ivda
.vda_name
>= string_sec
->sh_size
)
11521 else if (name
!= NULL
&& name
!= invalid
)
11522 name
= _("*both*");
11524 name
= strtab
+ ivda
.vda_name
;
11528 nn
+= printf ("(%s%-*s",
11530 12 - (int) strlen (name
),
11534 printf ("%*c", 18 - nn
, ' ');
11552 printf (_("\nNo version information found in this file.\n"));
11557 static const char *
11558 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11560 static char buff
[64];
11564 case STB_LOCAL
: return "LOCAL";
11565 case STB_GLOBAL
: return "GLOBAL";
11566 case STB_WEAK
: return "WEAK";
11568 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11569 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11571 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11573 if (binding
== STB_GNU_UNIQUE
11574 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11576 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11579 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11584 static const char *
11585 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11587 static char buff
[64];
11591 case STT_NOTYPE
: return "NOTYPE";
11592 case STT_OBJECT
: return "OBJECT";
11593 case STT_FUNC
: return "FUNC";
11594 case STT_SECTION
: return "SECTION";
11595 case STT_FILE
: return "FILE";
11596 case STT_COMMON
: return "COMMON";
11597 case STT_TLS
: return "TLS";
11598 case STT_RELC
: return "RELC";
11599 case STT_SRELC
: return "SRELC";
11601 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11603 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11604 return "THUMB_FUNC";
11606 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11609 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11610 return "PARISC_MILLI";
11612 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11614 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11616 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11618 if (type
== STT_HP_OPAQUE
)
11619 return "HP_OPAQUE";
11620 if (type
== STT_HP_STUB
)
11624 if (type
== STT_GNU_IFUNC
11625 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11626 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11629 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11632 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11637 static const char *
11638 get_symbol_visibility (unsigned int visibility
)
11640 switch (visibility
)
11642 case STV_DEFAULT
: return "DEFAULT";
11643 case STV_INTERNAL
: return "INTERNAL";
11644 case STV_HIDDEN
: return "HIDDEN";
11645 case STV_PROTECTED
: return "PROTECTED";
11647 error (_("Unrecognized visibility value: %u\n"), visibility
);
11648 return _("<unknown>");
11652 static const char *
11653 get_alpha_symbol_other (unsigned int other
)
11657 case STO_ALPHA_NOPV
: return "NOPV";
11658 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11660 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11661 return _("<unknown>");
11665 static const char *
11666 get_solaris_symbol_visibility (unsigned int visibility
)
11668 switch (visibility
)
11670 case 4: return "EXPORTED";
11671 case 5: return "SINGLETON";
11672 case 6: return "ELIMINATE";
11673 default: return get_symbol_visibility (visibility
);
11677 static const char *
11678 get_aarch64_symbol_other (unsigned int other
)
11680 static char buf
[32];
11682 if (other
& STO_AARCH64_VARIANT_PCS
)
11684 other
&= ~STO_AARCH64_VARIANT_PCS
;
11686 return "VARIANT_PCS";
11687 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11693 static const char *
11694 get_mips_symbol_other (unsigned int other
)
11698 case STO_OPTIONAL
: return "OPTIONAL";
11699 case STO_MIPS_PLT
: return "MIPS PLT";
11700 case STO_MIPS_PIC
: return "MIPS PIC";
11701 case STO_MICROMIPS
: return "MICROMIPS";
11702 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11703 case STO_MIPS16
: return "MIPS16";
11704 default: return NULL
;
11708 static const char *
11709 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11711 if (is_ia64_vms (filedata
))
11713 static char res
[32];
11717 /* Function types is for images and .STB files only. */
11718 switch (filedata
->file_header
.e_type
)
11722 switch (VMS_ST_FUNC_TYPE (other
))
11724 case VMS_SFT_CODE_ADDR
:
11725 strcat (res
, " CA");
11727 case VMS_SFT_SYMV_IDX
:
11728 strcat (res
, " VEC");
11731 strcat (res
, " FD");
11733 case VMS_SFT_RESERVE
:
11734 strcat (res
, " RSV");
11737 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11738 VMS_ST_FUNC_TYPE (other
));
11739 strcat (res
, " <unknown>");
11746 switch (VMS_ST_LINKAGE (other
))
11748 case VMS_STL_IGNORE
:
11749 strcat (res
, " IGN");
11751 case VMS_STL_RESERVE
:
11752 strcat (res
, " RSV");
11755 strcat (res
, " STD");
11758 strcat (res
, " LNK");
11761 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11762 VMS_ST_LINKAGE (other
));
11763 strcat (res
, " <unknown>");
11775 static const char *
11776 get_ppc64_symbol_other (unsigned int other
)
11778 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11781 other
>>= STO_PPC64_LOCAL_BIT
;
11784 static char buf
[64];
11786 other
= ppc64_decode_local_entry (other
);
11787 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11793 static const char *
11794 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11796 const char * result
= NULL
;
11797 static char buff
[64];
11802 switch (filedata
->file_header
.e_machine
)
11805 result
= get_alpha_symbol_other (other
);
11808 result
= get_aarch64_symbol_other (other
);
11811 result
= get_mips_symbol_other (other
);
11814 result
= get_ia64_symbol_other (filedata
, other
);
11817 result
= get_ppc64_symbol_other (other
);
11827 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11831 static const char *
11832 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11834 static char buff
[32];
11838 case SHN_UNDEF
: return "UND";
11839 case SHN_ABS
: return "ABS";
11840 case SHN_COMMON
: return "COM";
11842 if (type
== SHN_IA_64_ANSI_COMMON
11843 && filedata
->file_header
.e_machine
== EM_IA_64
11844 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11846 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11847 || filedata
->file_header
.e_machine
== EM_L1OM
11848 || filedata
->file_header
.e_machine
== EM_K1OM
)
11849 && type
== SHN_X86_64_LCOMMON
)
11850 return "LARGE_COM";
11851 else if ((type
== SHN_MIPS_SCOMMON
11852 && filedata
->file_header
.e_machine
== EM_MIPS
)
11853 || (type
== SHN_TIC6X_SCOMMON
11854 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11856 else if (type
== SHN_MIPS_SUNDEFINED
11857 && filedata
->file_header
.e_machine
== EM_MIPS
)
11859 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11860 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11861 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11862 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11863 else if (type
>= SHN_LORESERVE
)
11864 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11865 else if (filedata
->file_header
.e_shnum
!= 0
11866 && type
>= filedata
->file_header
.e_shnum
)
11867 sprintf (buff
, _("bad section index[%3d]"), type
);
11869 sprintf (buff
, "%3d", type
);
11876 static const char *
11877 get_symbol_version_string (Filedata
* filedata
,
11878 bfd_boolean is_dynsym
,
11879 const char * strtab
,
11880 unsigned long int strtab_size
,
11882 Elf_Internal_Sym
* psym
,
11883 enum versioned_symbol_info
* sym_info
,
11884 unsigned short * vna_other
)
11886 unsigned char data
[2];
11887 unsigned short vers_data
;
11888 unsigned long offset
;
11889 unsigned short max_vd_ndx
;
11892 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11895 offset
= offset_from_vma (filedata
,
11896 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11897 sizeof data
+ si
* sizeof (vers_data
));
11899 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11900 sizeof (data
), 1, _("version data")) == NULL
)
11903 vers_data
= byte_get (data
, 2);
11905 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11908 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11911 /* Usually we'd only see verdef for defined symbols, and verneed for
11912 undefined symbols. However, symbols defined by the linker in
11913 .dynbss for variables copied from a shared library in order to
11914 avoid text relocations are defined yet have verneed. We could
11915 use a heuristic to detect the special case, for example, check
11916 for verneed first on symbols defined in SHT_NOBITS sections, but
11917 it is simpler and more reliable to just look for both verdef and
11918 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11920 if (psym
->st_shndx
!= SHN_UNDEF
11921 && vers_data
!= 0x8001
11922 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11924 Elf_Internal_Verdef ivd
;
11925 Elf_Internal_Verdaux ivda
;
11926 Elf_External_Verdaux evda
;
11929 off
= offset_from_vma (filedata
,
11930 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11931 sizeof (Elf_External_Verdef
));
11935 Elf_External_Verdef evd
;
11937 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11938 _("version def")) == NULL
)
11947 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11948 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11949 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11950 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11953 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11954 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11956 off
+= ivd
.vd_next
;
11958 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11960 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11962 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11965 off
-= ivd
.vd_next
;
11968 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11969 _("version def aux")) != NULL
)
11971 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11973 if (psym
->st_name
!= ivda
.vda_name
)
11974 return (ivda
.vda_name
< strtab_size
11975 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11980 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11982 Elf_External_Verneed evn
;
11983 Elf_Internal_Verneed ivn
;
11984 Elf_Internal_Vernaux ivna
;
11986 offset
= offset_from_vma (filedata
,
11987 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11991 unsigned long vna_off
;
11993 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11994 _("version need")) == NULL
)
11997 ivna
.vna_other
= 0;
12002 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12003 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12005 vna_off
= offset
+ ivn
.vn_aux
;
12009 Elf_External_Vernaux evna
;
12011 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12012 _("version need aux (3)")) == NULL
)
12015 ivna
.vna_other
= 0;
12020 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12021 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12022 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12025 vna_off
+= ivna
.vna_next
;
12027 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12029 if (ivna
.vna_other
== vers_data
)
12032 offset
+= ivn
.vn_next
;
12034 while (ivn
.vn_next
!= 0);
12036 if (ivna
.vna_other
== vers_data
)
12038 *sym_info
= symbol_undefined
;
12039 *vna_other
= ivna
.vna_other
;
12040 return (ivna
.vna_name
< strtab_size
12041 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12043 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12044 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12045 return _("<corrupt>");
12051 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12052 Elf_Internal_Sym
*symtab
,
12053 Elf_Internal_Shdr
*section
,
12054 char *strtab
, size_t strtab_size
)
12056 const char *version_string
;
12057 enum versioned_symbol_info sym_info
;
12058 unsigned short vna_other
;
12059 Elf_Internal_Sym
*psym
= symtab
+ si
;
12061 printf ("%6ld: ", si
);
12062 print_vma (psym
->st_value
, LONG_HEX
);
12064 print_vma (psym
->st_size
, DEC_5
);
12065 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12066 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12067 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12068 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12071 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12073 printf (" %-7s", get_symbol_visibility (vis
));
12074 /* Check to see if any other bits in the st_other field are set.
12075 Note - displaying this information disrupts the layout of the
12076 table being generated, but for the moment this case is very rare. */
12077 if (psym
->st_other
^ vis
)
12078 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12080 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12082 bfd_boolean is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
,
12084 const char * sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12087 = get_symbol_version_string (filedata
,
12089 || section
->sh_type
== SHT_DYNSYM
),
12090 strtab
, strtab_size
, si
,
12091 psym
, &sym_info
, &vna_other
);
12093 int len_avail
= 21;
12094 if (! do_wide
&& version_string
!= NULL
)
12098 len_avail
-= 1 + strlen (version_string
);
12100 if (sym_info
== symbol_undefined
)
12101 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12102 else if (sym_info
!= symbol_hidden
)
12106 print_symbol (len_avail
, sstr
);
12108 if (version_string
)
12110 if (sym_info
== symbol_undefined
)
12111 printf ("@%s (%d)", version_string
, vna_other
);
12113 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12119 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12121 && si
>= section
->sh_info
12122 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12123 && filedata
->file_header
.e_machine
!= EM_MIPS
12124 /* Solaris binaries have been found to violate this requirement as
12125 well. Not sure if this is a bug or an ABI requirement. */
12126 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12127 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12128 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12131 /* Dump the symbol table. */
12133 process_symbol_table (Filedata
* filedata
)
12135 Elf_Internal_Shdr
* section
;
12137 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12140 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12142 && do_using_dynamic
12143 && filedata
->dynamic_strings
!= NULL
12144 && filedata
->dynamic_symbols
!= NULL
)
12148 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12149 "\nSymbol table for image contains %lu entries:\n",
12150 filedata
->num_dynamic_syms
),
12151 filedata
->num_dynamic_syms
);
12153 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12155 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12157 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12158 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12159 filedata
->dynamic_strings
,
12160 filedata
->dynamic_strings_length
);
12162 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12163 && filedata
->section_headers
!= NULL
)
12167 for (i
= 0, section
= filedata
->section_headers
;
12168 i
< filedata
->file_header
.e_shnum
;
12171 char * strtab
= NULL
;
12172 unsigned long int strtab_size
= 0;
12173 Elf_Internal_Sym
* symtab
;
12174 unsigned long si
, num_syms
;
12176 if ((section
->sh_type
!= SHT_SYMTAB
12177 && section
->sh_type
!= SHT_DYNSYM
)
12179 && section
->sh_type
== SHT_SYMTAB
))
12182 if (section
->sh_entsize
== 0)
12184 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12185 printable_section_name (filedata
, section
));
12189 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12190 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12191 "\nSymbol table '%s' contains %lu entries:\n",
12193 printable_section_name (filedata
, section
),
12197 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12199 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12201 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12202 if (symtab
== NULL
)
12205 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12207 strtab
= filedata
->string_table
;
12208 strtab_size
= filedata
->string_table_length
;
12210 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12212 Elf_Internal_Shdr
* string_sec
;
12214 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12216 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12217 1, string_sec
->sh_size
,
12218 _("string table"));
12219 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12222 for (si
= 0; si
< num_syms
; si
++)
12223 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12224 strtab
, strtab_size
);
12227 if (strtab
!= filedata
->string_table
)
12233 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12235 if (do_histogram
&& filedata
->buckets
!= NULL
)
12237 unsigned long * lengths
;
12238 unsigned long * counts
;
12241 unsigned long maxlength
= 0;
12242 unsigned long nzero_counts
= 0;
12243 unsigned long nsyms
= 0;
12246 printf (ngettext ("\nHistogram for bucket list length "
12247 "(total of %lu bucket):\n",
12248 "\nHistogram for bucket list length "
12249 "(total of %lu buckets):\n",
12250 (unsigned long) filedata
->nbuckets
),
12251 (unsigned long) filedata
->nbuckets
);
12253 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12254 sizeof (*lengths
));
12255 if (lengths
== NULL
)
12257 error (_("Out of memory allocating space for histogram buckets\n"));
12260 visited
= xcmalloc (filedata
->nchains
, 1);
12261 memset (visited
, 0, filedata
->nchains
);
12263 printf (_(" Length Number %% of total Coverage\n"));
12264 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12266 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12269 if (maxlength
< ++lengths
[hn
])
12271 if (si
>= filedata
->nchains
|| visited
[si
])
12273 error (_("histogram chain is corrupt\n"));
12281 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12282 if (counts
== NULL
)
12285 error (_("Out of memory allocating space for histogram counts\n"));
12289 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12290 ++counts
[lengths
[hn
]];
12292 if (filedata
->nbuckets
> 0)
12295 printf (" 0 %-10lu (%5.1f%%)\n",
12296 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12297 for (i
= 1; i
<= maxlength
; ++i
)
12299 nzero_counts
+= counts
[i
] * i
;
12300 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12301 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12302 (nzero_counts
* 100.0) / nsyms
);
12310 free (filedata
->buckets
);
12311 filedata
->buckets
= NULL
;
12312 filedata
->nbuckets
= 0;
12313 free (filedata
->chains
);
12314 filedata
->chains
= NULL
;
12316 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12318 unsigned long * lengths
;
12319 unsigned long * counts
;
12321 unsigned long maxlength
= 0;
12322 unsigned long nzero_counts
= 0;
12323 unsigned long nsyms
= 0;
12325 printf (ngettext ("\nHistogram for `%s' bucket list length "
12326 "(total of %lu bucket):\n",
12327 "\nHistogram for `%s' bucket list length "
12328 "(total of %lu buckets):\n",
12329 (unsigned long) filedata
->ngnubuckets
),
12330 GNU_HASH_SECTION_NAME (filedata
),
12331 (unsigned long) filedata
->ngnubuckets
);
12333 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12334 sizeof (*lengths
));
12335 if (lengths
== NULL
)
12337 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12341 printf (_(" Length Number %% of total Coverage\n"));
12343 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12344 if (filedata
->gnubuckets
[hn
] != 0)
12346 bfd_vma off
, length
= 1;
12348 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12349 /* PR 17531 file: 010-77222-0.004. */
12350 off
< filedata
->ngnuchains
12351 && (filedata
->gnuchains
[off
] & 1) == 0;
12354 lengths
[hn
] = length
;
12355 if (length
> maxlength
)
12356 maxlength
= length
;
12360 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12361 if (counts
== NULL
)
12364 error (_("Out of memory allocating space for gnu histogram counts\n"));
12368 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12369 ++counts
[lengths
[hn
]];
12371 if (filedata
->ngnubuckets
> 0)
12374 printf (" 0 %-10lu (%5.1f%%)\n",
12375 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12376 for (j
= 1; j
<= maxlength
; ++j
)
12378 nzero_counts
+= counts
[j
] * j
;
12379 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12380 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12381 (nzero_counts
* 100.0) / nsyms
);
12388 free (filedata
->gnubuckets
);
12389 filedata
->gnubuckets
= NULL
;
12390 filedata
->ngnubuckets
= 0;
12391 free (filedata
->gnuchains
);
12392 filedata
->gnuchains
= NULL
;
12393 filedata
->ngnuchains
= 0;
12394 free (filedata
->mipsxlat
);
12395 filedata
->mipsxlat
= NULL
;
12399 free (filedata
->gnubuckets
);
12400 filedata
->gnubuckets
= NULL
;
12401 filedata
->ngnubuckets
= 0;
12402 free (filedata
->gnuchains
);
12403 filedata
->gnuchains
= NULL
;
12404 filedata
->ngnuchains
= 0;
12405 free (filedata
->mipsxlat
);
12406 filedata
->mipsxlat
= NULL
;
12407 free (filedata
->buckets
);
12408 filedata
->buckets
= NULL
;
12409 filedata
->nbuckets
= 0;
12410 free (filedata
->chains
);
12411 filedata
->chains
= NULL
;
12416 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12420 if (filedata
->dynamic_syminfo
== NULL
12422 /* No syminfo, this is ok. */
12425 /* There better should be a dynamic symbol section. */
12426 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12429 if (filedata
->dynamic_addr
)
12430 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12431 "contains %d entry:\n",
12432 "\nDynamic info segment at offset 0x%lx "
12433 "contains %d entries:\n",
12434 filedata
->dynamic_syminfo_nent
),
12435 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12437 printf (_(" Num: Name BoundTo Flags\n"));
12438 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12440 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12442 printf ("%4d: ", i
);
12443 if (i
>= filedata
->num_dynamic_syms
)
12444 printf (_("<corrupt index>"));
12445 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12446 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12447 filedata
->dynamic_symbols
[i
].st_name
));
12449 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12452 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12454 case SYMINFO_BT_SELF
:
12455 fputs ("SELF ", stdout
);
12457 case SYMINFO_BT_PARENT
:
12458 fputs ("PARENT ", stdout
);
12461 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12462 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12463 && VALID_DYNAMIC_NAME (filedata
,
12464 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12466 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12467 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12471 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12475 if (flags
& SYMINFO_FLG_DIRECT
)
12476 printf (" DIRECT");
12477 if (flags
& SYMINFO_FLG_PASSTHRU
)
12478 printf (" PASSTHRU");
12479 if (flags
& SYMINFO_FLG_COPY
)
12481 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12482 printf (" LAZYLOAD");
12490 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12491 is contained by the region START .. END. The types of ADDR, START
12492 and END should all be the same. Note both ADDR + NELEM and END
12493 point to just beyond the end of the regions that are being tested. */
12494 #define IN_RANGE(START,END,ADDR,NELEM) \
12495 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12497 /* Check to see if the given reloc needs to be handled in a target specific
12498 manner. If so then process the reloc and return TRUE otherwise return
12501 If called with reloc == NULL, then this is a signal that reloc processing
12502 for the current section has finished, and any saved state should be
12506 target_specific_reloc_handling (Filedata
* filedata
,
12507 Elf_Internal_Rela
* reloc
,
12508 unsigned char * start
,
12509 unsigned char * end
,
12510 Elf_Internal_Sym
* symtab
,
12511 unsigned long num_syms
)
12513 unsigned int reloc_type
= 0;
12514 unsigned long sym_index
= 0;
12518 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12519 sym_index
= get_reloc_symindex (reloc
->r_info
);
12522 switch (filedata
->file_header
.e_machine
)
12525 case EM_MSP430_OLD
:
12527 static Elf_Internal_Sym
* saved_sym
= NULL
;
12535 switch (reloc_type
)
12537 case 10: /* R_MSP430_SYM_DIFF */
12538 if (uses_msp430x_relocs (filedata
))
12540 /* Fall through. */
12541 case 21: /* R_MSP430X_SYM_DIFF */
12543 if (sym_index
>= num_syms
)
12544 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12547 saved_sym
= symtab
+ sym_index
;
12550 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12551 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12552 goto handle_sym_diff
;
12554 case 5: /* R_MSP430_16_BYTE */
12555 case 9: /* R_MSP430_8 */
12556 if (uses_msp430x_relocs (filedata
))
12558 goto handle_sym_diff
;
12560 case 2: /* R_MSP430_ABS16 */
12561 case 15: /* R_MSP430X_ABS16 */
12562 if (! uses_msp430x_relocs (filedata
))
12564 goto handle_sym_diff
;
12567 if (saved_sym
!= NULL
)
12569 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12572 if (sym_index
>= num_syms
)
12573 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12577 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12578 - saved_sym
->st_value
);
12580 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12581 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12584 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12585 (long) reloc
->r_offset
);
12594 if (saved_sym
!= NULL
)
12595 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12602 case EM_CYGNUS_MN10300
:
12604 static Elf_Internal_Sym
* saved_sym
= NULL
;
12612 switch (reloc_type
)
12614 case 34: /* R_MN10300_ALIGN */
12616 case 33: /* R_MN10300_SYM_DIFF */
12617 if (sym_index
>= num_syms
)
12618 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12621 saved_sym
= symtab
+ sym_index
;
12624 case 1: /* R_MN10300_32 */
12625 case 2: /* R_MN10300_16 */
12626 if (saved_sym
!= NULL
)
12628 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12631 if (sym_index
>= num_syms
)
12632 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12636 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12637 - saved_sym
->st_value
);
12639 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12640 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12642 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12643 (long) reloc
->r_offset
);
12651 if (saved_sym
!= NULL
)
12652 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12660 static bfd_vma saved_sym1
= 0;
12661 static bfd_vma saved_sym2
= 0;
12662 static bfd_vma value
;
12666 saved_sym1
= saved_sym2
= 0;
12670 switch (reloc_type
)
12672 case 0x80: /* R_RL78_SYM. */
12673 saved_sym1
= saved_sym2
;
12674 if (sym_index
>= num_syms
)
12675 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12679 saved_sym2
= symtab
[sym_index
].st_value
;
12680 saved_sym2
+= reloc
->r_addend
;
12684 case 0x83: /* R_RL78_OPsub. */
12685 value
= saved_sym1
- saved_sym2
;
12686 saved_sym2
= saved_sym1
= 0;
12690 case 0x41: /* R_RL78_ABS32. */
12691 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12692 byte_put (start
+ reloc
->r_offset
, value
, 4);
12694 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12695 (long) reloc
->r_offset
);
12699 case 0x43: /* R_RL78_ABS16. */
12700 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12701 byte_put (start
+ reloc
->r_offset
, value
, 2);
12703 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12704 (long) reloc
->r_offset
);
12718 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12719 DWARF debug sections. This is a target specific test. Note - we do not
12720 go through the whole including-target-headers-multiple-times route, (as
12721 we have already done with <elf/h8.h>) because this would become very
12722 messy and even then this function would have to contain target specific
12723 information (the names of the relocs instead of their numeric values).
12724 FIXME: This is not the correct way to solve this problem. The proper way
12725 is to have target specific reloc sizing and typing functions created by
12726 the reloc-macros.h header, in the same way that it already creates the
12727 reloc naming functions. */
12730 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12732 /* Please keep this table alpha-sorted for ease of visual lookup. */
12733 switch (filedata
->file_header
.e_machine
)
12737 return reloc_type
== 1; /* R_386_32. */
12739 return reloc_type
== 1; /* R_68K_32. */
12741 return reloc_type
== 1; /* R_860_32. */
12743 return reloc_type
== 2; /* R_960_32. */
12745 return (reloc_type
== 258
12746 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12748 return reloc_type
== 11; /* R_BPF_DATA_32 */
12749 case EM_ADAPTEVA_EPIPHANY
:
12750 return reloc_type
== 3;
12752 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12754 return reloc_type
== 1; /* R_ARC_32. */
12755 case EM_ARC_COMPACT
:
12756 case EM_ARC_COMPACT2
:
12757 return reloc_type
== 4; /* R_ARC_32. */
12759 return reloc_type
== 2; /* R_ARM_ABS32 */
12762 return reloc_type
== 1;
12764 return reloc_type
== 0x12; /* R_byte4_data. */
12766 return reloc_type
== 3; /* R_CRIS_32. */
12768 return reloc_type
== 3; /* R_CR16_NUM32. */
12770 return reloc_type
== 15; /* R_CRX_NUM32. */
12772 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12773 case EM_CYGNUS_FRV
:
12774 return reloc_type
== 1;
12775 case EM_CYGNUS_D10V
:
12777 return reloc_type
== 6; /* R_D10V_32. */
12778 case EM_CYGNUS_D30V
:
12780 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12782 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12783 case EM_CYGNUS_FR30
:
12785 return reloc_type
== 3; /* R_FR30_32. */
12787 return reloc_type
== 1; /* R_FT32_32. */
12791 return reloc_type
== 1; /* R_H8_DIR32. */
12793 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12794 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12795 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12796 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12799 return reloc_type
== 2; /* R_IP2K_32. */
12801 return reloc_type
== 2; /* R_IQ2000_32. */
12802 case EM_LATTICEMICO32
:
12803 return reloc_type
== 3; /* R_LM32_32. */
12806 return reloc_type
== 3; /* R_M32C_32. */
12808 return reloc_type
== 34; /* R_M32R_32_RELA. */
12811 return reloc_type
== 6; /* R_M68HC11_32. */
12813 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12814 reloc_type
== 6; /* R_S12Z_CW32. */
12816 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12817 case EM_CYGNUS_MEP
:
12818 return reloc_type
== 4; /* R_MEP_32. */
12820 return reloc_type
== 2; /* R_METAG_ADDR32. */
12821 case EM_MICROBLAZE
:
12822 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12824 return reloc_type
== 2; /* R_MIPS_32. */
12826 return reloc_type
== 4; /* R_MMIX_32. */
12827 case EM_CYGNUS_MN10200
:
12829 return reloc_type
== 1; /* R_MN10200_32. */
12830 case EM_CYGNUS_MN10300
:
12832 return reloc_type
== 1; /* R_MN10300_32. */
12834 return reloc_type
== 1; /* R_MOXIE_32. */
12835 case EM_MSP430_OLD
:
12837 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12839 return reloc_type
== 2; /* R_MT_32. */
12841 return reloc_type
== 20; /* R_NDS32_RELA. */
12842 case EM_ALTERA_NIOS2
:
12843 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12845 return reloc_type
== 1; /* R_NIOS_32. */
12847 return reloc_type
== 1; /* R_OR1K_32. */
12849 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12850 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12851 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12854 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12856 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12858 return reloc_type
== 1; /* R_PPC_ADDR32. */
12860 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12862 return reloc_type
== 1; /* R_RISCV_32. */
12864 return reloc_type
== 1; /* R_RL78_DIR32. */
12866 return reloc_type
== 1; /* R_RX_DIR32. */
12868 return reloc_type
== 1; /* R_I370_ADDR31. */
12871 return reloc_type
== 4; /* R_S390_32. */
12873 return reloc_type
== 8; /* R_SCORE_ABS32. */
12875 return reloc_type
== 1; /* R_SH_DIR32. */
12876 case EM_SPARC32PLUS
:
12879 return reloc_type
== 3 /* R_SPARC_32. */
12880 || reloc_type
== 23; /* R_SPARC_UA32. */
12882 return reloc_type
== 6; /* R_SPU_ADDR32 */
12884 return reloc_type
== 1; /* R_C6000_ABS32. */
12886 return reloc_type
== 2; /* R_TILEGX_32. */
12888 return reloc_type
== 1; /* R_TILEPRO_32. */
12889 case EM_CYGNUS_V850
:
12891 return reloc_type
== 6; /* R_V850_ABS32. */
12893 return reloc_type
== 0x33; /* R_V810_WORD. */
12895 return reloc_type
== 1; /* R_VAX_32. */
12897 return reloc_type
== 3; /* R_VISIUM_32. */
12898 case EM_WEBASSEMBLY
:
12899 return reloc_type
== 1; /* R_WASM32_32. */
12903 return reloc_type
== 10; /* R_X86_64_32. */
12906 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12908 return reloc_type
== 4; /* R_XGATE_32. */
12910 return reloc_type
== 1; /* R_XSTROMY16_32. */
12911 case EM_XTENSA_OLD
:
12913 return reloc_type
== 1; /* R_XTENSA_32. */
12915 return reloc_type
== 6; /* R_Z80_32. */
12918 static unsigned int prev_warn
= 0;
12920 /* Avoid repeating the same warning multiple times. */
12921 if (prev_warn
!= filedata
->file_header
.e_machine
)
12922 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12923 filedata
->file_header
.e_machine
);
12924 prev_warn
= filedata
->file_header
.e_machine
;
12930 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12931 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12934 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12936 switch (filedata
->file_header
.e_machine
)
12937 /* Please keep this table alpha-sorted for ease of visual lookup. */
12941 return reloc_type
== 2; /* R_386_PC32. */
12943 return reloc_type
== 4; /* R_68K_PC32. */
12945 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12946 case EM_ADAPTEVA_EPIPHANY
:
12947 return reloc_type
== 6;
12949 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12950 case EM_ARC_COMPACT
:
12951 case EM_ARC_COMPACT2
:
12952 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12954 return reloc_type
== 3; /* R_ARM_REL32 */
12957 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12958 case EM_MICROBLAZE
:
12959 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12961 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12963 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12965 return reloc_type
== 26; /* R_PPC_REL32. */
12967 return reloc_type
== 26; /* R_PPC64_REL32. */
12969 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12972 return reloc_type
== 5; /* R_390_PC32. */
12974 return reloc_type
== 2; /* R_SH_REL32. */
12975 case EM_SPARC32PLUS
:
12978 return reloc_type
== 6; /* R_SPARC_DISP32. */
12980 return reloc_type
== 13; /* R_SPU_REL32. */
12982 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12984 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12986 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12990 return reloc_type
== 2; /* R_X86_64_PC32. */
12992 return reloc_type
== 4; /* R_VAX_PCREL32. */
12993 case EM_XTENSA_OLD
:
12995 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12997 /* Do not abort or issue an error message here. Not all targets use
12998 pc-relative 32-bit relocs in their DWARF debug information and we
12999 have already tested for target coverage in is_32bit_abs_reloc. A
13000 more helpful warning message will be generated by apply_relocations
13001 anyway, so just return. */
13006 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13007 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13010 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13012 switch (filedata
->file_header
.e_machine
)
13015 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13017 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13019 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13020 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13022 return reloc_type
== 80; /* R_PARISC_DIR64. */
13024 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13026 return reloc_type
== 2; /* R_RISCV_64. */
13027 case EM_SPARC32PLUS
:
13030 return reloc_type
== 32 /* R_SPARC_64. */
13031 || reloc_type
== 54; /* R_SPARC_UA64. */
13035 return reloc_type
== 1; /* R_X86_64_64. */
13038 return reloc_type
== 22; /* R_S390_64. */
13040 return reloc_type
== 1; /* R_TILEGX_64. */
13042 return reloc_type
== 18; /* R_MIPS_64. */
13048 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13049 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13052 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13054 switch (filedata
->file_header
.e_machine
)
13057 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13059 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13061 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13062 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13064 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13066 return reloc_type
== 44; /* R_PPC64_REL64. */
13067 case EM_SPARC32PLUS
:
13070 return reloc_type
== 46; /* R_SPARC_DISP64. */
13074 return reloc_type
== 24; /* R_X86_64_PC64. */
13077 return reloc_type
== 23; /* R_S390_PC64. */
13079 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13085 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13086 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13089 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13091 switch (filedata
->file_header
.e_machine
)
13093 case EM_CYGNUS_MN10200
:
13095 return reloc_type
== 4; /* R_MN10200_24. */
13097 return reloc_type
== 5; /* R_FT32_20. */
13099 return reloc_type
== 5; /* R_Z80_24. */
13105 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13106 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13109 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13111 /* Please keep this table alpha-sorted for ease of visual lookup. */
13112 switch (filedata
->file_header
.e_machine
)
13115 case EM_ARC_COMPACT
:
13116 case EM_ARC_COMPACT2
:
13117 return reloc_type
== 2; /* R_ARC_16. */
13118 case EM_ADAPTEVA_EPIPHANY
:
13119 return reloc_type
== 5;
13122 return reloc_type
== 4; /* R_AVR_16. */
13123 case EM_CYGNUS_D10V
:
13125 return reloc_type
== 3; /* R_D10V_16. */
13127 return reloc_type
== 2; /* R_FT32_16. */
13131 return reloc_type
== R_H8_DIR16
;
13134 return reloc_type
== 1; /* R_IP2K_16. */
13137 return reloc_type
== 1; /* R_M32C_16 */
13138 case EM_CYGNUS_MN10200
:
13140 return reloc_type
== 2; /* R_MN10200_16. */
13141 case EM_CYGNUS_MN10300
:
13143 return reloc_type
== 2; /* R_MN10300_16. */
13145 if (uses_msp430x_relocs (filedata
))
13146 return reloc_type
== 2; /* R_MSP430_ABS16. */
13147 /* Fall through. */
13148 case EM_MSP430_OLD
:
13149 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13151 return reloc_type
== 19; /* R_NDS32_RELA. */
13152 case EM_ALTERA_NIOS2
:
13153 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13155 return reloc_type
== 9; /* R_NIOS_16. */
13157 return reloc_type
== 2; /* R_OR1K_16. */
13159 return reloc_type
== 55; /* R_RISCV_SET16. */
13161 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13163 return reloc_type
== 2; /* R_C6000_ABS16. */
13165 return reloc_type
== 2; /* R_VISIUM_16. */
13168 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13170 return reloc_type
== 3; /* R_XGATE_16. */
13172 return reloc_type
== 4; /* R_Z80_16. */
13178 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13179 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13182 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13184 switch (filedata
->file_header
.e_machine
)
13187 return reloc_type
== 54; /* R_RISCV_SET8. */
13189 return reloc_type
== 1; /* R_Z80_8. */
13195 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13196 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13199 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13201 switch (filedata
->file_header
.e_machine
)
13204 return reloc_type
== 53; /* R_RISCV_SET6. */
13210 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13211 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13214 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13216 /* Please keep this table alpha-sorted for ease of visual lookup. */
13217 switch (filedata
->file_header
.e_machine
)
13220 return reloc_type
== 35; /* R_RISCV_ADD32. */
13226 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13227 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13230 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13232 /* Please keep this table alpha-sorted for ease of visual lookup. */
13233 switch (filedata
->file_header
.e_machine
)
13236 return reloc_type
== 39; /* R_RISCV_SUB32. */
13242 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13243 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13246 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13248 /* Please keep this table alpha-sorted for ease of visual lookup. */
13249 switch (filedata
->file_header
.e_machine
)
13252 return reloc_type
== 36; /* R_RISCV_ADD64. */
13258 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13259 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13262 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13264 /* Please keep this table alpha-sorted for ease of visual lookup. */
13265 switch (filedata
->file_header
.e_machine
)
13268 return reloc_type
== 40; /* R_RISCV_SUB64. */
13274 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13275 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13278 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13280 /* Please keep this table alpha-sorted for ease of visual lookup. */
13281 switch (filedata
->file_header
.e_machine
)
13284 return reloc_type
== 34; /* R_RISCV_ADD16. */
13290 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13291 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13294 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13296 /* Please keep this table alpha-sorted for ease of visual lookup. */
13297 switch (filedata
->file_header
.e_machine
)
13300 return reloc_type
== 38; /* R_RISCV_SUB16. */
13306 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13307 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13310 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13312 /* Please keep this table alpha-sorted for ease of visual lookup. */
13313 switch (filedata
->file_header
.e_machine
)
13316 return reloc_type
== 33; /* R_RISCV_ADD8. */
13322 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13323 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13326 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13328 /* Please keep this table alpha-sorted for ease of visual lookup. */
13329 switch (filedata
->file_header
.e_machine
)
13332 return reloc_type
== 37; /* R_RISCV_SUB8. */
13338 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13339 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13342 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13344 switch (filedata
->file_header
.e_machine
)
13347 return reloc_type
== 52; /* R_RISCV_SUB6. */
13353 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13354 relocation entries (possibly formerly used for SHT_GROUP sections). */
13357 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13359 switch (filedata
->file_header
.e_machine
)
13361 case EM_386
: /* R_386_NONE. */
13362 case EM_68K
: /* R_68K_NONE. */
13363 case EM_ADAPTEVA_EPIPHANY
:
13364 case EM_ALPHA
: /* R_ALPHA_NONE. */
13365 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13366 case EM_ARC
: /* R_ARC_NONE. */
13367 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13368 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13369 case EM_ARM
: /* R_ARM_NONE. */
13370 case EM_C166
: /* R_XC16X_NONE. */
13371 case EM_CRIS
: /* R_CRIS_NONE. */
13372 case EM_FT32
: /* R_FT32_NONE. */
13373 case EM_IA_64
: /* R_IA64_NONE. */
13374 case EM_K1OM
: /* R_X86_64_NONE. */
13375 case EM_L1OM
: /* R_X86_64_NONE. */
13376 case EM_M32R
: /* R_M32R_NONE. */
13377 case EM_MIPS
: /* R_MIPS_NONE. */
13378 case EM_MN10300
: /* R_MN10300_NONE. */
13379 case EM_MOXIE
: /* R_MOXIE_NONE. */
13380 case EM_NIOS32
: /* R_NIOS_NONE. */
13381 case EM_OR1K
: /* R_OR1K_NONE. */
13382 case EM_PARISC
: /* R_PARISC_NONE. */
13383 case EM_PPC64
: /* R_PPC64_NONE. */
13384 case EM_PPC
: /* R_PPC_NONE. */
13385 case EM_RISCV
: /* R_RISCV_NONE. */
13386 case EM_S390
: /* R_390_NONE. */
13388 case EM_SH
: /* R_SH_NONE. */
13389 case EM_SPARC32PLUS
:
13390 case EM_SPARC
: /* R_SPARC_NONE. */
13392 case EM_TILEGX
: /* R_TILEGX_NONE. */
13393 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13394 case EM_TI_C6000
:/* R_C6000_NONE. */
13395 case EM_X86_64
: /* R_X86_64_NONE. */
13397 case EM_Z80
: /* R_Z80_NONE. */
13398 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13399 return reloc_type
== 0;
13402 return reloc_type
== 0 || reloc_type
== 256;
13405 return (reloc_type
== 0 /* R_AVR_NONE. */
13406 || reloc_type
== 30 /* R_AVR_DIFF8. */
13407 || reloc_type
== 31 /* R_AVR_DIFF16. */
13408 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13410 return reloc_type
== 3; /* R_METAG_NONE. */
13412 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13413 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13414 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13415 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13416 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13418 return (reloc_type
== 0 /* R_PRU_NONE. */
13419 || reloc_type
== 65 /* R_PRU_DIFF8. */
13420 || reloc_type
== 66 /* R_PRU_DIFF16. */
13421 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13422 case EM_XTENSA_OLD
:
13424 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13425 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13426 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13427 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13428 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13429 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13430 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13431 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13432 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13433 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13438 /* Returns TRUE if there is a relocation against
13439 section NAME at OFFSET bytes. */
13442 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13444 Elf_Internal_Rela
* relocs
;
13445 Elf_Internal_Rela
* rp
;
13447 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13450 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13452 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13453 if (rp
->r_offset
== offset
)
13459 /* Apply relocations to a section.
13460 Returns TRUE upon success, FALSE otherwise.
13461 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13462 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13463 will be set to the number of relocs loaded.
13465 Note: So far support has been added only for those relocations
13466 which can be found in debug sections. FIXME: Add support for
13467 more relocations ? */
13470 apply_relocations (Filedata
* filedata
,
13471 const Elf_Internal_Shdr
* section
,
13472 unsigned char * start
,
13473 bfd_size_type size
,
13474 void ** relocs_return
,
13475 unsigned long * num_relocs_return
)
13477 Elf_Internal_Shdr
* relsec
;
13478 unsigned char * end
= start
+ size
;
13480 if (relocs_return
!= NULL
)
13482 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13483 * num_relocs_return
= 0;
13486 if (filedata
->file_header
.e_type
!= ET_REL
)
13487 /* No relocs to apply. */
13490 /* Find the reloc section associated with the section. */
13491 for (relsec
= filedata
->section_headers
;
13492 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13495 bfd_boolean is_rela
;
13496 unsigned long num_relocs
;
13497 Elf_Internal_Rela
* relocs
;
13498 Elf_Internal_Rela
* rp
;
13499 Elf_Internal_Shdr
* symsec
;
13500 Elf_Internal_Sym
* symtab
;
13501 unsigned long num_syms
;
13502 Elf_Internal_Sym
* sym
;
13504 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13505 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13506 || filedata
->section_headers
+ relsec
->sh_info
!= section
13507 || relsec
->sh_size
== 0
13508 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13511 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13512 if (symsec
->sh_type
!= SHT_SYMTAB
13513 && symsec
->sh_type
!= SHT_DYNSYM
)
13516 is_rela
= relsec
->sh_type
== SHT_RELA
;
13520 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13521 relsec
->sh_size
, & relocs
, & num_relocs
))
13526 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13527 relsec
->sh_size
, & relocs
, & num_relocs
))
13531 /* SH uses RELA but uses in place value instead of the addend field. */
13532 if (filedata
->file_header
.e_machine
== EM_SH
)
13535 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13537 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13540 unsigned int reloc_type
;
13541 unsigned int reloc_size
;
13542 bfd_boolean reloc_inplace
= FALSE
;
13543 bfd_boolean reloc_subtract
= FALSE
;
13544 unsigned char * rloc
;
13545 unsigned long sym_index
;
13547 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13549 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13551 else if (is_none_reloc (filedata
, reloc_type
))
13553 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13554 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13556 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13557 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13559 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13561 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13563 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13564 || is_6bit_abs_reloc (filedata
, reloc_type
))
13566 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13568 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13571 reloc_inplace
= TRUE
;
13573 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13575 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13578 reloc_inplace
= TRUE
;
13580 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13582 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13585 reloc_inplace
= TRUE
;
13587 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13589 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13592 reloc_inplace
= TRUE
;
13594 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13598 reloc_inplace
= TRUE
;
13602 static unsigned int prev_reloc
= 0;
13604 if (reloc_type
!= prev_reloc
)
13605 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13606 reloc_type
, printable_section_name (filedata
, section
));
13607 prev_reloc
= reloc_type
;
13611 rloc
= start
+ rp
->r_offset
;
13612 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13614 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13615 (unsigned long) rp
->r_offset
,
13616 printable_section_name (filedata
, section
));
13620 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13621 if (sym_index
>= num_syms
)
13623 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13624 sym_index
, printable_section_name (filedata
, section
));
13627 sym
= symtab
+ sym_index
;
13629 /* If the reloc has a symbol associated with it,
13630 make sure that it is of an appropriate type.
13632 Relocations against symbols without type can happen.
13633 Gcc -feliminate-dwarf2-dups may generate symbols
13634 without type for debug info.
13636 Icc generates relocations against function symbols
13637 instead of local labels.
13639 Relocations against object symbols can happen, eg when
13640 referencing a global array. For an example of this see
13641 the _clz.o binary in libgcc.a. */
13643 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13644 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13646 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13647 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13648 printable_section_name (filedata
, relsec
),
13649 (long int)(rp
- relocs
));
13655 addend
+= rp
->r_addend
;
13656 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13657 partial_inplace. */
13659 || (filedata
->file_header
.e_machine
== EM_XTENSA
13660 && reloc_type
== 1)
13661 || ((filedata
->file_header
.e_machine
== EM_PJ
13662 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13663 && reloc_type
== 1)
13664 || ((filedata
->file_header
.e_machine
== EM_D30V
13665 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13666 && reloc_type
== 12)
13669 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13670 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13672 addend
+= byte_get (rloc
, reloc_size
);
13675 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13676 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13678 /* On HPPA, all pc-relative relocations are biased by 8. */
13679 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13681 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13684 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13685 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13687 if (reloc_subtract
)
13688 addend
-= sym
->st_value
;
13690 addend
+= sym
->st_value
;
13691 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13692 byte_put (rloc
, addend
, reloc_size
);
13694 else if (reloc_subtract
)
13695 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13697 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13701 /* Let the target specific reloc processing code know that
13702 we have finished with these relocs. */
13703 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13707 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13708 * num_relocs_return
= num_relocs
;
13719 #ifdef SUPPORT_DISASSEMBLY
13721 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13723 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13725 /* FIXME: XXX -- to be done --- XXX */
13731 /* Reads in the contents of SECTION from FILE, returning a pointer
13732 to a malloc'ed buffer or NULL if something went wrong. */
13735 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13737 bfd_size_type num_bytes
= section
->sh_size
;
13739 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13741 printf (_("Section '%s' has no data to dump.\n"),
13742 printable_section_name (filedata
, section
));
13746 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13747 _("section contents"));
13750 /* Uncompresses a section that was compressed using zlib, in place. */
13753 uncompress_section_contents (unsigned char ** buffer
,
13754 dwarf_size_type uncompressed_size
,
13755 dwarf_size_type
* size
)
13757 dwarf_size_type compressed_size
= *size
;
13758 unsigned char * compressed_buffer
= *buffer
;
13759 unsigned char * uncompressed_buffer
;
13763 /* It is possible the section consists of several compressed
13764 buffers concatenated together, so we uncompress in a loop. */
13765 /* PR 18313: The state field in the z_stream structure is supposed
13766 to be invisible to the user (ie us), but some compilers will
13767 still complain about it being used without initialisation. So
13768 we first zero the entire z_stream structure and then set the fields
13770 memset (& strm
, 0, sizeof strm
);
13771 strm
.avail_in
= compressed_size
;
13772 strm
.next_in
= (Bytef
*) compressed_buffer
;
13773 strm
.avail_out
= uncompressed_size
;
13774 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13776 rc
= inflateInit (& strm
);
13777 while (strm
.avail_in
> 0)
13781 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13782 + (uncompressed_size
- strm
.avail_out
));
13783 rc
= inflate (&strm
, Z_FINISH
);
13784 if (rc
!= Z_STREAM_END
)
13786 rc
= inflateReset (& strm
);
13788 rc
= inflateEnd (& strm
);
13790 || strm
.avail_out
!= 0)
13793 *buffer
= uncompressed_buffer
;
13794 *size
= uncompressed_size
;
13798 free (uncompressed_buffer
);
13799 /* Indicate decompression failure. */
13805 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13807 Elf_Internal_Shdr
* relsec
;
13808 bfd_size_type num_bytes
;
13809 unsigned char * data
;
13810 unsigned char * end
;
13811 unsigned char * real_start
;
13812 unsigned char * start
;
13813 bfd_boolean some_strings_shown
;
13815 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13817 /* PR 21820: Do not fail if the section was empty. */
13818 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13820 num_bytes
= section
->sh_size
;
13822 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13824 if (decompress_dumps
)
13826 dwarf_size_type new_size
= num_bytes
;
13827 dwarf_size_type uncompressed_size
= 0;
13829 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13831 Elf_Internal_Chdr chdr
;
13832 unsigned int compression_header_size
13833 = get_compression_header (& chdr
, (unsigned char *) start
,
13835 if (compression_header_size
== 0)
13836 /* An error message will have already been generated
13837 by get_compression_header. */
13840 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13842 warn (_("section '%s' has unsupported compress type: %d\n"),
13843 printable_section_name (filedata
, section
), chdr
.ch_type
);
13846 uncompressed_size
= chdr
.ch_size
;
13847 start
+= compression_header_size
;
13848 new_size
-= compression_header_size
;
13850 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13852 /* Read the zlib header. In this case, it should be "ZLIB"
13853 followed by the uncompressed section size, 8 bytes in
13854 big-endian order. */
13855 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13856 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13857 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13858 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13859 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13860 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13861 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13862 uncompressed_size
+= start
[11];
13867 if (uncompressed_size
)
13869 if (uncompress_section_contents (& start
,
13870 uncompressed_size
, & new_size
))
13871 num_bytes
= new_size
;
13874 error (_("Unable to decompress section %s\n"),
13875 printable_section_name (filedata
, section
));
13880 start
= real_start
;
13883 /* If the section being dumped has relocations against it the user might
13884 be expecting these relocations to have been applied. Check for this
13885 case and issue a warning message in order to avoid confusion.
13886 FIXME: Maybe we ought to have an option that dumps a section with
13887 relocs applied ? */
13888 for (relsec
= filedata
->section_headers
;
13889 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13892 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13893 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13894 || filedata
->section_headers
+ relsec
->sh_info
!= section
13895 || relsec
->sh_size
== 0
13896 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13899 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13904 end
= start
+ num_bytes
;
13905 some_strings_shown
= FALSE
;
13907 #ifdef HAVE_MBSTATE_T
13909 /* Initialise the multibyte conversion state. */
13910 memset (& state
, 0, sizeof (state
));
13913 bfd_boolean continuing
= FALSE
;
13917 while (!ISPRINT (* data
))
13918 if (++ data
>= end
)
13923 size_t maxlen
= end
- data
;
13928 continuing
= FALSE
;
13933 /* PR 11128: Use two separate invocations in order to work
13934 around bugs in the Solaris 8 implementation of printf. */
13935 printf (" [%6tx] ", data
- start
);
13937 printf (" [%6Ix] ", (size_t) (data
- start
));
13952 /* PR 25543: Treat new-lines as string-ending characters. */
13961 /* Do not print control characters directly as they can affect terminal
13962 settings. Such characters usually appear in the names generated
13963 by the assembler for local labels. */
13966 printf ("^%c", c
+ 0x40);
13968 else if (ISPRINT (c
))
13975 #ifdef HAVE_MBSTATE_T
13978 /* Let printf do the hard work of displaying multibyte characters. */
13979 printf ("%.1s", data
- 1);
13980 #ifdef HAVE_MBSTATE_T
13981 /* Try to find out how many bytes made up the character that was
13982 just printed. Advance the symbol pointer past the bytes that
13984 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13988 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13998 printf (_("<corrupt>\n"));
14001 some_strings_shown
= TRUE
;
14005 if (! some_strings_shown
)
14006 printf (_(" No strings found in this section."));
14019 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
14020 Filedata
* filedata
,
14021 bfd_boolean relocate
)
14023 Elf_Internal_Shdr
* relsec
;
14024 bfd_size_type bytes
;
14025 bfd_size_type section_size
;
14027 unsigned char * data
;
14028 unsigned char * real_start
;
14029 unsigned char * start
;
14031 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14033 /* PR 21820: Do not fail if the section was empty. */
14034 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14036 section_size
= section
->sh_size
;
14038 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
14040 if (decompress_dumps
)
14042 dwarf_size_type new_size
= section_size
;
14043 dwarf_size_type uncompressed_size
= 0;
14045 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14047 Elf_Internal_Chdr chdr
;
14048 unsigned int compression_header_size
14049 = get_compression_header (& chdr
, start
, section_size
);
14051 if (compression_header_size
== 0)
14052 /* An error message will have already been generated
14053 by get_compression_header. */
14056 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14058 warn (_("section '%s' has unsupported compress type: %d\n"),
14059 printable_section_name (filedata
, section
), chdr
.ch_type
);
14062 uncompressed_size
= chdr
.ch_size
;
14063 start
+= compression_header_size
;
14064 new_size
-= compression_header_size
;
14066 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14068 /* Read the zlib header. In this case, it should be "ZLIB"
14069 followed by the uncompressed section size, 8 bytes in
14070 big-endian order. */
14071 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14072 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14073 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14074 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14075 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14076 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14077 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14078 uncompressed_size
+= start
[11];
14083 if (uncompressed_size
)
14085 if (uncompress_section_contents (& start
, uncompressed_size
,
14088 section_size
= new_size
;
14092 error (_("Unable to decompress section %s\n"),
14093 printable_section_name (filedata
, section
));
14094 /* FIXME: Print the section anyway ? */
14099 start
= real_start
;
14104 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14109 /* If the section being dumped has relocations against it the user might
14110 be expecting these relocations to have been applied. Check for this
14111 case and issue a warning message in order to avoid confusion.
14112 FIXME: Maybe we ought to have an option that dumps a section with
14113 relocs applied ? */
14114 for (relsec
= filedata
->section_headers
;
14115 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14118 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14119 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14120 || filedata
->section_headers
+ relsec
->sh_info
!= section
14121 || relsec
->sh_size
== 0
14122 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14125 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14130 addr
= section
->sh_addr
;
14131 bytes
= section_size
;
14140 lbytes
= (bytes
> 16 ? 16 : bytes
);
14142 printf (" 0x%8.8lx ", (unsigned long) addr
);
14144 for (j
= 0; j
< 16; j
++)
14147 printf ("%2.2x", data
[j
]);
14155 for (j
= 0; j
< lbytes
; j
++)
14158 if (k
>= ' ' && k
< 0x7f)
14181 #ifdef ENABLE_LIBCTF
14182 static ctf_sect_t
*
14183 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14185 buf
->cts_name
= SECTION_NAME (shdr
);
14186 buf
->cts_size
= shdr
->sh_size
;
14187 buf
->cts_entsize
= shdr
->sh_entsize
;
14192 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14193 it is passed, or a pointer to newly-allocated storage, in which case
14194 dump_ctf() will free it when it no longer needs it. */
14197 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14198 char *s
, void *arg
)
14200 const char *blanks
= arg
;
14203 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14208 /* Dump one CTF archive member. */
14211 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
14213 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
14214 const char *things
[] = {"Header", "Labels", "Data objects",
14215 "Function objects", "Variables", "Types", "Strings",
14217 const char **thing
;
14218 ctf_next_t
*it
= NULL
;
14224 /* Only print out the name of non-default-named archive members.
14225 The name .ctf appears everywhere, even for things that aren't
14226 really archives, so printing it out is liable to be confusing.
14228 The parent, if there is one, is the default-owned archive member:
14229 avoid importing it into itself. (This does no harm, but looks
14232 if (strcmp (name
, ".ctf") != 0)
14234 printf (_("\nCTF archive member: %s:\n"), name
);
14235 ctf_import (ctf
, parent
);
14238 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14240 ctf_dump_state_t
*s
= NULL
;
14243 printf ("\n %s:\n", *thing
);
14244 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14245 (void *) " ")) != NULL
)
14247 printf ("%s\n", item
);
14251 if (ctf_errno (ctf
))
14253 error (_("Iteration failed: %s, %s\n"), *thing
,
14254 ctf_errmsg (ctf_errno (ctf
)));
14261 /* Dump accumulated errors and warnings. */
14262 while ((errtext
= ctf_errwarning_next (ctf
, &it
, &is_warning
)) != NULL
)
14264 error (_("%s: `%s'\n"), is_warning
? _("warning"): _("error"),
14268 if (ctf_errno (ctf
) != ECTF_NEXT_END
)
14270 error (_("CTF error: cannot get CTF errors: `%s'\n"),
14271 ctf_errmsg (ctf_errno (ctf
)));
14277 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14279 Elf_Internal_Shdr
* parent_sec
= NULL
;
14280 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14281 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14282 void * data
= NULL
;
14283 void * symdata
= NULL
;
14284 void * strdata
= NULL
;
14285 void * parentdata
= NULL
;
14286 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14287 ctf_sect_t
* symsectp
= NULL
;
14288 ctf_sect_t
* strsectp
= NULL
;
14289 ctf_archive_t
* ctfa
= NULL
;
14290 ctf_archive_t
* parenta
= NULL
, *lookparent
;
14291 ctf_file_t
* parent
= NULL
;
14294 bfd_boolean ret
= FALSE
;
14296 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14297 data
= get_section_contents (section
, filedata
);
14298 ctfsect
.cts_data
= data
;
14300 if (!dump_ctf_symtab_name
)
14301 dump_ctf_symtab_name
= strdup (".symtab");
14303 if (!dump_ctf_strtab_name
)
14304 dump_ctf_strtab_name
= strdup (".strtab");
14306 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14308 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14310 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14313 if ((symdata
= (void *) get_data (NULL
, filedata
,
14314 symtab_sec
->sh_offset
, 1,
14315 symtab_sec
->sh_size
,
14316 _("symbols"))) == NULL
)
14318 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14319 symsect
.cts_data
= symdata
;
14321 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
14323 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14325 error (_("No string table section named %s\n"),
14326 dump_ctf_strtab_name
);
14329 if ((strdata
= (void *) get_data (NULL
, filedata
,
14330 strtab_sec
->sh_offset
, 1,
14331 strtab_sec
->sh_size
,
14332 _("strings"))) == NULL
)
14334 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14335 strsect
.cts_data
= strdata
;
14337 if (dump_ctf_parent_name
)
14339 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14341 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14344 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14345 parent_sec
->sh_offset
, 1,
14346 parent_sec
->sh_size
,
14347 _("CTF parent"))) == NULL
)
14349 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14350 parentsect
.cts_data
= parentdata
;
14353 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
14354 libctf papers over the difference, so we can pretend it is always an
14355 archive. Possibly open the parent as well, if one was specified. */
14357 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14359 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14365 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
14368 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14371 lookparent
= parenta
;
14376 /* Assume that the applicable parent archive member is the default one.
14377 (This is what all known implementations are expected to do, if they
14378 put CTFs and their parents in archives together.) */
14379 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
14381 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14387 printf (_("\nDump of CTF section '%s':\n"),
14388 printable_section_name (filedata
, section
));
14390 if (ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
) != 0)
14394 ctf_file_close (parent
);
14396 ctf_close (parenta
);
14406 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14407 const Elf_Internal_Shdr
* sec
,
14410 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14412 Filedata
* filedata
= (Filedata
*) data
;
14414 if (section
->start
!= NULL
)
14416 /* If it is already loaded, do nothing. */
14417 if (streq (section
->filename
, filedata
->file_name
))
14419 free (section
->start
);
14422 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14423 section
->address
= sec
->sh_addr
;
14424 section
->user_data
= NULL
;
14425 section
->filename
= filedata
->file_name
;
14426 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14428 sec
->sh_size
, buf
);
14429 if (section
->start
== NULL
)
14433 unsigned char *start
= section
->start
;
14434 dwarf_size_type size
= sec
->sh_size
;
14435 dwarf_size_type uncompressed_size
= 0;
14437 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14439 Elf_Internal_Chdr chdr
;
14440 unsigned int compression_header_size
;
14442 if (size
< (is_32bit_elf
14443 ? sizeof (Elf32_External_Chdr
)
14444 : sizeof (Elf64_External_Chdr
)))
14446 warn (_("compressed section %s is too small to contain a compression header\n"),
14451 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14452 if (compression_header_size
== 0)
14453 /* An error message will have already been generated
14454 by get_compression_header. */
14457 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14459 warn (_("section '%s' has unsupported compress type: %d\n"),
14460 section
->name
, chdr
.ch_type
);
14463 uncompressed_size
= chdr
.ch_size
;
14464 start
+= compression_header_size
;
14465 size
-= compression_header_size
;
14467 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14469 /* Read the zlib header. In this case, it should be "ZLIB"
14470 followed by the uncompressed section size, 8 bytes in
14471 big-endian order. */
14472 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14473 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14474 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14475 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14476 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14477 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14478 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14479 uncompressed_size
+= start
[11];
14484 if (uncompressed_size
)
14486 if (uncompress_section_contents (&start
, uncompressed_size
,
14489 /* Free the compressed buffer, update the section buffer
14490 and the section size if uncompress is successful. */
14491 free (section
->start
);
14492 section
->start
= start
;
14496 error (_("Unable to decompress section %s\n"),
14497 printable_section_name (filedata
, sec
));
14502 section
->size
= size
;
14505 if (section
->start
== NULL
)
14508 if (debug_displays
[debug
].relocate
)
14510 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14511 & section
->reloc_info
, & section
->num_relocs
))
14516 section
->reloc_info
= NULL
;
14517 section
->num_relocs
= 0;
14523 #if HAVE_LIBDEBUGINFOD
14524 /* Return a hex string representation of the build-id. */
14526 get_build_id (void * data
)
14528 Filedata
* filedata
= (Filedata
*)data
;
14529 Elf_Internal_Shdr
* shdr
;
14532 /* Iterate through notes to find note.gnu.build-id.
14533 FIXME: Only the first note in any note section is examined. */
14534 for (i
= 0, shdr
= filedata
->section_headers
;
14535 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14538 if (shdr
->sh_type
!= SHT_NOTE
)
14543 size_t data_remaining
;
14545 Elf_External_Note
* enote
;
14546 Elf_Internal_Note inote
;
14548 bfd_vma offset
= shdr
->sh_offset
;
14549 bfd_vma align
= shdr
->sh_addralign
;
14550 bfd_vma length
= shdr
->sh_size
;
14552 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14558 else if (align
!= 4 && align
!= 8)
14564 end
= (char *) enote
+ length
;
14565 data_remaining
= end
- (char *) enote
;
14567 if (!is_ia64_vms (filedata
))
14569 min_notesz
= offsetof (Elf_External_Note
, name
);
14570 if (data_remaining
< min_notesz
)
14573 malformed note encountered in section %s whilst scanning for build-id note\n"),
14574 printable_section_name (filedata
, shdr
));
14578 data_remaining
-= min_notesz
;
14580 inote
.type
= BYTE_GET (enote
->type
);
14581 inote
.namesz
= BYTE_GET (enote
->namesz
);
14582 inote
.namedata
= enote
->name
;
14583 inote
.descsz
= BYTE_GET (enote
->descsz
);
14584 inote
.descdata
= ((char *) enote
14585 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14586 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14587 next
= ((char *) enote
14588 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14592 Elf64_External_VMS_Note
*vms_enote
;
14594 /* PR binutils/15191
14595 Make sure that there is enough data to read. */
14596 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14597 if (data_remaining
< min_notesz
)
14600 malformed note encountered in section %s whilst scanning for build-id note\n"),
14601 printable_section_name (filedata
, shdr
));
14605 data_remaining
-= min_notesz
;
14607 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14608 inote
.type
= BYTE_GET (vms_enote
->type
);
14609 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14610 inote
.namedata
= vms_enote
->name
;
14611 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14612 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14613 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14614 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14617 /* Skip malformed notes. */
14618 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14619 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14620 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14621 || ((size_t) (next
- inote
.descdata
)
14622 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14625 malformed note encountered in section %s whilst scanning for build-id note\n"),
14626 printable_section_name (filedata
, shdr
));
14631 /* Check if this is the build-id note. If so then convert the build-id
14632 bytes to a hex string. */
14633 if (inote
.namesz
> 0
14634 && const_strneq (inote
.namedata
, "GNU")
14635 && inote
.type
== NT_GNU_BUILD_ID
)
14640 build_id
= malloc (inote
.descsz
* 2 + 1);
14641 if (build_id
== NULL
)
14647 for (j
= 0; j
< inote
.descsz
; ++j
)
14648 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14649 build_id
[inote
.descsz
* 2] = '\0';
14652 return (unsigned char *) build_id
;
14659 #endif /* HAVE_LIBDEBUGINFOD */
14661 /* If this is not NULL, load_debug_section will only look for sections
14662 within the list of sections given here. */
14663 static unsigned int * section_subset
= NULL
;
14666 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14668 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14669 Elf_Internal_Shdr
* sec
;
14670 Filedata
* filedata
= (Filedata
*) data
;
14672 /* Without section headers we cannot find any sections. */
14673 if (filedata
->section_headers
== NULL
)
14676 if (filedata
->string_table
== NULL
14677 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14678 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14680 Elf_Internal_Shdr
* strs
;
14682 /* Read in the string table, so that we have section names to scan. */
14683 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14685 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14687 filedata
->string_table
14688 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14689 1, strs
->sh_size
, _("string table"));
14691 filedata
->string_table_length
14692 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14696 /* Locate the debug section. */
14697 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14699 section
->name
= section
->uncompressed_name
;
14702 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14704 section
->name
= section
->compressed_name
;
14709 /* If we're loading from a subset of sections, and we've loaded
14710 a section matching this name before, it's likely that it's a
14712 if (section_subset
!= NULL
)
14713 free_debug_section (debug
);
14715 return load_specific_debug_section (debug
, sec
, data
);
14719 free_debug_section (enum dwarf_section_display_enum debug
)
14721 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14723 if (section
->start
== NULL
)
14726 free ((char *) section
->start
);
14727 section
->start
= NULL
;
14728 section
->address
= 0;
14731 free (section
->reloc_info
);
14732 section
->reloc_info
= NULL
;
14733 section
->num_relocs
= 0;
14737 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14739 char * name
= SECTION_NAME (section
);
14740 const char * print_name
= printable_section_name (filedata
, section
);
14741 bfd_size_type length
;
14742 bfd_boolean result
= TRUE
;
14745 length
= section
->sh_size
;
14748 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14751 if (section
->sh_type
== SHT_NOBITS
)
14753 /* There is no point in dumping the contents of a debugging section
14754 which has the NOBITS type - the bits in the file will be random.
14755 This can happen when a file containing a .eh_frame section is
14756 stripped with the --only-keep-debug command line option. */
14757 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14762 if (const_strneq (name
, ".gnu.linkonce.wi."))
14763 name
= ".debug_info";
14765 /* See if we know how to display the contents of this section. */
14766 for (i
= 0; i
< max
; i
++)
14768 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14769 struct dwarf_section_display
* display
= debug_displays
+ i
;
14770 struct dwarf_section
* sec
= & display
->section
;
14772 if (streq (sec
->uncompressed_name
, name
)
14773 || (id
== line
&& const_strneq (name
, ".debug_line."))
14774 || streq (sec
->compressed_name
, name
))
14776 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14779 free_debug_section (id
);
14781 if (i
== line
&& const_strneq (name
, ".debug_line."))
14783 else if (streq (sec
->uncompressed_name
, name
))
14784 sec
->name
= sec
->uncompressed_name
;
14786 sec
->name
= sec
->compressed_name
;
14788 if (load_specific_debug_section (id
, section
, filedata
))
14790 /* If this debug section is part of a CU/TU set in a .dwp file,
14791 restrict load_debug_section to the sections in that set. */
14792 section_subset
= find_cu_tu_set (filedata
, shndx
);
14794 result
&= display
->display (sec
, filedata
);
14796 section_subset
= NULL
;
14798 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14799 free_debug_section (id
);
14807 printf (_("Unrecognized debug section: %s\n"), print_name
);
14814 /* Set DUMP_SECTS for all sections where dumps were requested
14815 based on section name. */
14818 initialise_dumps_byname (Filedata
* filedata
)
14820 struct dump_list_entry
* cur
;
14822 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14825 bfd_boolean any
= FALSE
;
14827 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14828 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14830 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14835 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14841 process_section_contents (Filedata
* filedata
)
14843 Elf_Internal_Shdr
* section
;
14845 bfd_boolean res
= TRUE
;
14850 initialise_dumps_byname (filedata
);
14852 for (i
= 0, section
= filedata
->section_headers
;
14853 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14856 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14858 #ifdef SUPPORT_DISASSEMBLY
14859 if (dump
& DISASS_DUMP
)
14861 if (! disassemble_section (section
, filedata
))
14865 if (dump
& HEX_DUMP
)
14867 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14871 if (dump
& RELOC_DUMP
)
14873 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14877 if (dump
& STRING_DUMP
)
14879 if (! dump_section_as_strings (section
, filedata
))
14883 if (dump
& DEBUG_DUMP
)
14885 if (! display_debug_section (i
, section
, filedata
))
14889 #ifdef ENABLE_LIBCTF
14890 if (dump
& CTF_DUMP
)
14892 if (! dump_section_as_ctf (section
, filedata
))
14898 /* Check to see if the user requested a
14899 dump of a section that does not exist. */
14900 while (i
< filedata
->dump
.num_dump_sects
)
14902 if (filedata
->dump
.dump_sects
[i
])
14904 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14914 process_mips_fpe_exception (int mask
)
14918 bfd_boolean first
= TRUE
;
14920 if (mask
& OEX_FPU_INEX
)
14921 fputs ("INEX", stdout
), first
= FALSE
;
14922 if (mask
& OEX_FPU_UFLO
)
14923 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14924 if (mask
& OEX_FPU_OFLO
)
14925 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14926 if (mask
& OEX_FPU_DIV0
)
14927 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14928 if (mask
& OEX_FPU_INVAL
)
14929 printf ("%sINVAL", first
? "" : "|");
14932 fputs ("0", stdout
);
14935 /* Display's the value of TAG at location P. If TAG is
14936 greater than 0 it is assumed to be an unknown tag, and
14937 a message is printed to this effect. Otherwise it is
14938 assumed that a message has already been printed.
14940 If the bottom bit of TAG is set it assumed to have a
14941 string value, otherwise it is assumed to have an integer
14944 Returns an updated P pointing to the first unread byte
14945 beyond the end of TAG's value.
14947 Reads at or beyond END will not be made. */
14949 static unsigned char *
14950 display_tag_value (signed int tag
,
14952 const unsigned char * const end
)
14957 printf (" Tag_unknown_%d: ", tag
);
14961 warn (_("<corrupt tag>\n"));
14965 /* PR 17531 file: 027-19978-0.004. */
14966 size_t maxlen
= (end
- p
) - 1;
14971 print_symbol ((int) maxlen
, (const char *) p
);
14972 p
+= strnlen ((char *) p
, maxlen
) + 1;
14976 printf (_("<corrupt string tag>"));
14977 p
= (unsigned char *) end
;
14983 READ_ULEB (val
, p
, end
);
14984 printf ("%ld (0x%lx)\n", val
, val
);
14991 /* ARC ABI attributes section. */
14993 static unsigned char *
14994 display_arc_attribute (unsigned char * p
,
14995 const unsigned char * const end
)
15000 READ_ULEB (tag
, p
, end
);
15004 case Tag_ARC_PCS_config
:
15005 READ_ULEB (val
, p
, end
);
15006 printf (" Tag_ARC_PCS_config: ");
15010 printf (_("Absent/Non standard\n"));
15013 printf (_("Bare metal/mwdt\n"));
15016 printf (_("Bare metal/newlib\n"));
15019 printf (_("Linux/uclibc\n"));
15022 printf (_("Linux/glibc\n"));
15025 printf (_("Unknown\n"));
15030 case Tag_ARC_CPU_base
:
15031 READ_ULEB (val
, p
, end
);
15032 printf (" Tag_ARC_CPU_base: ");
15037 printf (_("Absent\n"));
15039 case TAG_CPU_ARC6xx
:
15040 printf ("ARC6xx\n");
15042 case TAG_CPU_ARC7xx
:
15043 printf ("ARC7xx\n");
15045 case TAG_CPU_ARCEM
:
15046 printf ("ARCEM\n");
15048 case TAG_CPU_ARCHS
:
15049 printf ("ARCHS\n");
15054 case Tag_ARC_CPU_variation
:
15055 READ_ULEB (val
, p
, end
);
15056 printf (" Tag_ARC_CPU_variation: ");
15060 if (val
> 0 && val
< 16)
15061 printf ("Core%d\n", val
);
15063 printf ("Unknown\n");
15067 printf (_("Absent\n"));
15072 case Tag_ARC_CPU_name
:
15073 printf (" Tag_ARC_CPU_name: ");
15074 p
= display_tag_value (-1, p
, end
);
15077 case Tag_ARC_ABI_rf16
:
15078 READ_ULEB (val
, p
, end
);
15079 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15082 case Tag_ARC_ABI_osver
:
15083 READ_ULEB (val
, p
, end
);
15084 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15087 case Tag_ARC_ABI_pic
:
15088 case Tag_ARC_ABI_sda
:
15089 READ_ULEB (val
, p
, end
);
15090 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15091 : " Tag_ARC_ABI_pic: ");
15095 printf (_("Absent\n"));
15104 printf (_("Unknown\n"));
15109 case Tag_ARC_ABI_tls
:
15110 READ_ULEB (val
, p
, end
);
15111 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15114 case Tag_ARC_ABI_enumsize
:
15115 READ_ULEB (val
, p
, end
);
15116 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15120 case Tag_ARC_ABI_exceptions
:
15121 READ_ULEB (val
, p
, end
);
15122 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15126 case Tag_ARC_ABI_double_size
:
15127 READ_ULEB (val
, p
, end
);
15128 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15131 case Tag_ARC_ISA_config
:
15132 printf (" Tag_ARC_ISA_config: ");
15133 p
= display_tag_value (-1, p
, end
);
15136 case Tag_ARC_ISA_apex
:
15137 printf (" Tag_ARC_ISA_apex: ");
15138 p
= display_tag_value (-1, p
, end
);
15141 case Tag_ARC_ISA_mpy_option
:
15142 READ_ULEB (val
, p
, end
);
15143 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15146 case Tag_ARC_ATR_version
:
15147 READ_ULEB (val
, p
, end
);
15148 printf (" Tag_ARC_ATR_version: %d\n", val
);
15152 return display_tag_value (tag
& 1, p
, end
);
15158 /* ARM EABI attributes section. */
15163 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15165 const char ** table
;
15166 } arm_attr_public_tag
;
15168 static const char * arm_attr_tag_CPU_arch
[] =
15169 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15170 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15171 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15172 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15173 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15174 {"No", "Thumb-1", "Thumb-2", "Yes"};
15175 static const char * arm_attr_tag_FP_arch
[] =
15176 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15177 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15178 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15179 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15180 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15181 "NEON for ARMv8.1"};
15182 static const char * arm_attr_tag_PCS_config
[] =
15183 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15184 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15185 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15186 {"V6", "SB", "TLS", "Unused"};
15187 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15188 {"Absolute", "PC-relative", "SB-relative", "None"};
15189 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15190 {"Absolute", "PC-relative", "None"};
15191 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15192 {"None", "direct", "GOT-indirect"};
15193 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15194 {"None", "??? 1", "2", "??? 3", "4"};
15195 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15196 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15197 {"Unused", "Needed", "Sign only"};
15198 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15199 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15200 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15201 {"Unused", "Finite", "RTABI", "IEEE 754"};
15202 static const char * arm_attr_tag_ABI_enum_size
[] =
15203 {"Unused", "small", "int", "forced to int"};
15204 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15205 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15206 static const char * arm_attr_tag_ABI_VFP_args
[] =
15207 {"AAPCS", "VFP registers", "custom", "compatible"};
15208 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15209 {"AAPCS", "WMMX registers", "custom"};
15210 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15211 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15212 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15213 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15214 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15215 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15216 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15217 static const char * arm_attr_tag_FP_HP_extension
[] =
15218 {"Not Allowed", "Allowed"};
15219 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15220 {"None", "IEEE 754", "Alternative Format"};
15221 static const char * arm_attr_tag_DSP_extension
[] =
15222 {"Follow architecture", "Allowed"};
15223 static const char * arm_attr_tag_MPextension_use
[] =
15224 {"Not Allowed", "Allowed"};
15225 static const char * arm_attr_tag_DIV_use
[] =
15226 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15227 "Allowed in v7-A with integer division extension"};
15228 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15229 static const char * arm_attr_tag_Virtualization_use
[] =
15230 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15231 "TrustZone and Virtualization Extensions"};
15232 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15233 {"Not Allowed", "Allowed"};
15235 static const char * arm_attr_tag_MVE_arch
[] =
15236 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15238 #define LOOKUP(id, name) \
15239 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15240 static arm_attr_public_tag arm_attr_public_tags
[] =
15242 {4, "CPU_raw_name", 1, NULL
},
15243 {5, "CPU_name", 1, NULL
},
15244 LOOKUP(6, CPU_arch
),
15245 {7, "CPU_arch_profile", 0, NULL
},
15246 LOOKUP(8, ARM_ISA_use
),
15247 LOOKUP(9, THUMB_ISA_use
),
15248 LOOKUP(10, FP_arch
),
15249 LOOKUP(11, WMMX_arch
),
15250 LOOKUP(12, Advanced_SIMD_arch
),
15251 LOOKUP(13, PCS_config
),
15252 LOOKUP(14, ABI_PCS_R9_use
),
15253 LOOKUP(15, ABI_PCS_RW_data
),
15254 LOOKUP(16, ABI_PCS_RO_data
),
15255 LOOKUP(17, ABI_PCS_GOT_use
),
15256 LOOKUP(18, ABI_PCS_wchar_t
),
15257 LOOKUP(19, ABI_FP_rounding
),
15258 LOOKUP(20, ABI_FP_denormal
),
15259 LOOKUP(21, ABI_FP_exceptions
),
15260 LOOKUP(22, ABI_FP_user_exceptions
),
15261 LOOKUP(23, ABI_FP_number_model
),
15262 {24, "ABI_align_needed", 0, NULL
},
15263 {25, "ABI_align_preserved", 0, NULL
},
15264 LOOKUP(26, ABI_enum_size
),
15265 LOOKUP(27, ABI_HardFP_use
),
15266 LOOKUP(28, ABI_VFP_args
),
15267 LOOKUP(29, ABI_WMMX_args
),
15268 LOOKUP(30, ABI_optimization_goals
),
15269 LOOKUP(31, ABI_FP_optimization_goals
),
15270 {32, "compatibility", 0, NULL
},
15271 LOOKUP(34, CPU_unaligned_access
),
15272 LOOKUP(36, FP_HP_extension
),
15273 LOOKUP(38, ABI_FP_16bit_format
),
15274 LOOKUP(42, MPextension_use
),
15275 LOOKUP(44, DIV_use
),
15276 LOOKUP(46, DSP_extension
),
15277 LOOKUP(48, MVE_arch
),
15278 {64, "nodefaults", 0, NULL
},
15279 {65, "also_compatible_with", 0, NULL
},
15280 LOOKUP(66, T2EE_use
),
15281 {67, "conformance", 1, NULL
},
15282 LOOKUP(68, Virtualization_use
),
15283 LOOKUP(70, MPextension_use_legacy
)
15287 static unsigned char *
15288 display_arm_attribute (unsigned char * p
,
15289 const unsigned char * const end
)
15293 arm_attr_public_tag
* attr
;
15297 READ_ULEB (tag
, p
, end
);
15299 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15301 if (arm_attr_public_tags
[i
].tag
== tag
)
15303 attr
= &arm_attr_public_tags
[i
];
15310 printf (" Tag_%s: ", attr
->name
);
15311 switch (attr
->type
)
15316 case 7: /* Tag_CPU_arch_profile. */
15317 READ_ULEB (val
, p
, end
);
15320 case 0: printf (_("None\n")); break;
15321 case 'A': printf (_("Application\n")); break;
15322 case 'R': printf (_("Realtime\n")); break;
15323 case 'M': printf (_("Microcontroller\n")); break;
15324 case 'S': printf (_("Application or Realtime\n")); break;
15325 default: printf ("??? (%d)\n", val
); break;
15329 case 24: /* Tag_align_needed. */
15330 READ_ULEB (val
, p
, end
);
15333 case 0: printf (_("None\n")); break;
15334 case 1: printf (_("8-byte\n")); break;
15335 case 2: printf (_("4-byte\n")); break;
15336 case 3: printf ("??? 3\n"); break;
15339 printf (_("8-byte and up to %d-byte extended\n"),
15342 printf ("??? (%d)\n", val
);
15347 case 25: /* Tag_align_preserved. */
15348 READ_ULEB (val
, p
, end
);
15351 case 0: printf (_("None\n")); break;
15352 case 1: printf (_("8-byte, except leaf SP\n")); break;
15353 case 2: printf (_("8-byte\n")); break;
15354 case 3: printf ("??? 3\n"); break;
15357 printf (_("8-byte and up to %d-byte extended\n"),
15360 printf ("??? (%d)\n", val
);
15365 case 32: /* Tag_compatibility. */
15367 READ_ULEB (val
, p
, end
);
15368 printf (_("flag = %d, vendor = "), val
);
15371 size_t maxlen
= (end
- p
) - 1;
15373 print_symbol ((int) maxlen
, (const char *) p
);
15374 p
+= strnlen ((char *) p
, maxlen
) + 1;
15378 printf (_("<corrupt>"));
15379 p
= (unsigned char *) end
;
15385 case 64: /* Tag_nodefaults. */
15386 /* PR 17531: file: 001-505008-0.01. */
15389 printf (_("True\n"));
15392 case 65: /* Tag_also_compatible_with. */
15393 READ_ULEB (val
, p
, end
);
15394 if (val
== 6 /* Tag_CPU_arch. */)
15396 READ_ULEB (val
, p
, end
);
15397 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15398 printf ("??? (%d)\n", val
);
15400 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15404 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15409 printf (_("<unknown: %d>\n"), tag
);
15415 return display_tag_value (-1, p
, end
);
15417 return display_tag_value (0, p
, end
);
15420 assert (attr
->type
& 0x80);
15421 READ_ULEB (val
, p
, end
);
15422 type
= attr
->type
& 0x7f;
15424 printf ("??? (%d)\n", val
);
15426 printf ("%s\n", attr
->table
[val
]);
15431 return display_tag_value (tag
, p
, end
);
15434 static unsigned char *
15435 display_gnu_attribute (unsigned char * p
,
15436 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15437 const unsigned char * const end
)
15442 READ_ULEB (tag
, p
, end
);
15444 /* Tag_compatibility is the only generic GNU attribute defined at
15448 READ_ULEB (val
, p
, end
);
15450 printf (_("flag = %d, vendor = "), val
);
15453 printf (_("<corrupt>\n"));
15454 warn (_("corrupt vendor attribute\n"));
15460 size_t maxlen
= (end
- p
) - 1;
15462 print_symbol ((int) maxlen
, (const char *) p
);
15463 p
+= strnlen ((char *) p
, maxlen
) + 1;
15467 printf (_("<corrupt>"));
15468 p
= (unsigned char *) end
;
15475 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15476 return display_proc_gnu_attribute (p
, tag
, end
);
15478 return display_tag_value (tag
, p
, end
);
15481 static unsigned char *
15482 display_m68k_gnu_attribute (unsigned char * p
,
15484 const unsigned char * const end
)
15488 if (tag
== Tag_GNU_M68K_ABI_FP
)
15490 printf (" Tag_GNU_M68K_ABI_FP: ");
15493 printf (_("<corrupt>\n"));
15496 READ_ULEB (val
, p
, end
);
15499 printf ("(%#x), ", val
);
15504 printf (_("unspecified hard/soft float\n"));
15507 printf (_("hard float\n"));
15510 printf (_("soft float\n"));
15516 return display_tag_value (tag
& 1, p
, end
);
15519 static unsigned char *
15520 display_power_gnu_attribute (unsigned char * p
,
15522 const unsigned char * const end
)
15526 if (tag
== Tag_GNU_Power_ABI_FP
)
15528 printf (" Tag_GNU_Power_ABI_FP: ");
15531 printf (_("<corrupt>\n"));
15534 READ_ULEB (val
, p
, end
);
15537 printf ("(%#x), ", val
);
15542 printf (_("unspecified hard/soft float, "));
15545 printf (_("hard float, "));
15548 printf (_("soft float, "));
15551 printf (_("single-precision hard float, "));
15558 printf (_("unspecified long double\n"));
15561 printf (_("128-bit IBM long double\n"));
15564 printf (_("64-bit long double\n"));
15567 printf (_("128-bit IEEE long double\n"));
15573 if (tag
== Tag_GNU_Power_ABI_Vector
)
15575 printf (" Tag_GNU_Power_ABI_Vector: ");
15578 printf (_("<corrupt>\n"));
15581 READ_ULEB (val
, p
, end
);
15584 printf ("(%#x), ", val
);
15589 printf (_("unspecified\n"));
15592 printf (_("generic\n"));
15595 printf ("AltiVec\n");
15604 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15606 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15609 printf (_("<corrupt>\n"));
15612 READ_ULEB (val
, p
, end
);
15615 printf ("(%#x), ", val
);
15620 printf (_("unspecified\n"));
15623 printf ("r3/r4\n");
15626 printf (_("memory\n"));
15635 return display_tag_value (tag
& 1, p
, end
);
15638 static unsigned char *
15639 display_s390_gnu_attribute (unsigned char * p
,
15641 const unsigned char * const end
)
15645 if (tag
== Tag_GNU_S390_ABI_Vector
)
15647 printf (" Tag_GNU_S390_ABI_Vector: ");
15648 READ_ULEB (val
, p
, end
);
15653 printf (_("any\n"));
15656 printf (_("software\n"));
15659 printf (_("hardware\n"));
15662 printf ("??? (%d)\n", val
);
15668 return display_tag_value (tag
& 1, p
, end
);
15672 display_sparc_hwcaps (unsigned int mask
)
15676 bfd_boolean first
= TRUE
;
15678 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15679 fputs ("mul32", stdout
), first
= FALSE
;
15680 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15681 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15682 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15683 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15684 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15685 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15686 if (mask
& ELF_SPARC_HWCAP_POPC
)
15687 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15688 if (mask
& ELF_SPARC_HWCAP_VIS
)
15689 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15690 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15691 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15692 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15693 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15694 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15695 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15696 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15697 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15698 if (mask
& ELF_SPARC_HWCAP_HPC
)
15699 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15700 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15701 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15702 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15703 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15704 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15705 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15706 if (mask
& ELF_SPARC_HWCAP_IMA
)
15707 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15708 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15709 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15712 fputc ('0', stdout
);
15713 fputc ('\n', stdout
);
15717 display_sparc_hwcaps2 (unsigned int mask
)
15721 bfd_boolean first
= TRUE
;
15723 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15724 fputs ("fjathplus", stdout
), first
= FALSE
;
15725 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15726 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15727 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15728 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15729 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15730 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15731 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15732 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15733 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15734 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15735 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15736 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15737 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15738 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15739 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15740 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15741 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15742 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15743 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15744 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15747 fputc ('0', stdout
);
15748 fputc ('\n', stdout
);
15751 static unsigned char *
15752 display_sparc_gnu_attribute (unsigned char * p
,
15754 const unsigned char * const end
)
15758 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15760 READ_ULEB (val
, p
, end
);
15761 printf (" Tag_GNU_Sparc_HWCAPS: ");
15762 display_sparc_hwcaps (val
);
15765 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15767 READ_ULEB (val
, p
, end
);
15768 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15769 display_sparc_hwcaps2 (val
);
15773 return display_tag_value (tag
, p
, end
);
15777 print_mips_fp_abi_value (unsigned int val
)
15781 case Val_GNU_MIPS_ABI_FP_ANY
:
15782 printf (_("Hard or soft float\n"));
15784 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15785 printf (_("Hard float (double precision)\n"));
15787 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15788 printf (_("Hard float (single precision)\n"));
15790 case Val_GNU_MIPS_ABI_FP_SOFT
:
15791 printf (_("Soft float\n"));
15793 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15794 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15796 case Val_GNU_MIPS_ABI_FP_XX
:
15797 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15799 case Val_GNU_MIPS_ABI_FP_64
:
15800 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15802 case Val_GNU_MIPS_ABI_FP_64A
:
15803 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15805 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15806 printf (_("NaN 2008 compatibility\n"));
15809 printf ("??? (%d)\n", val
);
15814 static unsigned char *
15815 display_mips_gnu_attribute (unsigned char * p
,
15817 const unsigned char * const end
)
15819 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15823 printf (" Tag_GNU_MIPS_ABI_FP: ");
15824 READ_ULEB (val
, p
, end
);
15825 print_mips_fp_abi_value (val
);
15829 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15833 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15834 READ_ULEB (val
, p
, end
);
15838 case Val_GNU_MIPS_ABI_MSA_ANY
:
15839 printf (_("Any MSA or not\n"));
15841 case Val_GNU_MIPS_ABI_MSA_128
:
15842 printf (_("128-bit MSA\n"));
15845 printf ("??? (%d)\n", val
);
15851 return display_tag_value (tag
& 1, p
, end
);
15854 static unsigned char *
15855 display_tic6x_attribute (unsigned char * p
,
15856 const unsigned char * const end
)
15861 READ_ULEB (tag
, p
, end
);
15866 printf (" Tag_ISA: ");
15867 READ_ULEB (val
, p
, end
);
15871 case C6XABI_Tag_ISA_none
:
15872 printf (_("None\n"));
15874 case C6XABI_Tag_ISA_C62X
:
15877 case C6XABI_Tag_ISA_C67X
:
15880 case C6XABI_Tag_ISA_C67XP
:
15881 printf ("C67x+\n");
15883 case C6XABI_Tag_ISA_C64X
:
15886 case C6XABI_Tag_ISA_C64XP
:
15887 printf ("C64x+\n");
15889 case C6XABI_Tag_ISA_C674X
:
15890 printf ("C674x\n");
15893 printf ("??? (%d)\n", val
);
15898 case Tag_ABI_wchar_t
:
15899 printf (" Tag_ABI_wchar_t: ");
15900 READ_ULEB (val
, p
, end
);
15904 printf (_("Not used\n"));
15907 printf (_("2 bytes\n"));
15910 printf (_("4 bytes\n"));
15913 printf ("??? (%d)\n", val
);
15918 case Tag_ABI_stack_align_needed
:
15919 printf (" Tag_ABI_stack_align_needed: ");
15920 READ_ULEB (val
, p
, end
);
15924 printf (_("8-byte\n"));
15927 printf (_("16-byte\n"));
15930 printf ("??? (%d)\n", val
);
15935 case Tag_ABI_stack_align_preserved
:
15936 READ_ULEB (val
, p
, end
);
15937 printf (" Tag_ABI_stack_align_preserved: ");
15941 printf (_("8-byte\n"));
15944 printf (_("16-byte\n"));
15947 printf ("??? (%d)\n", val
);
15953 READ_ULEB (val
, p
, end
);
15954 printf (" Tag_ABI_DSBT: ");
15958 printf (_("DSBT addressing not used\n"));
15961 printf (_("DSBT addressing used\n"));
15964 printf ("??? (%d)\n", val
);
15970 READ_ULEB (val
, p
, end
);
15971 printf (" Tag_ABI_PID: ");
15975 printf (_("Data addressing position-dependent\n"));
15978 printf (_("Data addressing position-independent, GOT near DP\n"));
15981 printf (_("Data addressing position-independent, GOT far from DP\n"));
15984 printf ("??? (%d)\n", val
);
15990 READ_ULEB (val
, p
, end
);
15991 printf (" Tag_ABI_PIC: ");
15995 printf (_("Code addressing position-dependent\n"));
15998 printf (_("Code addressing position-independent\n"));
16001 printf ("??? (%d)\n", val
);
16006 case Tag_ABI_array_object_alignment
:
16007 READ_ULEB (val
, p
, end
);
16008 printf (" Tag_ABI_array_object_alignment: ");
16012 printf (_("8-byte\n"));
16015 printf (_("4-byte\n"));
16018 printf (_("16-byte\n"));
16021 printf ("??? (%d)\n", val
);
16026 case Tag_ABI_array_object_align_expected
:
16027 READ_ULEB (val
, p
, end
);
16028 printf (" Tag_ABI_array_object_align_expected: ");
16032 printf (_("8-byte\n"));
16035 printf (_("4-byte\n"));
16038 printf (_("16-byte\n"));
16041 printf ("??? (%d)\n", val
);
16046 case Tag_ABI_compatibility
:
16048 READ_ULEB (val
, p
, end
);
16049 printf (" Tag_ABI_compatibility: ");
16050 printf (_("flag = %d, vendor = "), val
);
16053 size_t maxlen
= (end
- p
) - 1;
16055 print_symbol ((int) maxlen
, (const char *) p
);
16056 p
+= strnlen ((char *) p
, maxlen
) + 1;
16060 printf (_("<corrupt>"));
16061 p
= (unsigned char *) end
;
16067 case Tag_ABI_conformance
:
16069 printf (" Tag_ABI_conformance: \"");
16072 size_t maxlen
= (end
- p
) - 1;
16074 print_symbol ((int) maxlen
, (const char *) p
);
16075 p
+= strnlen ((char *) p
, maxlen
) + 1;
16079 printf (_("<corrupt>"));
16080 p
= (unsigned char *) end
;
16087 return display_tag_value (tag
, p
, end
);
16091 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16093 unsigned long addr
= 0;
16094 size_t bytes
= end
- p
;
16101 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16103 printf (" 0x%8.8lx ", addr
);
16105 for (j
= 0; j
< 16; j
++)
16108 printf ("%2.2x", p
[j
]);
16116 for (j
= 0; j
< lbytes
; j
++)
16119 if (k
>= ' ' && k
< 0x7f)
16135 static unsigned char *
16136 display_msp430x_attribute (unsigned char * p
,
16137 const unsigned char * const end
)
16142 READ_ULEB (tag
, p
, end
);
16146 case OFBA_MSPABI_Tag_ISA
:
16147 printf (" Tag_ISA: ");
16148 READ_ULEB (val
, p
, end
);
16151 case 0: printf (_("None\n")); break;
16152 case 1: printf (_("MSP430\n")); break;
16153 case 2: printf (_("MSP430X\n")); break;
16154 default: printf ("??? (%d)\n", val
); break;
16158 case OFBA_MSPABI_Tag_Code_Model
:
16159 printf (" Tag_Code_Model: ");
16160 READ_ULEB (val
, p
, end
);
16163 case 0: printf (_("None\n")); break;
16164 case 1: printf (_("Small\n")); break;
16165 case 2: printf (_("Large\n")); break;
16166 default: printf ("??? (%d)\n", val
); break;
16170 case OFBA_MSPABI_Tag_Data_Model
:
16171 printf (" Tag_Data_Model: ");
16172 READ_ULEB (val
, p
, end
);
16175 case 0: printf (_("None\n")); break;
16176 case 1: printf (_("Small\n")); break;
16177 case 2: printf (_("Large\n")); break;
16178 case 3: printf (_("Restricted Large\n")); break;
16179 default: printf ("??? (%d)\n", val
); break;
16184 printf (_(" <unknown tag %d>: "), tag
);
16191 size_t maxlen
= (end
- p
) - 1;
16193 print_symbol ((int) maxlen
, (const char *) p
);
16194 p
+= strnlen ((char *) p
, maxlen
) + 1;
16198 printf (_("<corrupt>"));
16199 p
= (unsigned char *) end
;
16205 READ_ULEB (val
, p
, end
);
16206 printf ("%d (0x%x)\n", val
, val
);
16215 static unsigned char *
16216 display_msp430_gnu_attribute (unsigned char * p
,
16218 const unsigned char * const end
)
16220 if (tag
== Tag_GNU_MSP430_Data_Region
)
16224 printf (" Tag_GNU_MSP430_Data_Region: ");
16225 READ_ULEB (val
, p
, end
);
16229 case Val_GNU_MSP430_Data_Region_Any
:
16230 printf (_("Any Region\n"));
16232 case Val_GNU_MSP430_Data_Region_Lower
:
16233 printf (_("Lower Region Only\n"));
16236 printf ("??? (%u)\n", val
);
16240 return display_tag_value (tag
& 1, p
, end
);
16243 struct riscv_attr_tag_t
{
16248 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16250 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16253 T(priv_spec_minor
),
16254 T(priv_spec_revision
),
16255 T(unaligned_access
),
16260 static unsigned char *
16261 display_riscv_attribute (unsigned char *p
,
16262 const unsigned char * const end
)
16266 struct riscv_attr_tag_t
*attr
= NULL
;
16269 READ_ULEB (tag
, p
, end
);
16271 /* Find the name of attribute. */
16272 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16274 if (riscv_attr_tag
[i
].tag
== tag
)
16276 attr
= &riscv_attr_tag
[i
];
16282 printf (" %s: ", attr
->name
);
16284 return display_tag_value (tag
, p
, end
);
16288 case Tag_RISCV_priv_spec
:
16289 case Tag_RISCV_priv_spec_minor
:
16290 case Tag_RISCV_priv_spec_revision
:
16291 READ_ULEB (val
, p
, end
);
16292 printf (_("%u\n"), val
);
16294 case Tag_RISCV_unaligned_access
:
16295 READ_ULEB (val
, p
, end
);
16299 printf (_("No unaligned access\n"));
16302 printf (_("Unaligned access\n"));
16306 case Tag_RISCV_stack_align
:
16307 READ_ULEB (val
, p
, end
);
16308 printf (_("%u-bytes\n"), val
);
16310 case Tag_RISCV_arch
:
16311 p
= display_tag_value (-1, p
, end
);
16314 return display_tag_value (tag
, p
, end
);
16321 process_attributes (Filedata
* filedata
,
16322 const char * public_name
,
16323 unsigned int proc_type
,
16324 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16325 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16327 Elf_Internal_Shdr
* sect
;
16329 bfd_boolean res
= TRUE
;
16331 /* Find the section header so that we get the size. */
16332 for (i
= 0, sect
= filedata
->section_headers
;
16333 i
< filedata
->file_header
.e_shnum
;
16336 unsigned char * contents
;
16339 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16342 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16343 sect
->sh_size
, _("attributes"));
16344 if (contents
== NULL
)
16351 /* The first character is the version of the attributes.
16352 Currently only version 1, (aka 'A') is recognised here. */
16355 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16360 bfd_vma section_len
;
16362 section_len
= sect
->sh_size
- 1;
16365 while (section_len
> 0)
16368 unsigned int namelen
;
16369 bfd_boolean public_section
;
16370 bfd_boolean gnu_section
;
16372 if (section_len
<= 4)
16374 error (_("Tag section ends prematurely\n"));
16378 attr_len
= byte_get (p
, 4);
16381 if (attr_len
> section_len
)
16383 error (_("Bad attribute length (%u > %u)\n"),
16384 (unsigned) attr_len
, (unsigned) section_len
);
16385 attr_len
= section_len
;
16388 /* PR 17531: file: 001-101425-0.004 */
16389 else if (attr_len
< 5)
16391 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16396 section_len
-= attr_len
;
16399 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16400 if (namelen
== 0 || namelen
>= attr_len
)
16402 error (_("Corrupt attribute section name\n"));
16407 printf (_("Attribute Section: "));
16408 print_symbol (INT_MAX
, (const char *) p
);
16411 if (public_name
&& streq ((char *) p
, public_name
))
16412 public_section
= TRUE
;
16414 public_section
= FALSE
;
16416 if (streq ((char *) p
, "gnu"))
16417 gnu_section
= TRUE
;
16419 gnu_section
= FALSE
;
16422 attr_len
-= namelen
;
16424 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16429 unsigned char * end
;
16431 /* PR binutils/17531: Safe handling of corrupt files. */
16434 error (_("Unused bytes at end of section\n"));
16441 size
= byte_get (p
, 4);
16442 if (size
> attr_len
)
16444 error (_("Bad subsection length (%u > %u)\n"),
16445 (unsigned) size
, (unsigned) attr_len
);
16449 /* PR binutils/17531: Safe handling of corrupt files. */
16452 error (_("Bad subsection length (%u < 6)\n"),
16460 end
= p
+ size
- 1;
16461 assert (end
<= contents
+ sect
->sh_size
);
16467 printf (_("File Attributes\n"));
16470 printf (_("Section Attributes:"));
16473 printf (_("Symbol Attributes:"));
16474 /* Fall through. */
16478 READ_ULEB (val
, p
, end
);
16481 printf (" %d", val
);
16486 printf (_("Unknown tag: %d\n"), tag
);
16487 public_section
= FALSE
;
16491 if (public_section
&& display_pub_attribute
!= NULL
)
16494 p
= display_pub_attribute (p
, end
);
16497 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16500 p
= display_gnu_attribute (p
,
16501 display_proc_gnu_attribute
,
16507 printf (_(" Unknown attribute:\n"));
16508 display_raw_attribute (p
, end
);
16523 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16524 Print the Address, Access and Initial fields of an entry at VMA ADDR
16525 and return the VMA of the next entry, or -1 if there was a problem.
16526 Does not read from DATA_END or beyond. */
16529 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16530 unsigned char * data_end
)
16533 print_vma (addr
, LONG_HEX
);
16535 if (addr
< pltgot
+ 0xfff0)
16536 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16538 printf ("%10s", "");
16541 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16545 unsigned char * from
= data
+ addr
- pltgot
;
16547 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16549 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16550 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16551 return (bfd_vma
) -1;
16555 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16556 print_vma (entry
, LONG_HEX
);
16559 return addr
+ (is_32bit_elf
? 4 : 8);
16562 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16563 PLTGOT. Print the Address and Initial fields of an entry at VMA
16564 ADDR and return the VMA of the next entry. */
16567 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16570 print_vma (addr
, LONG_HEX
);
16573 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16578 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16579 print_vma (entry
, LONG_HEX
);
16581 return addr
+ (is_32bit_elf
? 4 : 8);
16585 print_mips_ases (unsigned int mask
)
16587 if (mask
& AFL_ASE_DSP
)
16588 fputs ("\n\tDSP ASE", stdout
);
16589 if (mask
& AFL_ASE_DSPR2
)
16590 fputs ("\n\tDSP R2 ASE", stdout
);
16591 if (mask
& AFL_ASE_DSPR3
)
16592 fputs ("\n\tDSP R3 ASE", stdout
);
16593 if (mask
& AFL_ASE_EVA
)
16594 fputs ("\n\tEnhanced VA Scheme", stdout
);
16595 if (mask
& AFL_ASE_MCU
)
16596 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16597 if (mask
& AFL_ASE_MDMX
)
16598 fputs ("\n\tMDMX ASE", stdout
);
16599 if (mask
& AFL_ASE_MIPS3D
)
16600 fputs ("\n\tMIPS-3D ASE", stdout
);
16601 if (mask
& AFL_ASE_MT
)
16602 fputs ("\n\tMT ASE", stdout
);
16603 if (mask
& AFL_ASE_SMARTMIPS
)
16604 fputs ("\n\tSmartMIPS ASE", stdout
);
16605 if (mask
& AFL_ASE_VIRT
)
16606 fputs ("\n\tVZ ASE", stdout
);
16607 if (mask
& AFL_ASE_MSA
)
16608 fputs ("\n\tMSA ASE", stdout
);
16609 if (mask
& AFL_ASE_MIPS16
)
16610 fputs ("\n\tMIPS16 ASE", stdout
);
16611 if (mask
& AFL_ASE_MICROMIPS
)
16612 fputs ("\n\tMICROMIPS ASE", stdout
);
16613 if (mask
& AFL_ASE_XPA
)
16614 fputs ("\n\tXPA ASE", stdout
);
16615 if (mask
& AFL_ASE_MIPS16E2
)
16616 fputs ("\n\tMIPS16e2 ASE", stdout
);
16617 if (mask
& AFL_ASE_CRC
)
16618 fputs ("\n\tCRC ASE", stdout
);
16619 if (mask
& AFL_ASE_GINV
)
16620 fputs ("\n\tGINV ASE", stdout
);
16621 if (mask
& AFL_ASE_LOONGSON_MMI
)
16622 fputs ("\n\tLoongson MMI ASE", stdout
);
16623 if (mask
& AFL_ASE_LOONGSON_CAM
)
16624 fputs ("\n\tLoongson CAM ASE", stdout
);
16625 if (mask
& AFL_ASE_LOONGSON_EXT
)
16626 fputs ("\n\tLoongson EXT ASE", stdout
);
16627 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16628 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16630 fprintf (stdout
, "\n\t%s", _("None"));
16631 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16632 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16636 print_mips_isa_ext (unsigned int isa_ext
)
16641 fputs (_("None"), stdout
);
16644 fputs ("RMI XLR", stdout
);
16646 case AFL_EXT_OCTEON3
:
16647 fputs ("Cavium Networks Octeon3", stdout
);
16649 case AFL_EXT_OCTEON2
:
16650 fputs ("Cavium Networks Octeon2", stdout
);
16652 case AFL_EXT_OCTEONP
:
16653 fputs ("Cavium Networks OcteonP", stdout
);
16655 case AFL_EXT_OCTEON
:
16656 fputs ("Cavium Networks Octeon", stdout
);
16659 fputs ("Toshiba R5900", stdout
);
16662 fputs ("MIPS R4650", stdout
);
16665 fputs ("LSI R4010", stdout
);
16668 fputs ("NEC VR4100", stdout
);
16671 fputs ("Toshiba R3900", stdout
);
16673 case AFL_EXT_10000
:
16674 fputs ("MIPS R10000", stdout
);
16677 fputs ("Broadcom SB-1", stdout
);
16680 fputs ("NEC VR4111/VR4181", stdout
);
16683 fputs ("NEC VR4120", stdout
);
16686 fputs ("NEC VR5400", stdout
);
16689 fputs ("NEC VR5500", stdout
);
16691 case AFL_EXT_LOONGSON_2E
:
16692 fputs ("ST Microelectronics Loongson 2E", stdout
);
16694 case AFL_EXT_LOONGSON_2F
:
16695 fputs ("ST Microelectronics Loongson 2F", stdout
);
16697 case AFL_EXT_INTERAPTIV_MR2
:
16698 fputs ("Imagination interAptiv MR2", stdout
);
16701 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16706 get_mips_reg_size (int reg_size
)
16708 return (reg_size
== AFL_REG_NONE
) ? 0
16709 : (reg_size
== AFL_REG_32
) ? 32
16710 : (reg_size
== AFL_REG_64
) ? 64
16711 : (reg_size
== AFL_REG_128
) ? 128
16716 process_mips_specific (Filedata
* filedata
)
16718 Elf_Internal_Dyn
* entry
;
16719 Elf_Internal_Shdr
*sect
= NULL
;
16720 size_t liblist_offset
= 0;
16721 size_t liblistno
= 0;
16722 size_t conflictsno
= 0;
16723 size_t options_offset
= 0;
16724 size_t conflicts_offset
= 0;
16725 size_t pltrelsz
= 0;
16727 bfd_vma pltgot
= 0;
16728 bfd_vma mips_pltgot
= 0;
16729 bfd_vma jmprel
= 0;
16730 bfd_vma local_gotno
= 0;
16731 bfd_vma gotsym
= 0;
16732 bfd_vma symtabno
= 0;
16733 bfd_boolean res
= TRUE
;
16735 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16736 display_mips_gnu_attribute
))
16739 sect
= find_section (filedata
, ".MIPS.abiflags");
16743 Elf_External_ABIFlags_v0
*abiflags_ext
;
16744 Elf_Internal_ABIFlags_v0 abiflags_in
;
16746 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16748 error (_("Corrupt MIPS ABI Flags section.\n"));
16753 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16754 sect
->sh_size
, _("MIPS ABI Flags section"));
16757 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16758 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16759 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16760 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16761 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16762 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16763 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16764 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16765 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16766 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16767 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16769 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16770 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16771 if (abiflags_in
.isa_rev
> 1)
16772 printf ("r%d", abiflags_in
.isa_rev
);
16773 printf ("\nGPR size: %d",
16774 get_mips_reg_size (abiflags_in
.gpr_size
));
16775 printf ("\nCPR1 size: %d",
16776 get_mips_reg_size (abiflags_in
.cpr1_size
));
16777 printf ("\nCPR2 size: %d",
16778 get_mips_reg_size (abiflags_in
.cpr2_size
));
16779 fputs ("\nFP ABI: ", stdout
);
16780 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16781 fputs ("ISA Extension: ", stdout
);
16782 print_mips_isa_ext (abiflags_in
.isa_ext
);
16783 fputs ("\nASEs:", stdout
);
16784 print_mips_ases (abiflags_in
.ases
);
16785 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16786 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16787 fputc ('\n', stdout
);
16788 free (abiflags_ext
);
16793 /* We have a lot of special sections. Thanks SGI! */
16794 if (filedata
->dynamic_section
== NULL
)
16796 /* No dynamic information available. See if there is static GOT. */
16797 sect
= find_section (filedata
, ".got");
16800 unsigned char *data_end
;
16801 unsigned char *data
;
16805 pltgot
= sect
->sh_addr
;
16808 addr_size
= (is_32bit_elf
? 4 : 8);
16809 end
= pltgot
+ sect
->sh_size
;
16811 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16813 _("Global Offset Table data"));
16814 /* PR 12855: Null data is handled gracefully throughout. */
16815 data_end
= data
+ (end
- pltgot
);
16817 printf (_("\nStatic GOT:\n"));
16818 printf (_(" Canonical gp value: "));
16819 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16822 /* In a dynamic binary GOT[0] is reserved for the dynamic
16823 loader to store the lazy resolver pointer, however in
16824 a static binary it may well have been omitted and GOT
16825 reduced to a table of addresses.
16826 PR 21344: Check for the entry being fully available
16827 before fetching it. */
16829 && data
+ ent
- pltgot
+ addr_size
<= data_end
16830 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16832 printf (_(" Reserved entries:\n"));
16833 printf (_(" %*s %10s %*s\n"),
16834 addr_size
* 2, _("Address"), _("Access"),
16835 addr_size
* 2, _("Value"));
16836 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16838 if (ent
== (bfd_vma
) -1)
16839 goto sgot_print_fail
;
16841 /* Check for the MSB of GOT[1] being set, identifying a
16842 GNU object. This entry will be used by some runtime
16843 loaders, to store the module pointer. Otherwise this
16844 is an ordinary local entry.
16845 PR 21344: Check for the entry being fully available
16846 before fetching it. */
16848 && data
+ ent
- pltgot
+ addr_size
<= data_end
16849 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16850 >> (addr_size
* 8 - 1)) != 0)
16852 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16854 if (ent
== (bfd_vma
) -1)
16855 goto sgot_print_fail
;
16860 if (data
!= NULL
&& ent
< end
)
16862 printf (_(" Local entries:\n"));
16863 printf (" %*s %10s %*s\n",
16864 addr_size
* 2, _("Address"), _("Access"),
16865 addr_size
* 2, _("Value"));
16868 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16870 if (ent
== (bfd_vma
) -1)
16871 goto sgot_print_fail
;
16882 for (entry
= filedata
->dynamic_section
;
16883 /* PR 17531 file: 012-50589-0.004. */
16884 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16885 && entry
->d_tag
!= DT_NULL
);
16887 switch (entry
->d_tag
)
16889 case DT_MIPS_LIBLIST
:
16891 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16892 liblistno
* sizeof (Elf32_External_Lib
));
16894 case DT_MIPS_LIBLISTNO
:
16895 liblistno
= entry
->d_un
.d_val
;
16897 case DT_MIPS_OPTIONS
:
16898 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16900 case DT_MIPS_CONFLICT
:
16902 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16903 conflictsno
* sizeof (Elf32_External_Conflict
));
16905 case DT_MIPS_CONFLICTNO
:
16906 conflictsno
= entry
->d_un
.d_val
;
16909 pltgot
= entry
->d_un
.d_ptr
;
16911 case DT_MIPS_LOCAL_GOTNO
:
16912 local_gotno
= entry
->d_un
.d_val
;
16914 case DT_MIPS_GOTSYM
:
16915 gotsym
= entry
->d_un
.d_val
;
16917 case DT_MIPS_SYMTABNO
:
16918 symtabno
= entry
->d_un
.d_val
;
16920 case DT_MIPS_PLTGOT
:
16921 mips_pltgot
= entry
->d_un
.d_ptr
;
16924 pltrel
= entry
->d_un
.d_val
;
16927 pltrelsz
= entry
->d_un
.d_val
;
16930 jmprel
= entry
->d_un
.d_ptr
;
16936 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16938 Elf32_External_Lib
* elib
;
16941 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16942 sizeof (Elf32_External_Lib
),
16944 _("liblist section data"));
16947 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16948 "\nSection '.liblist' contains %lu entries:\n",
16949 (unsigned long) liblistno
),
16950 (unsigned long) liblistno
);
16951 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16954 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16961 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16962 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16963 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16964 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16965 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16967 tmp
= gmtime (&atime
);
16968 snprintf (timebuf
, sizeof (timebuf
),
16969 "%04u-%02u-%02uT%02u:%02u:%02u",
16970 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16971 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16973 printf ("%3lu: ", (unsigned long) cnt
);
16974 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
16975 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
16977 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16978 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16979 liblist
.l_version
);
16981 if (liblist
.l_flags
== 0)
16985 static const struct
16992 { " EXACT_MATCH", LL_EXACT_MATCH
},
16993 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16994 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16995 { " EXPORTS", LL_EXPORTS
},
16996 { " DELAY_LOAD", LL_DELAY_LOAD
},
16997 { " DELTA", LL_DELTA
}
16999 int flags
= liblist
.l_flags
;
17002 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17003 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17005 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17006 flags
^= l_flags_vals
[fcnt
].bit
;
17009 printf (" %#x", (unsigned int) flags
);
17021 if (options_offset
!= 0)
17023 Elf_External_Options
* eopt
;
17026 sect
= filedata
->section_headers
;
17028 /* Find the section header so that we get the size. */
17029 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17030 /* PR 17533 file: 012-277276-0.004. */
17033 error (_("No MIPS_OPTIONS header found\n"));
17037 if (sect
->sh_size
< sizeof (* eopt
))
17039 error (_("The MIPS options section is too small.\n"));
17043 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17044 sect
->sh_size
, _("options"));
17047 Elf_Internal_Options option
;
17050 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17052 Elf_External_Options
* eoption
;
17053 unsigned int optsize
;
17055 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17057 optsize
= BYTE_GET (eoption
->size
);
17059 /* PR 17531: file: ffa0fa3b. */
17060 if (optsize
< sizeof (* eopt
)
17061 || optsize
> sect
->sh_size
- offset
)
17063 error (_("Invalid size (%u) for MIPS option\n"),
17072 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17073 "\nSection '%s' contains %d entries:\n",
17075 printable_section_name (filedata
, sect
), cnt
);
17081 Elf_External_Options
* eoption
;
17083 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17085 option
.kind
= BYTE_GET (eoption
->kind
);
17086 option
.size
= BYTE_GET (eoption
->size
);
17087 option
.section
= BYTE_GET (eoption
->section
);
17088 option
.info
= BYTE_GET (eoption
->info
);
17090 switch (option
.kind
)
17093 /* This shouldn't happen. */
17094 printf (" NULL %" PRId16
" %" PRIx32
,
17095 option
.section
, option
.info
);
17099 printf (" REGINFO ");
17100 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17102 Elf32_External_RegInfo
* ereg
;
17103 Elf32_RegInfo reginfo
;
17106 if (option
.size
< (sizeof (Elf_External_Options
)
17107 + sizeof (Elf32_External_RegInfo
)))
17109 printf (_("<corrupt>\n"));
17110 error (_("Truncated MIPS REGINFO option\n"));
17115 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17117 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17118 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17119 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17120 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17121 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17122 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17124 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17125 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17127 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17128 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17129 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17130 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17135 Elf64_External_RegInfo
* ereg
;
17136 Elf64_Internal_RegInfo reginfo
;
17138 if (option
.size
< (sizeof (Elf_External_Options
)
17139 + sizeof (Elf64_External_RegInfo
)))
17141 printf (_("<corrupt>\n"));
17142 error (_("Truncated MIPS REGINFO option\n"));
17147 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
17148 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17149 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17150 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17151 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17152 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17153 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17155 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
17156 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17158 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17159 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17160 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17161 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17163 offset
+= option
.size
;
17166 case ODK_EXCEPTIONS
:
17167 fputs (" EXCEPTIONS fpe_min(", stdout
);
17168 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
17169 fputs (") fpe_max(", stdout
);
17170 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
17171 fputs (")", stdout
);
17173 if (option
.info
& OEX_PAGE0
)
17174 fputs (" PAGE0", stdout
);
17175 if (option
.info
& OEX_SMM
)
17176 fputs (" SMM", stdout
);
17177 if (option
.info
& OEX_FPDBUG
)
17178 fputs (" FPDBUG", stdout
);
17179 if (option
.info
& OEX_DISMISS
)
17180 fputs (" DISMISS", stdout
);
17184 fputs (" PAD ", stdout
);
17185 if (option
.info
& OPAD_PREFIX
)
17186 fputs (" PREFIX", stdout
);
17187 if (option
.info
& OPAD_POSTFIX
)
17188 fputs (" POSTFIX", stdout
);
17189 if (option
.info
& OPAD_SYMBOL
)
17190 fputs (" SYMBOL", stdout
);
17194 fputs (" HWPATCH ", stdout
);
17195 if (option
.info
& OHW_R4KEOP
)
17196 fputs (" R4KEOP", stdout
);
17197 if (option
.info
& OHW_R8KPFETCH
)
17198 fputs (" R8KPFETCH", stdout
);
17199 if (option
.info
& OHW_R5KEOP
)
17200 fputs (" R5KEOP", stdout
);
17201 if (option
.info
& OHW_R5KCVTL
)
17202 fputs (" R5KCVTL", stdout
);
17206 fputs (" FILL ", stdout
);
17207 /* XXX Print content of info word? */
17211 fputs (" TAGS ", stdout
);
17212 /* XXX Print content of info word? */
17216 fputs (" HWAND ", stdout
);
17217 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17218 fputs (" R4KEOP_CHECKED", stdout
);
17219 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17220 fputs (" R4KEOP_CLEAN", stdout
);
17224 fputs (" HWOR ", stdout
);
17225 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17226 fputs (" R4KEOP_CHECKED", stdout
);
17227 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17228 fputs (" R4KEOP_CLEAN", stdout
);
17232 printf (" GP_GROUP %#06x self-contained %#06x",
17233 option
.info
& OGP_GROUP
,
17234 (option
.info
& OGP_SELF
) >> 16);
17238 printf (" IDENT %#06x self-contained %#06x",
17239 option
.info
& OGP_GROUP
,
17240 (option
.info
& OGP_SELF
) >> 16);
17244 /* This shouldn't happen. */
17245 printf (" %3d ??? %" PRId16
" %" PRIx32
,
17246 option
.kind
, option
.section
, option
.info
);
17250 len
= sizeof (* eopt
);
17251 while (len
< option
.size
)
17253 unsigned char datum
= *((unsigned char *) eoption
+ len
);
17255 if (ISPRINT (datum
))
17256 printf ("%c", datum
);
17258 printf ("\\%03o", datum
);
17261 fputs ("\n", stdout
);
17263 offset
+= option
.size
;
17271 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17273 Elf32_Conflict
* iconf
;
17276 if (filedata
->dynamic_symbols
== NULL
)
17278 error (_("conflict list found without a dynamic symbol table\n"));
17282 /* PR 21345 - print a slightly more helpful error message
17283 if we are sure that the cmalloc will fail. */
17284 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17286 error (_("Overlarge number of conflicts detected: %lx\n"),
17287 (long) conflictsno
);
17291 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17294 error (_("Out of memory allocating space for dynamic conflicts\n"));
17300 Elf32_External_Conflict
* econf32
;
17302 econf32
= (Elf32_External_Conflict
*)
17303 get_data (NULL
, filedata
, conflicts_offset
,
17304 sizeof (*econf32
), conflictsno
, _("conflict"));
17311 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17312 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17318 Elf64_External_Conflict
* econf64
;
17320 econf64
= (Elf64_External_Conflict
*)
17321 get_data (NULL
, filedata
, conflicts_offset
,
17322 sizeof (*econf64
), conflictsno
, _("conflict"));
17329 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17330 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17335 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17336 "\nSection '.conflict' contains %lu entries:\n",
17337 (unsigned long) conflictsno
),
17338 (unsigned long) conflictsno
);
17339 puts (_(" Num: Index Value Name"));
17341 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17343 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17345 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17346 printf (_("<corrupt symbol index>"));
17349 Elf_Internal_Sym
* psym
;
17351 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17352 print_vma (psym
->st_value
, FULL_HEX
);
17354 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17355 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17357 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17365 if (pltgot
!= 0 && local_gotno
!= 0)
17367 bfd_vma ent
, local_end
, global_end
;
17369 unsigned char * data
;
17370 unsigned char * data_end
;
17374 addr_size
= (is_32bit_elf
? 4 : 8);
17375 local_end
= pltgot
+ local_gotno
* addr_size
;
17377 /* PR binutils/17533 file: 012-111227-0.004 */
17378 if (symtabno
< gotsym
)
17380 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17381 (unsigned long) gotsym
, (unsigned long) symtabno
);
17385 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17386 /* PR 17531: file: 54c91a34. */
17387 if (global_end
< local_end
)
17389 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17393 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17394 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17395 global_end
- pltgot
, 1,
17396 _("Global Offset Table data"));
17397 /* PR 12855: Null data is handled gracefully throughout. */
17398 data_end
= data
+ (global_end
- pltgot
);
17400 printf (_("\nPrimary GOT:\n"));
17401 printf (_(" Canonical gp value: "));
17402 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17405 printf (_(" Reserved entries:\n"));
17406 printf (_(" %*s %10s %*s Purpose\n"),
17407 addr_size
* 2, _("Address"), _("Access"),
17408 addr_size
* 2, _("Initial"));
17409 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17410 printf (_(" Lazy resolver\n"));
17411 if (ent
== (bfd_vma
) -1)
17412 goto got_print_fail
;
17414 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17415 This entry will be used by some runtime loaders, to store the
17416 module pointer. Otherwise this is an ordinary local entry.
17417 PR 21344: Check for the entry being fully available before
17420 && data
+ ent
- pltgot
+ addr_size
<= data_end
17421 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17422 >> (addr_size
* 8 - 1)) != 0)
17424 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17425 printf (_(" Module pointer (GNU extension)\n"));
17426 if (ent
== (bfd_vma
) -1)
17427 goto got_print_fail
;
17431 if (data
!= NULL
&& ent
< local_end
)
17433 printf (_(" Local entries:\n"));
17434 printf (" %*s %10s %*s\n",
17435 addr_size
* 2, _("Address"), _("Access"),
17436 addr_size
* 2, _("Initial"));
17437 while (ent
< local_end
)
17439 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17441 if (ent
== (bfd_vma
) -1)
17442 goto got_print_fail
;
17447 if (data
!= NULL
&& gotsym
< symtabno
)
17451 printf (_(" Global entries:\n"));
17452 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17453 addr_size
* 2, _("Address"),
17455 addr_size
* 2, _("Initial"),
17456 addr_size
* 2, _("Sym.Val."),
17458 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17459 _("Ndx"), _("Name"));
17461 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17463 for (i
= gotsym
; i
< symtabno
; i
++)
17465 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17468 if (filedata
->dynamic_symbols
== NULL
)
17469 printf (_("<no dynamic symbols>"));
17470 else if (i
< filedata
->num_dynamic_syms
)
17472 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17474 print_vma (psym
->st_value
, LONG_HEX
);
17475 printf (" %-7s %3s ",
17476 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17477 get_symbol_index_type (filedata
, psym
->st_shndx
));
17479 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17480 print_symbol (sym_width
,
17481 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17483 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17486 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17487 (unsigned long) i
);
17490 if (ent
== (bfd_vma
) -1)
17500 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17503 size_t offset
, rel_offset
;
17504 unsigned long count
, i
;
17505 unsigned char * data
;
17506 int addr_size
, sym_width
;
17507 Elf_Internal_Rela
* rels
;
17509 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17510 if (pltrel
== DT_RELA
)
17512 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17517 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17522 addr_size
= (is_32bit_elf
? 4 : 8);
17523 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17525 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17526 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17527 1, _("Procedure Linkage Table data"));
17531 printf ("\nPLT GOT:\n\n");
17532 printf (_(" Reserved entries:\n"));
17533 printf (_(" %*s %*s Purpose\n"),
17534 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17535 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17536 printf (_(" PLT lazy resolver\n"));
17537 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17538 printf (_(" Module pointer\n"));
17541 printf (_(" Entries:\n"));
17542 printf (" %*s %*s %*s %-7s %3s %s\n",
17543 addr_size
* 2, _("Address"),
17544 addr_size
* 2, _("Initial"),
17545 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17546 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17547 for (i
= 0; i
< count
; i
++)
17549 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17551 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17554 if (idx
>= filedata
->num_dynamic_syms
)
17555 printf (_("<corrupt symbol index: %lu>"), idx
);
17558 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17560 print_vma (psym
->st_value
, LONG_HEX
);
17561 printf (" %-7s %3s ",
17562 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17563 get_symbol_index_type (filedata
, psym
->st_shndx
));
17564 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17565 print_symbol (sym_width
,
17566 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17568 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17582 process_nds32_specific (Filedata
* filedata
)
17584 Elf_Internal_Shdr
*sect
= NULL
;
17586 sect
= find_section (filedata
, ".nds32_e_flags");
17587 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17589 unsigned char *buf
;
17592 printf ("\nNDS32 elf flags section:\n");
17593 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17594 _("NDS32 elf flags section"));
17599 flag
= byte_get (buf
, 4);
17601 switch (flag
& 0x3)
17604 printf ("(VEC_SIZE):\tNo entry.\n");
17607 printf ("(VEC_SIZE):\t4 bytes\n");
17610 printf ("(VEC_SIZE):\t16 bytes\n");
17613 printf ("(VEC_SIZE):\treserved\n");
17622 process_gnu_liblist (Filedata
* filedata
)
17624 Elf_Internal_Shdr
* section
;
17625 Elf_Internal_Shdr
* string_sec
;
17626 Elf32_External_Lib
* elib
;
17628 size_t strtab_size
;
17630 unsigned long num_liblist
;
17632 bfd_boolean res
= TRUE
;
17637 for (i
= 0, section
= filedata
->section_headers
;
17638 i
< filedata
->file_header
.e_shnum
;
17641 switch (section
->sh_type
)
17643 case SHT_GNU_LIBLIST
:
17644 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17647 elib
= (Elf32_External_Lib
*)
17648 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17649 _("liblist section data"));
17657 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17658 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17659 string_sec
->sh_size
,
17660 _("liblist string table"));
17662 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17669 strtab_size
= string_sec
->sh_size
;
17671 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17672 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17673 "\nLibrary list section '%s' contains %lu entries:\n",
17675 printable_section_name (filedata
, section
),
17678 puts (_(" Library Time Stamp Checksum Version Flags"));
17680 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17688 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17689 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17690 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17691 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17692 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17694 tmp
= gmtime (&atime
);
17695 snprintf (timebuf
, sizeof (timebuf
),
17696 "%04u-%02u-%02uT%02u:%02u:%02u",
17697 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17698 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17700 printf ("%3lu: ", (unsigned long) cnt
);
17702 printf ("%-20s", liblist
.l_name
< strtab_size
17703 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17705 printf ("%-20.20s", liblist
.l_name
< strtab_size
17706 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17707 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17708 liblist
.l_version
, liblist
.l_flags
);
17719 static const char *
17720 get_note_type (Filedata
* filedata
, unsigned e_type
)
17722 static char buff
[64];
17724 if (filedata
->file_header
.e_type
== ET_CORE
)
17728 return _("NT_AUXV (auxiliary vector)");
17730 return _("NT_PRSTATUS (prstatus structure)");
17732 return _("NT_FPREGSET (floating point registers)");
17734 return _("NT_PRPSINFO (prpsinfo structure)");
17735 case NT_TASKSTRUCT
:
17736 return _("NT_TASKSTRUCT (task structure)");
17738 return _("NT_PRXFPREG (user_xfpregs structure)");
17740 return _("NT_PPC_VMX (ppc Altivec registers)");
17742 return _("NT_PPC_VSX (ppc VSX registers)");
17744 return _("NT_PPC_TAR (ppc TAR register)");
17746 return _("NT_PPC_PPR (ppc PPR register)");
17748 return _("NT_PPC_DSCR (ppc DSCR register)");
17750 return _("NT_PPC_EBB (ppc EBB registers)");
17752 return _("NT_PPC_PMU (ppc PMU registers)");
17753 case NT_PPC_TM_CGPR
:
17754 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17755 case NT_PPC_TM_CFPR
:
17756 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17757 case NT_PPC_TM_CVMX
:
17758 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17759 case NT_PPC_TM_CVSX
:
17760 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17761 case NT_PPC_TM_SPR
:
17762 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17763 case NT_PPC_TM_CTAR
:
17764 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17765 case NT_PPC_TM_CPPR
:
17766 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17767 case NT_PPC_TM_CDSCR
:
17768 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17770 return _("NT_386_TLS (x86 TLS information)");
17771 case NT_386_IOPERM
:
17772 return _("NT_386_IOPERM (x86 I/O permissions)");
17773 case NT_X86_XSTATE
:
17774 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17775 case NT_S390_HIGH_GPRS
:
17776 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17777 case NT_S390_TIMER
:
17778 return _("NT_S390_TIMER (s390 timer register)");
17779 case NT_S390_TODCMP
:
17780 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17781 case NT_S390_TODPREG
:
17782 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17784 return _("NT_S390_CTRS (s390 control registers)");
17785 case NT_S390_PREFIX
:
17786 return _("NT_S390_PREFIX (s390 prefix register)");
17787 case NT_S390_LAST_BREAK
:
17788 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17789 case NT_S390_SYSTEM_CALL
:
17790 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17792 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17793 case NT_S390_VXRS_LOW
:
17794 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17795 case NT_S390_VXRS_HIGH
:
17796 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17797 case NT_S390_GS_CB
:
17798 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17799 case NT_S390_GS_BC
:
17800 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17802 return _("NT_ARM_VFP (arm VFP registers)");
17804 return _("NT_ARM_TLS (AArch TLS registers)");
17805 case NT_ARM_HW_BREAK
:
17806 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17807 case NT_ARM_HW_WATCH
:
17808 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17810 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17812 return _("NT_PSTATUS (pstatus structure)");
17814 return _("NT_FPREGS (floating point registers)");
17816 return _("NT_PSINFO (psinfo structure)");
17818 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17820 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17821 case NT_WIN32PSTATUS
:
17822 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17824 return _("NT_SIGINFO (siginfo_t data)");
17826 return _("NT_FILE (mapped files)");
17834 return _("NT_VERSION (version)");
17836 return _("NT_ARCH (architecture)");
17837 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17839 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17845 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17850 print_core_note (Elf_Internal_Note
*pnote
)
17852 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17853 bfd_vma count
, page_size
;
17854 unsigned char *descdata
, *filenames
, *descend
;
17856 if (pnote
->type
!= NT_FILE
)
17866 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17867 /* Still "successful". */
17872 if (pnote
->descsz
< 2 * addr_size
)
17874 error (_(" Malformed note - too short for header\n"));
17878 descdata
= (unsigned char *) pnote
->descdata
;
17879 descend
= descdata
+ pnote
->descsz
;
17881 if (descdata
[pnote
->descsz
- 1] != '\0')
17883 error (_(" Malformed note - does not end with \\0\n"));
17887 count
= byte_get (descdata
, addr_size
);
17888 descdata
+= addr_size
;
17890 page_size
= byte_get (descdata
, addr_size
);
17891 descdata
+= addr_size
;
17893 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17894 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17896 error (_(" Malformed note - too short for supplied file count\n"));
17900 printf (_(" Page size: "));
17901 print_vma (page_size
, DEC
);
17904 printf (_(" %*s%*s%*s\n"),
17905 (int) (2 + 2 * addr_size
), _("Start"),
17906 (int) (4 + 2 * addr_size
), _("End"),
17907 (int) (4 + 2 * addr_size
), _("Page Offset"));
17908 filenames
= descdata
+ count
* 3 * addr_size
;
17909 while (count
-- > 0)
17911 bfd_vma start
, end
, file_ofs
;
17913 if (filenames
== descend
)
17915 error (_(" Malformed note - filenames end too early\n"));
17919 start
= byte_get (descdata
, addr_size
);
17920 descdata
+= addr_size
;
17921 end
= byte_get (descdata
, addr_size
);
17922 descdata
+= addr_size
;
17923 file_ofs
= byte_get (descdata
, addr_size
);
17924 descdata
+= addr_size
;
17927 print_vma (start
, FULL_HEX
);
17929 print_vma (end
, FULL_HEX
);
17931 print_vma (file_ofs
, FULL_HEX
);
17932 printf ("\n %s\n", filenames
);
17934 filenames
+= 1 + strlen ((char *) filenames
);
17940 static const char *
17941 get_gnu_elf_note_type (unsigned e_type
)
17943 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17946 case NT_GNU_ABI_TAG
:
17947 return _("NT_GNU_ABI_TAG (ABI version tag)");
17949 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17950 case NT_GNU_BUILD_ID
:
17951 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17952 case NT_GNU_GOLD_VERSION
:
17953 return _("NT_GNU_GOLD_VERSION (gold version)");
17954 case NT_GNU_PROPERTY_TYPE_0
:
17955 return _("NT_GNU_PROPERTY_TYPE_0");
17956 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17957 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17958 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17959 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17962 static char buff
[64];
17964 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17971 decode_x86_compat_isa (unsigned int bitmask
)
17975 unsigned int bit
= bitmask
& (- bitmask
);
17980 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17983 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17986 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17989 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17992 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17995 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17998 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18001 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18004 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18007 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18010 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18013 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18014 printf ("AVX512F");
18016 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18017 printf ("AVX512CD");
18019 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18020 printf ("AVX512ER");
18022 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18023 printf ("AVX512PF");
18025 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18026 printf ("AVX512VL");
18028 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18029 printf ("AVX512DQ");
18031 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18032 printf ("AVX512BW");
18035 printf (_("<unknown: %x>"), bit
);
18044 decode_x86_isa (unsigned int bitmask
)
18048 printf (_("<None>"));
18054 unsigned int bit
= bitmask
& (- bitmask
);
18059 case GNU_PROPERTY_X86_ISA_1_CMOV
:
18062 case GNU_PROPERTY_X86_ISA_1_SSE
:
18065 case GNU_PROPERTY_X86_ISA_1_SSE2
:
18068 case GNU_PROPERTY_X86_ISA_1_SSE3
:
18071 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
18074 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
18077 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
18080 case GNU_PROPERTY_X86_ISA_1_AVX
:
18083 case GNU_PROPERTY_X86_ISA_1_AVX2
:
18086 case GNU_PROPERTY_X86_ISA_1_FMA
:
18089 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
18090 printf ("AVX512F");
18092 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
18093 printf ("AVX512CD");
18095 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
18096 printf ("AVX512ER");
18098 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
18099 printf ("AVX512PF");
18101 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
18102 printf ("AVX512VL");
18104 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
18105 printf ("AVX512DQ");
18107 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
18108 printf ("AVX512BW");
18110 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
18111 printf ("AVX512_4FMAPS");
18113 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
18114 printf ("AVX512_4VNNIW");
18116 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
18117 printf ("AVX512_BITALG");
18119 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
18120 printf ("AVX512_IFMA");
18122 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
18123 printf ("AVX512_VBMI");
18125 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
18126 printf ("AVX512_VBMI2");
18128 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
18129 printf ("AVX512_VNNI");
18131 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
18132 printf ("AVX512_BF16");
18135 printf (_("<unknown: %x>"), bit
);
18144 decode_x86_feature_1 (unsigned int bitmask
)
18148 printf (_("<None>"));
18154 unsigned int bit
= bitmask
& (- bitmask
);
18159 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18162 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18166 printf (_("<unknown: %x>"), bit
);
18175 decode_x86_feature_2 (unsigned int bitmask
)
18179 printf (_("<None>"));
18185 unsigned int bit
= bitmask
& (- bitmask
);
18190 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18193 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18196 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18199 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18202 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18205 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18208 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
18211 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18214 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18217 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18218 printf ("XSAVEOPT");
18220 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18224 printf (_("<unknown: %x>"), bit
);
18233 decode_aarch64_feature_1_and (unsigned int bitmask
)
18237 unsigned int bit
= bitmask
& (- bitmask
);
18242 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18246 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18251 printf (_("<unknown: %x>"), bit
);
18260 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18262 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18263 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18264 unsigned int size
= is_32bit_elf
? 4 : 8;
18266 printf (_(" Properties: "));
18268 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18270 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18274 while (ptr
< ptr_end
)
18278 unsigned int datasz
;
18280 if ((size_t) (ptr_end
- ptr
) < 8)
18282 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18286 type
= byte_get (ptr
, 4);
18287 datasz
= byte_get (ptr
+ 4, 4);
18291 if (datasz
> (size_t) (ptr_end
- ptr
))
18293 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18298 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18300 if (filedata
->file_header
.e_machine
== EM_X86_64
18301 || filedata
->file_header
.e_machine
== EM_IAMCU
18302 || filedata
->file_header
.e_machine
== EM_386
)
18304 unsigned int bitmask
;
18307 bitmask
= byte_get (ptr
, 4);
18313 case GNU_PROPERTY_X86_ISA_1_USED
:
18315 printf (_("x86 ISA used: <corrupt length: %#x> "),
18319 printf ("x86 ISA used: ");
18320 decode_x86_isa (bitmask
);
18324 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18326 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18330 printf ("x86 ISA needed: ");
18331 decode_x86_isa (bitmask
);
18335 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18337 printf (_("x86 feature: <corrupt length: %#x> "),
18341 printf ("x86 feature: ");
18342 decode_x86_feature_1 (bitmask
);
18346 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18348 printf (_("x86 feature used: <corrupt length: %#x> "),
18352 printf ("x86 feature used: ");
18353 decode_x86_feature_2 (bitmask
);
18357 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18359 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18362 printf ("x86 feature needed: ");
18363 decode_x86_feature_2 (bitmask
);
18367 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18369 printf (_("x86 ISA used: <corrupt length: %#x> "),
18373 printf ("x86 ISA used: ");
18374 decode_x86_compat_isa (bitmask
);
18378 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18380 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18384 printf ("x86 ISA needed: ");
18385 decode_x86_compat_isa (bitmask
);
18393 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18395 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18397 printf ("AArch64 feature: ");
18399 printf (_("<corrupt length: %#x> "), datasz
);
18401 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18410 case GNU_PROPERTY_STACK_SIZE
:
18411 printf (_("stack size: "));
18412 if (datasz
!= size
)
18413 printf (_("<corrupt length: %#x> "), datasz
);
18415 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18418 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18419 printf ("no copy on protected ");
18421 printf (_("<corrupt length: %#x> "), datasz
);
18429 if (type
< GNU_PROPERTY_LOPROC
)
18430 printf (_("<unknown type %#x data: "), type
);
18431 else if (type
< GNU_PROPERTY_LOUSER
)
18432 printf (_("<procesor-specific type %#x data: "), type
);
18434 printf (_("<application-specific type %#x data: "), type
);
18435 for (j
= 0; j
< datasz
; ++j
)
18436 printf ("%02x ", ptr
[j
] & 0xff);
18440 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18441 if (ptr
== ptr_end
)
18454 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18456 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18457 switch (pnote
->type
)
18459 case NT_GNU_BUILD_ID
:
18463 printf (_(" Build ID: "));
18464 for (i
= 0; i
< pnote
->descsz
; ++i
)
18465 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18470 case NT_GNU_ABI_TAG
:
18472 unsigned long os
, major
, minor
, subminor
;
18473 const char *osname
;
18475 /* PR 17531: file: 030-599401-0.004. */
18476 if (pnote
->descsz
< 16)
18478 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18482 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18483 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18484 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18485 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18489 case GNU_ABI_TAG_LINUX
:
18492 case GNU_ABI_TAG_HURD
:
18495 case GNU_ABI_TAG_SOLARIS
:
18496 osname
= "Solaris";
18498 case GNU_ABI_TAG_FREEBSD
:
18499 osname
= "FreeBSD";
18501 case GNU_ABI_TAG_NETBSD
:
18504 case GNU_ABI_TAG_SYLLABLE
:
18505 osname
= "Syllable";
18507 case GNU_ABI_TAG_NACL
:
18511 osname
= "Unknown";
18515 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18516 major
, minor
, subminor
);
18520 case NT_GNU_GOLD_VERSION
:
18524 printf (_(" Version: "));
18525 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18526 printf ("%c", pnote
->descdata
[i
]);
18533 unsigned long num_entries
, mask
;
18535 /* Hardware capabilities information. Word 0 is the number of entries.
18536 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18537 is a series of entries, where each entry is a single byte followed
18538 by a nul terminated string. The byte gives the bit number to test
18539 if enabled in the bitmask. */
18540 printf (_(" Hardware Capabilities: "));
18541 if (pnote
->descsz
< 8)
18543 error (_("<corrupt GNU_HWCAP>\n"));
18546 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18547 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18548 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18549 /* FIXME: Add code to display the entries... */
18553 case NT_GNU_PROPERTY_TYPE_0
:
18554 print_gnu_property_note (filedata
, pnote
);
18558 /* Handle unrecognised types. An error message should have already been
18559 created by get_gnu_elf_note_type(), so all that we need to do is to
18560 display the data. */
18564 printf (_(" Description data: "));
18565 for (i
= 0; i
< pnote
->descsz
; ++i
)
18566 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18575 static const char *
18576 get_v850_elf_note_type (enum v850_notes n_type
)
18578 static char buff
[64];
18582 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18583 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18584 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18585 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18586 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18587 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18589 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18595 print_v850_note (Elf_Internal_Note
* pnote
)
18599 if (pnote
->descsz
!= 4)
18602 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18606 printf (_("not set\n"));
18610 switch (pnote
->type
)
18612 case V850_NOTE_ALIGNMENT
:
18615 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18616 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18620 case V850_NOTE_DATA_SIZE
:
18623 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18624 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18628 case V850_NOTE_FPU_INFO
:
18631 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18632 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18636 case V850_NOTE_MMU_INFO
:
18637 case V850_NOTE_CACHE_INFO
:
18638 case V850_NOTE_SIMD_INFO
:
18639 if (val
== EF_RH850_SIMD
)
18641 printf (_("yes\n"));
18647 /* An 'unknown note type' message will already have been displayed. */
18651 printf (_("unknown value: %x\n"), val
);
18656 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18658 unsigned int version
;
18660 switch (pnote
->type
)
18662 case NT_NETBSD_IDENT
:
18663 if (pnote
->descsz
< 1)
18665 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18666 if ((version
/ 10000) % 100)
18667 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18668 version
, version
/ 100000000, (version
/ 1000000) % 100,
18669 (version
/ 10000) % 100 > 26 ? "Z" : "",
18670 'A' + (version
/ 10000) % 26);
18672 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18673 version
, version
/ 100000000, (version
/ 1000000) % 100,
18674 (version
/ 100) % 100);
18677 case NT_NETBSD_MARCH
:
18678 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18682 #ifdef NT_NETBSD_PAX
18683 case NT_NETBSD_PAX
:
18684 if (pnote
->descsz
< 1)
18686 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18687 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18688 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18689 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18690 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18691 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18692 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18693 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18698 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18699 pnote
->descsz
, pnote
->type
);
18703 static const char *
18704 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18708 case NT_FREEBSD_THRMISC
:
18709 return _("NT_THRMISC (thrmisc structure)");
18710 case NT_FREEBSD_PROCSTAT_PROC
:
18711 return _("NT_PROCSTAT_PROC (proc data)");
18712 case NT_FREEBSD_PROCSTAT_FILES
:
18713 return _("NT_PROCSTAT_FILES (files data)");
18714 case NT_FREEBSD_PROCSTAT_VMMAP
:
18715 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18716 case NT_FREEBSD_PROCSTAT_GROUPS
:
18717 return _("NT_PROCSTAT_GROUPS (groups data)");
18718 case NT_FREEBSD_PROCSTAT_UMASK
:
18719 return _("NT_PROCSTAT_UMASK (umask data)");
18720 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18721 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18722 case NT_FREEBSD_PROCSTAT_OSREL
:
18723 return _("NT_PROCSTAT_OSREL (osreldate data)");
18724 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18725 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18726 case NT_FREEBSD_PROCSTAT_AUXV
:
18727 return _("NT_PROCSTAT_AUXV (auxv data)");
18728 case NT_FREEBSD_PTLWPINFO
:
18729 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18731 return get_note_type (filedata
, e_type
);
18734 static const char *
18735 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18737 static char buff
[64];
18741 case NT_NETBSDCORE_PROCINFO
:
18742 /* NetBSD core "procinfo" structure. */
18743 return _("NetBSD procinfo structure");
18745 #ifdef NT_NETBSDCORE_AUXV
18746 case NT_NETBSDCORE_AUXV
:
18747 return _("NetBSD ELF auxiliary vector data");
18750 #ifdef NT_NETBSDCORE_LWPSTATUS
18751 case NT_NETBSDCORE_LWPSTATUS
:
18752 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18756 /* As of Jan 2020 there are no other machine-independent notes
18757 defined for NetBSD core files. If the note type is less
18758 than the start of the machine-dependent note types, we don't
18761 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18763 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18769 switch (filedata
->file_header
.e_machine
)
18771 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18772 and PT_GETFPREGS == mach+2. */
18777 case EM_SPARC32PLUS
:
18781 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18782 return _("PT_GETREGS (reg structure)");
18783 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18784 return _("PT_GETFPREGS (fpreg structure)");
18790 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18791 There's also old PT___GETREGS40 == mach + 1 for old reg
18792 structure which lacks GBR. */
18796 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18797 return _("PT___GETREGS40 (old reg structure)");
18798 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18799 return _("PT_GETREGS (reg structure)");
18800 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18801 return _("PT_GETFPREGS (fpreg structure)");
18807 /* On all other arch's, PT_GETREGS == mach+1 and
18808 PT_GETFPREGS == mach+3. */
18812 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18813 return _("PT_GETREGS (reg structure)");
18814 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18815 return _("PT_GETFPREGS (fpreg structure)");
18821 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18822 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18826 static const char *
18827 get_stapsdt_note_type (unsigned e_type
)
18829 static char buff
[64];
18834 return _("NT_STAPSDT (SystemTap probe descriptors)");
18840 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18845 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18847 size_t len
, maxlen
;
18848 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18849 char *data
= pnote
->descdata
;
18850 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18851 bfd_vma pc
, base_addr
, semaphore
;
18852 char *provider
, *probe
, *arg_fmt
;
18854 if (pnote
->descsz
< (addr_size
* 3))
18855 goto stapdt_note_too_small
;
18857 pc
= byte_get ((unsigned char *) data
, addr_size
);
18860 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18863 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18866 if (data
>= data_end
)
18867 goto stapdt_note_too_small
;
18868 maxlen
= data_end
- data
;
18869 len
= strnlen (data
, maxlen
);
18876 goto stapdt_note_too_small
;
18878 if (data
>= data_end
)
18879 goto stapdt_note_too_small
;
18880 maxlen
= data_end
- data
;
18881 len
= strnlen (data
, maxlen
);
18888 goto stapdt_note_too_small
;
18890 if (data
>= data_end
)
18891 goto stapdt_note_too_small
;
18892 maxlen
= data_end
- data
;
18893 len
= strnlen (data
, maxlen
);
18900 goto stapdt_note_too_small
;
18902 printf (_(" Provider: %s\n"), provider
);
18903 printf (_(" Name: %s\n"), probe
);
18904 printf (_(" Location: "));
18905 print_vma (pc
, FULL_HEX
);
18906 printf (_(", Base: "));
18907 print_vma (base_addr
, FULL_HEX
);
18908 printf (_(", Semaphore: "));
18909 print_vma (semaphore
, FULL_HEX
);
18911 printf (_(" Arguments: %s\n"), arg_fmt
);
18913 return data
== data_end
;
18915 stapdt_note_too_small
:
18916 printf (_(" <corrupt - note is too small>\n"));
18917 error (_("corrupt stapdt note - the data size is too small\n"));
18921 static const char *
18922 get_ia64_vms_note_type (unsigned e_type
)
18924 static char buff
[64];
18929 return _("NT_VMS_MHD (module header)");
18931 return _("NT_VMS_LNM (language name)");
18933 return _("NT_VMS_SRC (source files)");
18935 return "NT_VMS_TITLE";
18937 return _("NT_VMS_EIDC (consistency check)");
18938 case NT_VMS_FPMODE
:
18939 return _("NT_VMS_FPMODE (FP mode)");
18940 case NT_VMS_LINKTIME
:
18941 return "NT_VMS_LINKTIME";
18942 case NT_VMS_IMGNAM
:
18943 return _("NT_VMS_IMGNAM (image name)");
18945 return _("NT_VMS_IMGID (image id)");
18946 case NT_VMS_LINKID
:
18947 return _("NT_VMS_LINKID (link id)");
18948 case NT_VMS_IMGBID
:
18949 return _("NT_VMS_IMGBID (build id)");
18950 case NT_VMS_GSTNAM
:
18951 return _("NT_VMS_GSTNAM (sym table name)");
18952 case NT_VMS_ORIG_DYN
:
18953 return "NT_VMS_ORIG_DYN";
18954 case NT_VMS_PATCHTIME
:
18955 return "NT_VMS_PATCHTIME";
18957 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18963 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18965 int maxlen
= pnote
->descsz
;
18967 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18968 goto desc_size_fail
;
18970 switch (pnote
->type
)
18974 goto desc_size_fail
;
18976 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18978 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18979 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18980 if (l
+ 34 < maxlen
)
18982 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18983 if (l
+ 35 < maxlen
)
18984 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18986 printf (_(" Module version : <missing>\n"));
18990 printf (_(" Module name : <missing>\n"));
18991 printf (_(" Module version : <missing>\n"));
18996 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19000 case NT_VMS_FPMODE
:
19001 printf (_(" Floating Point mode: "));
19003 goto desc_size_fail
;
19004 /* FIXME: Generate an error if descsz > 8 ? */
19006 printf ("0x%016" BFD_VMA_FMT
"x\n",
19007 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19010 case NT_VMS_LINKTIME
:
19011 printf (_(" Link time: "));
19013 goto desc_size_fail
;
19014 /* FIXME: Generate an error if descsz > 8 ? */
19017 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19021 case NT_VMS_PATCHTIME
:
19022 printf (_(" Patch time: "));
19024 goto desc_size_fail
;
19025 /* FIXME: Generate an error if descsz > 8 ? */
19028 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19032 case NT_VMS_ORIG_DYN
:
19034 goto desc_size_fail
;
19036 printf (_(" Major id: %u, minor id: %u\n"),
19037 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
19038 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
19039 printf (_(" Last modified : "));
19041 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
19042 printf (_("\n Link flags : "));
19043 printf ("0x%016" BFD_VMA_FMT
"x\n",
19044 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
19045 printf (_(" Header flags: 0x%08x\n"),
19046 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
19047 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
19051 case NT_VMS_IMGNAM
:
19052 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
19055 case NT_VMS_GSTNAM
:
19056 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
19060 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
19063 case NT_VMS_LINKID
:
19064 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
19074 printf (_(" <corrupt - data size is too small>\n"));
19075 error (_("corrupt IA64 note: data size is too small\n"));
19079 struct build_attr_cache
{
19080 Filedata
*filedata
;
19082 unsigned long strtablen
;
19083 Elf_Internal_Sym
*symtab
;
19084 unsigned long nsyms
;
19087 /* Find the symbol associated with a build attribute that is attached
19088 to address OFFSET. If PNAME is non-NULL then store the name of
19089 the symbol (if found) in the provided pointer, Returns NULL if a
19090 symbol could not be found. */
19092 static Elf_Internal_Sym
*
19093 get_symbol_for_build_attribute (Filedata
* filedata
,
19094 unsigned long offset
,
19095 bfd_boolean is_open_attr
,
19096 const char ** pname
)
19098 Elf_Internal_Sym
*saved_sym
= NULL
;
19099 Elf_Internal_Sym
*sym
;
19101 if (filedata
->section_headers
!= NULL
19102 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
19104 Elf_Internal_Shdr
* symsec
;
19106 free (ba_cache
.strtab
);
19107 ba_cache
.strtab
= NULL
;
19108 free (ba_cache
.symtab
);
19109 ba_cache
.symtab
= NULL
;
19111 /* Load the symbol and string sections. */
19112 for (symsec
= filedata
->section_headers
;
19113 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19116 if (symsec
->sh_type
== SHT_SYMTAB
19117 && get_symtab (filedata
, symsec
,
19118 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19119 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19122 ba_cache
.filedata
= filedata
;
19125 if (ba_cache
.symtab
== NULL
)
19128 /* Find a symbol whose value matches offset. */
19129 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19130 if (sym
->st_value
== offset
)
19132 if (sym
->st_name
>= ba_cache
.strtablen
)
19133 /* Huh ? This should not happen. */
19136 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19139 /* The AArch64 and ARM architectures define mapping symbols
19140 (eg $d, $x, $t) which we want to ignore. */
19141 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19142 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19143 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19148 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19149 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19150 FUNC symbols entirely. */
19151 switch (ELF_ST_TYPE (sym
->st_info
))
19158 /* If the symbol has a size associated
19159 with it then we can stop searching. */
19160 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19165 /* Ignore function symbols. */
19172 switch (ELF_ST_BIND (sym
->st_info
))
19175 if (saved_sym
== NULL
19176 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19181 if (saved_sym
== NULL
)
19191 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19199 if (saved_sym
&& pname
)
19200 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19205 /* Returns true iff addr1 and addr2 are in the same section. */
19208 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19210 Elf_Internal_Shdr
* a1
;
19211 Elf_Internal_Shdr
* a2
;
19213 a1
= find_section_by_address (filedata
, addr1
);
19214 a2
= find_section_by_address (filedata
, addr2
);
19216 return a1
== a2
&& a1
!= NULL
;
19220 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19221 Filedata
* filedata
)
19223 static unsigned long global_offset
= 0;
19224 static unsigned long global_end
= 0;
19225 static unsigned long func_offset
= 0;
19226 static unsigned long func_end
= 0;
19228 Elf_Internal_Sym
* sym
;
19230 unsigned long start
;
19232 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19234 switch (pnote
->descsz
)
19237 /* A zero-length description means that the range of
19238 the previous note of the same type should be used. */
19241 if (global_end
> global_offset
)
19242 printf (_(" Applies to region from %#lx to %#lx\n"),
19243 global_offset
, global_end
);
19245 printf (_(" Applies to region from %#lx\n"), global_offset
);
19249 if (func_end
> func_offset
)
19250 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19252 printf (_(" Applies to region from %#lx\n"), func_offset
);
19257 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19264 /* FIXME: We should check that version 3+ notes are being used here... */
19265 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19266 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19270 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19276 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19277 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19281 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19282 printf (_(" <invalid descsz>"));
19287 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19288 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19289 in order to avoid them being confused with the start address of the
19290 first function in the file... */
19291 if (sym
== NULL
&& is_open_attr
)
19292 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19295 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19296 end
= start
+ sym
->st_size
;
19300 /* FIXME: Need to properly allow for section alignment.
19301 16 is just the alignment used on x86_64. */
19303 && start
> BFD_ALIGN (global_end
, 16)
19304 /* Build notes are not guaranteed to be organised in order of
19305 increasing address, but we should find the all of the notes
19306 for one section in the same place. */
19307 && same_section (filedata
, start
, global_end
))
19308 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19309 global_end
+ 1, start
- 1);
19311 printf (_(" Applies to region from %#lx"), start
);
19312 global_offset
= start
;
19316 printf (_(" to %#lx"), end
);
19322 printf (_(" Applies to region from %#lx"), start
);
19323 func_offset
= start
;
19327 printf (_(" to %#lx"), end
);
19333 printf (_(" (%s)"), name
);
19340 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19342 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19343 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19344 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19346 char name_attribute
;
19347 const char * expected_types
;
19348 const char * name
= pnote
->namedata
;
19352 if (name
== NULL
|| pnote
->namesz
< 2)
19354 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19355 print_symbol (-20, _(" <corrupt name>"));
19364 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19365 if (name
[0] == 'G' && name
[1] == 'A')
19367 if (pnote
->namesz
< 4)
19369 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19370 print_symbol (-20, _(" <corrupt name>"));
19379 switch ((name_type
= * name
))
19381 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19382 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19383 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19384 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19385 printf ("%c", * name
);
19389 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19390 print_symbol (-20, _("<unknown name type>"));
19397 switch ((name_attribute
= * name
))
19399 case GNU_BUILD_ATTRIBUTE_VERSION
:
19400 text
= _("<version>");
19401 expected_types
= string_expected
;
19404 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19405 text
= _("<stack prot>");
19406 expected_types
= "!+*";
19409 case GNU_BUILD_ATTRIBUTE_RELRO
:
19410 text
= _("<relro>");
19411 expected_types
= bool_expected
;
19414 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19415 text
= _("<stack size>");
19416 expected_types
= number_expected
;
19419 case GNU_BUILD_ATTRIBUTE_TOOL
:
19420 text
= _("<tool>");
19421 expected_types
= string_expected
;
19424 case GNU_BUILD_ATTRIBUTE_ABI
:
19426 expected_types
= "$*";
19429 case GNU_BUILD_ATTRIBUTE_PIC
:
19431 expected_types
= number_expected
;
19434 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19435 text
= _("<short enum>");
19436 expected_types
= bool_expected
;
19440 if (ISPRINT (* name
))
19442 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19444 if (len
> left
&& ! do_wide
)
19446 printf ("%.*s:", len
, name
);
19452 static char tmpbuf
[128];
19454 error (_("unrecognised byte in name field: %d\n"), * name
);
19455 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19459 expected_types
= "*$!+";
19464 left
-= printf ("%s", text
);
19466 if (strchr (expected_types
, name_type
) == NULL
)
19467 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19469 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19471 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19472 (unsigned long) pnote
->namesz
,
19473 (long) (name
- pnote
->namedata
));
19477 if (left
< 1 && ! do_wide
)
19482 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19484 unsigned int bytes
;
19485 unsigned long long val
= 0;
19486 unsigned int shift
= 0;
19487 char * decoded
= NULL
;
19489 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19491 /* The -1 is because the name field is always 0 terminated, and we
19492 want to be able to ensure that the shift in the while loop below
19493 will not overflow. */
19496 if (bytes
> sizeof (val
))
19498 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19500 bytes
= sizeof (val
);
19502 /* We do not bother to warn if bytes == 0 as this can
19503 happen with some early versions of the gcc plugin. */
19507 unsigned long byte
= (* name
++) & 0xff;
19509 val
|= byte
<< shift
;
19513 switch (name_attribute
)
19515 case GNU_BUILD_ATTRIBUTE_PIC
:
19518 case 0: decoded
= "static"; break;
19519 case 1: decoded
= "pic"; break;
19520 case 2: decoded
= "PIC"; break;
19521 case 3: decoded
= "pie"; break;
19522 case 4: decoded
= "PIE"; break;
19526 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19529 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19530 case 0: decoded
= "off"; break;
19531 case 1: decoded
= "on"; break;
19532 case 2: decoded
= "all"; break;
19533 case 3: decoded
= "strong"; break;
19534 case 4: decoded
= "explicit"; break;
19542 if (decoded
!= NULL
)
19544 print_symbol (-left
, decoded
);
19555 left
-= printf ("0x%llx", val
);
19557 left
-= printf ("0x%-.*llx", left
, val
);
19561 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19562 left
-= print_symbol (- left
, name
);
19564 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19565 left
-= print_symbol (- left
, "true");
19567 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19568 left
-= print_symbol (- left
, "false");
19572 if (do_wide
&& left
> 0)
19573 printf ("%-*s", left
, " ");
19578 /* Note that by the ELF standard, the name field is already null byte
19579 terminated, and namesz includes the terminating null byte.
19580 I.E. the value of namesz for the name "FSF" is 4.
19582 If the value of namesz is zero, there is no name present. */
19585 process_note (Elf_Internal_Note
* pnote
,
19586 Filedata
* filedata
)
19588 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19591 if (pnote
->namesz
== 0)
19592 /* If there is no note name, then use the default set of
19593 note type strings. */
19594 nt
= get_note_type (filedata
, pnote
->type
);
19596 else if (const_strneq (pnote
->namedata
, "GNU"))
19597 /* GNU-specific object file notes. */
19598 nt
= get_gnu_elf_note_type (pnote
->type
);
19600 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19601 /* FreeBSD-specific core file notes. */
19602 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19604 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19605 /* NetBSD-specific core file notes. */
19606 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19608 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19609 /* NetBSD-specific core file notes. */
19610 return process_netbsd_elf_note (pnote
);
19612 else if (const_strneq (pnote
->namedata
, "PaX"))
19613 /* NetBSD-specific core file notes. */
19614 return process_netbsd_elf_note (pnote
);
19616 else if (strneq (pnote
->namedata
, "SPU/", 4))
19618 /* SPU-specific core file notes. */
19619 nt
= pnote
->namedata
+ 4;
19623 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19624 /* VMS/ia64-specific file notes. */
19625 nt
= get_ia64_vms_note_type (pnote
->type
);
19627 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19628 nt
= get_stapsdt_note_type (pnote
->type
);
19631 /* Don't recognize this note name; just use the default set of
19632 note type strings. */
19633 nt
= get_note_type (filedata
, pnote
->type
);
19637 if (((const_strneq (pnote
->namedata
, "GA")
19638 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19639 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19640 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19641 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19642 print_gnu_build_attribute_name (pnote
);
19644 print_symbol (-20, name
);
19647 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19649 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19651 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19652 return print_ia64_vms_note (pnote
);
19653 else if (const_strneq (pnote
->namedata
, "GNU"))
19654 return print_gnu_note (filedata
, pnote
);
19655 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19656 return print_stapsdt_note (pnote
);
19657 else if (const_strneq (pnote
->namedata
, "CORE"))
19658 return print_core_note (pnote
);
19659 else if (((const_strneq (pnote
->namedata
, "GA")
19660 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19661 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19662 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19663 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19664 return print_gnu_build_attribute_description (pnote
, filedata
);
19670 printf (_(" description data: "));
19671 for (i
= 0; i
< pnote
->descsz
; i
++)
19672 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19684 process_notes_at (Filedata
* filedata
,
19685 Elf_Internal_Shdr
* section
,
19690 Elf_External_Note
* pnotes
;
19691 Elf_External_Note
* external
;
19693 bfd_boolean res
= TRUE
;
19700 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19703 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19711 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19714 if (pnotes
== NULL
)
19720 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19722 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19723 (unsigned long) offset
, (unsigned long) length
);
19725 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19726 specifies that notes should be aligned to 4 bytes in 32-bit
19727 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19728 we also support 4 byte alignment in 64-bit objects. If section
19729 alignment is less than 4, we treate alignment as 4 bytes. */
19732 else if (align
!= 4 && align
!= 8)
19734 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19740 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19742 end
= (char *) pnotes
+ length
;
19743 while ((char *) external
< end
)
19745 Elf_Internal_Note inote
;
19748 char * temp
= NULL
;
19749 size_t data_remaining
= end
- (char *) external
;
19751 if (!is_ia64_vms (filedata
))
19753 /* PR binutils/15191
19754 Make sure that there is enough data to read. */
19755 min_notesz
= offsetof (Elf_External_Note
, name
);
19756 if (data_remaining
< min_notesz
)
19758 warn (ngettext ("Corrupt note: only %ld byte remains, "
19759 "not enough for a full note\n",
19760 "Corrupt note: only %ld bytes remain, "
19761 "not enough for a full note\n",
19763 (long) data_remaining
);
19766 data_remaining
-= min_notesz
;
19768 inote
.type
= BYTE_GET (external
->type
);
19769 inote
.namesz
= BYTE_GET (external
->namesz
);
19770 inote
.namedata
= external
->name
;
19771 inote
.descsz
= BYTE_GET (external
->descsz
);
19772 inote
.descdata
= ((char *) external
19773 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19774 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19775 next
= ((char *) external
19776 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19780 Elf64_External_VMS_Note
*vms_external
;
19782 /* PR binutils/15191
19783 Make sure that there is enough data to read. */
19784 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19785 if (data_remaining
< min_notesz
)
19787 warn (ngettext ("Corrupt note: only %ld byte remains, "
19788 "not enough for a full note\n",
19789 "Corrupt note: only %ld bytes remain, "
19790 "not enough for a full note\n",
19792 (long) data_remaining
);
19795 data_remaining
-= min_notesz
;
19797 vms_external
= (Elf64_External_VMS_Note
*) external
;
19798 inote
.type
= BYTE_GET (vms_external
->type
);
19799 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19800 inote
.namedata
= vms_external
->name
;
19801 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19802 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19803 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19804 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19807 /* PR 17531: file: 3443835e. */
19808 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19809 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19810 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19811 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19812 || ((size_t) (next
- inote
.descdata
)
19813 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19815 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19816 (unsigned long) ((char *) external
- (char *) pnotes
));
19817 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19818 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19822 external
= (Elf_External_Note
*) next
;
19824 /* Verify that name is null terminated. It appears that at least
19825 one version of Linux (RedHat 6.0) generates corefiles that don't
19826 comply with the ELF spec by failing to include the null byte in
19828 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19830 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19832 temp
= (char *) malloc (inote
.namesz
+ 1);
19835 error (_("Out of memory allocating space for inote name\n"));
19840 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19841 inote
.namedata
= temp
;
19843 inote
.namedata
[inote
.namesz
] = 0;
19846 if (! process_note (& inote
, filedata
))
19859 process_corefile_note_segments (Filedata
* filedata
)
19861 Elf_Internal_Phdr
* segment
;
19863 bfd_boolean res
= TRUE
;
19865 if (! get_program_headers (filedata
))
19868 for (i
= 0, segment
= filedata
->program_headers
;
19869 i
< filedata
->file_header
.e_phnum
;
19872 if (segment
->p_type
== PT_NOTE
)
19873 if (! process_notes_at (filedata
, NULL
,
19874 (bfd_vma
) segment
->p_offset
,
19875 (bfd_vma
) segment
->p_filesz
,
19876 (bfd_vma
) segment
->p_align
))
19884 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19886 Elf_External_Note
* pnotes
;
19887 Elf_External_Note
* external
;
19889 bfd_boolean res
= TRUE
;
19894 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19896 if (pnotes
== NULL
)
19900 end
= (char*) pnotes
+ length
;
19902 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19903 (unsigned long) offset
, (unsigned long) length
);
19905 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19907 Elf_External_Note
* next
;
19908 Elf_Internal_Note inote
;
19910 inote
.type
= BYTE_GET (external
->type
);
19911 inote
.namesz
= BYTE_GET (external
->namesz
);
19912 inote
.namedata
= external
->name
;
19913 inote
.descsz
= BYTE_GET (external
->descsz
);
19914 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19915 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19917 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19919 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19920 inote
.descdata
= inote
.namedata
;
19924 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19926 if ( ((char *) next
> end
)
19927 || ((char *) next
< (char *) pnotes
))
19929 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19930 (unsigned long) ((char *) external
- (char *) pnotes
));
19931 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19932 inote
.type
, inote
.namesz
, inote
.descsz
);
19938 /* Prevent out-of-bounds indexing. */
19939 if ( inote
.namedata
+ inote
.namesz
> end
19940 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19942 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19943 (unsigned long) ((char *) external
- (char *) pnotes
));
19944 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19945 inote
.type
, inote
.namesz
, inote
.descsz
);
19949 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19951 if (! print_v850_note (& inote
))
19954 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19955 inote
.namesz
, inote
.descsz
);
19965 process_note_sections (Filedata
* filedata
)
19967 Elf_Internal_Shdr
* section
;
19969 unsigned int n
= 0;
19970 bfd_boolean res
= TRUE
;
19972 for (i
= 0, section
= filedata
->section_headers
;
19973 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19976 if (section
->sh_type
== SHT_NOTE
)
19978 if (! process_notes_at (filedata
, section
,
19979 (bfd_vma
) section
->sh_offset
,
19980 (bfd_vma
) section
->sh_size
,
19981 (bfd_vma
) section
->sh_addralign
))
19986 if (( filedata
->file_header
.e_machine
== EM_V800
19987 || filedata
->file_header
.e_machine
== EM_V850
19988 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19989 && section
->sh_type
== SHT_RENESAS_INFO
)
19991 if (! process_v850_notes (filedata
,
19992 (bfd_vma
) section
->sh_offset
,
19993 (bfd_vma
) section
->sh_size
))
20000 /* Try processing NOTE segments instead. */
20001 return process_corefile_note_segments (filedata
);
20007 process_notes (Filedata
* filedata
)
20009 /* If we have not been asked to display the notes then do nothing. */
20013 if (filedata
->file_header
.e_type
!= ET_CORE
)
20014 return process_note_sections (filedata
);
20016 /* No program headers means no NOTE segment. */
20017 if (filedata
->file_header
.e_phnum
> 0)
20018 return process_corefile_note_segments (filedata
);
20020 printf (_("No note segments present in the core file.\n"));
20024 static unsigned char *
20025 display_public_gnu_attributes (unsigned char * start
,
20026 const unsigned char * const end
)
20028 printf (_(" Unknown GNU attribute: %s\n"), start
);
20030 start
+= strnlen ((char *) start
, end
- start
);
20031 display_raw_attribute (start
, end
);
20033 return (unsigned char *) end
;
20036 static unsigned char *
20037 display_generic_attribute (unsigned char * start
,
20039 const unsigned char * const end
)
20042 return (unsigned char *) end
;
20044 return display_tag_value (tag
, start
, end
);
20048 process_arch_specific (Filedata
* filedata
)
20053 switch (filedata
->file_header
.e_machine
)
20056 case EM_ARC_COMPACT
:
20057 case EM_ARC_COMPACT2
:
20058 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
20059 display_arc_attribute
,
20060 display_generic_attribute
);
20062 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
20063 display_arm_attribute
,
20064 display_generic_attribute
);
20067 case EM_MIPS_RS3_LE
:
20068 return process_mips_specific (filedata
);
20071 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
20072 display_msp430x_attribute
,
20073 display_msp430_gnu_attribute
);
20076 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
20077 display_riscv_attribute
,
20078 display_generic_attribute
);
20081 return process_nds32_specific (filedata
);
20084 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20085 display_m68k_gnu_attribute
);
20089 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20090 display_power_gnu_attribute
);
20094 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20095 display_s390_gnu_attribute
);
20098 case EM_SPARC32PLUS
:
20100 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20101 display_sparc_gnu_attribute
);
20104 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
20105 display_tic6x_attribute
,
20106 display_generic_attribute
);
20109 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20110 display_public_gnu_attributes
,
20111 display_generic_attribute
);
20116 get_file_header (Filedata
* filedata
)
20118 /* Read in the identity array. */
20119 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20122 /* Determine how to read the rest of the header. */
20123 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20128 byte_get
= byte_get_little_endian
;
20129 byte_put
= byte_put_little_endian
;
20132 byte_get
= byte_get_big_endian
;
20133 byte_put
= byte_put_big_endian
;
20137 /* For now we only support 32 bit and 64 bit ELF files. */
20138 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20140 /* Read in the rest of the header. */
20143 Elf32_External_Ehdr ehdr32
;
20145 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20148 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20149 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20150 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20151 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20152 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20153 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20154 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20155 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20156 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20157 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20158 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20159 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20160 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20164 Elf64_External_Ehdr ehdr64
;
20166 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20167 we will not be able to cope with the 64bit data found in
20168 64 ELF files. Detect this now and abort before we start
20169 overwriting things. */
20170 if (sizeof (bfd_vma
) < 8)
20172 error (_("This instance of readelf has been built without support for a\n\
20173 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20177 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20180 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20181 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20182 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20183 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20184 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20185 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20186 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20187 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20188 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20189 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20190 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20191 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20192 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20195 if (filedata
->file_header
.e_shoff
)
20197 /* There may be some extensions in the first section header. Don't
20198 bomb if we can't read it. */
20200 get_32bit_section_headers (filedata
, TRUE
);
20202 get_64bit_section_headers (filedata
, TRUE
);
20209 close_file (Filedata
* filedata
)
20213 if (filedata
->handle
)
20214 fclose (filedata
->handle
);
20220 close_debug_file (void * data
)
20222 close_file ((Filedata
*) data
);
20226 open_file (const char * pathname
)
20228 struct stat statbuf
;
20229 Filedata
* filedata
= NULL
;
20231 if (stat (pathname
, & statbuf
) < 0
20232 || ! S_ISREG (statbuf
.st_mode
))
20235 filedata
= calloc (1, sizeof * filedata
);
20236 if (filedata
== NULL
)
20239 filedata
->handle
= fopen (pathname
, "rb");
20240 if (filedata
->handle
== NULL
)
20243 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20244 filedata
->file_name
= pathname
;
20246 if (! get_file_header (filedata
))
20249 if (filedata
->file_header
.e_shoff
)
20253 /* Read the section headers again, this time for real. */
20255 res
= get_32bit_section_headers (filedata
, FALSE
);
20257 res
= get_64bit_section_headers (filedata
, FALSE
);
20268 if (filedata
->handle
)
20269 fclose (filedata
->handle
);
20276 open_debug_file (const char * pathname
)
20278 return open_file (pathname
);
20281 /* Process one ELF object file according to the command line options.
20282 This file may actually be stored in an archive. The file is
20283 positioned at the start of the ELF object. Returns TRUE if no
20284 problems were encountered, FALSE otherwise. */
20287 process_object (Filedata
* filedata
)
20289 bfd_boolean have_separate_files
;
20293 if (! get_file_header (filedata
))
20295 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20299 /* Initialise per file variables. */
20300 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20301 filedata
->version_info
[i
] = 0;
20303 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20304 filedata
->dynamic_info
[i
] = 0;
20305 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20306 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20308 /* Process the file. */
20310 printf (_("\nFile: %s\n"), filedata
->file_name
);
20312 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20313 Note we do this even if cmdline_dump_sects is empty because we
20314 must make sure that the dump_sets array is zeroed out before each
20315 object file is processed. */
20316 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20317 memset (filedata
->dump
.dump_sects
, 0,
20318 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20320 if (cmdline
.num_dump_sects
> 0)
20322 if (filedata
->dump
.num_dump_sects
== 0)
20323 /* A sneaky way of allocating the dump_sects array. */
20324 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20326 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20327 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20328 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20331 if (! process_file_header (filedata
))
20334 if (! process_section_headers (filedata
))
20336 /* Without loaded section headers we cannot process lots of things. */
20337 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20339 if (! do_using_dynamic
)
20340 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20343 if (! process_section_groups (filedata
))
20344 /* Without loaded section groups we cannot process unwind. */
20347 res
= process_program_headers (filedata
);
20349 res
= process_dynamic_section (filedata
);
20351 if (! process_relocs (filedata
))
20354 if (! process_unwind (filedata
))
20357 if (! process_symbol_table (filedata
))
20360 if (! process_syminfo (filedata
))
20363 if (! process_version_sections (filedata
))
20366 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20367 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20369 have_separate_files
= FALSE
;
20371 if (! process_section_contents (filedata
))
20374 if (have_separate_files
)
20378 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20380 if (! process_section_headers (d
->handle
))
20382 else if (! process_section_contents (d
->handle
))
20386 /* The file handles are closed by the call to free_debug_memory() below. */
20389 if (! process_notes (filedata
))
20392 if (! process_gnu_liblist (filedata
))
20395 if (! process_arch_specific (filedata
))
20398 free (filedata
->program_headers
);
20399 filedata
->program_headers
= NULL
;
20401 free (filedata
->section_headers
);
20402 filedata
->section_headers
= NULL
;
20404 free (filedata
->string_table
);
20405 filedata
->string_table
= NULL
;
20406 filedata
->string_table_length
= 0;
20408 free (filedata
->dump
.dump_sects
);
20409 filedata
->dump
.dump_sects
= NULL
;
20410 filedata
->dump
.num_dump_sects
= 0;
20412 free (filedata
->dynamic_strings
);
20413 filedata
->dynamic_strings
= NULL
;
20414 filedata
->dynamic_strings_length
= 0;
20416 free (filedata
->dynamic_symbols
);
20417 filedata
->dynamic_symbols
= NULL
;
20418 filedata
->num_dynamic_syms
= 0;
20420 free (filedata
->dynamic_syminfo
);
20421 filedata
->dynamic_syminfo
= NULL
;
20423 free (filedata
->dynamic_section
);
20424 filedata
->dynamic_section
= NULL
;
20426 while (filedata
->symtab_shndx_list
!= NULL
)
20428 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20429 free (filedata
->symtab_shndx_list
);
20430 filedata
->symtab_shndx_list
= next
;
20433 free (filedata
->section_headers_groups
);
20434 filedata
->section_headers_groups
= NULL
;
20436 if (filedata
->section_groups
)
20438 struct group_list
* g
;
20439 struct group_list
* next
;
20441 for (i
= 0; i
< filedata
->group_count
; i
++)
20443 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20450 free (filedata
->section_groups
);
20451 filedata
->section_groups
= NULL
;
20454 free_debug_memory ();
20459 /* Process an ELF archive.
20460 On entry the file is positioned just after the ARMAG string.
20461 Returns TRUE upon success, FALSE otherwise. */
20464 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20466 struct archive_info arch
;
20467 struct archive_info nested_arch
;
20469 bfd_boolean ret
= TRUE
;
20473 /* The ARCH structure is used to hold information about this archive. */
20474 arch
.file_name
= NULL
;
20476 arch
.index_array
= NULL
;
20477 arch
.sym_table
= NULL
;
20478 arch
.longnames
= NULL
;
20480 /* The NESTED_ARCH structure is used as a single-item cache of information
20481 about a nested archive (when members of a thin archive reside within
20482 another regular archive file). */
20483 nested_arch
.file_name
= NULL
;
20484 nested_arch
.file
= NULL
;
20485 nested_arch
.index_array
= NULL
;
20486 nested_arch
.sym_table
= NULL
;
20487 nested_arch
.longnames
= NULL
;
20489 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20490 filedata
->file_size
, is_thin_archive
,
20491 do_archive_index
) != 0)
20497 if (do_archive_index
)
20499 if (arch
.sym_table
== NULL
)
20500 error (_("%s: unable to dump the index as none was found\n"),
20501 filedata
->file_name
);
20504 unsigned long i
, l
;
20505 unsigned long current_pos
;
20507 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20508 "in the symbol table)\n"),
20509 filedata
->file_name
, (unsigned long) arch
.index_num
,
20512 current_pos
= ftell (filedata
->handle
);
20514 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20517 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20520 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20523 if (member_name
!= NULL
)
20525 char * qualified_name
20526 = make_qualified_name (&arch
, &nested_arch
,
20529 if (qualified_name
!= NULL
)
20531 printf (_("Contents of binary %s at offset "),
20533 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20535 free (qualified_name
);
20537 free (member_name
);
20541 if (l
>= arch
.sym_size
)
20543 error (_("%s: end of the symbol table reached "
20544 "before the end of the index\n"),
20545 filedata
->file_name
);
20549 /* PR 17531: file: 0b6630b2. */
20550 printf ("\t%.*s\n",
20551 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20552 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20555 if (arch
.uses_64bit_indices
)
20560 if (l
< arch
.sym_size
)
20562 error (ngettext ("%s: %ld byte remains in the symbol table, "
20563 "but without corresponding entries in "
20564 "the index table\n",
20565 "%s: %ld bytes remain in the symbol table, "
20566 "but without corresponding entries in "
20567 "the index table\n",
20568 arch
.sym_size
- l
),
20569 filedata
->file_name
, arch
.sym_size
- l
);
20573 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20575 error (_("%s: failed to seek back to start of object files "
20576 "in the archive\n"),
20577 filedata
->file_name
);
20583 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20584 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20585 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20586 && !do_section_groups
&& !do_dyn_syms
)
20588 ret
= TRUE
; /* Archive index only. */
20597 char * qualified_name
;
20599 /* Read the next archive header. */
20600 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20602 error (_("%s: failed to seek to next archive header\n"),
20607 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20608 if (got
!= sizeof arch
.arhdr
)
20612 /* PR 24049 - we cannot use filedata->file_name as this will
20613 have already been freed. */
20614 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20619 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20621 error (_("%s: did not find a valid archive header\n"),
20627 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20629 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20630 if (filedata
->archive_file_size
& 01)
20631 ++filedata
->archive_file_size
;
20633 name
= get_archive_member_name (&arch
, &nested_arch
);
20636 error (_("%s: bad archive file name\n"), arch
.file_name
);
20640 namelen
= strlen (name
);
20642 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20643 if (qualified_name
== NULL
)
20645 error (_("%s: bad archive file name\n"), arch
.file_name
);
20651 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20653 /* This is a proxy for an external member of a thin archive. */
20654 Filedata
* member_filedata
;
20655 char * member_file_name
= adjust_relative_path
20656 (filedata
->file_name
, name
, namelen
);
20659 if (member_file_name
== NULL
)
20661 free (qualified_name
);
20666 member_filedata
= open_file (member_file_name
);
20667 if (member_filedata
== NULL
)
20669 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20670 free (member_file_name
);
20671 free (qualified_name
);
20676 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20677 member_filedata
->file_name
= qualified_name
;
20679 if (! process_object (member_filedata
))
20682 close_file (member_filedata
);
20683 free (member_file_name
);
20685 else if (is_thin_archive
)
20687 Filedata thin_filedata
;
20689 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20691 /* PR 15140: Allow for corrupt thin archives. */
20692 if (nested_arch
.file
== NULL
)
20694 error (_("%s: contains corrupt thin archive: %s\n"),
20695 qualified_name
, name
);
20696 free (qualified_name
);
20703 /* This is a proxy for a member of a nested archive. */
20704 filedata
->archive_file_offset
20705 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20707 /* The nested archive file will have been opened and setup by
20708 get_archive_member_name. */
20709 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20712 error (_("%s: failed to seek to archive member.\n"),
20713 nested_arch
.file_name
);
20714 free (qualified_name
);
20719 thin_filedata
.handle
= nested_arch
.file
;
20720 thin_filedata
.file_name
= qualified_name
;
20722 if (! process_object (& thin_filedata
))
20728 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20729 filedata
->file_name
= qualified_name
;
20730 if (! process_object (filedata
))
20732 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20733 /* Stop looping with "negative" archive_file_size. */
20734 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20735 arch
.next_arhdr_offset
= -1ul;
20738 free (qualified_name
);
20742 if (nested_arch
.file
!= NULL
)
20743 fclose (nested_arch
.file
);
20744 release_archive (&nested_arch
);
20745 release_archive (&arch
);
20751 process_file (char * file_name
)
20753 Filedata
* filedata
= NULL
;
20754 struct stat statbuf
;
20755 char armag
[SARMAG
];
20756 bfd_boolean ret
= TRUE
;
20758 if (stat (file_name
, &statbuf
) < 0)
20760 if (errno
== ENOENT
)
20761 error (_("'%s': No such file\n"), file_name
);
20763 error (_("Could not locate '%s'. System error message: %s\n"),
20764 file_name
, strerror (errno
));
20768 if (! S_ISREG (statbuf
.st_mode
))
20770 error (_("'%s' is not an ordinary file\n"), file_name
);
20774 filedata
= calloc (1, sizeof * filedata
);
20775 if (filedata
== NULL
)
20777 error (_("Out of memory allocating file data structure\n"));
20781 filedata
->file_name
= file_name
;
20782 filedata
->handle
= fopen (file_name
, "rb");
20783 if (filedata
->handle
== NULL
)
20785 error (_("Input file '%s' is not readable.\n"), file_name
);
20790 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20792 error (_("%s: Failed to read file's magic number\n"), file_name
);
20793 fclose (filedata
->handle
);
20798 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20800 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20802 if (! process_archive (filedata
, FALSE
))
20805 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20807 if ( ! process_archive (filedata
, TRUE
))
20812 if (do_archive_index
&& !check_all
)
20813 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20816 rewind (filedata
->handle
);
20817 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20819 if (! process_object (filedata
))
20823 fclose (filedata
->handle
);
20824 free (filedata
->section_headers
);
20825 free (filedata
->program_headers
);
20826 free (filedata
->string_table
);
20827 free (filedata
->dump
.dump_sects
);
20830 free (ba_cache
.strtab
);
20831 ba_cache
.strtab
= NULL
;
20832 free (ba_cache
.symtab
);
20833 ba_cache
.symtab
= NULL
;
20834 ba_cache
.filedata
= NULL
;
20839 #ifdef SUPPORT_DISASSEMBLY
20840 /* Needed by the i386 disassembler. For extra credit, someone could
20841 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20845 print_address (unsigned int addr
, FILE * outfile
)
20847 fprintf (outfile
,"0x%8.8x", addr
);
20850 /* Needed by the i386 disassembler. */
20853 db_task_printsym (unsigned int addr
)
20855 print_address (addr
, stderr
);
20860 main (int argc
, char ** argv
)
20864 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20865 setlocale (LC_MESSAGES
, "");
20867 #if defined (HAVE_SETLOCALE)
20868 setlocale (LC_CTYPE
, "");
20870 bindtextdomain (PACKAGE
, LOCALEDIR
);
20871 textdomain (PACKAGE
);
20873 expandargv (&argc
, &argv
);
20875 parse_args (& cmdline
, argc
, argv
);
20877 if (optind
< (argc
- 1))
20878 /* When displaying information for more than one file,
20879 prefix the information with the file name. */
20881 else if (optind
>= argc
)
20883 /* Ensure that the warning is always displayed. */
20886 warn (_("Nothing to do.\n"));
20891 while (optind
< argc
)
20892 if (! process_file (argv
[optind
++]))
20895 free (cmdline
.dump_sects
);
20897 free (dump_ctf_symtab_name
);
20898 free (dump_ctf_strtab_name
);
20899 free (dump_ctf_parent_name
);
20901 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;