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 do_checks
= FALSE
;
235 static bfd_boolean check_all
= FALSE
;
236 static bfd_boolean is_32bit_elf
= FALSE
;
237 static bfd_boolean decompress_dumps
= 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 char * dynamic_strings
;
272 unsigned long dynamic_strings_length
;
273 unsigned long num_dynamic_syms
;
274 Elf_Internal_Sym
* dynamic_symbols
;
275 bfd_vma version_info
[16];
276 unsigned int dynamic_syminfo_nent
;
277 Elf_Internal_Syminfo
* dynamic_syminfo
;
278 unsigned long dynamic_syminfo_offset
;
279 bfd_size_type nbuckets
;
280 bfd_size_type nchains
;
283 bfd_size_type ngnubuckets
;
284 bfd_size_type ngnuchains
;
285 bfd_vma
* gnubuckets
;
289 char program_interpreter
[PATH_MAX
];
290 bfd_vma dynamic_info
[DT_ENCODING
];
291 bfd_vma dynamic_info_DT_GNU_HASH
;
292 bfd_vma dynamic_info_DT_MIPS_XHASH
;
293 elf_section_list
* symtab_shndx_list
;
295 struct group
* section_groups
;
296 struct group
** section_headers_groups
;
297 /* A dynamic array of flags indicating for which sections a dump of
298 some kind has been requested. It is reset on a per-object file
299 basis and then initialised from the cmdline_dump_sects array,
300 the results of interpreting the -w switch, and the
301 dump_sects_byname list. */
302 struct dump_data dump
;
305 /* How to print a vma value. */
306 typedef enum print_mode
318 /* Versioned symbol info. */
319 enum versioned_symbol_info
326 static const char * get_symbol_version_string
327 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
328 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
332 #define SECTION_NAME(X) \
333 ((X) == NULL ? _("<none>") \
334 : filedata->string_table == NULL ? _("<no-strings>") \
335 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
336 : filedata->string_table + (X)->sh_name))
338 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
340 #define GET_ELF_SYMBOLS(file, section, sym_count) \
341 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
342 : get_64bit_elf_symbols (file, section, sym_count))
344 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
345 (strtab != NULL && offset < strtab_size)
346 #define VALID_DYNAMIC_NAME(filedata, offset) \
347 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
348 filedata->dynamic_strings_length, offset)
349 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
350 already been called and verified that the string exists. */
351 #define GET_DYNAMIC_NAME(filedata, offset) \
352 (filedata->dynamic_strings + offset)
354 #define REMOVE_ARCH_BITS(ADDR) \
357 if (filedata->file_header.e_machine == EM_ARM) \
362 /* Get the correct GNU hash section name. */
363 #define GNU_HASH_SECTION_NAME(filedata) \
364 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
366 /* Print a BFD_VMA to an internal buffer, for use in error messages.
367 BFD_FMA_FMT can't be used in translated strings. */
370 bfd_vmatoa (char *fmtch
, bfd_vma value
)
372 /* bfd_vmatoa is used more then once in a printf call for output.
373 Cycle through an array of buffers. */
374 static int buf_pos
= 0;
375 static struct bfd_vmatoa_buf
382 ret
= buf
[buf_pos
++].place
;
383 buf_pos
%= ARRAY_SIZE (buf
);
385 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
386 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
390 /* A version of the warn() function that is disabled if do_checks is not active. */
393 warn (const char *message
, ...)
400 /* Try to keep warning messages in sync with the program's normal output. */
403 va_start (args
, message
);
404 fprintf (stderr
, _("%s: Warning: "), program_name
);
405 vfprintf (stderr
, message
, args
);
409 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
410 OFFSET + the offset of the current archive member, if we are examining an
411 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
412 allocate a buffer using malloc and fill that. In either case return the
413 pointer to the start of the retrieved data or NULL if something went wrong.
414 If something does go wrong and REASON is not NULL then emit an error
415 message using REASON as part of the context. */
418 get_data (void * var
,
420 unsigned long offset
,
426 bfd_size_type amt
= size
* nmemb
;
428 if (size
== 0 || nmemb
== 0)
431 /* If the size_t type is smaller than the bfd_size_type, eg because
432 you are building a 32-bit tool on a 64-bit host, then make sure
433 that when the sizes are cast to (size_t) no information is lost. */
434 if ((size_t) size
!= size
435 || (size_t) nmemb
!= nmemb
436 || (size_t) amt
!= amt
)
439 error (_("Size truncation prevents reading %s"
440 " elements of size %s for %s\n"),
441 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
445 /* Check for size overflow. */
446 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
449 error (_("Size overflow prevents reading %s"
450 " elements of size %s for %s\n"),
451 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
455 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
456 attempting to allocate memory when the read is bound to fail. */
457 if (filedata
->archive_file_offset
> filedata
->file_size
458 || offset
> filedata
->file_size
- filedata
->archive_file_offset
459 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
462 error (_("Reading %s bytes extends past end of file for %s\n"),
463 bfd_vmatoa ("u", amt
), reason
);
467 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
471 error (_("Unable to seek to 0x%lx for %s\n"),
472 filedata
->archive_file_offset
+ offset
, reason
);
479 /* + 1 so that we can '\0' terminate invalid string table sections. */
480 mvar
= malloc ((size_t) amt
+ 1);
485 error (_("Out of memory allocating %s bytes for %s\n"),
486 bfd_vmatoa ("u", amt
), reason
);
490 ((char *) mvar
)[amt
] = '\0';
493 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
496 error (_("Unable to read in %s bytes of %s\n"),
497 bfd_vmatoa ("u", amt
), reason
);
506 /* Print a VMA value in the MODE specified.
507 Returns the number of characters displayed. */
510 print_vma (bfd_vma vma
, print_mode mode
)
522 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
529 return printf ("%5" BFD_VMA_FMT
"d", vma
);
535 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
538 return printf ("%" BFD_VMA_FMT
"d", vma
);
541 return printf ("%" BFD_VMA_FMT
"u", vma
);
544 /* FIXME: Report unrecognised mode ? */
549 /* Display a symbol on stdout. Handles the display of control characters and
550 multibye characters (assuming the host environment supports them).
552 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
554 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
555 padding as necessary.
557 Returns the number of emitted characters. */
560 print_symbol (signed int width
, const char *symbol
)
562 bfd_boolean extra_padding
= FALSE
;
563 signed int num_printed
= 0;
564 #ifdef HAVE_MBSTATE_T
567 unsigned int width_remaining
;
571 /* Keep the width positive. This helps the code below. */
573 extra_padding
= TRUE
;
579 /* Set the remaining width to a very large value.
580 This simplifies the code below. */
581 width_remaining
= INT_MAX
;
583 width_remaining
= width
;
585 #ifdef HAVE_MBSTATE_T
586 /* Initialise the multibyte conversion state. */
587 memset (& state
, 0, sizeof (state
));
590 while (width_remaining
)
593 const char c
= *symbol
++;
598 /* Do not print control characters directly as they can affect terminal
599 settings. Such characters usually appear in the names generated
600 by the assembler for local labels. */
603 if (width_remaining
< 2)
606 printf ("^%c", c
+ 0x40);
607 width_remaining
-= 2;
610 else if (ISPRINT (c
))
618 #ifdef HAVE_MBSTATE_T
621 /* Let printf do the hard work of displaying multibyte characters. */
622 printf ("%.1s", symbol
- 1);
626 #ifdef HAVE_MBSTATE_T
627 /* Try to find out how many bytes made up the character that was
628 just printed. Advance the symbol pointer past the bytes that
630 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
634 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
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 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4525 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4526 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4527 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4529 {"version", no_argument
, 0, 'v'},
4530 {"wide", no_argument
, 0, 'W'},
4531 {"help", no_argument
, 0, 'H'},
4532 {0, no_argument
, 0, 0}
4536 usage (FILE * stream
)
4538 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4539 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4540 fprintf (stream
, _(" Options are:\n\
4541 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4542 -h --file-header Display the ELF file header\n\
4543 -l --program-headers Display the program headers\n\
4544 --segments An alias for --program-headers\n\
4545 -S --section-headers Display the sections' header\n\
4546 --sections An alias for --section-headers\n\
4547 -g --section-groups Display the section groups\n\
4548 -t --section-details Display the section details\n\
4549 -e --headers Equivalent to: -h -l -S\n\
4550 -s --syms Display the symbol table\n\
4551 --symbols An alias for --syms\n\
4552 --dyn-syms Display the dynamic symbol table\n\
4553 -n --notes Display the core notes (if present)\n\
4554 -r --relocs Display the relocations (if present)\n\
4555 -u --unwind Display the unwind info (if present)\n\
4556 -d --dynamic Display the dynamic section (if present)\n\
4557 -V --version-info Display the version sections (if present)\n\
4558 -A --arch-specific Display architecture specific information (if any)\n\
4559 -c --archive-index Display the symbol/file index in an archive\n\
4560 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4561 -L --lint|--enable-checks Display warning messages for possible problems\n\
4562 -x --hex-dump=<number|name>\n\
4563 Dump the contents of section <number|name> as bytes\n\
4564 -p --string-dump=<number|name>\n\
4565 Dump the contents of section <number|name> as strings\n\
4566 -R --relocated-dump=<number|name>\n\
4567 Dump the contents of section <number|name> as relocated bytes\n\
4568 -z --decompress Decompress section before dumping it\n\
4569 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4570 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4571 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4572 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4573 =addr,=cu_index,=links,=follow-links]\n\
4574 Display the contents of DWARF debug sections\n"));
4575 fprintf (stream
, _("\
4576 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4577 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4579 fprintf (stream
, _("\
4580 --ctf=<number|name> Display CTF info from section <number|name>\n\
4581 --ctf-parent=<number|name>\n\
4582 Use section <number|name> as the CTF parent\n\n\
4583 --ctf-symbols=<number|name>\n\
4584 Use section <number|name> as the CTF external symtab\n\n\
4585 --ctf-strings=<number|name>\n\
4586 Use section <number|name> as the CTF external strtab\n\n"));
4588 #ifdef SUPPORT_DISASSEMBLY
4589 fprintf (stream
, _("\
4590 -i --instruction-dump=<number|name>\n\
4591 Disassemble the contents of section <number|name>\n"));
4593 fprintf (stream
, _("\
4594 -I --histogram Display histogram of bucket list lengths\n\
4595 -W --wide Allow output width to exceed 80 characters\n\
4596 @<file> Read options from <file>\n\
4597 -H --help Display this information\n\
4598 -v --version Display the version number of readelf\n"));
4600 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4601 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4603 exit (stream
== stdout
? 0 : 1);
4606 /* Record the fact that the user wants the contents of section number
4607 SECTION to be displayed using the method(s) encoded as flags bits
4608 in TYPE. Note, TYPE can be zero if we are creating the array for
4612 request_dump_bynumber (struct dump_data
*dumpdata
,
4613 unsigned int section
, dump_type type
)
4615 if (section
>= dumpdata
->num_dump_sects
)
4617 dump_type
* new_dump_sects
;
4619 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4620 sizeof (* new_dump_sects
));
4622 if (new_dump_sects
== NULL
)
4623 error (_("Out of memory allocating dump request table.\n"));
4626 if (dumpdata
->dump_sects
)
4628 /* Copy current flag settings. */
4629 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4630 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4632 free (dumpdata
->dump_sects
);
4635 dumpdata
->dump_sects
= new_dump_sects
;
4636 dumpdata
->num_dump_sects
= section
+ 1;
4640 if (dumpdata
->dump_sects
)
4641 dumpdata
->dump_sects
[section
] |= type
;
4644 /* Request a dump by section name. */
4647 request_dump_byname (const char * section
, dump_type type
)
4649 struct dump_list_entry
* new_request
;
4651 new_request
= (struct dump_list_entry
*)
4652 malloc (sizeof (struct dump_list_entry
));
4654 error (_("Out of memory allocating dump request table.\n"));
4656 new_request
->name
= strdup (section
);
4657 if (!new_request
->name
)
4658 error (_("Out of memory allocating dump request table.\n"));
4660 new_request
->type
= type
;
4662 new_request
->next
= dump_sects_byname
;
4663 dump_sects_byname
= new_request
;
4667 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4673 section
= strtoul (optarg
, & cp
, 0);
4675 if (! *cp
&& section
>= 0)
4676 request_dump_bynumber (dumpdata
, section
, type
);
4678 request_dump_byname (optarg
, type
);
4682 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4689 while ((c
= getopt_long
4690 (argc
, argv
, "ADHILNR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4708 do_section_groups
= TRUE
;
4711 do_histogram
= TRUE
;
4716 do_section_groups
= TRUE
;
4721 do_section_details
= TRUE
;
4732 do_using_dynamic
= TRUE
;
4756 do_histogram
= TRUE
;
4762 do_archive_index
= TRUE
;
4768 request_dump (dumpdata
, HEX_DUMP
);
4771 request_dump (dumpdata
, STRING_DUMP
);
4774 request_dump (dumpdata
, RELOC_DUMP
);
4777 decompress_dumps
= TRUE
;
4783 do_debugging
= TRUE
;
4784 dwarf_select_sections_all ();
4788 do_debugging
= FALSE
;
4789 dwarf_select_sections_by_letters (optarg
);
4792 case OPTION_DEBUG_DUMP
:
4795 do_debugging
= TRUE
;
4798 do_debugging
= FALSE
;
4799 dwarf_select_sections_by_names (optarg
);
4802 case OPTION_DWARF_DEPTH
:
4806 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4809 case OPTION_DWARF_START
:
4813 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4816 case OPTION_DWARF_CHECK
:
4819 case OPTION_CTF_DUMP
:
4821 request_dump (dumpdata
, CTF_DUMP
);
4823 case OPTION_CTF_SYMBOLS
:
4824 dump_ctf_symtab_name
= strdup (optarg
);
4826 case OPTION_CTF_STRINGS
:
4827 dump_ctf_strtab_name
= strdup (optarg
);
4829 case OPTION_CTF_PARENT
:
4830 dump_ctf_parent_name
= strdup (optarg
);
4832 case OPTION_DYN_SYMS
:
4835 #ifdef SUPPORT_DISASSEMBLY
4837 request_dump (dumpdata
, DISASS_DUMP
);
4841 print_version (program_name
);
4850 /* xgettext:c-format */
4851 error (_("Invalid option '-%c'\n"), c
);
4858 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4859 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4860 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4861 && !do_section_groups
&& !do_archive_index
4867 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= TRUE
;
4868 do_segments
= do_header
= do_dump
= do_version
= TRUE
;
4869 do_histogram
= do_debugging
= do_arch
= do_notes
= TRUE
;
4870 do_section_groups
= do_archive_index
= do_dyn_syms
= TRUE
;
4878 get_elf_class (unsigned int elf_class
)
4880 static char buff
[32];
4884 case ELFCLASSNONE
: return _("none");
4885 case ELFCLASS32
: return "ELF32";
4886 case ELFCLASS64
: return "ELF64";
4888 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4894 get_data_encoding (unsigned int encoding
)
4896 static char buff
[32];
4900 case ELFDATANONE
: return _("none");
4901 case ELFDATA2LSB
: return _("2's complement, little endian");
4902 case ELFDATA2MSB
: return _("2's complement, big endian");
4904 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4909 /* Decode the data held in 'filedata->file_header'. */
4912 process_file_header (Filedata
* filedata
)
4914 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4916 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4917 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4918 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4919 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4922 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4926 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4932 printf (_("ELF Header:\n"));
4933 printf (_(" Magic: "));
4934 for (i
= 0; i
< EI_NIDENT
; i
++)
4935 printf ("%2.2x ", header
->e_ident
[i
]);
4937 printf (_(" Class: %s\n"),
4938 get_elf_class (header
->e_ident
[EI_CLASS
]));
4939 printf (_(" Data: %s\n"),
4940 get_data_encoding (header
->e_ident
[EI_DATA
]));
4941 printf (_(" Version: %d%s\n"),
4942 header
->e_ident
[EI_VERSION
],
4943 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4945 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4948 printf (_(" OS/ABI: %s\n"),
4949 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4950 printf (_(" ABI Version: %d\n"),
4951 header
->e_ident
[EI_ABIVERSION
]);
4952 printf (_(" Type: %s\n"),
4953 get_file_type (header
->e_type
));
4954 printf (_(" Machine: %s\n"),
4955 get_machine_name (header
->e_machine
));
4956 printf (_(" Version: 0x%lx\n"),
4959 printf (_(" Entry point address: "));
4960 print_vma (header
->e_entry
, PREFIX_HEX
);
4961 printf (_("\n Start of program headers: "));
4962 print_vma (header
->e_phoff
, DEC
);
4963 printf (_(" (bytes into file)\n Start of section headers: "));
4964 print_vma (header
->e_shoff
, DEC
);
4965 printf (_(" (bytes into file)\n"));
4967 printf (_(" Flags: 0x%lx%s\n"),
4969 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4970 printf (_(" Size of this header: %u (bytes)\n"),
4972 printf (_(" Size of program headers: %u (bytes)\n"),
4973 header
->e_phentsize
);
4974 printf (_(" Number of program headers: %u"),
4976 if (filedata
->section_headers
!= NULL
4977 && header
->e_phnum
== PN_XNUM
4978 && filedata
->section_headers
[0].sh_info
!= 0)
4980 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4981 printf (" (%u)", header
->e_phnum
);
4983 putc ('\n', stdout
);
4984 printf (_(" Size of section headers: %u (bytes)\n"),
4985 header
->e_shentsize
);
4986 printf (_(" Number of section headers: %u"),
4988 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4990 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4991 printf (" (%u)", header
->e_shnum
);
4993 putc ('\n', stdout
);
4994 printf (_(" Section header string table index: %u"),
4995 header
->e_shstrndx
);
4996 if (filedata
->section_headers
!= NULL
4997 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4999 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5000 printf (" (%u)", header
->e_shstrndx
);
5002 if (header
->e_shstrndx
!= SHN_UNDEF
5003 && header
->e_shstrndx
>= header
->e_shnum
)
5005 header
->e_shstrndx
= SHN_UNDEF
;
5006 printf (_(" <corrupt: out of range>"));
5008 putc ('\n', stdout
);
5011 if (filedata
->section_headers
!= NULL
)
5013 if (header
->e_phnum
== PN_XNUM
5014 && filedata
->section_headers
[0].sh_info
!= 0)
5015 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5016 if (header
->e_shnum
== SHN_UNDEF
)
5017 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5018 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5019 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5020 if (header
->e_shstrndx
>= header
->e_shnum
)
5021 header
->e_shstrndx
= SHN_UNDEF
;
5022 free (filedata
->section_headers
);
5023 filedata
->section_headers
= NULL
;
5029 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5030 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5033 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5035 Elf32_External_Phdr
* phdrs
;
5036 Elf32_External_Phdr
* external
;
5037 Elf_Internal_Phdr
* internal
;
5039 unsigned int size
= filedata
->file_header
.e_phentsize
;
5040 unsigned int num
= filedata
->file_header
.e_phnum
;
5042 /* PR binutils/17531: Cope with unexpected section header sizes. */
5043 if (size
== 0 || num
== 0)
5045 if (size
< sizeof * phdrs
)
5047 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5050 if (size
> sizeof * phdrs
)
5051 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5053 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5054 size
, num
, _("program headers"));
5058 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5059 i
< filedata
->file_header
.e_phnum
;
5060 i
++, internal
++, external
++)
5062 internal
->p_type
= BYTE_GET (external
->p_type
);
5063 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5064 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5065 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5066 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5067 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5068 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5069 internal
->p_align
= BYTE_GET (external
->p_align
);
5076 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5077 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5080 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5082 Elf64_External_Phdr
* phdrs
;
5083 Elf64_External_Phdr
* external
;
5084 Elf_Internal_Phdr
* internal
;
5086 unsigned int size
= filedata
->file_header
.e_phentsize
;
5087 unsigned int num
= filedata
->file_header
.e_phnum
;
5089 /* PR binutils/17531: Cope with unexpected section header sizes. */
5090 if (size
== 0 || num
== 0)
5092 if (size
< sizeof * phdrs
)
5094 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5097 if (size
> sizeof * phdrs
)
5098 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5100 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5101 size
, num
, _("program headers"));
5105 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5106 i
< filedata
->file_header
.e_phnum
;
5107 i
++, internal
++, external
++)
5109 internal
->p_type
= BYTE_GET (external
->p_type
);
5110 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5111 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5112 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5113 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5114 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5115 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5116 internal
->p_align
= BYTE_GET (external
->p_align
);
5123 /* Returns TRUE if the program headers were read into `program_headers'. */
5126 get_program_headers (Filedata
* filedata
)
5128 Elf_Internal_Phdr
* phdrs
;
5130 /* Check cache of prior read. */
5131 if (filedata
->program_headers
!= NULL
)
5134 /* Be kind to memory checkers by looking for
5135 e_phnum values which we know must be invalid. */
5136 if (filedata
->file_header
.e_phnum
5137 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5138 >= filedata
->file_size
)
5140 error (_("Too many program headers - %#x - the file is not that big\n"),
5141 filedata
->file_header
.e_phnum
);
5145 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5146 sizeof (Elf_Internal_Phdr
));
5149 error (_("Out of memory reading %u program headers\n"),
5150 filedata
->file_header
.e_phnum
);
5155 ? get_32bit_program_headers (filedata
, phdrs
)
5156 : get_64bit_program_headers (filedata
, phdrs
))
5158 filedata
->program_headers
= phdrs
;
5166 /* Returns TRUE if the program headers were loaded. */
5169 process_program_headers (Filedata
* filedata
)
5171 Elf_Internal_Phdr
* segment
;
5173 Elf_Internal_Phdr
* previous_load
= NULL
;
5175 filedata
->dynamic_addr
= 0;
5176 filedata
->dynamic_size
= 0;
5178 if (filedata
->file_header
.e_phnum
== 0)
5180 /* PR binutils/12467. */
5181 if (filedata
->file_header
.e_phoff
!= 0)
5183 warn (_("possibly corrupt ELF header - it has a non-zero program"
5184 " header offset, but no program headers\n"));
5187 else if (do_segments
)
5188 printf (_("\nThere are no program headers in this file.\n"));
5192 if (do_segments
&& !do_header
)
5194 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5195 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5196 printf (ngettext ("There is %d program header, starting at offset %s\n",
5197 "There are %d program headers, starting at offset %s\n",
5198 filedata
->file_header
.e_phnum
),
5199 filedata
->file_header
.e_phnum
,
5200 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5203 if (! get_program_headers (filedata
))
5208 if (filedata
->file_header
.e_phnum
> 1)
5209 printf (_("\nProgram Headers:\n"));
5211 printf (_("\nProgram Headers:\n"));
5215 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5218 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5222 (_(" Type Offset VirtAddr PhysAddr\n"));
5224 (_(" FileSiz MemSiz Flags Align\n"));
5228 for (i
= 0, segment
= filedata
->program_headers
;
5229 i
< filedata
->file_header
.e_phnum
;
5234 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5238 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5239 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5240 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5241 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5242 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5244 (segment
->p_flags
& PF_R
? 'R' : ' '),
5245 (segment
->p_flags
& PF_W
? 'W' : ' '),
5246 (segment
->p_flags
& PF_X
? 'E' : ' '));
5247 printf ("%#lx", (unsigned long) segment
->p_align
);
5251 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5252 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5255 print_vma (segment
->p_offset
, FULL_HEX
);
5259 print_vma (segment
->p_vaddr
, FULL_HEX
);
5261 print_vma (segment
->p_paddr
, FULL_HEX
);
5264 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5265 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5268 print_vma (segment
->p_filesz
, FULL_HEX
);
5272 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5273 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5276 print_vma (segment
->p_memsz
, FULL_HEX
);
5280 (segment
->p_flags
& PF_R
? 'R' : ' '),
5281 (segment
->p_flags
& PF_W
? 'W' : ' '),
5282 (segment
->p_flags
& PF_X
? 'E' : ' '));
5284 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5285 printf ("%#lx", (unsigned long) segment
->p_align
);
5288 print_vma (segment
->p_align
, PREFIX_HEX
);
5293 print_vma (segment
->p_offset
, FULL_HEX
);
5295 print_vma (segment
->p_vaddr
, FULL_HEX
);
5297 print_vma (segment
->p_paddr
, FULL_HEX
);
5299 print_vma (segment
->p_filesz
, FULL_HEX
);
5301 print_vma (segment
->p_memsz
, FULL_HEX
);
5303 (segment
->p_flags
& PF_R
? 'R' : ' '),
5304 (segment
->p_flags
& PF_W
? 'W' : ' '),
5305 (segment
->p_flags
& PF_X
? 'E' : ' '));
5306 print_vma (segment
->p_align
, PREFIX_HEX
);
5309 putc ('\n', stdout
);
5312 switch (segment
->p_type
)
5315 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5316 required by the ELF standard, several programs, including the Linux
5317 kernel, make use of non-ordered segments. */
5319 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5320 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5322 if (segment
->p_memsz
< segment
->p_filesz
)
5323 error (_("the segment's file size is larger than its memory size\n"));
5324 previous_load
= segment
;
5328 /* PR 20815 - Verify that the program header is loaded into memory. */
5329 if (i
> 0 && previous_load
!= NULL
)
5330 error (_("the PHDR segment must occur before any LOAD segment\n"));
5331 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5335 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5337 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5338 if (load
->p_type
== PT_LOAD
5339 && load
->p_offset
<= segment
->p_offset
5340 && (load
->p_offset
+ load
->p_filesz
5341 >= segment
->p_offset
+ segment
->p_filesz
)
5342 && load
->p_vaddr
<= segment
->p_vaddr
5343 && (load
->p_vaddr
+ load
->p_filesz
5344 >= segment
->p_vaddr
+ segment
->p_filesz
))
5347 if (j
== filedata
->file_header
.e_phnum
)
5348 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5353 if (filedata
->dynamic_addr
)
5354 error (_("more than one dynamic segment\n"));
5356 /* By default, assume that the .dynamic section is the first
5357 section in the DYNAMIC segment. */
5358 filedata
->dynamic_addr
= segment
->p_offset
;
5359 filedata
->dynamic_size
= segment
->p_filesz
;
5361 /* Try to locate the .dynamic section. If there is
5362 a section header table, we can easily locate it. */
5363 if (filedata
->section_headers
!= NULL
)
5365 Elf_Internal_Shdr
* sec
;
5367 sec
= find_section (filedata
, ".dynamic");
5368 if (sec
== NULL
|| sec
->sh_size
== 0)
5370 /* A corresponding .dynamic section is expected, but on
5371 IA-64/OpenVMS it is OK for it to be missing. */
5372 if (!is_ia64_vms (filedata
))
5373 error (_("no .dynamic section in the dynamic segment\n"));
5377 if (sec
->sh_type
== SHT_NOBITS
)
5379 filedata
->dynamic_size
= 0;
5383 filedata
->dynamic_addr
= sec
->sh_offset
;
5384 filedata
->dynamic_size
= sec
->sh_size
;
5386 if (filedata
->dynamic_addr
< segment
->p_offset
5387 || filedata
->dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5388 warn (_("the .dynamic section is not contained"
5389 " within the dynamic segment\n"));
5390 else if (filedata
->dynamic_addr
> segment
->p_offset
)
5391 warn (_("the .dynamic section is not the first section"
5392 " in the dynamic segment.\n"));
5395 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5396 segment. Check this after matching against the section headers
5397 so we don't warn on debuginfo file (which have NOBITS .dynamic
5399 if (filedata
->dynamic_addr
> filedata
->file_size
5400 || (filedata
->dynamic_size
5401 > filedata
->file_size
- filedata
->dynamic_addr
))
5403 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5404 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5409 if (fseek (filedata
->handle
,
5410 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5412 error (_("Unable to find program interpreter name\n"));
5416 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5418 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5419 error (_("Internal error: failed to create format string to display program interpreter\n"));
5421 filedata
->program_interpreter
[0] = 0;
5422 if (fscanf (filedata
->handle
, fmt
,
5423 filedata
->program_interpreter
) <= 0)
5424 error (_("Unable to read program interpreter name\n"));
5427 printf (_(" [Requesting program interpreter: %s]\n"),
5428 filedata
->program_interpreter
);
5435 && filedata
->section_headers
!= NULL
5436 && filedata
->string_table
!= NULL
)
5438 printf (_("\n Section to Segment mapping:\n"));
5439 printf (_(" Segment Sections...\n"));
5441 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5444 Elf_Internal_Shdr
* section
;
5446 segment
= filedata
->program_headers
+ i
;
5447 section
= filedata
->section_headers
+ 1;
5449 printf (" %2.2d ", i
);
5451 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5453 if (!ELF_TBSS_SPECIAL (section
, segment
)
5454 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5455 printf ("%s ", printable_section_name (filedata
, section
));
5466 /* Find the file offset corresponding to VMA by using the program headers. */
5469 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5471 Elf_Internal_Phdr
* seg
;
5473 if (! get_program_headers (filedata
))
5475 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5479 for (seg
= filedata
->program_headers
;
5480 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5483 if (seg
->p_type
!= PT_LOAD
)
5486 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5487 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5488 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5491 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5492 (unsigned long) vma
);
5497 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5498 If PROBE is true, this is just a probe and we do not generate any error
5499 messages if the load fails. */
5502 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5504 Elf32_External_Shdr
* shdrs
;
5505 Elf_Internal_Shdr
* internal
;
5507 unsigned int size
= filedata
->file_header
.e_shentsize
;
5508 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5510 /* PR binutils/17531: Cope with unexpected section header sizes. */
5511 if (size
== 0 || num
== 0)
5513 if (size
< sizeof * shdrs
)
5516 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5519 if (!probe
&& size
> sizeof * shdrs
)
5520 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5522 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5524 probe
? NULL
: _("section headers"));
5528 free (filedata
->section_headers
);
5529 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5530 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5531 if (filedata
->section_headers
== NULL
)
5534 error (_("Out of memory reading %u section headers\n"), num
);
5539 for (i
= 0, internal
= filedata
->section_headers
;
5543 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5544 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5545 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5546 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5547 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5548 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5549 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5550 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5551 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5552 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5553 if (!probe
&& internal
->sh_link
> num
)
5554 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5555 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5556 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5563 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5566 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5568 Elf64_External_Shdr
* shdrs
;
5569 Elf_Internal_Shdr
* internal
;
5571 unsigned int size
= filedata
->file_header
.e_shentsize
;
5572 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5574 /* PR binutils/17531: Cope with unexpected section header sizes. */
5575 if (size
== 0 || num
== 0)
5578 if (size
< sizeof * shdrs
)
5581 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5585 if (! probe
&& size
> sizeof * shdrs
)
5586 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5588 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5589 filedata
->file_header
.e_shoff
,
5591 probe
? NULL
: _("section headers"));
5595 free (filedata
->section_headers
);
5596 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5597 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5598 if (filedata
->section_headers
== NULL
)
5601 error (_("Out of memory reading %u section headers\n"), num
);
5606 for (i
= 0, internal
= filedata
->section_headers
;
5610 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5611 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5612 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5613 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5614 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5615 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5616 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5617 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5618 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5619 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5620 if (!probe
&& internal
->sh_link
> num
)
5621 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5622 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5623 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5630 static Elf_Internal_Sym
*
5631 get_32bit_elf_symbols (Filedata
* filedata
,
5632 Elf_Internal_Shdr
* section
,
5633 unsigned long * num_syms_return
)
5635 unsigned long number
= 0;
5636 Elf32_External_Sym
* esyms
= NULL
;
5637 Elf_External_Sym_Shndx
* shndx
= NULL
;
5638 Elf_Internal_Sym
* isyms
= NULL
;
5639 Elf_Internal_Sym
* psym
;
5641 elf_section_list
* entry
;
5643 if (section
->sh_size
== 0)
5645 if (num_syms_return
!= NULL
)
5646 * num_syms_return
= 0;
5650 /* Run some sanity checks first. */
5651 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5653 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5654 printable_section_name (filedata
, section
),
5655 (unsigned long) section
->sh_entsize
);
5659 if (section
->sh_size
> filedata
->file_size
)
5661 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5662 printable_section_name (filedata
, section
),
5663 (unsigned long) section
->sh_size
);
5667 number
= section
->sh_size
/ section
->sh_entsize
;
5669 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5671 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5672 (unsigned long) section
->sh_size
,
5673 printable_section_name (filedata
, section
),
5674 (unsigned long) section
->sh_entsize
);
5678 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5679 section
->sh_size
, _("symbols"));
5684 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5686 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5691 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5695 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5696 entry
->hdr
->sh_offset
,
5697 1, entry
->hdr
->sh_size
,
5698 _("symbol table section indices"));
5702 /* PR17531: file: heap-buffer-overflow */
5703 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5705 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5706 printable_section_name (filedata
, entry
->hdr
),
5707 (unsigned long) entry
->hdr
->sh_size
,
5708 (unsigned long) section
->sh_size
);
5713 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5717 error (_("Out of memory reading %lu symbols\n"),
5718 (unsigned long) number
);
5722 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5724 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5725 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5726 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5727 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5728 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5730 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5731 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5732 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5733 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5734 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5741 if (num_syms_return
!= NULL
)
5742 * num_syms_return
= isyms
== NULL
? 0 : number
;
5747 static Elf_Internal_Sym
*
5748 get_64bit_elf_symbols (Filedata
* filedata
,
5749 Elf_Internal_Shdr
* section
,
5750 unsigned long * num_syms_return
)
5752 unsigned long number
= 0;
5753 Elf64_External_Sym
* esyms
= NULL
;
5754 Elf_External_Sym_Shndx
* shndx
= NULL
;
5755 Elf_Internal_Sym
* isyms
= NULL
;
5756 Elf_Internal_Sym
* psym
;
5758 elf_section_list
* entry
;
5760 if (section
->sh_size
== 0)
5762 if (num_syms_return
!= NULL
)
5763 * num_syms_return
= 0;
5767 /* Run some sanity checks first. */
5768 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5770 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5771 printable_section_name (filedata
, section
),
5772 (unsigned long) section
->sh_entsize
);
5776 if (section
->sh_size
> filedata
->file_size
)
5778 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5779 printable_section_name (filedata
, section
),
5780 (unsigned long) section
->sh_size
);
5784 number
= section
->sh_size
/ section
->sh_entsize
;
5786 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5788 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5789 (unsigned long) section
->sh_size
,
5790 printable_section_name (filedata
, section
),
5791 (unsigned long) section
->sh_entsize
);
5795 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5796 section
->sh_size
, _("symbols"));
5801 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5803 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5808 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5812 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5813 entry
->hdr
->sh_offset
,
5814 1, entry
->hdr
->sh_size
,
5815 _("symbol table section indices"));
5819 /* PR17531: file: heap-buffer-overflow */
5820 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5822 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5823 printable_section_name (filedata
, entry
->hdr
),
5824 (unsigned long) entry
->hdr
->sh_size
,
5825 (unsigned long) section
->sh_size
);
5830 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5834 error (_("Out of memory reading %lu symbols\n"),
5835 (unsigned long) number
);
5839 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5841 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5842 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5843 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5844 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5846 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5848 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5849 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5850 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5852 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5853 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5860 if (num_syms_return
!= NULL
)
5861 * num_syms_return
= isyms
== NULL
? 0 : number
;
5867 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5869 static char buff
[1024];
5871 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5873 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5874 bfd_vma os_flags
= 0;
5875 bfd_vma proc_flags
= 0;
5876 bfd_vma unknown_flags
= 0;
5884 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5885 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5886 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5887 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5888 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5889 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5890 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5891 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5892 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5893 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5894 /* IA-64 specific. */
5895 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5896 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5897 /* IA-64 OpenVMS specific. */
5898 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5899 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5900 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5901 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5902 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5903 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5905 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5906 /* SPARC specific. */
5907 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5908 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5910 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5911 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5912 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5914 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5916 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5919 if (do_section_details
)
5921 sprintf (buff
, "[%*.*lx]: ",
5922 field_size
, field_size
, (unsigned long) sh_flags
);
5923 p
+= field_size
+ 4;
5930 flag
= sh_flags
& - sh_flags
;
5933 if (do_section_details
)
5937 case SHF_WRITE
: sindex
= 0; break;
5938 case SHF_ALLOC
: sindex
= 1; break;
5939 case SHF_EXECINSTR
: sindex
= 2; break;
5940 case SHF_MERGE
: sindex
= 3; break;
5941 case SHF_STRINGS
: sindex
= 4; break;
5942 case SHF_INFO_LINK
: sindex
= 5; break;
5943 case SHF_LINK_ORDER
: sindex
= 6; break;
5944 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5945 case SHF_GROUP
: sindex
= 8; break;
5946 case SHF_TLS
: sindex
= 9; break;
5947 case SHF_EXCLUDE
: sindex
= 18; break;
5948 case SHF_COMPRESSED
: sindex
= 20; break;
5949 case SHF_GNU_MBIND
: sindex
= 24; break;
5953 switch (filedata
->file_header
.e_machine
)
5956 if (flag
== SHF_IA_64_SHORT
)
5958 else if (flag
== SHF_IA_64_NORECOV
)
5961 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5964 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5965 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5966 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5967 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5968 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5969 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5980 case EM_OLD_SPARCV9
:
5981 case EM_SPARC32PLUS
:
5984 if (flag
== SHF_ORDERED
)
5991 case SHF_ENTRYSECT
: sindex
= 21; break;
5992 case SHF_ARM_PURECODE
: sindex
= 22; break;
5993 case SHF_COMDEF
: sindex
= 23; break;
5998 if (flag
== SHF_PPC_VLE
)
6009 if (p
!= buff
+ field_size
+ 4)
6011 if (size
< (10 + 2))
6013 warn (_("Internal error: not enough buffer room for section flag info"));
6014 return _("<unknown>");
6021 size
-= flags
[sindex
].len
;
6022 p
= stpcpy (p
, flags
[sindex
].str
);
6024 else if (flag
& SHF_MASKOS
)
6026 else if (flag
& SHF_MASKPROC
)
6029 unknown_flags
|= flag
;
6035 case SHF_WRITE
: *p
= 'W'; break;
6036 case SHF_ALLOC
: *p
= 'A'; break;
6037 case SHF_EXECINSTR
: *p
= 'X'; break;
6038 case SHF_MERGE
: *p
= 'M'; break;
6039 case SHF_STRINGS
: *p
= 'S'; break;
6040 case SHF_INFO_LINK
: *p
= 'I'; break;
6041 case SHF_LINK_ORDER
: *p
= 'L'; break;
6042 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6043 case SHF_GROUP
: *p
= 'G'; break;
6044 case SHF_TLS
: *p
= 'T'; break;
6045 case SHF_EXCLUDE
: *p
= 'E'; break;
6046 case SHF_COMPRESSED
: *p
= 'C'; break;
6047 case SHF_GNU_MBIND
: *p
= 'D'; break;
6050 if ((filedata
->file_header
.e_machine
== EM_X86_64
6051 || filedata
->file_header
.e_machine
== EM_L1OM
6052 || filedata
->file_header
.e_machine
== EM_K1OM
)
6053 && flag
== SHF_X86_64_LARGE
)
6055 else if (filedata
->file_header
.e_machine
== EM_ARM
6056 && flag
== SHF_ARM_PURECODE
)
6058 else if (filedata
->file_header
.e_machine
== EM_PPC
6059 && flag
== SHF_PPC_VLE
)
6061 else if (flag
& SHF_MASKOS
)
6064 sh_flags
&= ~ SHF_MASKOS
;
6066 else if (flag
& SHF_MASKPROC
)
6069 sh_flags
&= ~ SHF_MASKPROC
;
6079 if (do_section_details
)
6083 size
-= 5 + field_size
;
6084 if (p
!= buff
+ field_size
+ 4)
6088 warn (_("Internal error: not enough buffer room for section flag info"));
6089 return _("<unknown>");
6095 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6096 (unsigned long) os_flags
);
6097 p
+= 5 + field_size
;
6101 size
-= 7 + field_size
;
6102 if (p
!= buff
+ field_size
+ 4)
6106 warn (_("Internal error: not enough buffer room for section flag info"));
6107 return _("<unknown>");
6113 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6114 (unsigned long) proc_flags
);
6115 p
+= 7 + field_size
;
6119 size
-= 10 + field_size
;
6120 if (p
!= buff
+ field_size
+ 4)
6124 warn (_("Internal error: not enough buffer room for section flag info"));
6125 return _("<unknown>");
6131 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6132 (unsigned long) unknown_flags
);
6133 p
+= 10 + field_size
;
6141 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6142 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6146 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6148 if (size
< sizeof (* echdr
))
6150 error (_("Compressed section is too small even for a compression header\n"));
6154 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6155 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6156 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6157 return sizeof (*echdr
);
6161 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6163 if (size
< sizeof (* echdr
))
6165 error (_("Compressed section is too small even for a compression header\n"));
6169 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6170 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6171 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6172 return sizeof (*echdr
);
6177 process_section_headers (Filedata
* filedata
)
6179 Elf_Internal_Shdr
* section
;
6182 free (filedata
->section_headers
);
6183 filedata
->section_headers
= NULL
;
6184 free (filedata
->dynamic_symbols
);
6185 filedata
->dynamic_symbols
= NULL
;
6186 filedata
->num_dynamic_syms
= 0;
6187 free (filedata
->dynamic_strings
);
6188 filedata
->dynamic_strings
= NULL
;
6189 filedata
->dynamic_strings_length
= 0;
6190 free (filedata
->dynamic_syminfo
);
6191 filedata
->dynamic_syminfo
= NULL
;
6192 while (filedata
->symtab_shndx_list
!= NULL
)
6194 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6195 free (filedata
->symtab_shndx_list
);
6196 filedata
->symtab_shndx_list
= next
;
6199 if (filedata
->file_header
.e_shnum
== 0)
6201 /* PR binutils/12467. */
6202 if (filedata
->file_header
.e_shoff
!= 0)
6204 warn (_("possibly corrupt ELF file header - it has a non-zero"
6205 " section header offset, but no section headers\n"));
6208 else if (do_sections
)
6209 printf (_("\nThere are no sections in this file.\n"));
6214 if (do_sections
&& !do_header
)
6215 printf (ngettext ("There is %d section header, "
6216 "starting at offset 0x%lx:\n",
6217 "There are %d section headers, "
6218 "starting at offset 0x%lx:\n",
6219 filedata
->file_header
.e_shnum
),
6220 filedata
->file_header
.e_shnum
,
6221 (unsigned long) filedata
->file_header
.e_shoff
);
6225 if (! get_32bit_section_headers (filedata
, FALSE
))
6230 if (! get_64bit_section_headers (filedata
, FALSE
))
6234 /* Read in the string table, so that we have names to display. */
6235 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6236 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6238 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6240 if (section
->sh_size
!= 0)
6242 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6243 1, section
->sh_size
,
6246 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6250 /* Scan the sections for the dynamic symbol table
6251 and dynamic string table and debug sections. */
6252 eh_addr_size
= is_32bit_elf
? 4 : 8;
6253 switch (filedata
->file_header
.e_machine
)
6256 case EM_MIPS_RS3_LE
:
6257 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6258 FDE addresses. However, the ABI also has a semi-official ILP32
6259 variant for which the normal FDE address size rules apply.
6261 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6262 section, where XX is the size of longs in bits. Unfortunately,
6263 earlier compilers provided no way of distinguishing ILP32 objects
6264 from LP64 objects, so if there's any doubt, we should assume that
6265 the official LP64 form is being used. */
6266 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6267 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6273 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6275 case E_H8_MACH_H8300
:
6276 case E_H8_MACH_H8300HN
:
6277 case E_H8_MACH_H8300SN
:
6278 case E_H8_MACH_H8300SXN
:
6281 case E_H8_MACH_H8300H
:
6282 case E_H8_MACH_H8300S
:
6283 case E_H8_MACH_H8300SX
:
6291 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6293 case EF_M32C_CPU_M16C
:
6300 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6303 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6304 if (section->sh_entsize != expected_entsize) \
6307 sprintf_vma (buf, section->sh_entsize); \
6308 /* Note: coded this way so that there is a single string for \
6310 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6311 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6312 (unsigned) expected_entsize); \
6313 section->sh_entsize = expected_entsize; \
6318 #define CHECK_ENTSIZE(section, i, type) \
6319 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6320 sizeof (Elf64_External_##type))
6322 for (i
= 0, section
= filedata
->section_headers
;
6323 i
< filedata
->file_header
.e_shnum
;
6326 char * name
= SECTION_NAME (section
);
6328 /* Run some sanity checks on the headers and
6329 possibly fill in some file data as well. */
6330 switch (section
->sh_type
)
6333 if (filedata
->dynamic_symbols
!= NULL
)
6335 error (_("File contains multiple dynamic symbol tables\n"));
6339 CHECK_ENTSIZE (section
, i
, Sym
);
6340 filedata
->dynamic_symbols
6341 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6345 if (streq (name
, ".dynstr"))
6347 if (filedata
->dynamic_strings
!= NULL
)
6349 error (_("File contains multiple dynamic string tables\n"));
6353 filedata
->dynamic_strings
6354 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6355 1, section
->sh_size
, _("dynamic strings"));
6356 filedata
->dynamic_strings_length
6357 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6361 case SHT_SYMTAB_SHNDX
:
6363 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6365 entry
->hdr
= section
;
6366 entry
->next
= filedata
->symtab_shndx_list
;
6367 filedata
->symtab_shndx_list
= entry
;
6372 CHECK_ENTSIZE (section
, i
, Sym
);
6376 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6380 CHECK_ENTSIZE (section
, i
, Rel
);
6381 if (section
->sh_size
== 0)
6382 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6386 CHECK_ENTSIZE (section
, i
, Rela
);
6387 if (section
->sh_size
== 0)
6388 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6393 if (section
->sh_size
== 0)
6394 /* This is not illegal according to the ELF standard, but
6395 it might be an indication that something is wrong. */
6396 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6403 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6404 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6405 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6406 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6407 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6408 && (const_strneq (name
, ".debug_")
6409 || const_strneq (name
, ".zdebug_")))
6412 name
+= sizeof (".zdebug_") - 1;
6414 name
+= sizeof (".debug_") - 1;
6417 || (do_debug_info
&& const_strneq (name
, "info"))
6418 || (do_debug_info
&& const_strneq (name
, "types"))
6419 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6420 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6421 || (do_debug_lines
&& const_strneq (name
, "line."))
6422 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6423 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6424 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6425 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6426 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6427 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6428 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6429 || (do_debug_frames
&& const_strneq (name
, "frame"))
6430 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6431 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6432 || (do_debug_str
&& const_strneq (name
, "str"))
6433 || (do_debug_loc
&& const_strneq (name
, "loc"))
6434 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6435 || (do_debug_addr
&& const_strneq (name
, "addr"))
6436 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6437 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6439 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6441 /* Linkonce section to be combined with .debug_info at link time. */
6442 else if ((do_debugging
|| do_debug_info
)
6443 && const_strneq (name
, ".gnu.linkonce.wi."))
6444 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6445 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6446 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6447 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6448 || streq (name
, ".debug_names")))
6449 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6450 /* Trace sections for Itanium VMS. */
6451 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6452 || do_trace_aranges
)
6453 && const_strneq (name
, ".trace_"))
6455 name
+= sizeof (".trace_") - 1;
6458 || (do_trace_info
&& streq (name
, "info"))
6459 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6460 || (do_trace_aranges
&& streq (name
, "aranges"))
6462 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6464 else if ((do_debugging
|| do_debug_links
)
6465 && (const_strneq (name
, ".gnu_debuglink")
6466 || const_strneq (name
, ".gnu_debugaltlink")))
6467 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6473 if (filedata
->file_header
.e_shnum
> 1)
6474 printf (_("\nSection Headers:\n"));
6476 printf (_("\nSection Header:\n"));
6480 if (do_section_details
)
6482 printf (_(" [Nr] Name\n"));
6483 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6487 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6491 if (do_section_details
)
6493 printf (_(" [Nr] Name\n"));
6494 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6498 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6502 if (do_section_details
)
6504 printf (_(" [Nr] Name\n"));
6505 printf (_(" Type Address Offset Link\n"));
6506 printf (_(" Size EntSize Info Align\n"));
6510 printf (_(" [Nr] Name Type Address Offset\n"));
6511 printf (_(" Size EntSize Flags Link Info Align\n"));
6515 if (do_section_details
)
6516 printf (_(" Flags\n"));
6518 for (i
= 0, section
= filedata
->section_headers
;
6519 i
< filedata
->file_header
.e_shnum
;
6522 /* Run some sanity checks on the section header. */
6524 /* Check the sh_link field. */
6525 switch (section
->sh_type
)
6529 if (section
->sh_link
== 0
6530 && (filedata
->file_header
.e_type
== ET_EXEC
6531 || filedata
->file_header
.e_type
== ET_DYN
))
6532 /* A dynamic relocation section where all entries use a
6533 zero symbol index need not specify a symtab section. */
6536 case SHT_SYMTAB_SHNDX
:
6540 case SHT_GNU_versym
:
6541 if (section
->sh_link
== 0
6542 || section
->sh_link
>= filedata
->file_header
.e_shnum
6543 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6544 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6545 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6546 i
, section
->sh_link
);
6552 case SHT_GNU_verneed
:
6553 case SHT_GNU_verdef
:
6554 case SHT_GNU_LIBLIST
:
6555 if (section
->sh_link
== 0
6556 || section
->sh_link
>= filedata
->file_header
.e_shnum
6557 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6558 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6559 i
, section
->sh_link
);
6562 case SHT_INIT_ARRAY
:
6563 case SHT_FINI_ARRAY
:
6564 case SHT_PREINIT_ARRAY
:
6565 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6566 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6567 i
, section
->sh_link
);
6571 /* FIXME: Add support for target specific section types. */
6572 #if 0 /* Currently we do not check other section types as there are too
6573 many special cases. Stab sections for example have a type
6574 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6576 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6577 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6578 i
, section
->sh_link
);
6583 /* Check the sh_info field. */
6584 switch (section
->sh_type
)
6588 if (section
->sh_info
== 0
6589 && (filedata
->file_header
.e_type
== ET_EXEC
6590 || filedata
->file_header
.e_type
== ET_DYN
))
6591 /* Dynamic relocations apply to segments, so they do not
6592 need to specify the section they relocate. */
6594 if (section
->sh_info
== 0
6595 || section
->sh_info
>= filedata
->file_header
.e_shnum
6596 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6597 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6598 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6599 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6600 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6601 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6602 /* FIXME: Are other section types valid ? */
6603 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6604 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6605 i
, section
->sh_info
);
6610 case SHT_SYMTAB_SHNDX
:
6611 case SHT_INIT_ARRAY
:
6612 case SHT_FINI_ARRAY
:
6613 case SHT_PREINIT_ARRAY
:
6614 if (section
->sh_info
!= 0)
6615 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6616 i
, section
->sh_info
);
6622 /* A symbol index - we assume that it is valid. */
6626 /* FIXME: Add support for target specific section types. */
6627 if (section
->sh_type
== SHT_NOBITS
)
6628 /* NOBITS section headers with non-zero sh_info fields can be
6629 created when a binary is stripped of everything but its debug
6630 information. The stripped sections have their headers
6631 preserved but their types set to SHT_NOBITS. So do not check
6632 this type of section. */
6634 else if (section
->sh_flags
& SHF_INFO_LINK
)
6636 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6637 warn (_("[%2u]: Expected link to another section in info field"), i
);
6639 else if (section
->sh_type
< SHT_LOOS
6640 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6641 && section
->sh_info
!= 0)
6642 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6643 i
, section
->sh_info
);
6647 /* Check the sh_size field. */
6648 if (section
->sh_size
> filedata
->file_size
6649 && section
->sh_type
!= SHT_NOBITS
6650 && section
->sh_type
!= SHT_NULL
6651 && section
->sh_type
< SHT_LOOS
)
6652 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6654 printf (" [%2u] ", i
);
6655 if (do_section_details
)
6656 printf ("%s\n ", printable_section_name (filedata
, section
));
6658 print_symbol (-17, SECTION_NAME (section
));
6660 printf (do_wide
? " %-15s " : " %-15.15s ",
6661 get_section_type_name (filedata
, section
->sh_type
));
6665 const char * link_too_big
= NULL
;
6667 print_vma (section
->sh_addr
, LONG_HEX
);
6669 printf ( " %6.6lx %6.6lx %2.2lx",
6670 (unsigned long) section
->sh_offset
,
6671 (unsigned long) section
->sh_size
,
6672 (unsigned long) section
->sh_entsize
);
6674 if (do_section_details
)
6675 fputs (" ", stdout
);
6677 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6679 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6682 /* The sh_link value is out of range. Normally this indicates
6683 an error but it can have special values in Solaris binaries. */
6684 switch (filedata
->file_header
.e_machine
)
6691 case EM_OLD_SPARCV9
:
6692 case EM_SPARC32PLUS
:
6695 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6696 link_too_big
= "BEFORE";
6697 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6698 link_too_big
= "AFTER";
6705 if (do_section_details
)
6707 if (link_too_big
!= NULL
&& * link_too_big
)
6708 printf ("<%s> ", link_too_big
);
6710 printf ("%2u ", section
->sh_link
);
6711 printf ("%3u %2lu\n", section
->sh_info
,
6712 (unsigned long) section
->sh_addralign
);
6715 printf ("%2u %3u %2lu\n",
6718 (unsigned long) section
->sh_addralign
);
6720 if (link_too_big
&& ! * link_too_big
)
6721 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6722 i
, section
->sh_link
);
6726 print_vma (section
->sh_addr
, LONG_HEX
);
6728 if ((long) section
->sh_offset
== section
->sh_offset
)
6729 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6733 print_vma (section
->sh_offset
, LONG_HEX
);
6736 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6737 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6741 print_vma (section
->sh_size
, LONG_HEX
);
6744 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6745 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6749 print_vma (section
->sh_entsize
, LONG_HEX
);
6752 if (do_section_details
)
6753 fputs (" ", stdout
);
6755 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6757 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6759 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6760 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6763 print_vma (section
->sh_addralign
, DEC
);
6767 else if (do_section_details
)
6770 print_vma (section
->sh_addr
, LONG_HEX
);
6771 if ((long) section
->sh_offset
== section
->sh_offset
)
6772 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6776 print_vma (section
->sh_offset
, LONG_HEX
);
6778 printf (" %u\n ", section
->sh_link
);
6779 print_vma (section
->sh_size
, LONG_HEX
);
6781 print_vma (section
->sh_entsize
, LONG_HEX
);
6783 printf (" %-16u %lu\n",
6785 (unsigned long) section
->sh_addralign
);
6790 print_vma (section
->sh_addr
, LONG_HEX
);
6791 if ((long) section
->sh_offset
== section
->sh_offset
)
6792 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6796 print_vma (section
->sh_offset
, LONG_HEX
);
6799 print_vma (section
->sh_size
, LONG_HEX
);
6801 print_vma (section
->sh_entsize
, LONG_HEX
);
6803 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6805 printf (" %2u %3u %lu\n",
6808 (unsigned long) section
->sh_addralign
);
6811 if (do_section_details
)
6813 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6814 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6816 /* Minimum section size is 12 bytes for 32-bit compression
6817 header + 12 bytes for compressed data header. */
6818 unsigned char buf
[24];
6820 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6821 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6822 sizeof (buf
), _("compression header")))
6824 Elf_Internal_Chdr chdr
;
6826 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6827 printf (_(" [<corrupt>]\n"));
6830 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6833 printf (_(" [<unknown>: 0x%x], "),
6835 print_vma (chdr
.ch_size
, LONG_HEX
);
6836 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6843 if (!do_section_details
)
6845 /* The ordering of the letters shown here matches the ordering of the
6846 corresponding SHF_xxx values, and hence the order in which these
6847 letters will be displayed to the user. */
6848 printf (_("Key to Flags:\n\
6849 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6850 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6851 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6852 if (filedata
->file_header
.e_machine
== EM_X86_64
6853 || filedata
->file_header
.e_machine
== EM_L1OM
6854 || filedata
->file_header
.e_machine
== EM_K1OM
)
6855 printf (_("l (large), "));
6856 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6857 printf (_("y (purecode), "));
6858 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6859 printf (_("v (VLE), "));
6860 printf ("p (processor specific)\n");
6867 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6868 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6869 char **strtab
, unsigned long *strtablen
)
6873 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6875 if (*symtab
== NULL
)
6878 if (symsec
->sh_link
!= 0)
6880 Elf_Internal_Shdr
*strsec
;
6882 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6884 error (_("Bad sh_link in symbol table section\n"));
6891 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6893 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6894 1, strsec
->sh_size
, _("string table"));
6895 if (*strtab
== NULL
)
6902 *strtablen
= strsec
->sh_size
;
6908 get_group_flags (unsigned int flags
)
6910 static char buff
[128];
6914 else if (flags
== GRP_COMDAT
)
6917 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6919 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6920 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6921 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6922 ? _("<unknown>") : ""));
6928 process_section_groups (Filedata
* filedata
)
6930 Elf_Internal_Shdr
* section
;
6932 struct group
* group
;
6933 Elf_Internal_Shdr
* symtab_sec
;
6934 Elf_Internal_Shdr
* strtab_sec
;
6935 Elf_Internal_Sym
* symtab
;
6936 unsigned long num_syms
;
6940 /* Don't process section groups unless needed. */
6941 if (!do_unwind
&& !do_section_groups
)
6944 if (filedata
->file_header
.e_shnum
== 0)
6946 if (do_section_groups
)
6947 printf (_("\nThere are no sections to group in this file.\n"));
6952 if (filedata
->section_headers
== NULL
)
6954 error (_("Section headers are not available!\n"));
6955 /* PR 13622: This can happen with a corrupt ELF header. */
6959 filedata
->section_headers_groups
6960 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6961 sizeof (struct group
*));
6963 if (filedata
->section_headers_groups
== NULL
)
6965 error (_("Out of memory reading %u section group headers\n"),
6966 filedata
->file_header
.e_shnum
);
6970 /* Scan the sections for the group section. */
6971 filedata
->group_count
= 0;
6972 for (i
= 0, section
= filedata
->section_headers
;
6973 i
< filedata
->file_header
.e_shnum
;
6975 if (section
->sh_type
== SHT_GROUP
)
6976 filedata
->group_count
++;
6978 if (filedata
->group_count
== 0)
6980 if (do_section_groups
)
6981 printf (_("\nThere are no section groups in this file.\n"));
6986 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
6987 sizeof (struct group
));
6989 if (filedata
->section_groups
== NULL
)
6991 error (_("Out of memory reading %lu groups\n"),
6992 (unsigned long) filedata
->group_count
);
7002 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7003 i
< filedata
->file_header
.e_shnum
;
7006 if (section
->sh_type
== SHT_GROUP
)
7008 const char * name
= printable_section_name (filedata
, section
);
7009 const char * group_name
;
7010 unsigned char * start
;
7011 unsigned char * indices
;
7012 unsigned int entry
, j
, size
;
7013 Elf_Internal_Shdr
* sec
;
7014 Elf_Internal_Sym
* sym
;
7016 /* Get the symbol table. */
7017 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7018 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7021 error (_("Bad sh_link in group section `%s'\n"), name
);
7025 if (symtab_sec
!= sec
)
7030 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7035 error (_("Corrupt header in group section `%s'\n"), name
);
7039 if (section
->sh_info
>= num_syms
)
7041 error (_("Bad sh_info in group section `%s'\n"), name
);
7045 sym
= symtab
+ section
->sh_info
;
7047 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7049 if (sym
->st_shndx
== 0
7050 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7052 error (_("Bad sh_info in group section `%s'\n"), name
);
7056 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
7065 /* Get the string table. */
7066 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7075 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7081 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7082 1, strtab_sec
->sh_size
,
7084 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7086 group_name
= sym
->st_name
< strtab_size
7087 ? strtab
+ sym
->st_name
: _("<corrupt>");
7090 /* PR 17531: file: loop. */
7091 if (section
->sh_entsize
> section
->sh_size
)
7093 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7094 printable_section_name (filedata
, section
),
7095 (unsigned long) section
->sh_entsize
,
7096 (unsigned long) section
->sh_size
);
7100 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7101 1, section
->sh_size
,
7107 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7108 entry
= byte_get (indices
, 4);
7111 if (do_section_groups
)
7113 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7114 get_group_flags (entry
), i
, name
, group_name
, size
);
7116 printf (_(" [Index] Name\n"));
7119 group
->group_index
= i
;
7121 for (j
= 0; j
< size
; j
++)
7123 struct group_list
* g
;
7125 entry
= byte_get (indices
, 4);
7128 if (entry
>= filedata
->file_header
.e_shnum
)
7130 static unsigned num_group_errors
= 0;
7132 if (num_group_errors
++ < 10)
7134 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7135 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7136 if (num_group_errors
== 10)
7137 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7142 if (filedata
->section_headers_groups
[entry
] != NULL
)
7146 static unsigned num_errs
= 0;
7148 if (num_errs
++ < 10)
7150 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7152 filedata
->section_headers_groups
[entry
]->group_index
);
7154 warn (_("Further error messages about already contained group sections suppressed\n"));
7160 /* Intel C/C++ compiler may put section 0 in a
7161 section group. We just warn it the first time
7162 and ignore it afterwards. */
7163 static bfd_boolean warned
= FALSE
;
7166 error (_("section 0 in group section [%5u]\n"),
7167 filedata
->section_headers_groups
[entry
]->group_index
);
7173 filedata
->section_headers_groups
[entry
] = group
;
7175 if (do_section_groups
)
7177 sec
= filedata
->section_headers
+ entry
;
7178 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7181 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7182 g
->section_index
= entry
;
7183 g
->next
= group
->root
;
7201 /* Data used to display dynamic fixups. */
7203 struct ia64_vms_dynfixup
7205 bfd_vma needed_ident
; /* Library ident number. */
7206 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7207 bfd_vma fixup_needed
; /* Index of the library. */
7208 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7209 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7212 /* Data used to display dynamic relocations. */
7214 struct ia64_vms_dynimgrela
7216 bfd_vma img_rela_cnt
; /* Number of relocations. */
7217 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7220 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7224 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7225 struct ia64_vms_dynfixup
* fixup
,
7226 const char * strtab
,
7227 unsigned int strtab_sz
)
7229 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7231 const char * lib_name
;
7233 imfs
= get_data (NULL
, filedata
,
7234 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7235 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7236 _("dynamic section image fixups"));
7240 if (fixup
->needed
< strtab_sz
)
7241 lib_name
= strtab
+ fixup
->needed
;
7244 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7245 (unsigned long) fixup
->needed
);
7249 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7250 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7252 (_("Seg Offset Type SymVec DataType\n"));
7254 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7259 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7260 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7261 type
= BYTE_GET (imfs
[i
].type
);
7262 rtype
= elf_ia64_reloc_type (type
);
7264 printf (" 0x%08x ", type
);
7266 printf (" %-32s ", rtype
);
7267 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7268 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7275 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7278 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7280 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7283 imrs
= get_data (NULL
, filedata
,
7284 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7285 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7286 _("dynamic section image relocations"));
7290 printf (_("\nImage relocs\n"));
7292 (_("Seg Offset Type Addend Seg Sym Off\n"));
7294 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7299 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7300 printf ("%08" BFD_VMA_FMT
"x ",
7301 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7302 type
= BYTE_GET (imrs
[i
].type
);
7303 rtype
= elf_ia64_reloc_type (type
);
7305 printf ("0x%08x ", type
);
7307 printf ("%-31s ", rtype
);
7308 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7309 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7310 printf ("%08" BFD_VMA_FMT
"x\n",
7311 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7318 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7321 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7323 struct ia64_vms_dynfixup fixup
;
7324 struct ia64_vms_dynimgrela imgrela
;
7325 Elf_Internal_Dyn
*entry
;
7326 bfd_vma strtab_off
= 0;
7327 bfd_vma strtab_sz
= 0;
7328 char *strtab
= NULL
;
7329 bfd_boolean res
= TRUE
;
7331 memset (&fixup
, 0, sizeof (fixup
));
7332 memset (&imgrela
, 0, sizeof (imgrela
));
7334 /* Note: the order of the entries is specified by the OpenVMS specs. */
7335 for (entry
= filedata
->dynamic_section
;
7336 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7339 switch (entry
->d_tag
)
7341 case DT_IA_64_VMS_STRTAB_OFFSET
:
7342 strtab_off
= entry
->d_un
.d_val
;
7345 strtab_sz
= entry
->d_un
.d_val
;
7347 strtab
= get_data (NULL
, filedata
,
7348 filedata
->dynamic_addr
+ strtab_off
,
7349 1, strtab_sz
, _("dynamic string section"));
7354 case DT_IA_64_VMS_NEEDED_IDENT
:
7355 fixup
.needed_ident
= entry
->d_un
.d_val
;
7358 fixup
.needed
= entry
->d_un
.d_val
;
7360 case DT_IA_64_VMS_FIXUP_NEEDED
:
7361 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7363 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7364 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7366 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7367 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7368 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7371 case DT_IA_64_VMS_IMG_RELA_CNT
:
7372 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7374 case DT_IA_64_VMS_IMG_RELA_OFF
:
7375 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7376 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7398 dynamic_relocations
[] =
7400 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7401 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7402 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7405 /* Process the reloc section. */
7408 process_relocs (Filedata
* filedata
)
7410 unsigned long rel_size
;
7411 unsigned long rel_offset
;
7416 if (do_using_dynamic
)
7420 bfd_boolean has_dynamic_reloc
;
7423 has_dynamic_reloc
= FALSE
;
7425 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7427 is_rela
= dynamic_relocations
[i
].rela
;
7428 name
= dynamic_relocations
[i
].name
;
7429 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7430 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7433 has_dynamic_reloc
= TRUE
;
7435 if (is_rela
== UNKNOWN
)
7437 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7438 switch (filedata
->dynamic_info
[DT_PLTREL
])
7452 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7453 name
, rel_offset
, rel_size
);
7455 dump_relocations (filedata
,
7456 offset_from_vma (filedata
, rel_offset
, rel_size
),
7458 filedata
->dynamic_symbols
,
7459 filedata
->num_dynamic_syms
,
7460 filedata
->dynamic_strings
,
7461 filedata
->dynamic_strings_length
,
7462 is_rela
, TRUE
/* is_dynamic */);
7466 if (is_ia64_vms (filedata
))
7467 if (process_ia64_vms_dynamic_relocs (filedata
))
7468 has_dynamic_reloc
= TRUE
;
7470 if (! has_dynamic_reloc
)
7471 printf (_("\nThere are no dynamic relocations in this file.\n"));
7475 Elf_Internal_Shdr
* section
;
7477 bfd_boolean found
= FALSE
;
7479 for (i
= 0, section
= filedata
->section_headers
;
7480 i
< filedata
->file_header
.e_shnum
;
7483 if ( section
->sh_type
!= SHT_RELA
7484 && section
->sh_type
!= SHT_REL
)
7487 rel_offset
= section
->sh_offset
;
7488 rel_size
= section
->sh_size
;
7493 unsigned long num_rela
;
7495 printf (_("\nRelocation section "));
7497 if (filedata
->string_table
== NULL
)
7498 printf ("%d", section
->sh_name
);
7500 printf ("'%s'", printable_section_name (filedata
, section
));
7502 num_rela
= rel_size
/ section
->sh_entsize
;
7503 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7504 " at offset 0x%lx contains %lu entries:\n",
7506 rel_offset
, num_rela
);
7508 is_rela
= section
->sh_type
== SHT_RELA
;
7510 if (section
->sh_link
!= 0
7511 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7513 Elf_Internal_Shdr
* symsec
;
7514 Elf_Internal_Sym
* symtab
;
7515 unsigned long nsyms
;
7516 unsigned long strtablen
= 0;
7517 char * strtab
= NULL
;
7519 symsec
= filedata
->section_headers
+ section
->sh_link
;
7520 if (symsec
->sh_type
!= SHT_SYMTAB
7521 && symsec
->sh_type
!= SHT_DYNSYM
)
7524 if (!get_symtab (filedata
, symsec
,
7525 &symtab
, &nsyms
, &strtab
, &strtablen
))
7528 dump_relocations (filedata
, rel_offset
, rel_size
,
7529 symtab
, nsyms
, strtab
, strtablen
,
7531 symsec
->sh_type
== SHT_DYNSYM
);
7537 dump_relocations (filedata
, rel_offset
, rel_size
,
7538 NULL
, 0, NULL
, 0, is_rela
,
7539 FALSE
/* is_dynamic */);
7547 /* Users sometimes forget the -D option, so try to be helpful. */
7548 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7550 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7552 printf (_("\nThere are no static relocations in this file."));
7553 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7558 if (i
== ARRAY_SIZE (dynamic_relocations
))
7559 printf (_("\nThere are no relocations in this file.\n"));
7566 /* An absolute address consists of a section and an offset. If the
7567 section is NULL, the offset itself is the address, otherwise, the
7568 address equals to LOAD_ADDRESS(section) + offset. */
7572 unsigned short section
;
7576 /* Find the nearest symbol at or below ADDR. Returns the symbol
7577 name, if found, and the offset from the symbol to ADDR. */
7580 find_symbol_for_address (Filedata
* filedata
,
7581 Elf_Internal_Sym
* symtab
,
7582 unsigned long nsyms
,
7583 const char * strtab
,
7584 unsigned long strtab_size
,
7585 struct absaddr addr
,
7586 const char ** symname
,
7589 bfd_vma dist
= 0x100000;
7590 Elf_Internal_Sym
* sym
;
7591 Elf_Internal_Sym
* beg
;
7592 Elf_Internal_Sym
* end
;
7593 Elf_Internal_Sym
* best
= NULL
;
7595 REMOVE_ARCH_BITS (addr
.offset
);
7597 end
= symtab
+ nsyms
;
7603 sym
= beg
+ (end
- beg
) / 2;
7605 value
= sym
->st_value
;
7606 REMOVE_ARCH_BITS (value
);
7608 if (sym
->st_name
!= 0
7609 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7610 && addr
.offset
>= value
7611 && addr
.offset
- value
< dist
)
7614 dist
= addr
.offset
- value
;
7619 if (addr
.offset
< value
)
7627 *symname
= (best
->st_name
>= strtab_size
7628 ? _("<corrupt>") : strtab
+ best
->st_name
);
7634 *offset
= addr
.offset
;
7637 static /* signed */ int
7638 symcmp (const void *p
, const void *q
)
7640 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7641 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7643 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7646 /* Process the unwind section. */
7648 #include "unwind-ia64.h"
7650 struct ia64_unw_table_entry
7652 struct absaddr start
;
7654 struct absaddr info
;
7657 struct ia64_unw_aux_info
7659 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7660 unsigned long table_len
; /* Length of unwind table. */
7661 unsigned char * info
; /* Unwind info. */
7662 unsigned long info_size
; /* Size of unwind info. */
7663 bfd_vma info_addr
; /* Starting address of unwind info. */
7664 bfd_vma seg_base
; /* Starting address of segment. */
7665 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7666 unsigned long nsyms
; /* Number of symbols. */
7667 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7668 unsigned long nfuns
; /* Number of entries in funtab. */
7669 char * strtab
; /* The string table. */
7670 unsigned long strtab_size
; /* Size of string table. */
7674 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7676 struct ia64_unw_table_entry
* tp
;
7677 unsigned long j
, nfuns
;
7679 bfd_boolean res
= TRUE
;
7681 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7682 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7683 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7684 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7686 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7688 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7692 const unsigned char * dp
;
7693 const unsigned char * head
;
7694 const unsigned char * end
;
7695 const char * procname
;
7697 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7698 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7700 fputs ("\n<", stdout
);
7704 fputs (procname
, stdout
);
7707 printf ("+%lx", (unsigned long) offset
);
7710 fputs (">: [", stdout
);
7711 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7712 fputc ('-', stdout
);
7713 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7714 printf ("], info at +0x%lx\n",
7715 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7717 /* PR 17531: file: 86232b32. */
7718 if (aux
->info
== NULL
)
7721 offset
= tp
->info
.offset
;
7722 if (tp
->info
.section
)
7724 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7726 warn (_("Invalid section %u in table entry %ld\n"),
7727 tp
->info
.section
, (long) (tp
- aux
->table
));
7731 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7733 offset
-= aux
->info_addr
;
7734 /* PR 17531: file: 0997b4d1. */
7735 if (offset
>= aux
->info_size
7736 || aux
->info_size
- offset
< 8)
7738 warn (_("Invalid offset %lx in table entry %ld\n"),
7739 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7744 head
= aux
->info
+ offset
;
7745 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7747 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7748 (unsigned) UNW_VER (stamp
),
7749 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7750 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7751 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7752 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7754 if (UNW_VER (stamp
) != 1)
7756 printf (_("\tUnknown version.\n"));
7761 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7762 /* PR 17531: file: 16ceda89. */
7763 if (end
> aux
->info
+ aux
->info_size
)
7764 end
= aux
->info
+ aux
->info_size
;
7765 for (dp
= head
+ 8; dp
< end
;)
7766 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7775 slurp_ia64_unwind_table (Filedata
* filedata
,
7776 struct ia64_unw_aux_info
* aux
,
7777 Elf_Internal_Shdr
* sec
)
7779 unsigned long size
, nrelas
, i
;
7780 Elf_Internal_Phdr
* seg
;
7781 struct ia64_unw_table_entry
* tep
;
7782 Elf_Internal_Shdr
* relsec
;
7783 Elf_Internal_Rela
* rela
;
7784 Elf_Internal_Rela
* rp
;
7785 unsigned char * table
;
7787 Elf_Internal_Sym
* sym
;
7788 const char * relname
;
7792 /* First, find the starting address of the segment that includes
7795 if (filedata
->file_header
.e_phnum
)
7797 if (! get_program_headers (filedata
))
7800 for (seg
= filedata
->program_headers
;
7801 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7804 if (seg
->p_type
!= PT_LOAD
)
7807 if (sec
->sh_addr
>= seg
->p_vaddr
7808 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7810 aux
->seg_base
= seg
->p_vaddr
;
7816 /* Second, build the unwind table from the contents of the unwind section: */
7817 size
= sec
->sh_size
;
7818 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7823 aux
->table_len
= size
/ (3 * eh_addr_size
);
7824 aux
->table
= (struct ia64_unw_table_entry
*)
7825 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7828 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7830 tep
->start
.section
= SHN_UNDEF
;
7831 tep
->end
.section
= SHN_UNDEF
;
7832 tep
->info
.section
= SHN_UNDEF
;
7833 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7834 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7835 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7836 tep
->start
.offset
+= aux
->seg_base
;
7837 tep
->end
.offset
+= aux
->seg_base
;
7838 tep
->info
.offset
+= aux
->seg_base
;
7842 /* Third, apply any relocations to the unwind table: */
7843 for (relsec
= filedata
->section_headers
;
7844 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7847 if (relsec
->sh_type
!= SHT_RELA
7848 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7849 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7852 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7861 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7863 unsigned int sym_ndx
;
7864 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7865 relname
= elf_ia64_reloc_type (r_type
);
7867 /* PR 17531: file: 9fa67536. */
7868 if (relname
== NULL
)
7870 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7874 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7876 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7880 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7882 /* PR 17531: file: 5bc8d9bf. */
7883 if (i
>= aux
->table_len
)
7885 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7889 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7890 if (sym_ndx
>= aux
->nsyms
)
7892 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7896 sym
= aux
->symtab
+ sym_ndx
;
7898 switch (rp
->r_offset
/ eh_addr_size
% 3)
7901 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7902 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7905 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7906 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7909 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7910 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7924 ia64_process_unwind (Filedata
* filedata
)
7926 Elf_Internal_Shdr
* sec
;
7927 Elf_Internal_Shdr
* unwsec
= NULL
;
7928 unsigned long i
, unwcount
= 0, unwstart
= 0;
7929 struct ia64_unw_aux_info aux
;
7930 bfd_boolean res
= TRUE
;
7932 memset (& aux
, 0, sizeof (aux
));
7934 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7936 if (sec
->sh_type
== SHT_SYMTAB
)
7940 error (_("Multiple symbol tables encountered\n"));
7946 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7947 &aux
.strtab
, &aux
.strtab_size
))
7950 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7955 printf (_("\nThere are no unwind sections in this file.\n"));
7957 while (unwcount
-- > 0)
7962 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7963 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7964 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7969 /* We have already counted the number of SHT_IA64_UNWIND
7970 sections so the loop above should never fail. */
7971 assert (unwsec
!= NULL
);
7974 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7976 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7978 /* We need to find which section group it is in. */
7979 struct group_list
* g
;
7981 if (filedata
->section_headers_groups
== NULL
7982 || filedata
->section_headers_groups
[i
] == NULL
)
7983 i
= filedata
->file_header
.e_shnum
;
7986 g
= filedata
->section_headers_groups
[i
]->root
;
7988 for (; g
!= NULL
; g
= g
->next
)
7990 sec
= filedata
->section_headers
+ g
->section_index
;
7992 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7997 i
= filedata
->file_header
.e_shnum
;
8000 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
8002 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8003 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8004 suffix
= SECTION_NAME (unwsec
) + len
;
8005 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8007 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
8008 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8013 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8014 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8015 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8016 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8018 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
8019 suffix
= SECTION_NAME (unwsec
) + len
;
8020 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8022 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
8023 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8027 if (i
== filedata
->file_header
.e_shnum
)
8029 printf (_("\nCould not find unwind info section for "));
8031 if (filedata
->string_table
== NULL
)
8032 printf ("%d", unwsec
->sh_name
);
8034 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8038 aux
.info_addr
= sec
->sh_addr
;
8039 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8042 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8044 printf (_("\nUnwind section "));
8046 if (filedata
->string_table
== NULL
)
8047 printf ("%d", unwsec
->sh_name
);
8049 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8051 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8052 (unsigned long) unwsec
->sh_offset
,
8053 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8055 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8056 && aux
.table_len
> 0)
8057 dump_ia64_unwind (filedata
, & aux
);
8060 free ((char *) aux
.table
);
8062 free ((char *) aux
.info
);
8071 free ((char *) aux
.strtab
);
8076 struct hppa_unw_table_entry
8078 struct absaddr start
;
8080 unsigned int Cannot_unwind
:1; /* 0 */
8081 unsigned int Millicode
:1; /* 1 */
8082 unsigned int Millicode_save_sr0
:1; /* 2 */
8083 unsigned int Region_description
:2; /* 3..4 */
8084 unsigned int reserved1
:1; /* 5 */
8085 unsigned int Entry_SR
:1; /* 6 */
8086 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8087 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8088 unsigned int Args_stored
:1; /* 16 */
8089 unsigned int Variable_Frame
:1; /* 17 */
8090 unsigned int Separate_Package_Body
:1; /* 18 */
8091 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8092 unsigned int Stack_Overflow_Check
:1; /* 20 */
8093 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8094 unsigned int Ada_Region
:1; /* 22 */
8095 unsigned int cxx_info
:1; /* 23 */
8096 unsigned int cxx_try_catch
:1; /* 24 */
8097 unsigned int sched_entry_seq
:1; /* 25 */
8098 unsigned int reserved2
:1; /* 26 */
8099 unsigned int Save_SP
:1; /* 27 */
8100 unsigned int Save_RP
:1; /* 28 */
8101 unsigned int Save_MRP_in_frame
:1; /* 29 */
8102 unsigned int extn_ptr_defined
:1; /* 30 */
8103 unsigned int Cleanup_defined
:1; /* 31 */
8105 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8106 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8107 unsigned int Large_frame
:1; /* 2 */
8108 unsigned int Pseudo_SP_Set
:1; /* 3 */
8109 unsigned int reserved4
:1; /* 4 */
8110 unsigned int Total_frame_size
:27; /* 5..31 */
8113 struct hppa_unw_aux_info
8115 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8116 unsigned long table_len
; /* Length of unwind table. */
8117 bfd_vma seg_base
; /* Starting address of segment. */
8118 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8119 unsigned long nsyms
; /* Number of symbols. */
8120 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8121 unsigned long nfuns
; /* Number of entries in funtab. */
8122 char * strtab
; /* The string table. */
8123 unsigned long strtab_size
; /* Size of string table. */
8127 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8129 struct hppa_unw_table_entry
* tp
;
8130 unsigned long j
, nfuns
;
8131 bfd_boolean res
= TRUE
;
8133 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8134 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8135 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8136 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8138 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8140 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8143 const char * procname
;
8145 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8146 aux
->strtab_size
, tp
->start
, &procname
,
8149 fputs ("\n<", stdout
);
8153 fputs (procname
, stdout
);
8156 printf ("+%lx", (unsigned long) offset
);
8159 fputs (">: [", stdout
);
8160 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8161 fputc ('-', stdout
);
8162 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8165 #define PF(_m) if (tp->_m) printf (#_m " ");
8166 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8169 PF(Millicode_save_sr0
);
8170 /* PV(Region_description); */
8176 PF(Separate_Package_Body
);
8177 PF(Frame_Extension_Millicode
);
8178 PF(Stack_Overflow_Check
);
8179 PF(Two_Instruction_SP_Increment
);
8183 PF(sched_entry_seq
);
8186 PF(Save_MRP_in_frame
);
8187 PF(extn_ptr_defined
);
8188 PF(Cleanup_defined
);
8189 PF(MPE_XL_interrupt_marker
);
8190 PF(HP_UX_interrupt_marker
);
8193 PV(Total_frame_size
);
8206 slurp_hppa_unwind_table (Filedata
* filedata
,
8207 struct hppa_unw_aux_info
* aux
,
8208 Elf_Internal_Shdr
* sec
)
8210 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8211 Elf_Internal_Phdr
* seg
;
8212 struct hppa_unw_table_entry
* tep
;
8213 Elf_Internal_Shdr
* relsec
;
8214 Elf_Internal_Rela
* rela
;
8215 Elf_Internal_Rela
* rp
;
8216 unsigned char * table
;
8218 Elf_Internal_Sym
* sym
;
8219 const char * relname
;
8221 /* First, find the starting address of the segment that includes
8223 if (filedata
->file_header
.e_phnum
)
8225 if (! get_program_headers (filedata
))
8228 for (seg
= filedata
->program_headers
;
8229 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8232 if (seg
->p_type
!= PT_LOAD
)
8235 if (sec
->sh_addr
>= seg
->p_vaddr
8236 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8238 aux
->seg_base
= seg
->p_vaddr
;
8244 /* Second, build the unwind table from the contents of the unwind
8246 size
= sec
->sh_size
;
8247 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8253 nentries
= size
/ unw_ent_size
;
8254 size
= unw_ent_size
* nentries
;
8256 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8257 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8259 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8261 unsigned int tmp1
, tmp2
;
8263 tep
->start
.section
= SHN_UNDEF
;
8264 tep
->end
.section
= SHN_UNDEF
;
8266 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8267 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8268 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8269 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8271 tep
->start
.offset
+= aux
->seg_base
;
8272 tep
->end
.offset
+= aux
->seg_base
;
8274 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8275 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8276 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8277 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8278 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8279 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8280 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8281 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8282 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8283 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8284 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8285 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8286 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8287 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8288 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8289 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8290 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8291 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8292 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8293 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8294 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8295 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8296 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8297 tep
->Cleanup_defined
= tmp1
& 0x1;
8299 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8300 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8301 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8302 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8303 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8304 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8308 /* Third, apply any relocations to the unwind table. */
8309 for (relsec
= filedata
->section_headers
;
8310 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8313 if (relsec
->sh_type
!= SHT_RELA
8314 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8315 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8318 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8322 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8324 unsigned int sym_ndx
;
8325 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8326 relname
= elf_hppa_reloc_type (r_type
);
8328 if (relname
== NULL
)
8330 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8334 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8335 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8337 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8341 i
= rp
->r_offset
/ unw_ent_size
;
8342 if (i
>= aux
->table_len
)
8344 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8348 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8349 if (sym_ndx
>= aux
->nsyms
)
8351 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8355 sym
= aux
->symtab
+ sym_ndx
;
8357 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8360 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8361 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8364 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8365 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8375 aux
->table_len
= nentries
;
8381 hppa_process_unwind (Filedata
* filedata
)
8383 struct hppa_unw_aux_info aux
;
8384 Elf_Internal_Shdr
* unwsec
= NULL
;
8385 Elf_Internal_Shdr
* sec
;
8387 bfd_boolean res
= TRUE
;
8389 if (filedata
->string_table
== NULL
)
8392 memset (& aux
, 0, sizeof (aux
));
8394 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8396 if (sec
->sh_type
== SHT_SYMTAB
)
8400 error (_("Multiple symbol tables encountered\n"));
8406 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8407 &aux
.strtab
, &aux
.strtab_size
))
8410 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8415 printf (_("\nThere are no unwind sections in this file.\n"));
8417 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8419 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8421 unsigned long num_unwind
= sec
->sh_size
/ 16;
8423 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8424 "contains %lu entry:\n",
8425 "\nUnwind section '%s' at offset 0x%lx "
8426 "contains %lu entries:\n",
8428 printable_section_name (filedata
, sec
),
8429 (unsigned long) sec
->sh_offset
,
8432 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8435 if (res
&& aux
.table_len
> 0)
8437 if (! dump_hppa_unwind (filedata
, &aux
))
8442 free ((char *) aux
.table
);
8450 free ((char *) aux
.strtab
);
8457 unsigned char * data
; /* The unwind data. */
8458 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8459 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8460 unsigned long nrelas
; /* The number of relocations. */
8461 unsigned int rel_type
; /* REL or RELA ? */
8462 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8465 struct arm_unw_aux_info
8467 Filedata
* filedata
; /* The file containing the unwind sections. */
8468 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8469 unsigned long nsyms
; /* Number of symbols. */
8470 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8471 unsigned long nfuns
; /* Number of these symbols. */
8472 char * strtab
; /* The file's string table. */
8473 unsigned long strtab_size
; /* Size of string table. */
8477 arm_print_vma_and_name (Filedata
* filedata
,
8478 struct arm_unw_aux_info
* aux
,
8480 struct absaddr addr
)
8482 const char *procname
;
8485 if (addr
.section
== SHN_UNDEF
)
8488 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8489 aux
->strtab_size
, addr
, &procname
,
8492 print_vma (fn
, PREFIX_HEX
);
8496 fputs (" <", stdout
);
8497 fputs (procname
, stdout
);
8500 printf ("+0x%lx", (unsigned long) sym_offset
);
8501 fputc ('>', stdout
);
8508 arm_free_section (struct arm_section
*arm_sec
)
8510 if (arm_sec
->data
!= NULL
)
8511 free (arm_sec
->data
);
8513 if (arm_sec
->rela
!= NULL
)
8514 free (arm_sec
->rela
);
8517 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8518 cached section and install SEC instead.
8519 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8520 and return its valued in * WORDP, relocating if necessary.
8521 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8522 relocation's offset in ADDR.
8523 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8524 into the string table of the symbol associated with the reloc. If no
8525 reloc was applied store -1 there.
8526 5) Return TRUE upon success, FALSE otherwise. */
8529 get_unwind_section_word (Filedata
* filedata
,
8530 struct arm_unw_aux_info
* aux
,
8531 struct arm_section
* arm_sec
,
8532 Elf_Internal_Shdr
* sec
,
8533 bfd_vma word_offset
,
8534 unsigned int * wordp
,
8535 struct absaddr
* addr
,
8538 Elf_Internal_Rela
*rp
;
8539 Elf_Internal_Sym
*sym
;
8540 const char * relname
;
8542 bfd_boolean wrapped
;
8544 if (sec
== NULL
|| arm_sec
== NULL
)
8547 addr
->section
= SHN_UNDEF
;
8550 if (sym_name
!= NULL
)
8551 *sym_name
= (bfd_vma
) -1;
8553 /* If necessary, update the section cache. */
8554 if (sec
!= arm_sec
->sec
)
8556 Elf_Internal_Shdr
*relsec
;
8558 arm_free_section (arm_sec
);
8561 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8562 sec
->sh_size
, _("unwind data"));
8563 arm_sec
->rela
= NULL
;
8564 arm_sec
->nrelas
= 0;
8566 for (relsec
= filedata
->section_headers
;
8567 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8570 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8571 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8572 /* PR 15745: Check the section type as well. */
8573 || (relsec
->sh_type
!= SHT_REL
8574 && relsec
->sh_type
!= SHT_RELA
))
8577 arm_sec
->rel_type
= relsec
->sh_type
;
8578 if (relsec
->sh_type
== SHT_REL
)
8580 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8582 & arm_sec
->rela
, & arm_sec
->nrelas
))
8585 else /* relsec->sh_type == SHT_RELA */
8587 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8589 & arm_sec
->rela
, & arm_sec
->nrelas
))
8595 arm_sec
->next_rela
= arm_sec
->rela
;
8598 /* If there is no unwind data we can do nothing. */
8599 if (arm_sec
->data
== NULL
)
8602 /* If the offset is invalid then fail. */
8603 if (/* PR 21343 *//* PR 18879 */
8605 || word_offset
> (sec
->sh_size
- 4)
8606 || ((bfd_signed_vma
) word_offset
) < 0)
8609 /* Get the word at the required offset. */
8610 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8612 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8613 if (arm_sec
->rela
== NULL
)
8619 /* Look through the relocs to find the one that applies to the provided offset. */
8621 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8623 bfd_vma prelval
, offset
;
8625 if (rp
->r_offset
> word_offset
&& !wrapped
)
8630 if (rp
->r_offset
> word_offset
)
8633 if (rp
->r_offset
& 3)
8635 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8636 (unsigned long) rp
->r_offset
);
8640 if (rp
->r_offset
< word_offset
)
8643 /* PR 17531: file: 027-161405-0.004 */
8644 if (aux
->symtab
== NULL
)
8647 if (arm_sec
->rel_type
== SHT_REL
)
8649 offset
= word
& 0x7fffffff;
8650 if (offset
& 0x40000000)
8651 offset
|= ~ (bfd_vma
) 0x7fffffff;
8653 else if (arm_sec
->rel_type
== SHT_RELA
)
8654 offset
= rp
->r_addend
;
8657 error (_("Unknown section relocation type %d encountered\n"),
8662 /* PR 17531 file: 027-1241568-0.004. */
8663 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8665 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8666 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8670 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8671 offset
+= sym
->st_value
;
8672 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8674 /* Check that we are processing the expected reloc type. */
8675 if (filedata
->file_header
.e_machine
== EM_ARM
)
8677 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8678 if (relname
== NULL
)
8680 warn (_("Skipping unknown ARM relocation type: %d\n"),
8681 (int) ELF32_R_TYPE (rp
->r_info
));
8685 if (streq (relname
, "R_ARM_NONE"))
8688 if (! streq (relname
, "R_ARM_PREL31"))
8690 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8694 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8696 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8697 if (relname
== NULL
)
8699 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8700 (int) ELF32_R_TYPE (rp
->r_info
));
8704 if (streq (relname
, "R_C6000_NONE"))
8707 if (! streq (relname
, "R_C6000_PREL31"))
8709 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8717 /* This function currently only supports ARM and TI unwinders. */
8718 warn (_("Only TI and ARM unwinders are currently supported\n"));
8722 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8723 addr
->section
= sym
->st_shndx
;
8724 addr
->offset
= offset
;
8727 * sym_name
= sym
->st_name
;
8732 arm_sec
->next_rela
= rp
;
8737 static const char *tic6x_unwind_regnames
[16] =
8739 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8740 "A14", "A13", "A12", "A11", "A10",
8741 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8745 decode_tic6x_unwind_regmask (unsigned int mask
)
8749 for (i
= 12; mask
; mask
>>= 1, i
--)
8753 fputs (tic6x_unwind_regnames
[i
], stdout
);
8755 fputs (", ", stdout
);
8761 if (remaining == 0 && more_words) \
8764 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8765 data_offset, & word, & addr, NULL)) \
8771 #define GET_OP(OP) \
8776 (OP) = word >> 24; \
8781 printf (_("[Truncated opcode]\n")); \
8784 printf ("0x%02x ", OP)
8787 decode_arm_unwind_bytecode (Filedata
* filedata
,
8788 struct arm_unw_aux_info
* aux
,
8790 unsigned int remaining
,
8791 unsigned int more_words
,
8792 bfd_vma data_offset
,
8793 Elf_Internal_Shdr
* data_sec
,
8794 struct arm_section
* data_arm_sec
)
8796 struct absaddr addr
;
8797 bfd_boolean res
= TRUE
;
8799 /* Decode the unwinding instructions. */
8802 unsigned int op
, op2
;
8811 printf (" 0x%02x ", op
);
8813 if ((op
& 0xc0) == 0x00)
8815 int offset
= ((op
& 0x3f) << 2) + 4;
8817 printf (" vsp = vsp + %d", offset
);
8819 else if ((op
& 0xc0) == 0x40)
8821 int offset
= ((op
& 0x3f) << 2) + 4;
8823 printf (" vsp = vsp - %d", offset
);
8825 else if ((op
& 0xf0) == 0x80)
8828 if (op
== 0x80 && op2
== 0)
8829 printf (_("Refuse to unwind"));
8832 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8833 bfd_boolean first
= TRUE
;
8837 for (i
= 0; i
< 12; i
++)
8838 if (mask
& (1 << i
))
8844 printf ("r%d", 4 + i
);
8849 else if ((op
& 0xf0) == 0x90)
8851 if (op
== 0x9d || op
== 0x9f)
8852 printf (_(" [Reserved]"));
8854 printf (" vsp = r%d", op
& 0x0f);
8856 else if ((op
& 0xf0) == 0xa0)
8858 int end
= 4 + (op
& 0x07);
8859 bfd_boolean first
= TRUE
;
8863 for (i
= 4; i
<= end
; i
++)
8879 else if (op
== 0xb0)
8880 printf (_(" finish"));
8881 else if (op
== 0xb1)
8884 if (op2
== 0 || (op2
& 0xf0) != 0)
8885 printf (_("[Spare]"));
8888 unsigned int mask
= op2
& 0x0f;
8889 bfd_boolean first
= TRUE
;
8893 for (i
= 0; i
< 12; i
++)
8894 if (mask
& (1 << i
))
8905 else if (op
== 0xb2)
8907 unsigned char buf
[9];
8908 unsigned int i
, len
;
8909 unsigned long offset
;
8911 for (i
= 0; i
< sizeof (buf
); i
++)
8914 if ((buf
[i
] & 0x80) == 0)
8917 if (i
== sizeof (buf
))
8919 error (_("corrupt change to vsp\n"));
8924 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8925 assert (len
== i
+ 1);
8926 offset
= offset
* 4 + 0x204;
8927 printf ("vsp = vsp + %ld", offset
);
8930 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8932 unsigned int first
, last
;
8939 printf ("pop {D%d", first
);
8941 printf ("-D%d", first
+ last
);
8944 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8946 unsigned int count
= op
& 0x07;
8950 printf ("-D%d", 8 + count
);
8953 else if (op
>= 0xc0 && op
<= 0xc5)
8955 unsigned int count
= op
& 0x07;
8957 printf (" pop {wR10");
8959 printf ("-wR%d", 10 + count
);
8962 else if (op
== 0xc6)
8964 unsigned int first
, last
;
8969 printf ("pop {wR%d", first
);
8971 printf ("-wR%d", first
+ last
);
8974 else if (op
== 0xc7)
8977 if (op2
== 0 || (op2
& 0xf0) != 0)
8978 printf (_("[Spare]"));
8981 unsigned int mask
= op2
& 0x0f;
8982 bfd_boolean first
= TRUE
;
8986 for (i
= 0; i
< 4; i
++)
8987 if (mask
& (1 << i
))
8993 printf ("wCGR%d", i
);
9000 printf (_(" [unsupported opcode]"));
9011 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9012 struct arm_unw_aux_info
* aux
,
9014 unsigned int remaining
,
9015 unsigned int more_words
,
9016 bfd_vma data_offset
,
9017 Elf_Internal_Shdr
* data_sec
,
9018 struct arm_section
* data_arm_sec
)
9020 struct absaddr addr
;
9022 /* Decode the unwinding instructions. */
9025 unsigned int op
, op2
;
9034 printf (" 0x%02x ", op
);
9036 if ((op
& 0xc0) == 0x00)
9038 int offset
= ((op
& 0x3f) << 3) + 8;
9039 printf (" sp = sp + %d", offset
);
9041 else if ((op
& 0xc0) == 0x80)
9044 if (op
== 0x80 && op2
== 0)
9045 printf (_("Refuse to unwind"));
9048 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9050 printf ("pop compact {");
9054 decode_tic6x_unwind_regmask (mask
);
9058 else if ((op
& 0xf0) == 0xc0)
9066 unsigned int offset
;
9070 /* Scan entire instruction first so that GET_OP output is not
9071 interleaved with disassembly. */
9073 for (i
= 0; nregs
< (op
& 0xf); i
++)
9079 regpos
[nregs
].offset
= i
* 2;
9080 regpos
[nregs
].reg
= reg
;
9087 regpos
[nregs
].offset
= i
* 2 + 1;
9088 regpos
[nregs
].reg
= reg
;
9093 printf (_("pop frame {"));
9096 printf (_("*corrupt* - no registers specified"));
9101 for (i
= i
* 2; i
> 0; i
--)
9103 if (regpos
[reg
].offset
== i
- 1)
9105 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9112 fputs (name
, stdout
);
9120 else if (op
== 0xd0)
9121 printf (" MOV FP, SP");
9122 else if (op
== 0xd1)
9123 printf (" __c6xabi_pop_rts");
9124 else if (op
== 0xd2)
9126 unsigned char buf
[9];
9127 unsigned int i
, len
;
9128 unsigned long offset
;
9130 for (i
= 0; i
< sizeof (buf
); i
++)
9133 if ((buf
[i
] & 0x80) == 0)
9136 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9137 if (i
== sizeof (buf
))
9139 warn (_("Corrupt stack pointer adjustment detected\n"));
9143 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9144 assert (len
== i
+ 1);
9145 offset
= offset
* 8 + 0x408;
9146 printf (_("sp = sp + %ld"), offset
);
9148 else if ((op
& 0xf0) == 0xe0)
9150 if ((op
& 0x0f) == 7)
9153 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9157 printf (_(" [unsupported opcode]"));
9166 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9170 offset
= word
& 0x7fffffff;
9171 if (offset
& 0x40000000)
9172 offset
|= ~ (bfd_vma
) 0x7fffffff;
9174 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9177 return offset
+ where
;
9181 decode_arm_unwind (Filedata
* filedata
,
9182 struct arm_unw_aux_info
* aux
,
9184 unsigned int remaining
,
9185 bfd_vma data_offset
,
9186 Elf_Internal_Shdr
* data_sec
,
9187 struct arm_section
* data_arm_sec
)
9190 unsigned int more_words
= 0;
9191 struct absaddr addr
;
9192 bfd_vma sym_name
= (bfd_vma
) -1;
9193 bfd_boolean res
= TRUE
;
9197 /* Fetch the first word.
9198 Note - when decoding an object file the address extracted
9199 here will always be 0. So we also pass in the sym_name
9200 parameter so that we can find the symbol associated with
9201 the personality routine. */
9202 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9203 & word
, & addr
, & sym_name
))
9210 addr
.section
= SHN_UNDEF
;
9214 if ((word
& 0x80000000) == 0)
9216 /* Expand prel31 for personality routine. */
9218 const char *procname
;
9220 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9221 printf (_(" Personality routine: "));
9223 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9224 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9226 procname
= aux
->strtab
+ sym_name
;
9227 print_vma (fn
, PREFIX_HEX
);
9230 fputs (" <", stdout
);
9231 fputs (procname
, stdout
);
9232 fputc ('>', stdout
);
9236 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9237 fputc ('\n', stdout
);
9239 /* The GCC personality routines use the standard compact
9240 encoding, starting with one byte giving the number of
9242 if (procname
!= NULL
9243 && (const_strneq (procname
, "__gcc_personality_v0")
9244 || const_strneq (procname
, "__gxx_personality_v0")
9245 || const_strneq (procname
, "__gcj_personality_v0")
9246 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9253 printf (_(" [Truncated data]\n"));
9256 more_words
= word
>> 24;
9266 /* ARM EHABI Section 6.3:
9268 An exception-handling table entry for the compact model looks like:
9272 1 0 index Data for personalityRoutine[index] */
9274 if (filedata
->file_header
.e_machine
== EM_ARM
9275 && (word
& 0x70000000))
9277 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9281 per_index
= (word
>> 24) & 0x7f;
9282 printf (_(" Compact model index: %d\n"), per_index
);
9289 else if (per_index
< 3)
9291 more_words
= (word
>> 16) & 0xff;
9297 switch (filedata
->file_header
.e_machine
)
9302 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9303 data_offset
, data_sec
, data_arm_sec
))
9308 warn (_("Unknown ARM compact model index encountered\n"));
9309 printf (_(" [reserved]\n"));
9317 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9318 data_offset
, data_sec
, data_arm_sec
))
9321 else if (per_index
< 5)
9323 if (((word
>> 17) & 0x7f) == 0x7f)
9324 printf (_(" Restore stack from frame pointer\n"));
9326 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9327 printf (_(" Registers restored: "));
9329 printf (" (compact) ");
9330 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9332 printf (_(" Return register: %s\n"),
9333 tic6x_unwind_regnames
[word
& 0xf]);
9336 printf (_(" [reserved (%d)]\n"), per_index
);
9340 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9341 filedata
->file_header
.e_machine
);
9345 /* Decode the descriptors. Not implemented. */
9351 dump_arm_unwind (Filedata
* filedata
,
9352 struct arm_unw_aux_info
* aux
,
9353 Elf_Internal_Shdr
* exidx_sec
)
9355 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9356 unsigned int i
, exidx_len
;
9357 unsigned long j
, nfuns
;
9358 bfd_boolean res
= TRUE
;
9360 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9361 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9362 exidx_len
= exidx_sec
->sh_size
/ 8;
9364 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9365 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9366 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9367 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9369 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9371 for (i
= 0; i
< exidx_len
; i
++)
9373 unsigned int exidx_fn
, exidx_entry
;
9374 struct absaddr fn_addr
, entry_addr
;
9377 fputc ('\n', stdout
);
9379 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9380 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9381 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9382 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9385 arm_free_section (& exidx_arm_sec
);
9386 arm_free_section (& extab_arm_sec
);
9390 /* ARM EHABI, Section 5:
9391 An index table entry consists of 2 words.
9392 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9393 if (exidx_fn
& 0x80000000)
9395 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9399 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9401 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9402 fputs (": ", stdout
);
9404 if (exidx_entry
== 1)
9406 print_vma (exidx_entry
, PREFIX_HEX
);
9407 fputs (" [cantunwind]\n", stdout
);
9409 else if (exidx_entry
& 0x80000000)
9411 print_vma (exidx_entry
, PREFIX_HEX
);
9412 fputc ('\n', stdout
);
9413 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9417 bfd_vma table
, table_offset
= 0;
9418 Elf_Internal_Shdr
*table_sec
;
9420 fputs ("@", stdout
);
9421 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9422 print_vma (table
, PREFIX_HEX
);
9425 /* Locate the matching .ARM.extab. */
9426 if (entry_addr
.section
!= SHN_UNDEF
9427 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9429 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9430 table_offset
= entry_addr
.offset
;
9432 if (table_offset
> table_sec
->sh_size
9433 || ((bfd_signed_vma
) table_offset
) < 0)
9435 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9436 (unsigned long) table_offset
,
9437 printable_section_name (filedata
, table_sec
));
9444 table_sec
= find_section_by_address (filedata
, table
);
9445 if (table_sec
!= NULL
)
9446 table_offset
= table
- table_sec
->sh_addr
;
9449 if (table_sec
== NULL
)
9451 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9452 (unsigned long) table
);
9457 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9466 arm_free_section (&exidx_arm_sec
);
9467 arm_free_section (&extab_arm_sec
);
9472 /* Used for both ARM and C6X unwinding tables. */
9475 arm_process_unwind (Filedata
* filedata
)
9477 struct arm_unw_aux_info aux
;
9478 Elf_Internal_Shdr
*unwsec
= NULL
;
9479 Elf_Internal_Shdr
*sec
;
9481 unsigned int sec_type
;
9482 bfd_boolean res
= TRUE
;
9484 switch (filedata
->file_header
.e_machine
)
9487 sec_type
= SHT_ARM_EXIDX
;
9491 sec_type
= SHT_C6000_UNWIND
;
9495 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9496 filedata
->file_header
.e_machine
);
9500 if (filedata
->string_table
== NULL
)
9503 memset (& aux
, 0, sizeof (aux
));
9504 aux
.filedata
= filedata
;
9506 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9508 if (sec
->sh_type
== SHT_SYMTAB
)
9512 error (_("Multiple symbol tables encountered\n"));
9518 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9519 &aux
.strtab
, &aux
.strtab_size
))
9522 else if (sec
->sh_type
== sec_type
)
9527 printf (_("\nThere are no unwind sections in this file.\n"));
9529 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9531 if (sec
->sh_type
== sec_type
)
9533 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9534 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9535 "contains %lu entry:\n",
9536 "\nUnwind section '%s' at offset 0x%lx "
9537 "contains %lu entries:\n",
9539 printable_section_name (filedata
, sec
),
9540 (unsigned long) sec
->sh_offset
,
9543 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9551 free ((char *) aux
.strtab
);
9557 process_unwind (Filedata
* filedata
)
9559 struct unwind_handler
9561 unsigned int machtype
;
9562 bfd_boolean (* handler
)(Filedata
*);
9565 { EM_ARM
, arm_process_unwind
},
9566 { EM_IA_64
, ia64_process_unwind
},
9567 { EM_PARISC
, hppa_process_unwind
},
9568 { EM_TI_C6000
, arm_process_unwind
},
9576 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9577 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9578 return handlers
[i
].handler (filedata
);
9580 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9581 get_machine_name (filedata
->file_header
.e_machine
));
9586 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9588 switch (entry
->d_tag
)
9590 case DT_AARCH64_BTI_PLT
:
9591 case DT_AARCH64_PAC_PLT
:
9594 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9601 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9603 switch (entry
->d_tag
)
9606 if (entry
->d_un
.d_val
== 0)
9610 static const char * opts
[] =
9612 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9613 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9614 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9615 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9619 bfd_boolean first
= TRUE
;
9621 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9622 if (entry
->d_un
.d_val
& (1 << cnt
))
9624 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9630 case DT_MIPS_IVERSION
:
9631 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9632 printf (_("Interface Version: %s"),
9633 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9637 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9638 /* Note: coded this way so that there is a single string for translation. */
9639 printf (_("<corrupt: %s>"), buf
);
9643 case DT_MIPS_TIME_STAMP
:
9647 time_t atime
= entry
->d_un
.d_val
;
9649 tmp
= gmtime (&atime
);
9650 /* PR 17531: file: 6accc532. */
9652 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9654 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9655 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9656 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9657 printf (_("Time Stamp: %s"), timebuf
);
9661 case DT_MIPS_RLD_VERSION
:
9662 case DT_MIPS_LOCAL_GOTNO
:
9663 case DT_MIPS_CONFLICTNO
:
9664 case DT_MIPS_LIBLISTNO
:
9665 case DT_MIPS_SYMTABNO
:
9666 case DT_MIPS_UNREFEXTNO
:
9667 case DT_MIPS_HIPAGENO
:
9668 case DT_MIPS_DELTA_CLASS_NO
:
9669 case DT_MIPS_DELTA_INSTANCE_NO
:
9670 case DT_MIPS_DELTA_RELOC_NO
:
9671 case DT_MIPS_DELTA_SYM_NO
:
9672 case DT_MIPS_DELTA_CLASSSYM_NO
:
9673 case DT_MIPS_COMPACT_SIZE
:
9674 print_vma (entry
->d_un
.d_val
, DEC
);
9678 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9679 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9680 /* Falls through. */
9683 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9689 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9691 switch (entry
->d_tag
)
9693 case DT_HP_DLD_FLAGS
:
9702 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9703 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9704 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9705 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9706 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9707 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9708 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9709 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9710 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9711 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9712 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9713 { DT_HP_GST
, "HP_GST" },
9714 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9715 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9716 { DT_HP_NODELETE
, "HP_NODELETE" },
9717 { DT_HP_GROUP
, "HP_GROUP" },
9718 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9720 bfd_boolean first
= TRUE
;
9722 bfd_vma val
= entry
->d_un
.d_val
;
9724 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9725 if (val
& flags
[cnt
].bit
)
9729 fputs (flags
[cnt
].str
, stdout
);
9731 val
^= flags
[cnt
].bit
;
9734 if (val
!= 0 || first
)
9738 print_vma (val
, HEX
);
9744 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9752 /* VMS vs Unix time offset and factor. */
9754 #define VMS_EPOCH_OFFSET 35067168000000000LL
9755 #define VMS_GRANULARITY_FACTOR 10000000
9757 /* Display a VMS time in a human readable format. */
9760 print_vms_time (bfd_int64_t vmstime
)
9765 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9766 tm
= gmtime (&unxtime
);
9767 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9768 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9769 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9774 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9776 switch (entry
->d_tag
)
9778 case DT_IA_64_PLT_RESERVE
:
9779 /* First 3 slots reserved. */
9780 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9782 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9785 case DT_IA_64_VMS_LINKTIME
:
9787 print_vms_time (entry
->d_un
.d_val
);
9791 case DT_IA_64_VMS_LNKFLAGS
:
9792 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9793 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9794 printf (" CALL_DEBUG");
9795 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9796 printf (" NOP0BUFS");
9797 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9798 printf (" P0IMAGE");
9799 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9800 printf (" MKTHREADS");
9801 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9802 printf (" UPCALLS");
9803 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9805 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9806 printf (" INITIALIZE");
9807 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9809 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9810 printf (" EXE_INIT");
9811 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9812 printf (" TBK_IN_IMG");
9813 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9814 printf (" DBG_IN_IMG");
9815 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9816 printf (" TBK_IN_DSF");
9817 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9818 printf (" DBG_IN_DSF");
9819 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9820 printf (" SIGNATURES");
9821 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9822 printf (" REL_SEG_OFF");
9826 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9833 get_32bit_dynamic_section (Filedata
* filedata
)
9835 Elf32_External_Dyn
* edyn
;
9836 Elf32_External_Dyn
* ext
;
9837 Elf_Internal_Dyn
* entry
;
9839 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9840 filedata
->dynamic_addr
, 1,
9841 filedata
->dynamic_size
,
9842 _("dynamic section"));
9846 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9847 might not have the luxury of section headers. Look for the DT_NULL
9848 terminator to determine the number of entries. */
9849 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9850 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9853 filedata
->dynamic_nent
++;
9854 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9858 filedata
->dynamic_section
9859 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9860 if (filedata
->dynamic_section
== NULL
)
9862 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9863 (unsigned long) filedata
->dynamic_nent
);
9868 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9869 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9872 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9873 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9882 get_64bit_dynamic_section (Filedata
* filedata
)
9884 Elf64_External_Dyn
* edyn
;
9885 Elf64_External_Dyn
* ext
;
9886 Elf_Internal_Dyn
* entry
;
9888 /* Read in the data. */
9889 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9890 filedata
->dynamic_addr
, 1,
9891 filedata
->dynamic_size
,
9892 _("dynamic section"));
9896 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9897 might not have the luxury of section headers. Look for the DT_NULL
9898 terminator to determine the number of entries. */
9899 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9900 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9901 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9904 filedata
->dynamic_nent
++;
9905 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9909 filedata
->dynamic_section
9910 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9911 if (filedata
->dynamic_section
== NULL
)
9913 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9914 (unsigned long) filedata
->dynamic_nent
);
9919 /* Convert from external to internal formats. */
9920 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9921 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9924 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9925 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9934 print_dynamic_flags (bfd_vma flags
)
9936 bfd_boolean first
= TRUE
;
9942 flag
= flags
& - flags
;
9952 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9953 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9954 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9955 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9956 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9957 default: fputs (_("unknown"), stdout
); break;
9964 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9966 unsigned char * e_data
;
9969 /* If the size_t type is smaller than the bfd_size_type, eg because
9970 you are building a 32-bit tool on a 64-bit host, then make sure
9971 that when (number) is cast to (size_t) no information is lost. */
9972 if (sizeof (size_t) < sizeof (bfd_size_type
)
9973 && (bfd_size_type
) ((size_t) number
) != number
)
9975 error (_("Size truncation prevents reading %s elements of size %u\n"),
9976 bfd_vmatoa ("u", number
), ent_size
);
9980 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9981 attempting to allocate memory when the read is bound to fail. */
9982 if (ent_size
* number
> filedata
->file_size
)
9984 error (_("Invalid number of dynamic entries: %s\n"),
9985 bfd_vmatoa ("u", number
));
9989 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9992 error (_("Out of memory reading %s dynamic entries\n"),
9993 bfd_vmatoa ("u", number
));
9997 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9999 error (_("Unable to read in %s bytes of dynamic data\n"),
10000 bfd_vmatoa ("u", number
* ent_size
));
10005 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10006 if (i_data
== NULL
)
10008 error (_("Out of memory allocating space for %s dynamic entries\n"),
10009 bfd_vmatoa ("u", number
));
10015 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10022 static unsigned long
10023 get_num_dynamic_syms (Filedata
* filedata
)
10025 unsigned long num_of_syms
= 0;
10027 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10028 return num_of_syms
;
10030 if (filedata
->dynamic_info
[DT_HASH
])
10032 unsigned char nb
[8];
10033 unsigned char nc
[8];
10034 unsigned int hash_ent_size
= 4;
10036 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10037 || filedata
->file_header
.e_machine
== EM_S390
10038 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10039 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10042 if (fseek (filedata
->handle
,
10043 (filedata
->archive_file_offset
10044 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10045 sizeof nb
+ sizeof nc
)),
10048 error (_("Unable to seek to start of dynamic information\n"));
10052 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10054 error (_("Failed to read in number of buckets\n"));
10058 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10060 error (_("Failed to read in number of chains\n"));
10064 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10065 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10067 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10069 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10071 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10074 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10075 num_of_syms
= filedata
->nchains
;
10078 if (num_of_syms
== 0)
10080 if (filedata
->buckets
)
10082 free (filedata
->buckets
);
10083 filedata
->buckets
= NULL
;
10085 if (filedata
->chains
)
10087 free (filedata
->chains
);
10088 filedata
->chains
= NULL
;
10090 filedata
->nbuckets
= 0;
10094 if (filedata
->dynamic_info_DT_GNU_HASH
)
10096 unsigned char nb
[16];
10097 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10098 bfd_vma buckets_vma
;
10101 if (fseek (filedata
->handle
,
10102 (filedata
->archive_file_offset
10103 + offset_from_vma (filedata
,
10104 filedata
->dynamic_info_DT_GNU_HASH
,
10108 error (_("Unable to seek to start of dynamic information\n"));
10112 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10114 error (_("Failed to read in number of buckets\n"));
10118 filedata
->ngnubuckets
= byte_get (nb
, 4);
10119 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10120 bitmaskwords
= byte_get (nb
+ 8, 4);
10121 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10123 buckets_vma
+= bitmaskwords
* 4;
10125 buckets_vma
+= bitmaskwords
* 8;
10127 if (fseek (filedata
->handle
,
10128 (filedata
->archive_file_offset
10129 + offset_from_vma (filedata
, buckets_vma
, 4)),
10132 error (_("Unable to seek to start of dynamic information\n"));
10136 filedata
->gnubuckets
10137 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10139 if (filedata
->gnubuckets
== NULL
)
10142 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10143 if (filedata
->gnubuckets
[i
] != 0)
10145 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10148 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10149 maxchain
= filedata
->gnubuckets
[i
];
10152 if (maxchain
== 0xffffffff)
10155 maxchain
-= filedata
->gnusymidx
;
10157 if (fseek (filedata
->handle
,
10158 (filedata
->archive_file_offset
10159 + offset_from_vma (filedata
,
10160 buckets_vma
+ 4 * (filedata
->ngnubuckets
10165 error (_("Unable to seek to start of dynamic information\n"));
10171 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10173 error (_("Failed to determine last chain length\n"));
10177 if (maxchain
+ 1 == 0)
10182 while ((byte_get (nb
, 4) & 1) == 0);
10184 if (fseek (filedata
->handle
,
10185 (filedata
->archive_file_offset
10186 + offset_from_vma (filedata
, (buckets_vma
10187 + 4 * filedata
->ngnubuckets
),
10191 error (_("Unable to seek to start of dynamic information\n"));
10195 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10196 filedata
->ngnuchains
= maxchain
;
10198 if (filedata
->gnuchains
== NULL
)
10201 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10203 if (fseek (filedata
->handle
,
10204 (filedata
->archive_file_offset
10205 + offset_from_vma (filedata
, (buckets_vma
10206 + 4 * (filedata
->ngnubuckets
10210 error (_("Unable to seek to start of dynamic information\n"));
10214 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10215 if (filedata
->mipsxlat
== NULL
)
10219 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10220 if (filedata
->gnubuckets
[hn
] != 0)
10222 bfd_vma si
= filedata
->gnubuckets
[hn
];
10223 bfd_vma off
= si
- filedata
->gnusymidx
;
10227 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10229 if (filedata
->mipsxlat
[off
] >= num_of_syms
)
10230 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10234 if (si
>= num_of_syms
)
10235 num_of_syms
= si
+ 1;
10239 while (off
< filedata
->ngnuchains
10240 && (filedata
->gnuchains
[off
++] & 1) == 0);
10243 if (num_of_syms
== 0)
10246 if (filedata
->mipsxlat
)
10248 free (filedata
->mipsxlat
);
10249 filedata
->mipsxlat
= NULL
;
10251 if (filedata
->gnuchains
)
10253 free (filedata
->gnuchains
);
10254 filedata
->gnuchains
= NULL
;
10256 if (filedata
->gnubuckets
)
10258 free (filedata
->gnubuckets
);
10259 filedata
->gnubuckets
= NULL
;
10261 filedata
->ngnubuckets
= 0;
10262 filedata
->ngnuchains
= 0;
10266 return num_of_syms
;
10269 /* Parse and display the contents of the dynamic section. */
10272 process_dynamic_section (Filedata
* filedata
)
10274 Elf_Internal_Dyn
* entry
;
10276 if (filedata
->dynamic_size
== 0)
10279 printf (_("\nThere is no dynamic section in this file.\n"));
10286 if (! get_32bit_dynamic_section (filedata
))
10291 if (! get_64bit_dynamic_section (filedata
))
10295 /* Find the appropriate symbol table. */
10296 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10298 unsigned long num_of_syms
;
10300 for (entry
= filedata
->dynamic_section
;
10301 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10303 if (entry
->d_tag
== DT_SYMTAB
)
10304 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10305 else if (entry
->d_tag
== DT_SYMENT
)
10306 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10307 else if (entry
->d_tag
== DT_HASH
)
10308 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10309 else if (entry
->d_tag
== DT_GNU_HASH
)
10310 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10311 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10312 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10313 && entry
->d_tag
== DT_MIPS_XHASH
)
10315 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10316 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10319 num_of_syms
= get_num_dynamic_syms (filedata
);
10321 if (num_of_syms
!= 0
10322 && filedata
->dynamic_symbols
== NULL
10323 && filedata
->dynamic_info
[DT_SYMTAB
]
10324 && filedata
->dynamic_info
[DT_SYMENT
])
10326 Elf_Internal_Phdr
*seg
;
10327 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10329 if (! get_program_headers (filedata
))
10331 error (_("Cannot interpret virtual addresses "
10332 "without program headers.\n"));
10336 for (seg
= filedata
->program_headers
;
10337 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10340 if (seg
->p_type
!= PT_LOAD
)
10343 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10345 /* See PR 21379 for a reproducer. */
10346 error (_("Invalid PT_LOAD entry\n"));
10350 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10351 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10353 /* Since we do not know how big the symbol table is,
10354 we default to reading in up to the end of PT_LOAD
10355 segment and processing that. This is overkill, I
10356 know, but it should work. */
10357 Elf_Internal_Shdr section
;
10358 section
.sh_offset
= (vma
- seg
->p_vaddr
10360 section
.sh_size
= (num_of_syms
10361 * filedata
->dynamic_info
[DT_SYMENT
]);
10362 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10363 section
.sh_name
= filedata
->string_table_length
;
10364 filedata
->dynamic_symbols
10365 = GET_ELF_SYMBOLS (filedata
, §ion
,
10366 &filedata
->num_dynamic_syms
);
10367 if (filedata
->dynamic_symbols
== NULL
10368 || filedata
->num_dynamic_syms
!= num_of_syms
)
10370 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10379 /* Similarly find a string table. */
10380 if (filedata
->dynamic_strings
== NULL
)
10381 for (entry
= filedata
->dynamic_section
;
10382 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10385 if (entry
->d_tag
== DT_STRTAB
)
10386 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10388 if (entry
->d_tag
== DT_STRSZ
)
10389 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10391 if (filedata
->dynamic_info
[DT_STRTAB
]
10392 && filedata
->dynamic_info
[DT_STRSZ
])
10394 unsigned long offset
;
10395 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10397 offset
= offset_from_vma (filedata
,
10398 filedata
->dynamic_info
[DT_STRTAB
],
10400 filedata
->dynamic_strings
10401 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10402 _("dynamic string table"));
10403 if (filedata
->dynamic_strings
== NULL
)
10405 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10409 filedata
->dynamic_strings_length
= str_tab_len
;
10414 /* And find the syminfo section if available. */
10415 if (filedata
->dynamic_syminfo
== NULL
)
10417 unsigned long syminsz
= 0;
10419 for (entry
= filedata
->dynamic_section
;
10420 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10423 if (entry
->d_tag
== DT_SYMINENT
)
10425 /* Note: these braces are necessary to avoid a syntax
10426 error from the SunOS4 C compiler. */
10427 /* PR binutils/17531: A corrupt file can trigger this test.
10428 So do not use an assert, instead generate an error message. */
10429 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10430 error (_("Bad value (%d) for SYMINENT entry\n"),
10431 (int) entry
->d_un
.d_val
);
10433 else if (entry
->d_tag
== DT_SYMINSZ
)
10434 syminsz
= entry
->d_un
.d_val
;
10435 else if (entry
->d_tag
== DT_SYMINFO
)
10436 filedata
->dynamic_syminfo_offset
10437 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10440 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10442 Elf_External_Syminfo
* extsyminfo
;
10443 Elf_External_Syminfo
* extsym
;
10444 Elf_Internal_Syminfo
* syminfo
;
10446 /* There is a syminfo section. Read the data. */
10447 extsyminfo
= (Elf_External_Syminfo
*)
10448 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10449 1, syminsz
, _("symbol information"));
10453 if (filedata
->dynamic_syminfo
!= NULL
)
10455 error (_("Multiple dynamic symbol information sections found\n"));
10456 free (filedata
->dynamic_syminfo
);
10458 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10459 if (filedata
->dynamic_syminfo
== NULL
)
10461 error (_("Out of memory allocating %lu bytes "
10462 "for dynamic symbol info\n"),
10463 (unsigned long) syminsz
);
10467 filedata
->dynamic_syminfo_nent
10468 = syminsz
/ sizeof (Elf_External_Syminfo
);
10469 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10470 syminfo
< (filedata
->dynamic_syminfo
10471 + filedata
->dynamic_syminfo_nent
);
10472 ++syminfo
, ++extsym
)
10474 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10475 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10482 if (do_dynamic
&& filedata
->dynamic_addr
)
10483 printf (ngettext ("\nDynamic section at offset 0x%lx "
10484 "contains %lu entry:\n",
10485 "\nDynamic section at offset 0x%lx "
10486 "contains %lu entries:\n",
10487 filedata
->dynamic_nent
),
10488 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10490 printf (_(" Tag Type Name/Value\n"));
10492 for (entry
= filedata
->dynamic_section
;
10493 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10498 const char * dtype
;
10501 print_vma (entry
->d_tag
, FULL_HEX
);
10502 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10503 printf (" (%s)%*s", dtype
,
10504 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10507 switch (entry
->d_tag
)
10511 print_dynamic_flags (entry
->d_un
.d_val
);
10521 switch (entry
->d_tag
)
10524 printf (_("Auxiliary library"));
10528 printf (_("Filter library"));
10532 printf (_("Configuration file"));
10536 printf (_("Dependency audit library"));
10540 printf (_("Audit library"));
10544 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10545 printf (": [%s]\n",
10546 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10550 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10559 printf (_("Flags:"));
10561 if (entry
->d_un
.d_val
== 0)
10562 printf (_(" None\n"));
10565 unsigned long int val
= entry
->d_un
.d_val
;
10567 if (val
& DTF_1_PARINIT
)
10569 printf (" PARINIT");
10570 val
^= DTF_1_PARINIT
;
10572 if (val
& DTF_1_CONFEXP
)
10574 printf (" CONFEXP");
10575 val
^= DTF_1_CONFEXP
;
10578 printf (" %lx", val
);
10587 printf (_("Flags:"));
10589 if (entry
->d_un
.d_val
== 0)
10590 printf (_(" None\n"));
10593 unsigned long int val
= entry
->d_un
.d_val
;
10595 if (val
& DF_P1_LAZYLOAD
)
10597 printf (" LAZYLOAD");
10598 val
^= DF_P1_LAZYLOAD
;
10600 if (val
& DF_P1_GROUPPERM
)
10602 printf (" GROUPPERM");
10603 val
^= DF_P1_GROUPPERM
;
10606 printf (" %lx", val
);
10615 printf (_("Flags:"));
10616 if (entry
->d_un
.d_val
== 0)
10617 printf (_(" None\n"));
10620 unsigned long int val
= entry
->d_un
.d_val
;
10622 if (val
& DF_1_NOW
)
10627 if (val
& DF_1_GLOBAL
)
10629 printf (" GLOBAL");
10630 val
^= DF_1_GLOBAL
;
10632 if (val
& DF_1_GROUP
)
10637 if (val
& DF_1_NODELETE
)
10639 printf (" NODELETE");
10640 val
^= DF_1_NODELETE
;
10642 if (val
& DF_1_LOADFLTR
)
10644 printf (" LOADFLTR");
10645 val
^= DF_1_LOADFLTR
;
10647 if (val
& DF_1_INITFIRST
)
10649 printf (" INITFIRST");
10650 val
^= DF_1_INITFIRST
;
10652 if (val
& DF_1_NOOPEN
)
10654 printf (" NOOPEN");
10655 val
^= DF_1_NOOPEN
;
10657 if (val
& DF_1_ORIGIN
)
10659 printf (" ORIGIN");
10660 val
^= DF_1_ORIGIN
;
10662 if (val
& DF_1_DIRECT
)
10664 printf (" DIRECT");
10665 val
^= DF_1_DIRECT
;
10667 if (val
& DF_1_TRANS
)
10672 if (val
& DF_1_INTERPOSE
)
10674 printf (" INTERPOSE");
10675 val
^= DF_1_INTERPOSE
;
10677 if (val
& DF_1_NODEFLIB
)
10679 printf (" NODEFLIB");
10680 val
^= DF_1_NODEFLIB
;
10682 if (val
& DF_1_NODUMP
)
10684 printf (" NODUMP");
10685 val
^= DF_1_NODUMP
;
10687 if (val
& DF_1_CONFALT
)
10689 printf (" CONFALT");
10690 val
^= DF_1_CONFALT
;
10692 if (val
& DF_1_ENDFILTEE
)
10694 printf (" ENDFILTEE");
10695 val
^= DF_1_ENDFILTEE
;
10697 if (val
& DF_1_DISPRELDNE
)
10699 printf (" DISPRELDNE");
10700 val
^= DF_1_DISPRELDNE
;
10702 if (val
& DF_1_DISPRELPND
)
10704 printf (" DISPRELPND");
10705 val
^= DF_1_DISPRELPND
;
10707 if (val
& DF_1_NODIRECT
)
10709 printf (" NODIRECT");
10710 val
^= DF_1_NODIRECT
;
10712 if (val
& DF_1_IGNMULDEF
)
10714 printf (" IGNMULDEF");
10715 val
^= DF_1_IGNMULDEF
;
10717 if (val
& DF_1_NOKSYMS
)
10719 printf (" NOKSYMS");
10720 val
^= DF_1_NOKSYMS
;
10722 if (val
& DF_1_NOHDR
)
10727 if (val
& DF_1_EDITED
)
10729 printf (" EDITED");
10730 val
^= DF_1_EDITED
;
10732 if (val
& DF_1_NORELOC
)
10734 printf (" NORELOC");
10735 val
^= DF_1_NORELOC
;
10737 if (val
& DF_1_SYMINTPOSE
)
10739 printf (" SYMINTPOSE");
10740 val
^= DF_1_SYMINTPOSE
;
10742 if (val
& DF_1_GLOBAUDIT
)
10744 printf (" GLOBAUDIT");
10745 val
^= DF_1_GLOBAUDIT
;
10747 if (val
& DF_1_SINGLETON
)
10749 printf (" SINGLETON");
10750 val
^= DF_1_SINGLETON
;
10752 if (val
& DF_1_STUB
)
10757 if (val
& DF_1_PIE
)
10762 if (val
& DF_1_KMOD
)
10767 if (val
& DF_1_WEAKFILTER
)
10769 printf (" WEAKFILTER");
10770 val
^= DF_1_WEAKFILTER
;
10772 if (val
& DF_1_NOCOMMON
)
10774 printf (" NOCOMMON");
10775 val
^= DF_1_NOCOMMON
;
10778 printf (" %lx", val
);
10785 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10787 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10807 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10813 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10814 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10820 switch (entry
->d_tag
)
10823 printf (_("Shared library: [%s]"), name
);
10825 if (streq (name
, filedata
->program_interpreter
))
10826 printf (_(" program interpreter"));
10830 printf (_("Library soname: [%s]"), name
);
10834 printf (_("Library rpath: [%s]"), name
);
10838 printf (_("Library runpath: [%s]"), name
);
10842 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10847 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10860 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10861 /* Fall through. */
10865 case DT_INIT_ARRAYSZ
:
10866 case DT_FINI_ARRAYSZ
:
10867 case DT_GNU_CONFLICTSZ
:
10868 case DT_GNU_LIBLISTSZ
:
10871 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10872 printf (_(" (bytes)\n"));
10877 case DT_VERNEEDNUM
:
10882 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10891 case DT_INIT_ARRAY
:
10892 case DT_FINI_ARRAY
:
10895 if (entry
->d_tag
== DT_USED
10896 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10898 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10902 printf (_("Not needed object: [%s]\n"), name
);
10907 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10913 /* The value of this entry is ignored. */
10918 case DT_GNU_PRELINKED
:
10922 time_t atime
= entry
->d_un
.d_val
;
10924 tmp
= gmtime (&atime
);
10925 /* PR 17533 file: 041-1244816-0.004. */
10927 printf (_("<corrupt time val: %lx"),
10928 (unsigned long) atime
);
10930 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10931 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10932 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10938 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10941 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10947 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10948 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10949 = entry
->d_un
.d_val
;
10953 switch (filedata
->file_header
.e_machine
)
10956 dynamic_section_aarch64_val (entry
);
10959 case EM_MIPS_RS3_LE
:
10960 dynamic_section_mips_val (filedata
, entry
);
10963 dynamic_section_parisc_val (entry
);
10966 dynamic_section_ia64_val (entry
);
10969 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10981 get_ver_flags (unsigned int flags
)
10983 static char buff
[128];
10990 if (flags
& VER_FLG_BASE
)
10991 strcat (buff
, "BASE");
10993 if (flags
& VER_FLG_WEAK
)
10995 if (flags
& VER_FLG_BASE
)
10996 strcat (buff
, " | ");
10998 strcat (buff
, "WEAK");
11001 if (flags
& VER_FLG_INFO
)
11003 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11004 strcat (buff
, " | ");
11006 strcat (buff
, "INFO");
11009 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11011 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11012 strcat (buff
, " | ");
11014 strcat (buff
, _("<unknown>"));
11020 /* Display the contents of the version sections. */
11023 process_version_sections (Filedata
* filedata
)
11025 Elf_Internal_Shdr
* section
;
11027 bfd_boolean found
= FALSE
;
11032 for (i
= 0, section
= filedata
->section_headers
;
11033 i
< filedata
->file_header
.e_shnum
;
11036 switch (section
->sh_type
)
11038 case SHT_GNU_verdef
:
11040 Elf_External_Verdef
* edefs
;
11047 printf (ngettext ("\nVersion definition section '%s' "
11048 "contains %u entry:\n",
11049 "\nVersion definition section '%s' "
11050 "contains %u entries:\n",
11052 printable_section_name (filedata
, section
),
11055 printf (_(" Addr: 0x"));
11056 printf_vma (section
->sh_addr
);
11057 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11058 (unsigned long) section
->sh_offset
, section
->sh_link
,
11059 printable_section_name_from_index (filedata
, section
->sh_link
));
11061 edefs
= (Elf_External_Verdef
*)
11062 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11063 _("version definition section"));
11066 endbuf
= (char *) edefs
+ section
->sh_size
;
11068 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11071 Elf_External_Verdef
* edef
;
11072 Elf_Internal_Verdef ent
;
11073 Elf_External_Verdaux
* eaux
;
11074 Elf_Internal_Verdaux aux
;
11075 unsigned long isum
;
11078 vstart
= ((char *) edefs
) + idx
;
11079 if (vstart
+ sizeof (*edef
) > endbuf
)
11082 edef
= (Elf_External_Verdef
*) vstart
;
11084 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11085 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11086 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11087 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11088 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11089 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11090 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11092 printf (_(" %#06lx: Rev: %d Flags: %s"),
11093 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11095 printf (_(" Index: %d Cnt: %d "),
11096 ent
.vd_ndx
, ent
.vd_cnt
);
11098 /* Check for overflow. */
11099 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11102 vstart
+= ent
.vd_aux
;
11104 if (vstart
+ sizeof (*eaux
) > endbuf
)
11106 eaux
= (Elf_External_Verdaux
*) vstart
;
11108 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11109 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11111 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11112 printf (_("Name: %s\n"),
11113 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11115 printf (_("Name index: %ld\n"), aux
.vda_name
);
11117 isum
= idx
+ ent
.vd_aux
;
11119 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11121 if (aux
.vda_next
< sizeof (*eaux
)
11122 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11124 warn (_("Invalid vda_next field of %lx\n"),
11129 /* Check for overflow. */
11130 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11133 isum
+= aux
.vda_next
;
11134 vstart
+= aux
.vda_next
;
11136 if (vstart
+ sizeof (*eaux
) > endbuf
)
11138 eaux
= (Elf_External_Verdaux
*) vstart
;
11140 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11141 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11143 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11144 printf (_(" %#06lx: Parent %d: %s\n"),
11146 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11148 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11149 isum
, j
, aux
.vda_name
);
11152 if (j
< ent
.vd_cnt
)
11153 printf (_(" Version def aux past end of section\n"));
11156 file: id:000001,src:000172+005151,op:splice,rep:2. */
11157 if (ent
.vd_next
< sizeof (*edef
)
11158 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11160 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11161 cnt
= section
->sh_info
;
11164 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11167 idx
+= ent
.vd_next
;
11170 if (cnt
< section
->sh_info
)
11171 printf (_(" Version definition past end of section\n"));
11177 case SHT_GNU_verneed
:
11179 Elf_External_Verneed
* eneed
;
11186 printf (ngettext ("\nVersion needs section '%s' "
11187 "contains %u entry:\n",
11188 "\nVersion needs section '%s' "
11189 "contains %u entries:\n",
11191 printable_section_name (filedata
, section
), section
->sh_info
);
11193 printf (_(" Addr: 0x"));
11194 printf_vma (section
->sh_addr
);
11195 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11196 (unsigned long) section
->sh_offset
, section
->sh_link
,
11197 printable_section_name_from_index (filedata
, section
->sh_link
));
11199 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11200 section
->sh_offset
, 1,
11202 _("Version Needs section"));
11205 endbuf
= (char *) eneed
+ section
->sh_size
;
11207 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11209 Elf_External_Verneed
* entry
;
11210 Elf_Internal_Verneed ent
;
11211 unsigned long isum
;
11215 vstart
= ((char *) eneed
) + idx
;
11216 if (vstart
+ sizeof (*entry
) > endbuf
)
11219 entry
= (Elf_External_Verneed
*) vstart
;
11221 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11222 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11223 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11224 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11225 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11227 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11229 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11230 printf (_(" File: %s"),
11231 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11233 printf (_(" File: %lx"), ent
.vn_file
);
11235 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11237 /* Check for overflow. */
11238 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11240 vstart
+= ent
.vn_aux
;
11242 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11244 Elf_External_Vernaux
* eaux
;
11245 Elf_Internal_Vernaux aux
;
11247 if (vstart
+ sizeof (*eaux
) > endbuf
)
11249 eaux
= (Elf_External_Vernaux
*) vstart
;
11251 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11252 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11253 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11254 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11255 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11257 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11258 printf (_(" %#06lx: Name: %s"),
11259 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11261 printf (_(" %#06lx: Name index: %lx"),
11262 isum
, aux
.vna_name
);
11264 printf (_(" Flags: %s Version: %d\n"),
11265 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11267 if (aux
.vna_next
< sizeof (*eaux
)
11268 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11270 warn (_("Invalid vna_next field of %lx\n"),
11275 /* Check for overflow. */
11276 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11278 isum
+= aux
.vna_next
;
11279 vstart
+= aux
.vna_next
;
11282 if (j
< ent
.vn_cnt
)
11283 warn (_("Missing Version Needs auxillary information\n"));
11285 if (ent
.vn_next
< sizeof (*entry
)
11286 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11288 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11289 cnt
= section
->sh_info
;
11292 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11294 idx
+= ent
.vn_next
;
11297 if (cnt
< section
->sh_info
)
11298 warn (_("Missing Version Needs information\n"));
11304 case SHT_GNU_versym
:
11306 Elf_Internal_Shdr
* link_section
;
11309 unsigned char * edata
;
11310 unsigned short * data
;
11312 Elf_Internal_Sym
* symbols
;
11313 Elf_Internal_Shdr
* string_sec
;
11314 unsigned long num_syms
;
11317 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11320 link_section
= filedata
->section_headers
+ section
->sh_link
;
11321 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11323 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11328 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11329 if (symbols
== NULL
)
11332 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11334 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11335 string_sec
->sh_size
,
11336 _("version string table"));
11343 printf (ngettext ("\nVersion symbols section '%s' "
11344 "contains %lu entry:\n",
11345 "\nVersion symbols section '%s' "
11346 "contains %lu entries:\n",
11348 printable_section_name (filedata
, section
), (unsigned long) total
);
11350 printf (_(" Addr: 0x"));
11351 printf_vma (section
->sh_addr
);
11352 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11353 (unsigned long) section
->sh_offset
, section
->sh_link
,
11354 printable_section_name (filedata
, link_section
));
11356 off
= offset_from_vma (filedata
,
11357 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11358 total
* sizeof (short));
11359 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11360 sizeof (short), total
,
11361 _("version symbol data"));
11369 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11371 for (cnt
= total
; cnt
--;)
11372 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11377 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11381 char *invalid
= _("*invalid*");
11383 printf (" %03x:", cnt
);
11385 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11386 switch (data
[cnt
+ j
])
11389 fputs (_(" 0 (*local*) "), stdout
);
11393 fputs (_(" 1 (*global*) "), stdout
);
11397 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11398 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11400 /* If this index value is greater than the size of the symbols
11401 array, break to avoid an out-of-bounds read. */
11402 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11404 warn (_("invalid index into symbol array\n"));
11409 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11411 Elf_Internal_Verneed ivn
;
11412 unsigned long offset
;
11414 offset
= offset_from_vma
11416 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11417 sizeof (Elf_External_Verneed
));
11421 Elf_Internal_Vernaux ivna
;
11422 Elf_External_Verneed evn
;
11423 Elf_External_Vernaux evna
;
11424 unsigned long a_off
;
11426 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11427 _("version need")) == NULL
)
11430 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11431 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11433 a_off
= offset
+ ivn
.vn_aux
;
11437 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11438 1, _("version need aux (2)")) == NULL
)
11441 ivna
.vna_other
= 0;
11445 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11446 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11449 a_off
+= ivna
.vna_next
;
11451 while (ivna
.vna_other
!= data
[cnt
+ j
]
11452 && ivna
.vna_next
!= 0);
11454 if (ivna
.vna_other
== data
[cnt
+ j
])
11456 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11458 if (ivna
.vna_name
>= string_sec
->sh_size
)
11461 name
= strtab
+ ivna
.vna_name
;
11465 offset
+= ivn
.vn_next
;
11467 while (ivn
.vn_next
);
11470 if (data
[cnt
+ j
] != 0x8001
11471 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11473 Elf_Internal_Verdef ivd
;
11474 Elf_External_Verdef evd
;
11475 unsigned long offset
;
11477 offset
= offset_from_vma
11479 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11484 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11485 _("version def")) == NULL
)
11488 /* PR 17531: file: 046-1082287-0.004. */
11489 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11494 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11495 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11498 offset
+= ivd
.vd_next
;
11500 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11501 && ivd
.vd_next
!= 0);
11503 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11505 Elf_External_Verdaux evda
;
11506 Elf_Internal_Verdaux ivda
;
11508 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11510 if (get_data (&evda
, filedata
,
11511 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11513 _("version def aux")) == NULL
)
11516 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11518 if (ivda
.vda_name
>= string_sec
->sh_size
)
11520 else if (name
!= NULL
&& name
!= invalid
)
11521 name
= _("*both*");
11523 name
= strtab
+ ivda
.vda_name
;
11527 nn
+= printf ("(%s%-*s",
11529 12 - (int) strlen (name
),
11533 printf ("%*c", 18 - nn
, ' ');
11551 printf (_("\nNo version information found in this file.\n"));
11556 static const char *
11557 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11559 static char buff
[64];
11563 case STB_LOCAL
: return "LOCAL";
11564 case STB_GLOBAL
: return "GLOBAL";
11565 case STB_WEAK
: return "WEAK";
11567 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11568 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11570 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11572 if (binding
== STB_GNU_UNIQUE
11573 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11575 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11578 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11583 static const char *
11584 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11586 static char buff
[64];
11590 case STT_NOTYPE
: return "NOTYPE";
11591 case STT_OBJECT
: return "OBJECT";
11592 case STT_FUNC
: return "FUNC";
11593 case STT_SECTION
: return "SECTION";
11594 case STT_FILE
: return "FILE";
11595 case STT_COMMON
: return "COMMON";
11596 case STT_TLS
: return "TLS";
11597 case STT_RELC
: return "RELC";
11598 case STT_SRELC
: return "SRELC";
11600 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11602 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11603 return "THUMB_FUNC";
11605 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11608 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11609 return "PARISC_MILLI";
11611 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11613 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11615 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11617 if (type
== STT_HP_OPAQUE
)
11618 return "HP_OPAQUE";
11619 if (type
== STT_HP_STUB
)
11623 if (type
== STT_GNU_IFUNC
11624 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11625 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11628 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11631 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11636 static const char *
11637 get_symbol_visibility (unsigned int visibility
)
11639 switch (visibility
)
11641 case STV_DEFAULT
: return "DEFAULT";
11642 case STV_INTERNAL
: return "INTERNAL";
11643 case STV_HIDDEN
: return "HIDDEN";
11644 case STV_PROTECTED
: return "PROTECTED";
11646 error (_("Unrecognized visibility value: %u\n"), visibility
);
11647 return _("<unknown>");
11651 static const char *
11652 get_alpha_symbol_other (unsigned int other
)
11656 case STO_ALPHA_NOPV
: return "NOPV";
11657 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11659 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11660 return _("<unknown>");
11664 static const char *
11665 get_solaris_symbol_visibility (unsigned int visibility
)
11667 switch (visibility
)
11669 case 4: return "EXPORTED";
11670 case 5: return "SINGLETON";
11671 case 6: return "ELIMINATE";
11672 default: return get_symbol_visibility (visibility
);
11676 static const char *
11677 get_aarch64_symbol_other (unsigned int other
)
11679 static char buf
[32];
11681 if (other
& STO_AARCH64_VARIANT_PCS
)
11683 other
&= ~STO_AARCH64_VARIANT_PCS
;
11685 return "VARIANT_PCS";
11686 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11692 static const char *
11693 get_mips_symbol_other (unsigned int other
)
11697 case STO_OPTIONAL
: return "OPTIONAL";
11698 case STO_MIPS_PLT
: return "MIPS PLT";
11699 case STO_MIPS_PIC
: return "MIPS PIC";
11700 case STO_MICROMIPS
: return "MICROMIPS";
11701 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11702 case STO_MIPS16
: return "MIPS16";
11703 default: return NULL
;
11707 static const char *
11708 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11710 if (is_ia64_vms (filedata
))
11712 static char res
[32];
11716 /* Function types is for images and .STB files only. */
11717 switch (filedata
->file_header
.e_type
)
11721 switch (VMS_ST_FUNC_TYPE (other
))
11723 case VMS_SFT_CODE_ADDR
:
11724 strcat (res
, " CA");
11726 case VMS_SFT_SYMV_IDX
:
11727 strcat (res
, " VEC");
11730 strcat (res
, " FD");
11732 case VMS_SFT_RESERVE
:
11733 strcat (res
, " RSV");
11736 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11737 VMS_ST_FUNC_TYPE (other
));
11738 strcat (res
, " <unknown>");
11745 switch (VMS_ST_LINKAGE (other
))
11747 case VMS_STL_IGNORE
:
11748 strcat (res
, " IGN");
11750 case VMS_STL_RESERVE
:
11751 strcat (res
, " RSV");
11754 strcat (res
, " STD");
11757 strcat (res
, " LNK");
11760 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11761 VMS_ST_LINKAGE (other
));
11762 strcat (res
, " <unknown>");
11774 static const char *
11775 get_ppc64_symbol_other (unsigned int other
)
11777 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11780 other
>>= STO_PPC64_LOCAL_BIT
;
11783 static char buf
[64];
11785 other
= ppc64_decode_local_entry (other
);
11786 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11792 static const char *
11793 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11795 const char * result
= NULL
;
11796 static char buff
[64];
11801 switch (filedata
->file_header
.e_machine
)
11804 result
= get_alpha_symbol_other (other
);
11807 result
= get_aarch64_symbol_other (other
);
11810 result
= get_mips_symbol_other (other
);
11813 result
= get_ia64_symbol_other (filedata
, other
);
11816 result
= get_ppc64_symbol_other (other
);
11826 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11830 static const char *
11831 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11833 static char buff
[32];
11837 case SHN_UNDEF
: return "UND";
11838 case SHN_ABS
: return "ABS";
11839 case SHN_COMMON
: return "COM";
11841 if (type
== SHN_IA_64_ANSI_COMMON
11842 && filedata
->file_header
.e_machine
== EM_IA_64
11843 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11845 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11846 || filedata
->file_header
.e_machine
== EM_L1OM
11847 || filedata
->file_header
.e_machine
== EM_K1OM
)
11848 && type
== SHN_X86_64_LCOMMON
)
11849 return "LARGE_COM";
11850 else if ((type
== SHN_MIPS_SCOMMON
11851 && filedata
->file_header
.e_machine
== EM_MIPS
)
11852 || (type
== SHN_TIC6X_SCOMMON
11853 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11855 else if (type
== SHN_MIPS_SUNDEFINED
11856 && filedata
->file_header
.e_machine
== EM_MIPS
)
11858 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11859 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11860 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11861 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11862 else if (type
>= SHN_LORESERVE
)
11863 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11864 else if (filedata
->file_header
.e_shnum
!= 0
11865 && type
>= filedata
->file_header
.e_shnum
)
11866 sprintf (buff
, _("bad section index[%3d]"), type
);
11868 sprintf (buff
, "%3d", type
);
11875 static const char *
11876 get_symbol_version_string (Filedata
* filedata
,
11877 bfd_boolean is_dynsym
,
11878 const char * strtab
,
11879 unsigned long int strtab_size
,
11881 Elf_Internal_Sym
* psym
,
11882 enum versioned_symbol_info
* sym_info
,
11883 unsigned short * vna_other
)
11885 unsigned char data
[2];
11886 unsigned short vers_data
;
11887 unsigned long offset
;
11888 unsigned short max_vd_ndx
;
11891 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11894 offset
= offset_from_vma (filedata
,
11895 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11896 sizeof data
+ si
* sizeof (vers_data
));
11898 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11899 sizeof (data
), 1, _("version data")) == NULL
)
11902 vers_data
= byte_get (data
, 2);
11904 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11907 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11910 /* Usually we'd only see verdef for defined symbols, and verneed for
11911 undefined symbols. However, symbols defined by the linker in
11912 .dynbss for variables copied from a shared library in order to
11913 avoid text relocations are defined yet have verneed. We could
11914 use a heuristic to detect the special case, for example, check
11915 for verneed first on symbols defined in SHT_NOBITS sections, but
11916 it is simpler and more reliable to just look for both verdef and
11917 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11919 if (psym
->st_shndx
!= SHN_UNDEF
11920 && vers_data
!= 0x8001
11921 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11923 Elf_Internal_Verdef ivd
;
11924 Elf_Internal_Verdaux ivda
;
11925 Elf_External_Verdaux evda
;
11928 off
= offset_from_vma (filedata
,
11929 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11930 sizeof (Elf_External_Verdef
));
11934 Elf_External_Verdef evd
;
11936 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11937 _("version def")) == NULL
)
11946 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11947 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11948 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11949 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11952 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11953 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11955 off
+= ivd
.vd_next
;
11957 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11959 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11961 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11964 off
-= ivd
.vd_next
;
11967 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11968 _("version def aux")) != NULL
)
11970 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11972 if (psym
->st_name
!= ivda
.vda_name
)
11973 return (ivda
.vda_name
< strtab_size
11974 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11979 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11981 Elf_External_Verneed evn
;
11982 Elf_Internal_Verneed ivn
;
11983 Elf_Internal_Vernaux ivna
;
11985 offset
= offset_from_vma (filedata
,
11986 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11990 unsigned long vna_off
;
11992 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11993 _("version need")) == NULL
)
11996 ivna
.vna_other
= 0;
12001 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12002 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12004 vna_off
= offset
+ ivn
.vn_aux
;
12008 Elf_External_Vernaux evna
;
12010 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12011 _("version need aux (3)")) == NULL
)
12014 ivna
.vna_other
= 0;
12019 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12020 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12021 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12024 vna_off
+= ivna
.vna_next
;
12026 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12028 if (ivna
.vna_other
== vers_data
)
12031 offset
+= ivn
.vn_next
;
12033 while (ivn
.vn_next
!= 0);
12035 if (ivna
.vna_other
== vers_data
)
12037 *sym_info
= symbol_undefined
;
12038 *vna_other
= ivna
.vna_other
;
12039 return (ivna
.vna_name
< strtab_size
12040 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12042 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12043 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12044 return _("<corrupt>");
12050 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12051 Elf_Internal_Sym
*symtab
,
12052 Elf_Internal_Shdr
*section
,
12053 char *strtab
, size_t strtab_size
)
12055 const char *version_string
;
12056 enum versioned_symbol_info sym_info
;
12057 unsigned short vna_other
;
12058 Elf_Internal_Sym
*psym
= symtab
+ si
;
12060 printf ("%6ld: ", si
);
12061 print_vma (psym
->st_value
, LONG_HEX
);
12063 print_vma (psym
->st_size
, DEC_5
);
12064 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12065 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12066 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12067 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12070 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12072 printf (" %-7s", get_symbol_visibility (vis
));
12073 /* Check to see if any other bits in the st_other field are set.
12074 Note - displaying this information disrupts the layout of the
12075 table being generated, but for the moment this case is very rare. */
12076 if (psym
->st_other
^ vis
)
12077 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12079 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12080 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
12082 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12085 = get_symbol_version_string (filedata
,
12087 || section
->sh_type
== SHT_DYNSYM
),
12088 strtab
, strtab_size
, si
,
12089 psym
, &sym_info
, &vna_other
);
12090 if (version_string
)
12092 if (sym_info
== symbol_undefined
)
12093 printf ("@%s (%d)", version_string
, vna_other
);
12095 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12101 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12103 && si
>= section
->sh_info
12104 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12105 && filedata
->file_header
.e_machine
!= EM_MIPS
12106 /* Solaris binaries have been found to violate this requirement as
12107 well. Not sure if this is a bug or an ABI requirement. */
12108 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12109 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12110 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12113 /* Dump the symbol table. */
12115 process_symbol_table (Filedata
* filedata
)
12117 Elf_Internal_Shdr
* section
;
12119 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12122 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12124 && do_using_dynamic
12125 && filedata
->dynamic_strings
!= NULL
12126 && filedata
->dynamic_symbols
!= NULL
)
12130 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12131 "\nSymbol table for image contains %lu entries:\n",
12132 filedata
->num_dynamic_syms
),
12133 filedata
->num_dynamic_syms
);
12135 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12137 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12139 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12140 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12141 filedata
->dynamic_strings
,
12142 filedata
->dynamic_strings_length
);
12144 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12145 && filedata
->section_headers
!= NULL
)
12149 for (i
= 0, section
= filedata
->section_headers
;
12150 i
< filedata
->file_header
.e_shnum
;
12153 char * strtab
= NULL
;
12154 unsigned long int strtab_size
= 0;
12155 Elf_Internal_Sym
* symtab
;
12156 unsigned long si
, num_syms
;
12158 if ((section
->sh_type
!= SHT_SYMTAB
12159 && section
->sh_type
!= SHT_DYNSYM
)
12161 && section
->sh_type
== SHT_SYMTAB
))
12164 if (section
->sh_entsize
== 0)
12166 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12167 printable_section_name (filedata
, section
));
12171 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12172 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12173 "\nSymbol table '%s' contains %lu entries:\n",
12175 printable_section_name (filedata
, section
),
12179 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12181 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12183 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12184 if (symtab
== NULL
)
12187 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12189 strtab
= filedata
->string_table
;
12190 strtab_size
= filedata
->string_table_length
;
12192 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12194 Elf_Internal_Shdr
* string_sec
;
12196 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12198 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12199 1, string_sec
->sh_size
,
12200 _("string table"));
12201 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12204 for (si
= 0; si
< num_syms
; si
++)
12205 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12206 strtab
, strtab_size
);
12209 if (strtab
!= filedata
->string_table
)
12215 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12217 if (do_histogram
&& filedata
->buckets
!= NULL
)
12219 unsigned long * lengths
;
12220 unsigned long * counts
;
12223 unsigned long maxlength
= 0;
12224 unsigned long nzero_counts
= 0;
12225 unsigned long nsyms
= 0;
12228 printf (ngettext ("\nHistogram for bucket list length "
12229 "(total of %lu bucket):\n",
12230 "\nHistogram for bucket list length "
12231 "(total of %lu buckets):\n",
12232 (unsigned long) filedata
->nbuckets
),
12233 (unsigned long) filedata
->nbuckets
);
12235 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12236 sizeof (*lengths
));
12237 if (lengths
== NULL
)
12239 error (_("Out of memory allocating space for histogram buckets\n"));
12242 visited
= xcmalloc (filedata
->nchains
, 1);
12243 memset (visited
, 0, filedata
->nchains
);
12245 printf (_(" Length Number %% of total Coverage\n"));
12246 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12248 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12251 if (maxlength
< ++lengths
[hn
])
12253 if (si
>= filedata
->nchains
|| visited
[si
])
12255 error (_("histogram chain is corrupt\n"));
12263 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12264 if (counts
== NULL
)
12267 error (_("Out of memory allocating space for histogram counts\n"));
12271 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12272 ++counts
[lengths
[hn
]];
12274 if (filedata
->nbuckets
> 0)
12277 printf (" 0 %-10lu (%5.1f%%)\n",
12278 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12279 for (i
= 1; i
<= maxlength
; ++i
)
12281 nzero_counts
+= counts
[i
] * i
;
12282 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12283 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12284 (nzero_counts
* 100.0) / nsyms
);
12292 free (filedata
->buckets
);
12293 filedata
->buckets
= NULL
;
12294 filedata
->nbuckets
= 0;
12295 free (filedata
->chains
);
12296 filedata
->chains
= NULL
;
12298 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12300 unsigned long * lengths
;
12301 unsigned long * counts
;
12303 unsigned long maxlength
= 0;
12304 unsigned long nzero_counts
= 0;
12305 unsigned long nsyms
= 0;
12307 printf (ngettext ("\nHistogram for `%s' bucket list length "
12308 "(total of %lu bucket):\n",
12309 "\nHistogram for `%s' bucket list length "
12310 "(total of %lu buckets):\n",
12311 (unsigned long) filedata
->ngnubuckets
),
12312 GNU_HASH_SECTION_NAME (filedata
),
12313 (unsigned long) filedata
->ngnubuckets
);
12315 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12316 sizeof (*lengths
));
12317 if (lengths
== NULL
)
12319 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12323 printf (_(" Length Number %% of total Coverage\n"));
12325 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12326 if (filedata
->gnubuckets
[hn
] != 0)
12328 bfd_vma off
, length
= 1;
12330 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12331 /* PR 17531 file: 010-77222-0.004. */
12332 off
< filedata
->ngnuchains
12333 && (filedata
->gnuchains
[off
] & 1) == 0;
12336 lengths
[hn
] = length
;
12337 if (length
> maxlength
)
12338 maxlength
= length
;
12342 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12343 if (counts
== NULL
)
12346 error (_("Out of memory allocating space for gnu histogram counts\n"));
12350 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12351 ++counts
[lengths
[hn
]];
12353 if (filedata
->ngnubuckets
> 0)
12356 printf (" 0 %-10lu (%5.1f%%)\n",
12357 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12358 for (j
= 1; j
<= maxlength
; ++j
)
12360 nzero_counts
+= counts
[j
] * j
;
12361 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12362 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12363 (nzero_counts
* 100.0) / nsyms
);
12370 free (filedata
->gnubuckets
);
12371 filedata
->gnubuckets
= NULL
;
12372 filedata
->ngnubuckets
= 0;
12373 free (filedata
->gnuchains
);
12374 filedata
->gnuchains
= NULL
;
12375 filedata
->ngnuchains
= 0;
12376 free (filedata
->mipsxlat
);
12377 filedata
->mipsxlat
= NULL
;
12381 free (filedata
->gnubuckets
);
12382 filedata
->gnubuckets
= NULL
;
12383 filedata
->ngnubuckets
= 0;
12384 free (filedata
->gnuchains
);
12385 filedata
->gnuchains
= NULL
;
12386 filedata
->ngnuchains
= 0;
12387 free (filedata
->mipsxlat
);
12388 filedata
->mipsxlat
= NULL
;
12389 free (filedata
->buckets
);
12390 filedata
->buckets
= NULL
;
12391 filedata
->nbuckets
= 0;
12392 free (filedata
->chains
);
12393 filedata
->chains
= NULL
;
12398 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12402 if (filedata
->dynamic_syminfo
== NULL
12404 /* No syminfo, this is ok. */
12407 /* There better should be a dynamic symbol section. */
12408 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12411 if (filedata
->dynamic_addr
)
12412 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12413 "contains %d entry:\n",
12414 "\nDynamic info segment at offset 0x%lx "
12415 "contains %d entries:\n",
12416 filedata
->dynamic_syminfo_nent
),
12417 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12419 printf (_(" Num: Name BoundTo Flags\n"));
12420 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12422 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12424 printf ("%4d: ", i
);
12425 if (i
>= filedata
->num_dynamic_syms
)
12426 printf (_("<corrupt index>"));
12427 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12428 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12429 filedata
->dynamic_symbols
[i
].st_name
));
12431 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12434 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12436 case SYMINFO_BT_SELF
:
12437 fputs ("SELF ", stdout
);
12439 case SYMINFO_BT_PARENT
:
12440 fputs ("PARENT ", stdout
);
12443 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12444 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12445 && VALID_DYNAMIC_NAME (filedata
,
12446 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12448 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12449 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12453 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12457 if (flags
& SYMINFO_FLG_DIRECT
)
12458 printf (" DIRECT");
12459 if (flags
& SYMINFO_FLG_PASSTHRU
)
12460 printf (" PASSTHRU");
12461 if (flags
& SYMINFO_FLG_COPY
)
12463 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12464 printf (" LAZYLOAD");
12472 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12473 is contained by the region START .. END. The types of ADDR, START
12474 and END should all be the same. Note both ADDR + NELEM and END
12475 point to just beyond the end of the regions that are being tested. */
12476 #define IN_RANGE(START,END,ADDR,NELEM) \
12477 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12479 /* Check to see if the given reloc needs to be handled in a target specific
12480 manner. If so then process the reloc and return TRUE otherwise return
12483 If called with reloc == NULL, then this is a signal that reloc processing
12484 for the current section has finished, and any saved state should be
12488 target_specific_reloc_handling (Filedata
* filedata
,
12489 Elf_Internal_Rela
* reloc
,
12490 unsigned char * start
,
12491 unsigned char * end
,
12492 Elf_Internal_Sym
* symtab
,
12493 unsigned long num_syms
)
12495 unsigned int reloc_type
= 0;
12496 unsigned long sym_index
= 0;
12500 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12501 sym_index
= get_reloc_symindex (reloc
->r_info
);
12504 switch (filedata
->file_header
.e_machine
)
12507 case EM_MSP430_OLD
:
12509 static Elf_Internal_Sym
* saved_sym
= NULL
;
12517 switch (reloc_type
)
12519 case 10: /* R_MSP430_SYM_DIFF */
12520 if (uses_msp430x_relocs (filedata
))
12522 /* Fall through. */
12523 case 21: /* R_MSP430X_SYM_DIFF */
12525 if (sym_index
>= num_syms
)
12526 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12529 saved_sym
= symtab
+ sym_index
;
12532 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12533 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12534 goto handle_sym_diff
;
12536 case 5: /* R_MSP430_16_BYTE */
12537 case 9: /* R_MSP430_8 */
12538 if (uses_msp430x_relocs (filedata
))
12540 goto handle_sym_diff
;
12542 case 2: /* R_MSP430_ABS16 */
12543 case 15: /* R_MSP430X_ABS16 */
12544 if (! uses_msp430x_relocs (filedata
))
12546 goto handle_sym_diff
;
12549 if (saved_sym
!= NULL
)
12551 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12554 if (sym_index
>= num_syms
)
12555 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12559 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12560 - saved_sym
->st_value
);
12562 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12563 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12566 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12567 (long) reloc
->r_offset
);
12576 if (saved_sym
!= NULL
)
12577 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12584 case EM_CYGNUS_MN10300
:
12586 static Elf_Internal_Sym
* saved_sym
= NULL
;
12594 switch (reloc_type
)
12596 case 34: /* R_MN10300_ALIGN */
12598 case 33: /* R_MN10300_SYM_DIFF */
12599 if (sym_index
>= num_syms
)
12600 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12603 saved_sym
= symtab
+ sym_index
;
12606 case 1: /* R_MN10300_32 */
12607 case 2: /* R_MN10300_16 */
12608 if (saved_sym
!= NULL
)
12610 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12613 if (sym_index
>= num_syms
)
12614 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12618 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12619 - saved_sym
->st_value
);
12621 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12622 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12624 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12625 (long) reloc
->r_offset
);
12633 if (saved_sym
!= NULL
)
12634 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12642 static bfd_vma saved_sym1
= 0;
12643 static bfd_vma saved_sym2
= 0;
12644 static bfd_vma value
;
12648 saved_sym1
= saved_sym2
= 0;
12652 switch (reloc_type
)
12654 case 0x80: /* R_RL78_SYM. */
12655 saved_sym1
= saved_sym2
;
12656 if (sym_index
>= num_syms
)
12657 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12661 saved_sym2
= symtab
[sym_index
].st_value
;
12662 saved_sym2
+= reloc
->r_addend
;
12666 case 0x83: /* R_RL78_OPsub. */
12667 value
= saved_sym1
- saved_sym2
;
12668 saved_sym2
= saved_sym1
= 0;
12672 case 0x41: /* R_RL78_ABS32. */
12673 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12674 byte_put (start
+ reloc
->r_offset
, value
, 4);
12676 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12677 (long) reloc
->r_offset
);
12681 case 0x43: /* R_RL78_ABS16. */
12682 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12683 byte_put (start
+ reloc
->r_offset
, value
, 2);
12685 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12686 (long) reloc
->r_offset
);
12700 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12701 DWARF debug sections. This is a target specific test. Note - we do not
12702 go through the whole including-target-headers-multiple-times route, (as
12703 we have already done with <elf/h8.h>) because this would become very
12704 messy and even then this function would have to contain target specific
12705 information (the names of the relocs instead of their numeric values).
12706 FIXME: This is not the correct way to solve this problem. The proper way
12707 is to have target specific reloc sizing and typing functions created by
12708 the reloc-macros.h header, in the same way that it already creates the
12709 reloc naming functions. */
12712 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12714 /* Please keep this table alpha-sorted for ease of visual lookup. */
12715 switch (filedata
->file_header
.e_machine
)
12719 return reloc_type
== 1; /* R_386_32. */
12721 return reloc_type
== 1; /* R_68K_32. */
12723 return reloc_type
== 1; /* R_860_32. */
12725 return reloc_type
== 2; /* R_960_32. */
12727 return (reloc_type
== 258
12728 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12730 return reloc_type
== 11; /* R_BPF_DATA_32 */
12731 case EM_ADAPTEVA_EPIPHANY
:
12732 return reloc_type
== 3;
12734 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12736 return reloc_type
== 1; /* R_ARC_32. */
12737 case EM_ARC_COMPACT
:
12738 case EM_ARC_COMPACT2
:
12739 return reloc_type
== 4; /* R_ARC_32. */
12741 return reloc_type
== 2; /* R_ARM_ABS32 */
12744 return reloc_type
== 1;
12746 return reloc_type
== 0x12; /* R_byte4_data. */
12748 return reloc_type
== 3; /* R_CRIS_32. */
12750 return reloc_type
== 3; /* R_CR16_NUM32. */
12752 return reloc_type
== 15; /* R_CRX_NUM32. */
12754 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12755 case EM_CYGNUS_FRV
:
12756 return reloc_type
== 1;
12757 case EM_CYGNUS_D10V
:
12759 return reloc_type
== 6; /* R_D10V_32. */
12760 case EM_CYGNUS_D30V
:
12762 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12764 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12765 case EM_CYGNUS_FR30
:
12767 return reloc_type
== 3; /* R_FR30_32. */
12769 return reloc_type
== 1; /* R_FT32_32. */
12773 return reloc_type
== 1; /* R_H8_DIR32. */
12775 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12776 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12777 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12778 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12781 return reloc_type
== 2; /* R_IP2K_32. */
12783 return reloc_type
== 2; /* R_IQ2000_32. */
12784 case EM_LATTICEMICO32
:
12785 return reloc_type
== 3; /* R_LM32_32. */
12788 return reloc_type
== 3; /* R_M32C_32. */
12790 return reloc_type
== 34; /* R_M32R_32_RELA. */
12793 return reloc_type
== 6; /* R_M68HC11_32. */
12795 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12796 reloc_type
== 6; /* R_S12Z_CW32. */
12798 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12799 case EM_CYGNUS_MEP
:
12800 return reloc_type
== 4; /* R_MEP_32. */
12802 return reloc_type
== 2; /* R_METAG_ADDR32. */
12803 case EM_MICROBLAZE
:
12804 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12806 return reloc_type
== 2; /* R_MIPS_32. */
12808 return reloc_type
== 4; /* R_MMIX_32. */
12809 case EM_CYGNUS_MN10200
:
12811 return reloc_type
== 1; /* R_MN10200_32. */
12812 case EM_CYGNUS_MN10300
:
12814 return reloc_type
== 1; /* R_MN10300_32. */
12816 return reloc_type
== 1; /* R_MOXIE_32. */
12817 case EM_MSP430_OLD
:
12819 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12821 return reloc_type
== 2; /* R_MT_32. */
12823 return reloc_type
== 20; /* R_NDS32_RELA. */
12824 case EM_ALTERA_NIOS2
:
12825 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12827 return reloc_type
== 1; /* R_NIOS_32. */
12829 return reloc_type
== 1; /* R_OR1K_32. */
12831 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12832 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12833 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12836 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12838 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12840 return reloc_type
== 1; /* R_PPC_ADDR32. */
12842 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12844 return reloc_type
== 1; /* R_RISCV_32. */
12846 return reloc_type
== 1; /* R_RL78_DIR32. */
12848 return reloc_type
== 1; /* R_RX_DIR32. */
12850 return reloc_type
== 1; /* R_I370_ADDR31. */
12853 return reloc_type
== 4; /* R_S390_32. */
12855 return reloc_type
== 8; /* R_SCORE_ABS32. */
12857 return reloc_type
== 1; /* R_SH_DIR32. */
12858 case EM_SPARC32PLUS
:
12861 return reloc_type
== 3 /* R_SPARC_32. */
12862 || reloc_type
== 23; /* R_SPARC_UA32. */
12864 return reloc_type
== 6; /* R_SPU_ADDR32 */
12866 return reloc_type
== 1; /* R_C6000_ABS32. */
12868 return reloc_type
== 2; /* R_TILEGX_32. */
12870 return reloc_type
== 1; /* R_TILEPRO_32. */
12871 case EM_CYGNUS_V850
:
12873 return reloc_type
== 6; /* R_V850_ABS32. */
12875 return reloc_type
== 0x33; /* R_V810_WORD. */
12877 return reloc_type
== 1; /* R_VAX_32. */
12879 return reloc_type
== 3; /* R_VISIUM_32. */
12880 case EM_WEBASSEMBLY
:
12881 return reloc_type
== 1; /* R_WASM32_32. */
12885 return reloc_type
== 10; /* R_X86_64_32. */
12888 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12890 return reloc_type
== 4; /* R_XGATE_32. */
12892 return reloc_type
== 1; /* R_XSTROMY16_32. */
12893 case EM_XTENSA_OLD
:
12895 return reloc_type
== 1; /* R_XTENSA_32. */
12897 return reloc_type
== 6; /* R_Z80_32. */
12900 static unsigned int prev_warn
= 0;
12902 /* Avoid repeating the same warning multiple times. */
12903 if (prev_warn
!= filedata
->file_header
.e_machine
)
12904 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12905 filedata
->file_header
.e_machine
);
12906 prev_warn
= filedata
->file_header
.e_machine
;
12912 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12913 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12916 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12918 switch (filedata
->file_header
.e_machine
)
12919 /* Please keep this table alpha-sorted for ease of visual lookup. */
12923 return reloc_type
== 2; /* R_386_PC32. */
12925 return reloc_type
== 4; /* R_68K_PC32. */
12927 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12928 case EM_ADAPTEVA_EPIPHANY
:
12929 return reloc_type
== 6;
12931 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12932 case EM_ARC_COMPACT
:
12933 case EM_ARC_COMPACT2
:
12934 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12936 return reloc_type
== 3; /* R_ARM_REL32 */
12939 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12940 case EM_MICROBLAZE
:
12941 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12943 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12945 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12947 return reloc_type
== 26; /* R_PPC_REL32. */
12949 return reloc_type
== 26; /* R_PPC64_REL32. */
12951 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12954 return reloc_type
== 5; /* R_390_PC32. */
12956 return reloc_type
== 2; /* R_SH_REL32. */
12957 case EM_SPARC32PLUS
:
12960 return reloc_type
== 6; /* R_SPARC_DISP32. */
12962 return reloc_type
== 13; /* R_SPU_REL32. */
12964 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12966 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12968 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12972 return reloc_type
== 2; /* R_X86_64_PC32. */
12974 return reloc_type
== 4; /* R_VAX_PCREL32. */
12975 case EM_XTENSA_OLD
:
12977 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12979 /* Do not abort or issue an error message here. Not all targets use
12980 pc-relative 32-bit relocs in their DWARF debug information and we
12981 have already tested for target coverage in is_32bit_abs_reloc. A
12982 more helpful warning message will be generated by apply_relocations
12983 anyway, so just return. */
12988 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12989 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12992 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12994 switch (filedata
->file_header
.e_machine
)
12997 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12999 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13001 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13002 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13004 return reloc_type
== 80; /* R_PARISC_DIR64. */
13006 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13008 return reloc_type
== 2; /* R_RISCV_64. */
13009 case EM_SPARC32PLUS
:
13012 return reloc_type
== 32 /* R_SPARC_64. */
13013 || reloc_type
== 54; /* R_SPARC_UA64. */
13017 return reloc_type
== 1; /* R_X86_64_64. */
13020 return reloc_type
== 22; /* R_S390_64. */
13022 return reloc_type
== 1; /* R_TILEGX_64. */
13024 return reloc_type
== 18; /* R_MIPS_64. */
13030 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13031 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13034 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13036 switch (filedata
->file_header
.e_machine
)
13039 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13041 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13043 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13044 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13046 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13048 return reloc_type
== 44; /* R_PPC64_REL64. */
13049 case EM_SPARC32PLUS
:
13052 return reloc_type
== 46; /* R_SPARC_DISP64. */
13056 return reloc_type
== 24; /* R_X86_64_PC64. */
13059 return reloc_type
== 23; /* R_S390_PC64. */
13061 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13067 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13068 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13071 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13073 switch (filedata
->file_header
.e_machine
)
13075 case EM_CYGNUS_MN10200
:
13077 return reloc_type
== 4; /* R_MN10200_24. */
13079 return reloc_type
== 5; /* R_FT32_20. */
13081 return reloc_type
== 5; /* R_Z80_24. */
13087 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13088 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13091 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13093 /* Please keep this table alpha-sorted for ease of visual lookup. */
13094 switch (filedata
->file_header
.e_machine
)
13097 case EM_ARC_COMPACT
:
13098 case EM_ARC_COMPACT2
:
13099 return reloc_type
== 2; /* R_ARC_16. */
13100 case EM_ADAPTEVA_EPIPHANY
:
13101 return reloc_type
== 5;
13104 return reloc_type
== 4; /* R_AVR_16. */
13105 case EM_CYGNUS_D10V
:
13107 return reloc_type
== 3; /* R_D10V_16. */
13109 return reloc_type
== 2; /* R_FT32_16. */
13113 return reloc_type
== R_H8_DIR16
;
13116 return reloc_type
== 1; /* R_IP2K_16. */
13119 return reloc_type
== 1; /* R_M32C_16 */
13120 case EM_CYGNUS_MN10200
:
13122 return reloc_type
== 2; /* R_MN10200_16. */
13123 case EM_CYGNUS_MN10300
:
13125 return reloc_type
== 2; /* R_MN10300_16. */
13127 if (uses_msp430x_relocs (filedata
))
13128 return reloc_type
== 2; /* R_MSP430_ABS16. */
13129 /* Fall through. */
13130 case EM_MSP430_OLD
:
13131 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13133 return reloc_type
== 19; /* R_NDS32_RELA. */
13134 case EM_ALTERA_NIOS2
:
13135 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13137 return reloc_type
== 9; /* R_NIOS_16. */
13139 return reloc_type
== 2; /* R_OR1K_16. */
13141 return reloc_type
== 55; /* R_RISCV_SET16. */
13143 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13145 return reloc_type
== 2; /* R_C6000_ABS16. */
13147 return reloc_type
== 2; /* R_VISIUM_16. */
13150 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13152 return reloc_type
== 3; /* R_XGATE_16. */
13154 return reloc_type
== 4; /* R_Z80_16. */
13160 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13161 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13164 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13166 switch (filedata
->file_header
.e_machine
)
13169 return reloc_type
== 54; /* R_RISCV_SET8. */
13171 return reloc_type
== 1; /* R_Z80_8. */
13177 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13178 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13181 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13183 switch (filedata
->file_header
.e_machine
)
13186 return reloc_type
== 53; /* R_RISCV_SET6. */
13192 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13193 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13196 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13198 /* Please keep this table alpha-sorted for ease of visual lookup. */
13199 switch (filedata
->file_header
.e_machine
)
13202 return reloc_type
== 35; /* R_RISCV_ADD32. */
13208 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13209 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13212 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13214 /* Please keep this table alpha-sorted for ease of visual lookup. */
13215 switch (filedata
->file_header
.e_machine
)
13218 return reloc_type
== 39; /* R_RISCV_SUB32. */
13224 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13225 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13228 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13230 /* Please keep this table alpha-sorted for ease of visual lookup. */
13231 switch (filedata
->file_header
.e_machine
)
13234 return reloc_type
== 36; /* R_RISCV_ADD64. */
13240 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13241 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13244 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13246 /* Please keep this table alpha-sorted for ease of visual lookup. */
13247 switch (filedata
->file_header
.e_machine
)
13250 return reloc_type
== 40; /* R_RISCV_SUB64. */
13256 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13257 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13260 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13262 /* Please keep this table alpha-sorted for ease of visual lookup. */
13263 switch (filedata
->file_header
.e_machine
)
13266 return reloc_type
== 34; /* R_RISCV_ADD16. */
13272 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13273 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13276 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13278 /* Please keep this table alpha-sorted for ease of visual lookup. */
13279 switch (filedata
->file_header
.e_machine
)
13282 return reloc_type
== 38; /* R_RISCV_SUB16. */
13288 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13289 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13292 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13294 /* Please keep this table alpha-sorted for ease of visual lookup. */
13295 switch (filedata
->file_header
.e_machine
)
13298 return reloc_type
== 33; /* R_RISCV_ADD8. */
13304 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13305 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13308 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13310 /* Please keep this table alpha-sorted for ease of visual lookup. */
13311 switch (filedata
->file_header
.e_machine
)
13314 return reloc_type
== 37; /* R_RISCV_SUB8. */
13320 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13321 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13324 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13326 switch (filedata
->file_header
.e_machine
)
13329 return reloc_type
== 52; /* R_RISCV_SUB6. */
13335 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13336 relocation entries (possibly formerly used for SHT_GROUP sections). */
13339 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13341 switch (filedata
->file_header
.e_machine
)
13343 case EM_386
: /* R_386_NONE. */
13344 case EM_68K
: /* R_68K_NONE. */
13345 case EM_ADAPTEVA_EPIPHANY
:
13346 case EM_ALPHA
: /* R_ALPHA_NONE. */
13347 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13348 case EM_ARC
: /* R_ARC_NONE. */
13349 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13350 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13351 case EM_ARM
: /* R_ARM_NONE. */
13352 case EM_C166
: /* R_XC16X_NONE. */
13353 case EM_CRIS
: /* R_CRIS_NONE. */
13354 case EM_FT32
: /* R_FT32_NONE. */
13355 case EM_IA_64
: /* R_IA64_NONE. */
13356 case EM_K1OM
: /* R_X86_64_NONE. */
13357 case EM_L1OM
: /* R_X86_64_NONE. */
13358 case EM_M32R
: /* R_M32R_NONE. */
13359 case EM_MIPS
: /* R_MIPS_NONE. */
13360 case EM_MN10300
: /* R_MN10300_NONE. */
13361 case EM_MOXIE
: /* R_MOXIE_NONE. */
13362 case EM_NIOS32
: /* R_NIOS_NONE. */
13363 case EM_OR1K
: /* R_OR1K_NONE. */
13364 case EM_PARISC
: /* R_PARISC_NONE. */
13365 case EM_PPC64
: /* R_PPC64_NONE. */
13366 case EM_PPC
: /* R_PPC_NONE. */
13367 case EM_RISCV
: /* R_RISCV_NONE. */
13368 case EM_S390
: /* R_390_NONE. */
13370 case EM_SH
: /* R_SH_NONE. */
13371 case EM_SPARC32PLUS
:
13372 case EM_SPARC
: /* R_SPARC_NONE. */
13374 case EM_TILEGX
: /* R_TILEGX_NONE. */
13375 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13376 case EM_TI_C6000
:/* R_C6000_NONE. */
13377 case EM_X86_64
: /* R_X86_64_NONE. */
13379 case EM_Z80
: /* R_Z80_NONE. */
13380 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13381 return reloc_type
== 0;
13384 return reloc_type
== 0 || reloc_type
== 256;
13387 return (reloc_type
== 0 /* R_AVR_NONE. */
13388 || reloc_type
== 30 /* R_AVR_DIFF8. */
13389 || reloc_type
== 31 /* R_AVR_DIFF16. */
13390 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13392 return reloc_type
== 3; /* R_METAG_NONE. */
13394 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13395 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13396 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13397 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13398 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13400 return (reloc_type
== 0 /* R_PRU_NONE. */
13401 || reloc_type
== 65 /* R_PRU_DIFF8. */
13402 || reloc_type
== 66 /* R_PRU_DIFF16. */
13403 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13404 case EM_XTENSA_OLD
:
13406 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13407 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13408 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13409 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13410 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13411 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13412 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13413 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13414 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13415 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13420 /* Returns TRUE if there is a relocation against
13421 section NAME at OFFSET bytes. */
13424 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13426 Elf_Internal_Rela
* relocs
;
13427 Elf_Internal_Rela
* rp
;
13429 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13432 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13434 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13435 if (rp
->r_offset
== offset
)
13441 /* Apply relocations to a section.
13442 Returns TRUE upon success, FALSE otherwise.
13443 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13444 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13445 will be set to the number of relocs loaded.
13447 Note: So far support has been added only for those relocations
13448 which can be found in debug sections. FIXME: Add support for
13449 more relocations ? */
13452 apply_relocations (Filedata
* filedata
,
13453 const Elf_Internal_Shdr
* section
,
13454 unsigned char * start
,
13455 bfd_size_type size
,
13456 void ** relocs_return
,
13457 unsigned long * num_relocs_return
)
13459 Elf_Internal_Shdr
* relsec
;
13460 unsigned char * end
= start
+ size
;
13462 if (relocs_return
!= NULL
)
13464 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13465 * num_relocs_return
= 0;
13468 if (filedata
->file_header
.e_type
!= ET_REL
)
13469 /* No relocs to apply. */
13472 /* Find the reloc section associated with the section. */
13473 for (relsec
= filedata
->section_headers
;
13474 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13477 bfd_boolean is_rela
;
13478 unsigned long num_relocs
;
13479 Elf_Internal_Rela
* relocs
;
13480 Elf_Internal_Rela
* rp
;
13481 Elf_Internal_Shdr
* symsec
;
13482 Elf_Internal_Sym
* symtab
;
13483 unsigned long num_syms
;
13484 Elf_Internal_Sym
* sym
;
13486 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13487 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13488 || filedata
->section_headers
+ relsec
->sh_info
!= section
13489 || relsec
->sh_size
== 0
13490 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13493 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13494 if (symsec
->sh_type
!= SHT_SYMTAB
13495 && symsec
->sh_type
!= SHT_DYNSYM
)
13498 is_rela
= relsec
->sh_type
== SHT_RELA
;
13502 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13503 relsec
->sh_size
, & relocs
, & num_relocs
))
13508 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13509 relsec
->sh_size
, & relocs
, & num_relocs
))
13513 /* SH uses RELA but uses in place value instead of the addend field. */
13514 if (filedata
->file_header
.e_machine
== EM_SH
)
13517 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13519 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13522 unsigned int reloc_type
;
13523 unsigned int reloc_size
;
13524 bfd_boolean reloc_inplace
= FALSE
;
13525 bfd_boolean reloc_subtract
= FALSE
;
13526 unsigned char * rloc
;
13527 unsigned long sym_index
;
13529 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13531 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13533 else if (is_none_reloc (filedata
, reloc_type
))
13535 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13536 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13538 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13539 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13541 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13543 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13545 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13546 || is_6bit_abs_reloc (filedata
, reloc_type
))
13548 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13550 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13553 reloc_inplace
= TRUE
;
13555 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13557 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13560 reloc_inplace
= TRUE
;
13562 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13564 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13567 reloc_inplace
= TRUE
;
13569 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13571 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13574 reloc_inplace
= TRUE
;
13576 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13580 reloc_inplace
= TRUE
;
13584 static unsigned int prev_reloc
= 0;
13586 if (reloc_type
!= prev_reloc
)
13587 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13588 reloc_type
, printable_section_name (filedata
, section
));
13589 prev_reloc
= reloc_type
;
13593 rloc
= start
+ rp
->r_offset
;
13594 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13596 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13597 (unsigned long) rp
->r_offset
,
13598 printable_section_name (filedata
, section
));
13602 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13603 if (sym_index
>= num_syms
)
13605 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13606 sym_index
, printable_section_name (filedata
, section
));
13609 sym
= symtab
+ sym_index
;
13611 /* If the reloc has a symbol associated with it,
13612 make sure that it is of an appropriate type.
13614 Relocations against symbols without type can happen.
13615 Gcc -feliminate-dwarf2-dups may generate symbols
13616 without type for debug info.
13618 Icc generates relocations against function symbols
13619 instead of local labels.
13621 Relocations against object symbols can happen, eg when
13622 referencing a global array. For an example of this see
13623 the _clz.o binary in libgcc.a. */
13625 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13626 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13628 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13629 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13630 printable_section_name (filedata
, relsec
),
13631 (long int)(rp
- relocs
));
13637 addend
+= rp
->r_addend
;
13638 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13639 partial_inplace. */
13641 || (filedata
->file_header
.e_machine
== EM_XTENSA
13642 && reloc_type
== 1)
13643 || ((filedata
->file_header
.e_machine
== EM_PJ
13644 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13645 && reloc_type
== 1)
13646 || ((filedata
->file_header
.e_machine
== EM_D30V
13647 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13648 && reloc_type
== 12)
13651 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13652 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13654 addend
+= byte_get (rloc
, reloc_size
);
13657 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13658 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13660 /* On HPPA, all pc-relative relocations are biased by 8. */
13661 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13663 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13666 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13667 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13669 if (reloc_subtract
)
13670 addend
-= sym
->st_value
;
13672 addend
+= sym
->st_value
;
13673 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13674 byte_put (rloc
, addend
, reloc_size
);
13676 else if (reloc_subtract
)
13677 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13679 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13683 /* Let the target specific reloc processing code know that
13684 we have finished with these relocs. */
13685 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13689 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13690 * num_relocs_return
= num_relocs
;
13701 #ifdef SUPPORT_DISASSEMBLY
13703 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13705 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13707 /* FIXME: XXX -- to be done --- XXX */
13713 /* Reads in the contents of SECTION from FILE, returning a pointer
13714 to a malloc'ed buffer or NULL if something went wrong. */
13717 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13719 bfd_size_type num_bytes
= section
->sh_size
;
13721 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13723 printf (_("Section '%s' has no data to dump.\n"),
13724 printable_section_name (filedata
, section
));
13728 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13729 _("section contents"));
13732 /* Uncompresses a section that was compressed using zlib, in place. */
13735 uncompress_section_contents (unsigned char ** buffer
,
13736 dwarf_size_type uncompressed_size
,
13737 dwarf_size_type
* size
)
13739 dwarf_size_type compressed_size
= *size
;
13740 unsigned char * compressed_buffer
= *buffer
;
13741 unsigned char * uncompressed_buffer
;
13745 /* It is possible the section consists of several compressed
13746 buffers concatenated together, so we uncompress in a loop. */
13747 /* PR 18313: The state field in the z_stream structure is supposed
13748 to be invisible to the user (ie us), but some compilers will
13749 still complain about it being used without initialisation. So
13750 we first zero the entire z_stream structure and then set the fields
13752 memset (& strm
, 0, sizeof strm
);
13753 strm
.avail_in
= compressed_size
;
13754 strm
.next_in
= (Bytef
*) compressed_buffer
;
13755 strm
.avail_out
= uncompressed_size
;
13756 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13758 rc
= inflateInit (& strm
);
13759 while (strm
.avail_in
> 0)
13763 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13764 + (uncompressed_size
- strm
.avail_out
));
13765 rc
= inflate (&strm
, Z_FINISH
);
13766 if (rc
!= Z_STREAM_END
)
13768 rc
= inflateReset (& strm
);
13770 rc
= inflateEnd (& strm
);
13772 || strm
.avail_out
!= 0)
13775 *buffer
= uncompressed_buffer
;
13776 *size
= uncompressed_size
;
13780 free (uncompressed_buffer
);
13781 /* Indicate decompression failure. */
13787 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13789 Elf_Internal_Shdr
* relsec
;
13790 bfd_size_type num_bytes
;
13791 unsigned char * data
;
13792 unsigned char * end
;
13793 unsigned char * real_start
;
13794 unsigned char * start
;
13795 bfd_boolean some_strings_shown
;
13797 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13799 /* PR 21820: Do not fail if the section was empty. */
13800 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13802 num_bytes
= section
->sh_size
;
13804 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13806 if (decompress_dumps
)
13808 dwarf_size_type new_size
= num_bytes
;
13809 dwarf_size_type uncompressed_size
= 0;
13811 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13813 Elf_Internal_Chdr chdr
;
13814 unsigned int compression_header_size
13815 = get_compression_header (& chdr
, (unsigned char *) start
,
13817 if (compression_header_size
== 0)
13818 /* An error message will have already been generated
13819 by get_compression_header. */
13822 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13824 warn (_("section '%s' has unsupported compress type: %d\n"),
13825 printable_section_name (filedata
, section
), chdr
.ch_type
);
13828 uncompressed_size
= chdr
.ch_size
;
13829 start
+= compression_header_size
;
13830 new_size
-= compression_header_size
;
13832 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13834 /* Read the zlib header. In this case, it should be "ZLIB"
13835 followed by the uncompressed section size, 8 bytes in
13836 big-endian order. */
13837 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13838 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13839 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13840 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13841 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13842 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13843 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13844 uncompressed_size
+= start
[11];
13849 if (uncompressed_size
)
13851 if (uncompress_section_contents (& start
,
13852 uncompressed_size
, & new_size
))
13853 num_bytes
= new_size
;
13856 error (_("Unable to decompress section %s\n"),
13857 printable_section_name (filedata
, section
));
13862 start
= real_start
;
13865 /* If the section being dumped has relocations against it the user might
13866 be expecting these relocations to have been applied. Check for this
13867 case and issue a warning message in order to avoid confusion.
13868 FIXME: Maybe we ought to have an option that dumps a section with
13869 relocs applied ? */
13870 for (relsec
= filedata
->section_headers
;
13871 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13874 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13875 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13876 || filedata
->section_headers
+ relsec
->sh_info
!= section
13877 || relsec
->sh_size
== 0
13878 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13881 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13886 end
= start
+ num_bytes
;
13887 some_strings_shown
= FALSE
;
13889 #ifdef HAVE_MBSTATE_T
13891 /* Initialise the multibyte conversion state. */
13892 memset (& state
, 0, sizeof (state
));
13895 bfd_boolean continuing
= FALSE
;
13899 while (!ISPRINT (* data
))
13900 if (++ data
>= end
)
13905 size_t maxlen
= end
- data
;
13910 continuing
= FALSE
;
13915 /* PR 11128: Use two separate invocations in order to work
13916 around bugs in the Solaris 8 implementation of printf. */
13917 printf (" [%6tx] ", data
- start
);
13919 printf (" [%6Ix] ", (size_t) (data
- start
));
13934 /* PR 25543: Treat new-lines as string-ending characters. */
13943 /* Do not print control characters directly as they can affect terminal
13944 settings. Such characters usually appear in the names generated
13945 by the assembler for local labels. */
13948 printf ("^%c", c
+ 0x40);
13950 else if (ISPRINT (c
))
13957 #ifdef HAVE_MBSTATE_T
13960 /* Let printf do the hard work of displaying multibyte characters. */
13961 printf ("%.1s", data
- 1);
13962 #ifdef HAVE_MBSTATE_T
13963 /* Try to find out how many bytes made up the character that was
13964 just printed. Advance the symbol pointer past the bytes that
13966 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13970 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13980 printf (_("<corrupt>\n"));
13983 some_strings_shown
= TRUE
;
13987 if (! some_strings_shown
)
13988 printf (_(" No strings found in this section."));
14001 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
14002 Filedata
* filedata
,
14003 bfd_boolean relocate
)
14005 Elf_Internal_Shdr
* relsec
;
14006 bfd_size_type bytes
;
14007 bfd_size_type section_size
;
14009 unsigned char * data
;
14010 unsigned char * real_start
;
14011 unsigned char * start
;
14013 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14015 /* PR 21820: Do not fail if the section was empty. */
14016 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14018 section_size
= section
->sh_size
;
14020 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
14022 if (decompress_dumps
)
14024 dwarf_size_type new_size
= section_size
;
14025 dwarf_size_type uncompressed_size
= 0;
14027 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14029 Elf_Internal_Chdr chdr
;
14030 unsigned int compression_header_size
14031 = get_compression_header (& chdr
, start
, section_size
);
14033 if (compression_header_size
== 0)
14034 /* An error message will have already been generated
14035 by get_compression_header. */
14038 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14040 warn (_("section '%s' has unsupported compress type: %d\n"),
14041 printable_section_name (filedata
, section
), chdr
.ch_type
);
14044 uncompressed_size
= chdr
.ch_size
;
14045 start
+= compression_header_size
;
14046 new_size
-= compression_header_size
;
14048 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14050 /* Read the zlib header. In this case, it should be "ZLIB"
14051 followed by the uncompressed section size, 8 bytes in
14052 big-endian order. */
14053 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14054 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14055 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14056 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14057 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14058 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14059 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14060 uncompressed_size
+= start
[11];
14065 if (uncompressed_size
)
14067 if (uncompress_section_contents (& start
, uncompressed_size
,
14070 section_size
= new_size
;
14074 error (_("Unable to decompress section %s\n"),
14075 printable_section_name (filedata
, section
));
14076 /* FIXME: Print the section anyway ? */
14081 start
= real_start
;
14086 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14091 /* If the section being dumped has relocations against it the user might
14092 be expecting these relocations to have been applied. Check for this
14093 case and issue a warning message in order to avoid confusion.
14094 FIXME: Maybe we ought to have an option that dumps a section with
14095 relocs applied ? */
14096 for (relsec
= filedata
->section_headers
;
14097 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14100 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14101 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14102 || filedata
->section_headers
+ relsec
->sh_info
!= section
14103 || relsec
->sh_size
== 0
14104 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14107 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14112 addr
= section
->sh_addr
;
14113 bytes
= section_size
;
14122 lbytes
= (bytes
> 16 ? 16 : bytes
);
14124 printf (" 0x%8.8lx ", (unsigned long) addr
);
14126 for (j
= 0; j
< 16; j
++)
14129 printf ("%2.2x", data
[j
]);
14137 for (j
= 0; j
< lbytes
; j
++)
14140 if (k
>= ' ' && k
< 0x7f)
14163 static ctf_sect_t
*
14164 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14166 buf
->cts_name
= SECTION_NAME (shdr
);
14167 buf
->cts_size
= shdr
->sh_size
;
14168 buf
->cts_entsize
= shdr
->sh_entsize
;
14173 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14174 it is passed, or a pointer to newly-allocated storage, in which case
14175 dump_ctf() will free it when it no longer needs it. */
14177 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14178 char *s
, void *arg
)
14180 const char *blanks
= arg
;
14183 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14189 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14191 Elf_Internal_Shdr
* parent_sec
= NULL
;
14192 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14193 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14194 void * data
= NULL
;
14195 void * symdata
= NULL
;
14196 void * strdata
= NULL
;
14197 void * parentdata
= NULL
;
14198 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14199 ctf_sect_t
* symsectp
= NULL
;
14200 ctf_sect_t
* strsectp
= NULL
;
14201 ctf_file_t
* ctf
= NULL
;
14202 ctf_file_t
* parent
= NULL
;
14204 const char *things
[] = {"Header", "Labels", "Data objects",
14205 "Function objects", "Variables", "Types", "Strings",
14207 const char **thing
;
14209 bfd_boolean ret
= FALSE
;
14212 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14213 data
= get_section_contents (section
, filedata
);
14214 ctfsect
.cts_data
= data
;
14216 if (!dump_ctf_symtab_name
)
14217 dump_ctf_symtab_name
= strdup (".symtab");
14219 if (!dump_ctf_strtab_name
)
14220 dump_ctf_strtab_name
= strdup (".strtab");
14222 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14224 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14226 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14229 if ((symdata
= (void *) get_data (NULL
, filedata
,
14230 symtab_sec
->sh_offset
, 1,
14231 symtab_sec
->sh_size
,
14232 _("symbols"))) == NULL
)
14234 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14235 symsect
.cts_data
= symdata
;
14237 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14239 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14241 error (_("No string table section named %s\n"),
14242 dump_ctf_strtab_name
);
14245 if ((strdata
= (void *) get_data (NULL
, filedata
,
14246 strtab_sec
->sh_offset
, 1,
14247 strtab_sec
->sh_size
,
14248 _("strings"))) == NULL
)
14250 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14251 strsect
.cts_data
= strdata
;
14253 if (dump_ctf_parent_name
)
14255 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14257 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14260 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14261 parent_sec
->sh_offset
, 1,
14262 parent_sec
->sh_size
,
14263 _("CTF parent"))) == NULL
)
14265 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14266 parentsect
.cts_data
= parentdata
;
14269 /* Load the CTF file and dump it. */
14271 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14273 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14279 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14281 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14285 ctf_import (ctf
, parent
);
14290 printf (_("\nDump of CTF section '%s':\n"),
14291 printable_section_name (filedata
, section
));
14293 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14295 ctf_dump_state_t
*s
= NULL
;
14298 printf ("\n %s:\n", *thing
);
14299 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14300 (void *) " ")) != NULL
)
14302 printf ("%s\n", item
);
14306 if (ctf_errno (ctf
))
14308 error (_("Iteration failed: %s, %s\n"), *thing
,
14309 ctf_errmsg (ctf_errno (ctf
)));
14315 ctf_file_close (ctf
);
14316 ctf_file_close (parent
);
14325 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14326 const Elf_Internal_Shdr
* sec
,
14329 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14331 Filedata
* filedata
= (Filedata
*) data
;
14333 if (section
->start
!= NULL
)
14335 /* If it is already loaded, do nothing. */
14336 if (streq (section
->filename
, filedata
->file_name
))
14338 free (section
->start
);
14341 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14342 section
->address
= sec
->sh_addr
;
14343 section
->user_data
= NULL
;
14344 section
->filename
= filedata
->file_name
;
14345 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14347 sec
->sh_size
, buf
);
14348 if (section
->start
== NULL
)
14352 unsigned char *start
= section
->start
;
14353 dwarf_size_type size
= sec
->sh_size
;
14354 dwarf_size_type uncompressed_size
= 0;
14356 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14358 Elf_Internal_Chdr chdr
;
14359 unsigned int compression_header_size
;
14361 if (size
< (is_32bit_elf
14362 ? sizeof (Elf32_External_Chdr
)
14363 : sizeof (Elf64_External_Chdr
)))
14365 warn (_("compressed section %s is too small to contain a compression header\n"),
14370 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14371 if (compression_header_size
== 0)
14372 /* An error message will have already been generated
14373 by get_compression_header. */
14376 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14378 warn (_("section '%s' has unsupported compress type: %d\n"),
14379 section
->name
, chdr
.ch_type
);
14382 uncompressed_size
= chdr
.ch_size
;
14383 start
+= compression_header_size
;
14384 size
-= compression_header_size
;
14386 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14388 /* Read the zlib header. In this case, it should be "ZLIB"
14389 followed by the uncompressed section size, 8 bytes in
14390 big-endian order. */
14391 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14392 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14393 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14394 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14395 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14396 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14397 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14398 uncompressed_size
+= start
[11];
14403 if (uncompressed_size
)
14405 if (uncompress_section_contents (&start
, uncompressed_size
,
14408 /* Free the compressed buffer, update the section buffer
14409 and the section size if uncompress is successful. */
14410 free (section
->start
);
14411 section
->start
= start
;
14415 error (_("Unable to decompress section %s\n"),
14416 printable_section_name (filedata
, sec
));
14421 section
->size
= size
;
14424 if (section
->start
== NULL
)
14427 if (debug_displays
[debug
].relocate
)
14429 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14430 & section
->reloc_info
, & section
->num_relocs
))
14435 section
->reloc_info
= NULL
;
14436 section
->num_relocs
= 0;
14442 #if HAVE_LIBDEBUGINFOD
14443 /* Return a hex string representation of the build-id. */
14445 get_build_id (void * data
)
14447 Filedata
* filedata
= (Filedata
*)data
;
14448 Elf_Internal_Shdr
* shdr
;
14451 /* Iterate through notes to find note.gnu.build-id.
14452 FIXME: Only the first note in any note section is examined. */
14453 for (i
= 0, shdr
= filedata
->section_headers
;
14454 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14457 if (shdr
->sh_type
!= SHT_NOTE
)
14462 size_t data_remaining
;
14464 Elf_External_Note
* enote
;
14465 Elf_Internal_Note inote
;
14467 bfd_vma offset
= shdr
->sh_offset
;
14468 bfd_vma align
= shdr
->sh_addralign
;
14469 bfd_vma length
= shdr
->sh_size
;
14471 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14477 else if (align
!= 4 && align
!= 8)
14483 end
= (char *) enote
+ length
;
14484 data_remaining
= end
- (char *) enote
;
14486 if (!is_ia64_vms (filedata
))
14488 min_notesz
= offsetof (Elf_External_Note
, name
);
14489 if (data_remaining
< min_notesz
)
14492 malformed note encountered in section %s whilst scanning for build-id note\n"),
14493 printable_section_name (filedata
, shdr
));
14497 data_remaining
-= min_notesz
;
14499 inote
.type
= BYTE_GET (enote
->type
);
14500 inote
.namesz
= BYTE_GET (enote
->namesz
);
14501 inote
.namedata
= enote
->name
;
14502 inote
.descsz
= BYTE_GET (enote
->descsz
);
14503 inote
.descdata
= ((char *) enote
14504 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14505 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14506 next
= ((char *) enote
14507 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14511 Elf64_External_VMS_Note
*vms_enote
;
14513 /* PR binutils/15191
14514 Make sure that there is enough data to read. */
14515 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14516 if (data_remaining
< min_notesz
)
14519 malformed note encountered in section %s whilst scanning for build-id note\n"),
14520 printable_section_name (filedata
, shdr
));
14524 data_remaining
-= min_notesz
;
14526 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14527 inote
.type
= BYTE_GET (vms_enote
->type
);
14528 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14529 inote
.namedata
= vms_enote
->name
;
14530 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14531 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14532 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14533 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14536 /* Skip malformed notes. */
14537 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14538 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14539 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14540 || ((size_t) (next
- inote
.descdata
)
14541 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14544 malformed note encountered in section %s whilst scanning for build-id note\n"),
14545 printable_section_name (filedata
, shdr
));
14550 /* Check if this is the build-id note. If so then convert the build-id
14551 bytes to a hex string. */
14552 if (inote
.namesz
> 0
14553 && const_strneq (inote
.namedata
, "GNU")
14554 && inote
.type
== NT_GNU_BUILD_ID
)
14559 build_id
= malloc (inote
.descsz
* 2 + 1);
14560 if (build_id
== NULL
)
14566 for (j
= 0; j
< inote
.descsz
; ++j
)
14567 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14568 build_id
[inote
.descsz
* 2] = '\0';
14571 return (unsigned char *) build_id
;
14578 #endif /* HAVE_LIBDEBUGINFOD */
14580 /* If this is not NULL, load_debug_section will only look for sections
14581 within the list of sections given here. */
14582 static unsigned int * section_subset
= NULL
;
14585 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14587 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14588 Elf_Internal_Shdr
* sec
;
14589 Filedata
* filedata
= (Filedata
*) data
;
14591 /* Without section headers we cannot find any sections. */
14592 if (filedata
->section_headers
== NULL
)
14595 if (filedata
->string_table
== NULL
14596 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14597 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14599 Elf_Internal_Shdr
* strs
;
14601 /* Read in the string table, so that we have section names to scan. */
14602 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14604 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14606 filedata
->string_table
14607 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14608 1, strs
->sh_size
, _("string table"));
14610 filedata
->string_table_length
14611 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14615 /* Locate the debug section. */
14616 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14618 section
->name
= section
->uncompressed_name
;
14621 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14623 section
->name
= section
->compressed_name
;
14628 /* If we're loading from a subset of sections, and we've loaded
14629 a section matching this name before, it's likely that it's a
14631 if (section_subset
!= NULL
)
14632 free_debug_section (debug
);
14634 return load_specific_debug_section (debug
, sec
, data
);
14638 free_debug_section (enum dwarf_section_display_enum debug
)
14640 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14642 if (section
->start
== NULL
)
14645 free ((char *) section
->start
);
14646 section
->start
= NULL
;
14647 section
->address
= 0;
14650 if (section
->reloc_info
!= NULL
)
14652 free (section
->reloc_info
);
14653 section
->reloc_info
= NULL
;
14654 section
->num_relocs
= 0;
14659 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14661 char * name
= SECTION_NAME (section
);
14662 const char * print_name
= printable_section_name (filedata
, section
);
14663 bfd_size_type length
;
14664 bfd_boolean result
= TRUE
;
14667 length
= section
->sh_size
;
14670 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14673 if (section
->sh_type
== SHT_NOBITS
)
14675 /* There is no point in dumping the contents of a debugging section
14676 which has the NOBITS type - the bits in the file will be random.
14677 This can happen when a file containing a .eh_frame section is
14678 stripped with the --only-keep-debug command line option. */
14679 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14684 if (const_strneq (name
, ".gnu.linkonce.wi."))
14685 name
= ".debug_info";
14687 /* See if we know how to display the contents of this section. */
14688 for (i
= 0; i
< max
; i
++)
14690 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14691 struct dwarf_section_display
* display
= debug_displays
+ i
;
14692 struct dwarf_section
* sec
= & display
->section
;
14694 if (streq (sec
->uncompressed_name
, name
)
14695 || (id
== line
&& const_strneq (name
, ".debug_line."))
14696 || streq (sec
->compressed_name
, name
))
14698 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14701 free_debug_section (id
);
14703 if (i
== line
&& const_strneq (name
, ".debug_line."))
14705 else if (streq (sec
->uncompressed_name
, name
))
14706 sec
->name
= sec
->uncompressed_name
;
14708 sec
->name
= sec
->compressed_name
;
14710 if (load_specific_debug_section (id
, section
, filedata
))
14712 /* If this debug section is part of a CU/TU set in a .dwp file,
14713 restrict load_debug_section to the sections in that set. */
14714 section_subset
= find_cu_tu_set (filedata
, shndx
);
14716 result
&= display
->display (sec
, filedata
);
14718 section_subset
= NULL
;
14720 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14721 free_debug_section (id
);
14729 printf (_("Unrecognized debug section: %s\n"), print_name
);
14736 /* Set DUMP_SECTS for all sections where dumps were requested
14737 based on section name. */
14740 initialise_dumps_byname (Filedata
* filedata
)
14742 struct dump_list_entry
* cur
;
14744 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14747 bfd_boolean any
= FALSE
;
14749 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14750 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14752 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14757 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14763 process_section_contents (Filedata
* filedata
)
14765 Elf_Internal_Shdr
* section
;
14767 bfd_boolean res
= TRUE
;
14772 initialise_dumps_byname (filedata
);
14774 for (i
= 0, section
= filedata
->section_headers
;
14775 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14778 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14780 #ifdef SUPPORT_DISASSEMBLY
14781 if (dump
& DISASS_DUMP
)
14783 if (! disassemble_section (section
, filedata
))
14787 if (dump
& HEX_DUMP
)
14789 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14793 if (dump
& RELOC_DUMP
)
14795 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14799 if (dump
& STRING_DUMP
)
14801 if (! dump_section_as_strings (section
, filedata
))
14805 if (dump
& DEBUG_DUMP
)
14807 if (! display_debug_section (i
, section
, filedata
))
14811 if (dump
& CTF_DUMP
)
14813 if (! dump_section_as_ctf (section
, filedata
))
14818 /* Check to see if the user requested a
14819 dump of a section that does not exist. */
14820 while (i
< filedata
->dump
.num_dump_sects
)
14822 if (filedata
->dump
.dump_sects
[i
])
14824 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14834 process_mips_fpe_exception (int mask
)
14838 bfd_boolean first
= TRUE
;
14840 if (mask
& OEX_FPU_INEX
)
14841 fputs ("INEX", stdout
), first
= FALSE
;
14842 if (mask
& OEX_FPU_UFLO
)
14843 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14844 if (mask
& OEX_FPU_OFLO
)
14845 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14846 if (mask
& OEX_FPU_DIV0
)
14847 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14848 if (mask
& OEX_FPU_INVAL
)
14849 printf ("%sINVAL", first
? "" : "|");
14852 fputs ("0", stdout
);
14855 /* Display's the value of TAG at location P. If TAG is
14856 greater than 0 it is assumed to be an unknown tag, and
14857 a message is printed to this effect. Otherwise it is
14858 assumed that a message has already been printed.
14860 If the bottom bit of TAG is set it assumed to have a
14861 string value, otherwise it is assumed to have an integer
14864 Returns an updated P pointing to the first unread byte
14865 beyond the end of TAG's value.
14867 Reads at or beyond END will not be made. */
14869 static unsigned char *
14870 display_tag_value (signed int tag
,
14872 const unsigned char * const end
)
14877 printf (" Tag_unknown_%d: ", tag
);
14881 warn (_("<corrupt tag>\n"));
14885 /* PR 17531 file: 027-19978-0.004. */
14886 size_t maxlen
= (end
- p
) - 1;
14891 print_symbol ((int) maxlen
, (const char *) p
);
14892 p
+= strnlen ((char *) p
, maxlen
) + 1;
14896 printf (_("<corrupt string tag>"));
14897 p
= (unsigned char *) end
;
14903 READ_ULEB (val
, p
, end
);
14904 printf ("%ld (0x%lx)\n", val
, val
);
14911 /* ARC ABI attributes section. */
14913 static unsigned char *
14914 display_arc_attribute (unsigned char * p
,
14915 const unsigned char * const end
)
14920 READ_ULEB (tag
, p
, end
);
14924 case Tag_ARC_PCS_config
:
14925 READ_ULEB (val
, p
, end
);
14926 printf (" Tag_ARC_PCS_config: ");
14930 printf (_("Absent/Non standard\n"));
14933 printf (_("Bare metal/mwdt\n"));
14936 printf (_("Bare metal/newlib\n"));
14939 printf (_("Linux/uclibc\n"));
14942 printf (_("Linux/glibc\n"));
14945 printf (_("Unknown\n"));
14950 case Tag_ARC_CPU_base
:
14951 READ_ULEB (val
, p
, end
);
14952 printf (" Tag_ARC_CPU_base: ");
14957 printf (_("Absent\n"));
14959 case TAG_CPU_ARC6xx
:
14960 printf ("ARC6xx\n");
14962 case TAG_CPU_ARC7xx
:
14963 printf ("ARC7xx\n");
14965 case TAG_CPU_ARCEM
:
14966 printf ("ARCEM\n");
14968 case TAG_CPU_ARCHS
:
14969 printf ("ARCHS\n");
14974 case Tag_ARC_CPU_variation
:
14975 READ_ULEB (val
, p
, end
);
14976 printf (" Tag_ARC_CPU_variation: ");
14980 if (val
> 0 && val
< 16)
14981 printf ("Core%d\n", val
);
14983 printf ("Unknown\n");
14987 printf (_("Absent\n"));
14992 case Tag_ARC_CPU_name
:
14993 printf (" Tag_ARC_CPU_name: ");
14994 p
= display_tag_value (-1, p
, end
);
14997 case Tag_ARC_ABI_rf16
:
14998 READ_ULEB (val
, p
, end
);
14999 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15002 case Tag_ARC_ABI_osver
:
15003 READ_ULEB (val
, p
, end
);
15004 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15007 case Tag_ARC_ABI_pic
:
15008 case Tag_ARC_ABI_sda
:
15009 READ_ULEB (val
, p
, end
);
15010 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15011 : " Tag_ARC_ABI_pic: ");
15015 printf (_("Absent\n"));
15024 printf (_("Unknown\n"));
15029 case Tag_ARC_ABI_tls
:
15030 READ_ULEB (val
, p
, end
);
15031 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15034 case Tag_ARC_ABI_enumsize
:
15035 READ_ULEB (val
, p
, end
);
15036 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15040 case Tag_ARC_ABI_exceptions
:
15041 READ_ULEB (val
, p
, end
);
15042 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15046 case Tag_ARC_ABI_double_size
:
15047 READ_ULEB (val
, p
, end
);
15048 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15051 case Tag_ARC_ISA_config
:
15052 printf (" Tag_ARC_ISA_config: ");
15053 p
= display_tag_value (-1, p
, end
);
15056 case Tag_ARC_ISA_apex
:
15057 printf (" Tag_ARC_ISA_apex: ");
15058 p
= display_tag_value (-1, p
, end
);
15061 case Tag_ARC_ISA_mpy_option
:
15062 READ_ULEB (val
, p
, end
);
15063 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15066 case Tag_ARC_ATR_version
:
15067 READ_ULEB (val
, p
, end
);
15068 printf (" Tag_ARC_ATR_version: %d\n", val
);
15072 return display_tag_value (tag
& 1, p
, end
);
15078 /* ARM EABI attributes section. */
15083 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15085 const char ** table
;
15086 } arm_attr_public_tag
;
15088 static const char * arm_attr_tag_CPU_arch
[] =
15089 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15090 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15091 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15092 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15093 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15094 {"No", "Thumb-1", "Thumb-2", "Yes"};
15095 static const char * arm_attr_tag_FP_arch
[] =
15096 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15097 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15098 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15099 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15100 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15101 "NEON for ARMv8.1"};
15102 static const char * arm_attr_tag_PCS_config
[] =
15103 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15104 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15105 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15106 {"V6", "SB", "TLS", "Unused"};
15107 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15108 {"Absolute", "PC-relative", "SB-relative", "None"};
15109 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15110 {"Absolute", "PC-relative", "None"};
15111 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15112 {"None", "direct", "GOT-indirect"};
15113 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15114 {"None", "??? 1", "2", "??? 3", "4"};
15115 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15116 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15117 {"Unused", "Needed", "Sign only"};
15118 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15119 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15120 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15121 {"Unused", "Finite", "RTABI", "IEEE 754"};
15122 static const char * arm_attr_tag_ABI_enum_size
[] =
15123 {"Unused", "small", "int", "forced to int"};
15124 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15125 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15126 static const char * arm_attr_tag_ABI_VFP_args
[] =
15127 {"AAPCS", "VFP registers", "custom", "compatible"};
15128 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15129 {"AAPCS", "WMMX registers", "custom"};
15130 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15131 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15132 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15133 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15134 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15135 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15136 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15137 static const char * arm_attr_tag_FP_HP_extension
[] =
15138 {"Not Allowed", "Allowed"};
15139 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15140 {"None", "IEEE 754", "Alternative Format"};
15141 static const char * arm_attr_tag_DSP_extension
[] =
15142 {"Follow architecture", "Allowed"};
15143 static const char * arm_attr_tag_MPextension_use
[] =
15144 {"Not Allowed", "Allowed"};
15145 static const char * arm_attr_tag_DIV_use
[] =
15146 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15147 "Allowed in v7-A with integer division extension"};
15148 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15149 static const char * arm_attr_tag_Virtualization_use
[] =
15150 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15151 "TrustZone and Virtualization Extensions"};
15152 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15153 {"Not Allowed", "Allowed"};
15155 static const char * arm_attr_tag_MVE_arch
[] =
15156 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15158 #define LOOKUP(id, name) \
15159 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15160 static arm_attr_public_tag arm_attr_public_tags
[] =
15162 {4, "CPU_raw_name", 1, NULL
},
15163 {5, "CPU_name", 1, NULL
},
15164 LOOKUP(6, CPU_arch
),
15165 {7, "CPU_arch_profile", 0, NULL
},
15166 LOOKUP(8, ARM_ISA_use
),
15167 LOOKUP(9, THUMB_ISA_use
),
15168 LOOKUP(10, FP_arch
),
15169 LOOKUP(11, WMMX_arch
),
15170 LOOKUP(12, Advanced_SIMD_arch
),
15171 LOOKUP(13, PCS_config
),
15172 LOOKUP(14, ABI_PCS_R9_use
),
15173 LOOKUP(15, ABI_PCS_RW_data
),
15174 LOOKUP(16, ABI_PCS_RO_data
),
15175 LOOKUP(17, ABI_PCS_GOT_use
),
15176 LOOKUP(18, ABI_PCS_wchar_t
),
15177 LOOKUP(19, ABI_FP_rounding
),
15178 LOOKUP(20, ABI_FP_denormal
),
15179 LOOKUP(21, ABI_FP_exceptions
),
15180 LOOKUP(22, ABI_FP_user_exceptions
),
15181 LOOKUP(23, ABI_FP_number_model
),
15182 {24, "ABI_align_needed", 0, NULL
},
15183 {25, "ABI_align_preserved", 0, NULL
},
15184 LOOKUP(26, ABI_enum_size
),
15185 LOOKUP(27, ABI_HardFP_use
),
15186 LOOKUP(28, ABI_VFP_args
),
15187 LOOKUP(29, ABI_WMMX_args
),
15188 LOOKUP(30, ABI_optimization_goals
),
15189 LOOKUP(31, ABI_FP_optimization_goals
),
15190 {32, "compatibility", 0, NULL
},
15191 LOOKUP(34, CPU_unaligned_access
),
15192 LOOKUP(36, FP_HP_extension
),
15193 LOOKUP(38, ABI_FP_16bit_format
),
15194 LOOKUP(42, MPextension_use
),
15195 LOOKUP(44, DIV_use
),
15196 LOOKUP(46, DSP_extension
),
15197 LOOKUP(48, MVE_arch
),
15198 {64, "nodefaults", 0, NULL
},
15199 {65, "also_compatible_with", 0, NULL
},
15200 LOOKUP(66, T2EE_use
),
15201 {67, "conformance", 1, NULL
},
15202 LOOKUP(68, Virtualization_use
),
15203 LOOKUP(70, MPextension_use_legacy
)
15207 static unsigned char *
15208 display_arm_attribute (unsigned char * p
,
15209 const unsigned char * const end
)
15213 arm_attr_public_tag
* attr
;
15217 READ_ULEB (tag
, p
, end
);
15219 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15221 if (arm_attr_public_tags
[i
].tag
== tag
)
15223 attr
= &arm_attr_public_tags
[i
];
15230 printf (" Tag_%s: ", attr
->name
);
15231 switch (attr
->type
)
15236 case 7: /* Tag_CPU_arch_profile. */
15237 READ_ULEB (val
, p
, end
);
15240 case 0: printf (_("None\n")); break;
15241 case 'A': printf (_("Application\n")); break;
15242 case 'R': printf (_("Realtime\n")); break;
15243 case 'M': printf (_("Microcontroller\n")); break;
15244 case 'S': printf (_("Application or Realtime\n")); break;
15245 default: printf ("??? (%d)\n", val
); break;
15249 case 24: /* Tag_align_needed. */
15250 READ_ULEB (val
, p
, end
);
15253 case 0: printf (_("None\n")); break;
15254 case 1: printf (_("8-byte\n")); break;
15255 case 2: printf (_("4-byte\n")); break;
15256 case 3: printf ("??? 3\n"); break;
15259 printf (_("8-byte and up to %d-byte extended\n"),
15262 printf ("??? (%d)\n", val
);
15267 case 25: /* Tag_align_preserved. */
15268 READ_ULEB (val
, p
, end
);
15271 case 0: printf (_("None\n")); break;
15272 case 1: printf (_("8-byte, except leaf SP\n")); break;
15273 case 2: printf (_("8-byte\n")); break;
15274 case 3: printf ("??? 3\n"); break;
15277 printf (_("8-byte and up to %d-byte extended\n"),
15280 printf ("??? (%d)\n", val
);
15285 case 32: /* Tag_compatibility. */
15287 READ_ULEB (val
, p
, end
);
15288 printf (_("flag = %d, vendor = "), val
);
15291 size_t maxlen
= (end
- p
) - 1;
15293 print_symbol ((int) maxlen
, (const char *) p
);
15294 p
+= strnlen ((char *) p
, maxlen
) + 1;
15298 printf (_("<corrupt>"));
15299 p
= (unsigned char *) end
;
15305 case 64: /* Tag_nodefaults. */
15306 /* PR 17531: file: 001-505008-0.01. */
15309 printf (_("True\n"));
15312 case 65: /* Tag_also_compatible_with. */
15313 READ_ULEB (val
, p
, end
);
15314 if (val
== 6 /* Tag_CPU_arch. */)
15316 READ_ULEB (val
, p
, end
);
15317 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15318 printf ("??? (%d)\n", val
);
15320 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15324 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15329 printf (_("<unknown: %d>\n"), tag
);
15335 return display_tag_value (-1, p
, end
);
15337 return display_tag_value (0, p
, end
);
15340 assert (attr
->type
& 0x80);
15341 READ_ULEB (val
, p
, end
);
15342 type
= attr
->type
& 0x7f;
15344 printf ("??? (%d)\n", val
);
15346 printf ("%s\n", attr
->table
[val
]);
15351 return display_tag_value (tag
, p
, end
);
15354 static unsigned char *
15355 display_gnu_attribute (unsigned char * p
,
15356 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15357 const unsigned char * const end
)
15362 READ_ULEB (tag
, p
, end
);
15364 /* Tag_compatibility is the only generic GNU attribute defined at
15368 READ_ULEB (val
, p
, end
);
15370 printf (_("flag = %d, vendor = "), val
);
15373 printf (_("<corrupt>\n"));
15374 warn (_("corrupt vendor attribute\n"));
15380 size_t maxlen
= (end
- p
) - 1;
15382 print_symbol ((int) maxlen
, (const char *) p
);
15383 p
+= strnlen ((char *) p
, maxlen
) + 1;
15387 printf (_("<corrupt>"));
15388 p
= (unsigned char *) end
;
15395 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15396 return display_proc_gnu_attribute (p
, tag
, end
);
15398 return display_tag_value (tag
, p
, end
);
15401 static unsigned char *
15402 display_power_gnu_attribute (unsigned char * p
,
15404 const unsigned char * const end
)
15408 if (tag
== Tag_GNU_Power_ABI_FP
)
15410 printf (" Tag_GNU_Power_ABI_FP: ");
15413 printf (_("<corrupt>\n"));
15416 READ_ULEB (val
, p
, end
);
15419 printf ("(%#x), ", val
);
15424 printf (_("unspecified hard/soft float, "));
15427 printf (_("hard float, "));
15430 printf (_("soft float, "));
15433 printf (_("single-precision hard float, "));
15440 printf (_("unspecified long double\n"));
15443 printf (_("128-bit IBM long double\n"));
15446 printf (_("64-bit long double\n"));
15449 printf (_("128-bit IEEE long double\n"));
15455 if (tag
== Tag_GNU_Power_ABI_Vector
)
15457 printf (" Tag_GNU_Power_ABI_Vector: ");
15460 printf (_("<corrupt>\n"));
15463 READ_ULEB (val
, p
, end
);
15466 printf ("(%#x), ", val
);
15471 printf (_("unspecified\n"));
15474 printf (_("generic\n"));
15477 printf ("AltiVec\n");
15486 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15488 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15491 printf (_("<corrupt>\n"));
15494 READ_ULEB (val
, p
, end
);
15497 printf ("(%#x), ", val
);
15502 printf (_("unspecified\n"));
15505 printf ("r3/r4\n");
15508 printf (_("memory\n"));
15517 return display_tag_value (tag
& 1, p
, end
);
15520 static unsigned char *
15521 display_s390_gnu_attribute (unsigned char * p
,
15523 const unsigned char * const end
)
15527 if (tag
== Tag_GNU_S390_ABI_Vector
)
15529 printf (" Tag_GNU_S390_ABI_Vector: ");
15530 READ_ULEB (val
, p
, end
);
15535 printf (_("any\n"));
15538 printf (_("software\n"));
15541 printf (_("hardware\n"));
15544 printf ("??? (%d)\n", val
);
15550 return display_tag_value (tag
& 1, p
, end
);
15554 display_sparc_hwcaps (unsigned int mask
)
15558 bfd_boolean first
= TRUE
;
15560 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15561 fputs ("mul32", stdout
), first
= FALSE
;
15562 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15563 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15564 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15565 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15566 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15567 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15568 if (mask
& ELF_SPARC_HWCAP_POPC
)
15569 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15570 if (mask
& ELF_SPARC_HWCAP_VIS
)
15571 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15572 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15573 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15574 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15575 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15576 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15577 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15578 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15579 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15580 if (mask
& ELF_SPARC_HWCAP_HPC
)
15581 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15582 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15583 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15584 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15585 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15586 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15587 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15588 if (mask
& ELF_SPARC_HWCAP_IMA
)
15589 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15590 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15591 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15594 fputc ('0', stdout
);
15595 fputc ('\n', stdout
);
15599 display_sparc_hwcaps2 (unsigned int mask
)
15603 bfd_boolean first
= TRUE
;
15605 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15606 fputs ("fjathplus", stdout
), first
= FALSE
;
15607 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15608 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15609 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15610 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15611 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15612 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15613 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15614 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15615 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15616 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15617 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15618 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15619 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15620 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15621 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15622 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15623 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15624 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15625 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15626 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15629 fputc ('0', stdout
);
15630 fputc ('\n', stdout
);
15633 static unsigned char *
15634 display_sparc_gnu_attribute (unsigned char * p
,
15636 const unsigned char * const end
)
15640 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15642 READ_ULEB (val
, p
, end
);
15643 printf (" Tag_GNU_Sparc_HWCAPS: ");
15644 display_sparc_hwcaps (val
);
15647 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15649 READ_ULEB (val
, p
, end
);
15650 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15651 display_sparc_hwcaps2 (val
);
15655 return display_tag_value (tag
, p
, end
);
15659 print_mips_fp_abi_value (unsigned int val
)
15663 case Val_GNU_MIPS_ABI_FP_ANY
:
15664 printf (_("Hard or soft float\n"));
15666 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15667 printf (_("Hard float (double precision)\n"));
15669 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15670 printf (_("Hard float (single precision)\n"));
15672 case Val_GNU_MIPS_ABI_FP_SOFT
:
15673 printf (_("Soft float\n"));
15675 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15676 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15678 case Val_GNU_MIPS_ABI_FP_XX
:
15679 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15681 case Val_GNU_MIPS_ABI_FP_64
:
15682 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15684 case Val_GNU_MIPS_ABI_FP_64A
:
15685 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15687 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15688 printf (_("NaN 2008 compatibility\n"));
15691 printf ("??? (%d)\n", val
);
15696 static unsigned char *
15697 display_mips_gnu_attribute (unsigned char * p
,
15699 const unsigned char * const end
)
15701 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15705 printf (" Tag_GNU_MIPS_ABI_FP: ");
15706 READ_ULEB (val
, p
, end
);
15707 print_mips_fp_abi_value (val
);
15711 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15715 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15716 READ_ULEB (val
, p
, end
);
15720 case Val_GNU_MIPS_ABI_MSA_ANY
:
15721 printf (_("Any MSA or not\n"));
15723 case Val_GNU_MIPS_ABI_MSA_128
:
15724 printf (_("128-bit MSA\n"));
15727 printf ("??? (%d)\n", val
);
15733 return display_tag_value (tag
& 1, p
, end
);
15736 static unsigned char *
15737 display_tic6x_attribute (unsigned char * p
,
15738 const unsigned char * const end
)
15743 READ_ULEB (tag
, p
, end
);
15748 printf (" Tag_ISA: ");
15749 READ_ULEB (val
, p
, end
);
15753 case C6XABI_Tag_ISA_none
:
15754 printf (_("None\n"));
15756 case C6XABI_Tag_ISA_C62X
:
15759 case C6XABI_Tag_ISA_C67X
:
15762 case C6XABI_Tag_ISA_C67XP
:
15763 printf ("C67x+\n");
15765 case C6XABI_Tag_ISA_C64X
:
15768 case C6XABI_Tag_ISA_C64XP
:
15769 printf ("C64x+\n");
15771 case C6XABI_Tag_ISA_C674X
:
15772 printf ("C674x\n");
15775 printf ("??? (%d)\n", val
);
15780 case Tag_ABI_wchar_t
:
15781 printf (" Tag_ABI_wchar_t: ");
15782 READ_ULEB (val
, p
, end
);
15786 printf (_("Not used\n"));
15789 printf (_("2 bytes\n"));
15792 printf (_("4 bytes\n"));
15795 printf ("??? (%d)\n", val
);
15800 case Tag_ABI_stack_align_needed
:
15801 printf (" Tag_ABI_stack_align_needed: ");
15802 READ_ULEB (val
, p
, end
);
15806 printf (_("8-byte\n"));
15809 printf (_("16-byte\n"));
15812 printf ("??? (%d)\n", val
);
15817 case Tag_ABI_stack_align_preserved
:
15818 READ_ULEB (val
, p
, end
);
15819 printf (" Tag_ABI_stack_align_preserved: ");
15823 printf (_("8-byte\n"));
15826 printf (_("16-byte\n"));
15829 printf ("??? (%d)\n", val
);
15835 READ_ULEB (val
, p
, end
);
15836 printf (" Tag_ABI_DSBT: ");
15840 printf (_("DSBT addressing not used\n"));
15843 printf (_("DSBT addressing used\n"));
15846 printf ("??? (%d)\n", val
);
15852 READ_ULEB (val
, p
, end
);
15853 printf (" Tag_ABI_PID: ");
15857 printf (_("Data addressing position-dependent\n"));
15860 printf (_("Data addressing position-independent, GOT near DP\n"));
15863 printf (_("Data addressing position-independent, GOT far from DP\n"));
15866 printf ("??? (%d)\n", val
);
15872 READ_ULEB (val
, p
, end
);
15873 printf (" Tag_ABI_PIC: ");
15877 printf (_("Code addressing position-dependent\n"));
15880 printf (_("Code addressing position-independent\n"));
15883 printf ("??? (%d)\n", val
);
15888 case Tag_ABI_array_object_alignment
:
15889 READ_ULEB (val
, p
, end
);
15890 printf (" Tag_ABI_array_object_alignment: ");
15894 printf (_("8-byte\n"));
15897 printf (_("4-byte\n"));
15900 printf (_("16-byte\n"));
15903 printf ("??? (%d)\n", val
);
15908 case Tag_ABI_array_object_align_expected
:
15909 READ_ULEB (val
, p
, end
);
15910 printf (" Tag_ABI_array_object_align_expected: ");
15914 printf (_("8-byte\n"));
15917 printf (_("4-byte\n"));
15920 printf (_("16-byte\n"));
15923 printf ("??? (%d)\n", val
);
15928 case Tag_ABI_compatibility
:
15930 READ_ULEB (val
, p
, end
);
15931 printf (" Tag_ABI_compatibility: ");
15932 printf (_("flag = %d, vendor = "), val
);
15935 size_t maxlen
= (end
- p
) - 1;
15937 print_symbol ((int) maxlen
, (const char *) p
);
15938 p
+= strnlen ((char *) p
, maxlen
) + 1;
15942 printf (_("<corrupt>"));
15943 p
= (unsigned char *) end
;
15949 case Tag_ABI_conformance
:
15951 printf (" Tag_ABI_conformance: \"");
15954 size_t maxlen
= (end
- p
) - 1;
15956 print_symbol ((int) maxlen
, (const char *) p
);
15957 p
+= strnlen ((char *) p
, maxlen
) + 1;
15961 printf (_("<corrupt>"));
15962 p
= (unsigned char *) end
;
15969 return display_tag_value (tag
, p
, end
);
15973 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15975 unsigned long addr
= 0;
15976 size_t bytes
= end
- p
;
15983 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15985 printf (" 0x%8.8lx ", addr
);
15987 for (j
= 0; j
< 16; j
++)
15990 printf ("%2.2x", p
[j
]);
15998 for (j
= 0; j
< lbytes
; j
++)
16001 if (k
>= ' ' && k
< 0x7f)
16017 static unsigned char *
16018 display_msp430x_attribute (unsigned char * p
,
16019 const unsigned char * const end
)
16024 READ_ULEB (tag
, p
, end
);
16028 case OFBA_MSPABI_Tag_ISA
:
16029 printf (" Tag_ISA: ");
16030 READ_ULEB (val
, p
, end
);
16033 case 0: printf (_("None\n")); break;
16034 case 1: printf (_("MSP430\n")); break;
16035 case 2: printf (_("MSP430X\n")); break;
16036 default: printf ("??? (%d)\n", val
); break;
16040 case OFBA_MSPABI_Tag_Code_Model
:
16041 printf (" Tag_Code_Model: ");
16042 READ_ULEB (val
, p
, end
);
16045 case 0: printf (_("None\n")); break;
16046 case 1: printf (_("Small\n")); break;
16047 case 2: printf (_("Large\n")); break;
16048 default: printf ("??? (%d)\n", val
); break;
16052 case OFBA_MSPABI_Tag_Data_Model
:
16053 printf (" Tag_Data_Model: ");
16054 READ_ULEB (val
, p
, end
);
16057 case 0: printf (_("None\n")); break;
16058 case 1: printf (_("Small\n")); break;
16059 case 2: printf (_("Large\n")); break;
16060 case 3: printf (_("Restricted Large\n")); break;
16061 default: printf ("??? (%d)\n", val
); break;
16066 printf (_(" <unknown tag %d>: "), tag
);
16073 size_t maxlen
= (end
- p
) - 1;
16075 print_symbol ((int) maxlen
, (const char *) p
);
16076 p
+= strnlen ((char *) p
, maxlen
) + 1;
16080 printf (_("<corrupt>"));
16081 p
= (unsigned char *) end
;
16087 READ_ULEB (val
, p
, end
);
16088 printf ("%d (0x%x)\n", val
, val
);
16097 static unsigned char *
16098 display_msp430_gnu_attribute (unsigned char * p
,
16100 const unsigned char * const end
)
16102 if (tag
== Tag_GNU_MSP430_Data_Region
)
16106 printf (" Tag_GNU_MSP430_Data_Region: ");
16107 READ_ULEB (val
, p
, end
);
16111 case Val_GNU_MSP430_Data_Region_Any
:
16112 printf (_("Any Region\n"));
16114 case Val_GNU_MSP430_Data_Region_Lower
:
16115 printf (_("Lower Region Only\n"));
16118 printf ("??? (%u)\n", val
);
16122 return display_tag_value (tag
& 1, p
, end
);
16125 struct riscv_attr_tag_t
{
16130 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16132 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16135 T(priv_spec_minor
),
16136 T(priv_spec_revision
),
16137 T(unaligned_access
),
16142 static unsigned char *
16143 display_riscv_attribute (unsigned char *p
,
16144 const unsigned char * const end
)
16148 struct riscv_attr_tag_t
*attr
= NULL
;
16151 READ_ULEB (tag
, p
, end
);
16153 /* Find the name of attribute. */
16154 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16156 if (riscv_attr_tag
[i
].tag
== tag
)
16158 attr
= &riscv_attr_tag
[i
];
16164 printf (" %s: ", attr
->name
);
16166 return display_tag_value (tag
, p
, end
);
16170 case Tag_RISCV_priv_spec
:
16171 case Tag_RISCV_priv_spec_minor
:
16172 case Tag_RISCV_priv_spec_revision
:
16173 READ_ULEB (val
, p
, end
);
16174 printf (_("%u\n"), val
);
16176 case Tag_RISCV_unaligned_access
:
16177 READ_ULEB (val
, p
, end
);
16181 printf (_("No unaligned access\n"));
16184 printf (_("Unaligned access\n"));
16188 case Tag_RISCV_stack_align
:
16189 READ_ULEB (val
, p
, end
);
16190 printf (_("%u-bytes\n"), val
);
16192 case Tag_RISCV_arch
:
16193 p
= display_tag_value (-1, p
, end
);
16196 return display_tag_value (tag
, p
, end
);
16203 process_attributes (Filedata
* filedata
,
16204 const char * public_name
,
16205 unsigned int proc_type
,
16206 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16207 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16209 Elf_Internal_Shdr
* sect
;
16211 bfd_boolean res
= TRUE
;
16213 /* Find the section header so that we get the size. */
16214 for (i
= 0, sect
= filedata
->section_headers
;
16215 i
< filedata
->file_header
.e_shnum
;
16218 unsigned char * contents
;
16221 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16224 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16225 sect
->sh_size
, _("attributes"));
16226 if (contents
== NULL
)
16233 /* The first character is the version of the attributes.
16234 Currently only version 1, (aka 'A') is recognised here. */
16237 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16242 bfd_vma section_len
;
16244 section_len
= sect
->sh_size
- 1;
16247 while (section_len
> 0)
16250 unsigned int namelen
;
16251 bfd_boolean public_section
;
16252 bfd_boolean gnu_section
;
16254 if (section_len
<= 4)
16256 error (_("Tag section ends prematurely\n"));
16260 attr_len
= byte_get (p
, 4);
16263 if (attr_len
> section_len
)
16265 error (_("Bad attribute length (%u > %u)\n"),
16266 (unsigned) attr_len
, (unsigned) section_len
);
16267 attr_len
= section_len
;
16270 /* PR 17531: file: 001-101425-0.004 */
16271 else if (attr_len
< 5)
16273 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16278 section_len
-= attr_len
;
16281 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16282 if (namelen
== 0 || namelen
>= attr_len
)
16284 error (_("Corrupt attribute section name\n"));
16289 printf (_("Attribute Section: "));
16290 print_symbol (INT_MAX
, (const char *) p
);
16293 if (public_name
&& streq ((char *) p
, public_name
))
16294 public_section
= TRUE
;
16296 public_section
= FALSE
;
16298 if (streq ((char *) p
, "gnu"))
16299 gnu_section
= TRUE
;
16301 gnu_section
= FALSE
;
16304 attr_len
-= namelen
;
16306 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16311 unsigned char * end
;
16313 /* PR binutils/17531: Safe handling of corrupt files. */
16316 error (_("Unused bytes at end of section\n"));
16323 size
= byte_get (p
, 4);
16324 if (size
> attr_len
)
16326 error (_("Bad subsection length (%u > %u)\n"),
16327 (unsigned) size
, (unsigned) attr_len
);
16331 /* PR binutils/17531: Safe handling of corrupt files. */
16334 error (_("Bad subsection length (%u < 6)\n"),
16342 end
= p
+ size
- 1;
16343 assert (end
<= contents
+ sect
->sh_size
);
16349 printf (_("File Attributes\n"));
16352 printf (_("Section Attributes:"));
16355 printf (_("Symbol Attributes:"));
16356 /* Fall through. */
16360 READ_ULEB (val
, p
, end
);
16363 printf (" %d", val
);
16368 printf (_("Unknown tag: %d\n"), tag
);
16369 public_section
= FALSE
;
16373 if (public_section
&& display_pub_attribute
!= NULL
)
16376 p
= display_pub_attribute (p
, end
);
16379 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16382 p
= display_gnu_attribute (p
,
16383 display_proc_gnu_attribute
,
16389 printf (_(" Unknown attribute:\n"));
16390 display_raw_attribute (p
, end
);
16405 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16406 Print the Address, Access and Initial fields of an entry at VMA ADDR
16407 and return the VMA of the next entry, or -1 if there was a problem.
16408 Does not read from DATA_END or beyond. */
16411 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16412 unsigned char * data_end
)
16415 print_vma (addr
, LONG_HEX
);
16417 if (addr
< pltgot
+ 0xfff0)
16418 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16420 printf ("%10s", "");
16423 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16427 unsigned char * from
= data
+ addr
- pltgot
;
16429 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16431 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16432 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16433 return (bfd_vma
) -1;
16437 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16438 print_vma (entry
, LONG_HEX
);
16441 return addr
+ (is_32bit_elf
? 4 : 8);
16444 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16445 PLTGOT. Print the Address and Initial fields of an entry at VMA
16446 ADDR and return the VMA of the next entry. */
16449 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16452 print_vma (addr
, LONG_HEX
);
16455 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16460 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16461 print_vma (entry
, LONG_HEX
);
16463 return addr
+ (is_32bit_elf
? 4 : 8);
16467 print_mips_ases (unsigned int mask
)
16469 if (mask
& AFL_ASE_DSP
)
16470 fputs ("\n\tDSP ASE", stdout
);
16471 if (mask
& AFL_ASE_DSPR2
)
16472 fputs ("\n\tDSP R2 ASE", stdout
);
16473 if (mask
& AFL_ASE_DSPR3
)
16474 fputs ("\n\tDSP R3 ASE", stdout
);
16475 if (mask
& AFL_ASE_EVA
)
16476 fputs ("\n\tEnhanced VA Scheme", stdout
);
16477 if (mask
& AFL_ASE_MCU
)
16478 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16479 if (mask
& AFL_ASE_MDMX
)
16480 fputs ("\n\tMDMX ASE", stdout
);
16481 if (mask
& AFL_ASE_MIPS3D
)
16482 fputs ("\n\tMIPS-3D ASE", stdout
);
16483 if (mask
& AFL_ASE_MT
)
16484 fputs ("\n\tMT ASE", stdout
);
16485 if (mask
& AFL_ASE_SMARTMIPS
)
16486 fputs ("\n\tSmartMIPS ASE", stdout
);
16487 if (mask
& AFL_ASE_VIRT
)
16488 fputs ("\n\tVZ ASE", stdout
);
16489 if (mask
& AFL_ASE_MSA
)
16490 fputs ("\n\tMSA ASE", stdout
);
16491 if (mask
& AFL_ASE_MIPS16
)
16492 fputs ("\n\tMIPS16 ASE", stdout
);
16493 if (mask
& AFL_ASE_MICROMIPS
)
16494 fputs ("\n\tMICROMIPS ASE", stdout
);
16495 if (mask
& AFL_ASE_XPA
)
16496 fputs ("\n\tXPA ASE", stdout
);
16497 if (mask
& AFL_ASE_MIPS16E2
)
16498 fputs ("\n\tMIPS16e2 ASE", stdout
);
16499 if (mask
& AFL_ASE_CRC
)
16500 fputs ("\n\tCRC ASE", stdout
);
16501 if (mask
& AFL_ASE_GINV
)
16502 fputs ("\n\tGINV ASE", stdout
);
16503 if (mask
& AFL_ASE_LOONGSON_MMI
)
16504 fputs ("\n\tLoongson MMI ASE", stdout
);
16505 if (mask
& AFL_ASE_LOONGSON_CAM
)
16506 fputs ("\n\tLoongson CAM ASE", stdout
);
16507 if (mask
& AFL_ASE_LOONGSON_EXT
)
16508 fputs ("\n\tLoongson EXT ASE", stdout
);
16509 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16510 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16512 fprintf (stdout
, "\n\t%s", _("None"));
16513 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16514 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16518 print_mips_isa_ext (unsigned int isa_ext
)
16523 fputs (_("None"), stdout
);
16526 fputs ("RMI XLR", stdout
);
16528 case AFL_EXT_OCTEON3
:
16529 fputs ("Cavium Networks Octeon3", stdout
);
16531 case AFL_EXT_OCTEON2
:
16532 fputs ("Cavium Networks Octeon2", stdout
);
16534 case AFL_EXT_OCTEONP
:
16535 fputs ("Cavium Networks OcteonP", stdout
);
16537 case AFL_EXT_OCTEON
:
16538 fputs ("Cavium Networks Octeon", stdout
);
16541 fputs ("Toshiba R5900", stdout
);
16544 fputs ("MIPS R4650", stdout
);
16547 fputs ("LSI R4010", stdout
);
16550 fputs ("NEC VR4100", stdout
);
16553 fputs ("Toshiba R3900", stdout
);
16555 case AFL_EXT_10000
:
16556 fputs ("MIPS R10000", stdout
);
16559 fputs ("Broadcom SB-1", stdout
);
16562 fputs ("NEC VR4111/VR4181", stdout
);
16565 fputs ("NEC VR4120", stdout
);
16568 fputs ("NEC VR5400", stdout
);
16571 fputs ("NEC VR5500", stdout
);
16573 case AFL_EXT_LOONGSON_2E
:
16574 fputs ("ST Microelectronics Loongson 2E", stdout
);
16576 case AFL_EXT_LOONGSON_2F
:
16577 fputs ("ST Microelectronics Loongson 2F", stdout
);
16579 case AFL_EXT_INTERAPTIV_MR2
:
16580 fputs ("Imagination interAptiv MR2", stdout
);
16583 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16588 get_mips_reg_size (int reg_size
)
16590 return (reg_size
== AFL_REG_NONE
) ? 0
16591 : (reg_size
== AFL_REG_32
) ? 32
16592 : (reg_size
== AFL_REG_64
) ? 64
16593 : (reg_size
== AFL_REG_128
) ? 128
16598 process_mips_specific (Filedata
* filedata
)
16600 Elf_Internal_Dyn
* entry
;
16601 Elf_Internal_Shdr
*sect
= NULL
;
16602 size_t liblist_offset
= 0;
16603 size_t liblistno
= 0;
16604 size_t conflictsno
= 0;
16605 size_t options_offset
= 0;
16606 size_t conflicts_offset
= 0;
16607 size_t pltrelsz
= 0;
16609 bfd_vma pltgot
= 0;
16610 bfd_vma mips_pltgot
= 0;
16611 bfd_vma jmprel
= 0;
16612 bfd_vma local_gotno
= 0;
16613 bfd_vma gotsym
= 0;
16614 bfd_vma symtabno
= 0;
16615 bfd_boolean res
= TRUE
;
16617 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16618 display_mips_gnu_attribute
))
16621 sect
= find_section (filedata
, ".MIPS.abiflags");
16625 Elf_External_ABIFlags_v0
*abiflags_ext
;
16626 Elf_Internal_ABIFlags_v0 abiflags_in
;
16628 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16630 error (_("Corrupt MIPS ABI Flags section.\n"));
16635 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16636 sect
->sh_size
, _("MIPS ABI Flags section"));
16639 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16640 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16641 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16642 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16643 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16644 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16645 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16646 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16647 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16648 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16649 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16651 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16652 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16653 if (abiflags_in
.isa_rev
> 1)
16654 printf ("r%d", abiflags_in
.isa_rev
);
16655 printf ("\nGPR size: %d",
16656 get_mips_reg_size (abiflags_in
.gpr_size
));
16657 printf ("\nCPR1 size: %d",
16658 get_mips_reg_size (abiflags_in
.cpr1_size
));
16659 printf ("\nCPR2 size: %d",
16660 get_mips_reg_size (abiflags_in
.cpr2_size
));
16661 fputs ("\nFP ABI: ", stdout
);
16662 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16663 fputs ("ISA Extension: ", stdout
);
16664 print_mips_isa_ext (abiflags_in
.isa_ext
);
16665 fputs ("\nASEs:", stdout
);
16666 print_mips_ases (abiflags_in
.ases
);
16667 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16668 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16669 fputc ('\n', stdout
);
16670 free (abiflags_ext
);
16675 /* We have a lot of special sections. Thanks SGI! */
16676 if (filedata
->dynamic_section
== NULL
)
16678 /* No dynamic information available. See if there is static GOT. */
16679 sect
= find_section (filedata
, ".got");
16682 unsigned char *data_end
;
16683 unsigned char *data
;
16687 pltgot
= sect
->sh_addr
;
16690 addr_size
= (is_32bit_elf
? 4 : 8);
16691 end
= pltgot
+ sect
->sh_size
;
16693 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16695 _("Global Offset Table data"));
16696 /* PR 12855: Null data is handled gracefully throughout. */
16697 data_end
= data
+ (end
- pltgot
);
16699 printf (_("\nStatic GOT:\n"));
16700 printf (_(" Canonical gp value: "));
16701 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16704 /* In a dynamic binary GOT[0] is reserved for the dynamic
16705 loader to store the lazy resolver pointer, however in
16706 a static binary it may well have been omitted and GOT
16707 reduced to a table of addresses.
16708 PR 21344: Check for the entry being fully available
16709 before fetching it. */
16711 && data
+ ent
- pltgot
+ addr_size
<= data_end
16712 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16714 printf (_(" Reserved entries:\n"));
16715 printf (_(" %*s %10s %*s\n"),
16716 addr_size
* 2, _("Address"), _("Access"),
16717 addr_size
* 2, _("Value"));
16718 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16720 if (ent
== (bfd_vma
) -1)
16721 goto sgot_print_fail
;
16723 /* Check for the MSB of GOT[1] being set, identifying a
16724 GNU object. This entry will be used by some runtime
16725 loaders, to store the module pointer. Otherwise this
16726 is an ordinary local entry.
16727 PR 21344: Check for the entry being fully available
16728 before fetching it. */
16730 && data
+ ent
- pltgot
+ addr_size
<= data_end
16731 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16732 >> (addr_size
* 8 - 1)) != 0)
16734 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16736 if (ent
== (bfd_vma
) -1)
16737 goto sgot_print_fail
;
16742 if (data
!= NULL
&& ent
< end
)
16744 printf (_(" Local entries:\n"));
16745 printf (" %*s %10s %*s\n",
16746 addr_size
* 2, _("Address"), _("Access"),
16747 addr_size
* 2, _("Value"));
16750 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16752 if (ent
== (bfd_vma
) -1)
16753 goto sgot_print_fail
;
16765 for (entry
= filedata
->dynamic_section
;
16766 /* PR 17531 file: 012-50589-0.004. */
16767 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16768 && entry
->d_tag
!= DT_NULL
);
16770 switch (entry
->d_tag
)
16772 case DT_MIPS_LIBLIST
:
16774 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16775 liblistno
* sizeof (Elf32_External_Lib
));
16777 case DT_MIPS_LIBLISTNO
:
16778 liblistno
= entry
->d_un
.d_val
;
16780 case DT_MIPS_OPTIONS
:
16781 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16783 case DT_MIPS_CONFLICT
:
16785 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16786 conflictsno
* sizeof (Elf32_External_Conflict
));
16788 case DT_MIPS_CONFLICTNO
:
16789 conflictsno
= entry
->d_un
.d_val
;
16792 pltgot
= entry
->d_un
.d_ptr
;
16794 case DT_MIPS_LOCAL_GOTNO
:
16795 local_gotno
= entry
->d_un
.d_val
;
16797 case DT_MIPS_GOTSYM
:
16798 gotsym
= entry
->d_un
.d_val
;
16800 case DT_MIPS_SYMTABNO
:
16801 symtabno
= entry
->d_un
.d_val
;
16803 case DT_MIPS_PLTGOT
:
16804 mips_pltgot
= entry
->d_un
.d_ptr
;
16807 pltrel
= entry
->d_un
.d_val
;
16810 pltrelsz
= entry
->d_un
.d_val
;
16813 jmprel
= entry
->d_un
.d_ptr
;
16819 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16821 Elf32_External_Lib
* elib
;
16824 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16825 sizeof (Elf32_External_Lib
),
16827 _("liblist section data"));
16830 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16831 "\nSection '.liblist' contains %lu entries:\n",
16832 (unsigned long) liblistno
),
16833 (unsigned long) liblistno
);
16834 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16837 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16844 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16845 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16846 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16847 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16848 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16850 tmp
= gmtime (&atime
);
16851 snprintf (timebuf
, sizeof (timebuf
),
16852 "%04u-%02u-%02uT%02u:%02u:%02u",
16853 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16854 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16856 printf ("%3lu: ", (unsigned long) cnt
);
16857 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
16858 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
16860 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16861 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16862 liblist
.l_version
);
16864 if (liblist
.l_flags
== 0)
16868 static const struct
16875 { " EXACT_MATCH", LL_EXACT_MATCH
},
16876 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16877 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16878 { " EXPORTS", LL_EXPORTS
},
16879 { " DELAY_LOAD", LL_DELAY_LOAD
},
16880 { " DELTA", LL_DELTA
}
16882 int flags
= liblist
.l_flags
;
16885 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16886 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16888 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16889 flags
^= l_flags_vals
[fcnt
].bit
;
16892 printf (" %#x", (unsigned int) flags
);
16904 if (options_offset
!= 0)
16906 Elf_External_Options
* eopt
;
16909 sect
= filedata
->section_headers
;
16911 /* Find the section header so that we get the size. */
16912 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16913 /* PR 17533 file: 012-277276-0.004. */
16916 error (_("No MIPS_OPTIONS header found\n"));
16920 if (sect
->sh_size
< sizeof (* eopt
))
16922 error (_("The MIPS options section is too small.\n"));
16926 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16927 sect
->sh_size
, _("options"));
16930 Elf_Internal_Options
* iopt
;
16931 Elf_Internal_Options
* option
;
16932 Elf_Internal_Options
* iopt_end
;
16934 iopt
= (Elf_Internal_Options
*)
16935 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16938 error (_("Out of memory allocating space for MIPS options\n"));
16945 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16947 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16949 Elf_External_Options
* eoption
;
16951 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16953 option
->kind
= BYTE_GET (eoption
->kind
);
16954 option
->size
= BYTE_GET (eoption
->size
);
16955 option
->section
= BYTE_GET (eoption
->section
);
16956 option
->info
= BYTE_GET (eoption
->info
);
16958 /* PR 17531: file: ffa0fa3b. */
16959 if (option
->size
< sizeof (* eopt
)
16960 || offset
+ option
->size
> sect
->sh_size
)
16962 error (_("Invalid size (%u) for MIPS option\n"),
16968 offset
+= option
->size
;
16974 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16975 "\nSection '%s' contains %d entries:\n",
16977 printable_section_name (filedata
, sect
), cnt
);
16986 switch (option
->kind
)
16989 /* This shouldn't happen. */
16990 printf (" NULL %d %lx", option
->section
, option
->info
);
16994 printf (" REGINFO ");
16995 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16997 Elf32_External_RegInfo
* ereg
;
16998 Elf32_RegInfo reginfo
;
17001 if (option
+ 2 > iopt_end
)
17003 printf (_("<corrupt>\n"));
17004 error (_("Truncated MIPS REGINFO option\n"));
17009 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
17011 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17012 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17013 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17014 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17015 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17016 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17018 printf ("GPR %08lx GP 0x%lx\n",
17019 reginfo
.ri_gprmask
,
17020 (unsigned long) reginfo
.ri_gp_value
);
17021 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
17022 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17023 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17028 Elf64_External_RegInfo
* ereg
;
17029 Elf64_Internal_RegInfo reginfo
;
17031 if (option
+ 2 > iopt_end
)
17033 printf (_("<corrupt>\n"));
17034 error (_("Truncated MIPS REGINFO option\n"));
17039 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
17040 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17041 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17042 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17043 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17044 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17045 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17047 printf ("GPR %08lx GP 0x",
17048 reginfo
.ri_gprmask
);
17049 printf_vma (reginfo
.ri_gp_value
);
17052 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
17053 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17054 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17059 case ODK_EXCEPTIONS
:
17060 fputs (" EXCEPTIONS fpe_min(", stdout
);
17061 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
17062 fputs (") fpe_max(", stdout
);
17063 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
17064 fputs (")", stdout
);
17066 if (option
->info
& OEX_PAGE0
)
17067 fputs (" PAGE0", stdout
);
17068 if (option
->info
& OEX_SMM
)
17069 fputs (" SMM", stdout
);
17070 if (option
->info
& OEX_FPDBUG
)
17071 fputs (" FPDBUG", stdout
);
17072 if (option
->info
& OEX_DISMISS
)
17073 fputs (" DISMISS", stdout
);
17077 fputs (" PAD ", stdout
);
17078 if (option
->info
& OPAD_PREFIX
)
17079 fputs (" PREFIX", stdout
);
17080 if (option
->info
& OPAD_POSTFIX
)
17081 fputs (" POSTFIX", stdout
);
17082 if (option
->info
& OPAD_SYMBOL
)
17083 fputs (" SYMBOL", stdout
);
17087 fputs (" HWPATCH ", stdout
);
17088 if (option
->info
& OHW_R4KEOP
)
17089 fputs (" R4KEOP", stdout
);
17090 if (option
->info
& OHW_R8KPFETCH
)
17091 fputs (" R8KPFETCH", stdout
);
17092 if (option
->info
& OHW_R5KEOP
)
17093 fputs (" R5KEOP", stdout
);
17094 if (option
->info
& OHW_R5KCVTL
)
17095 fputs (" R5KCVTL", stdout
);
17099 fputs (" FILL ", stdout
);
17100 /* XXX Print content of info word? */
17104 fputs (" TAGS ", stdout
);
17105 /* XXX Print content of info word? */
17109 fputs (" HWAND ", stdout
);
17110 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17111 fputs (" R4KEOP_CHECKED", stdout
);
17112 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17113 fputs (" R4KEOP_CLEAN", stdout
);
17117 fputs (" HWOR ", stdout
);
17118 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17119 fputs (" R4KEOP_CHECKED", stdout
);
17120 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17121 fputs (" R4KEOP_CLEAN", stdout
);
17125 printf (" GP_GROUP %#06lx self-contained %#06lx",
17126 option
->info
& OGP_GROUP
,
17127 (option
->info
& OGP_SELF
) >> 16);
17131 printf (" IDENT %#06lx self-contained %#06lx",
17132 option
->info
& OGP_GROUP
,
17133 (option
->info
& OGP_SELF
) >> 16);
17137 /* This shouldn't happen. */
17138 printf (" %3d ??? %d %lx",
17139 option
->kind
, option
->section
, option
->info
);
17143 len
= sizeof (* eopt
);
17144 while (len
< option
->size
)
17146 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17148 if (ISPRINT (datum
))
17149 printf ("%c", datum
);
17151 printf ("\\%03o", datum
);
17154 fputs ("\n", stdout
);
17156 offset
+= option
->size
;
17166 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17168 Elf32_Conflict
* iconf
;
17171 if (filedata
->dynamic_symbols
== NULL
)
17173 error (_("conflict list found without a dynamic symbol table\n"));
17177 /* PR 21345 - print a slightly more helpful error message
17178 if we are sure that the cmalloc will fail. */
17179 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17181 error (_("Overlarge number of conflicts detected: %lx\n"),
17182 (long) conflictsno
);
17186 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17189 error (_("Out of memory allocating space for dynamic conflicts\n"));
17195 Elf32_External_Conflict
* econf32
;
17197 econf32
= (Elf32_External_Conflict
*)
17198 get_data (NULL
, filedata
, conflicts_offset
,
17199 sizeof (*econf32
), conflictsno
, _("conflict"));
17206 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17207 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17213 Elf64_External_Conflict
* econf64
;
17215 econf64
= (Elf64_External_Conflict
*)
17216 get_data (NULL
, filedata
, conflicts_offset
,
17217 sizeof (*econf64
), conflictsno
, _("conflict"));
17224 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17225 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17230 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17231 "\nSection '.conflict' contains %lu entries:\n",
17232 (unsigned long) conflictsno
),
17233 (unsigned long) conflictsno
);
17234 puts (_(" Num: Index Value Name"));
17236 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17238 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17240 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17241 printf (_("<corrupt symbol index>"));
17244 Elf_Internal_Sym
* psym
;
17246 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17247 print_vma (psym
->st_value
, FULL_HEX
);
17249 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17250 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17252 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17260 if (pltgot
!= 0 && local_gotno
!= 0)
17262 bfd_vma ent
, local_end
, global_end
;
17264 unsigned char * data
;
17265 unsigned char * data_end
;
17269 addr_size
= (is_32bit_elf
? 4 : 8);
17270 local_end
= pltgot
+ local_gotno
* addr_size
;
17272 /* PR binutils/17533 file: 012-111227-0.004 */
17273 if (symtabno
< gotsym
)
17275 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17276 (unsigned long) gotsym
, (unsigned long) symtabno
);
17280 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17281 /* PR 17531: file: 54c91a34. */
17282 if (global_end
< local_end
)
17284 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17288 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17289 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17290 global_end
- pltgot
, 1,
17291 _("Global Offset Table data"));
17292 /* PR 12855: Null data is handled gracefully throughout. */
17293 data_end
= data
+ (global_end
- pltgot
);
17295 printf (_("\nPrimary GOT:\n"));
17296 printf (_(" Canonical gp value: "));
17297 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17300 printf (_(" Reserved entries:\n"));
17301 printf (_(" %*s %10s %*s Purpose\n"),
17302 addr_size
* 2, _("Address"), _("Access"),
17303 addr_size
* 2, _("Initial"));
17304 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17305 printf (_(" Lazy resolver\n"));
17306 if (ent
== (bfd_vma
) -1)
17307 goto got_print_fail
;
17309 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17310 This entry will be used by some runtime loaders, to store the
17311 module pointer. Otherwise this is an ordinary local entry.
17312 PR 21344: Check for the entry being fully available before
17315 && data
+ ent
- pltgot
+ addr_size
<= data_end
17316 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17317 >> (addr_size
* 8 - 1)) != 0)
17319 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17320 printf (_(" Module pointer (GNU extension)\n"));
17321 if (ent
== (bfd_vma
) -1)
17322 goto got_print_fail
;
17326 if (data
!= NULL
&& ent
< local_end
)
17328 printf (_(" Local entries:\n"));
17329 printf (" %*s %10s %*s\n",
17330 addr_size
* 2, _("Address"), _("Access"),
17331 addr_size
* 2, _("Initial"));
17332 while (ent
< local_end
)
17334 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17336 if (ent
== (bfd_vma
) -1)
17337 goto got_print_fail
;
17342 if (data
!= NULL
&& gotsym
< symtabno
)
17346 printf (_(" Global entries:\n"));
17347 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17348 addr_size
* 2, _("Address"),
17350 addr_size
* 2, _("Initial"),
17351 addr_size
* 2, _("Sym.Val."),
17353 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17354 _("Ndx"), _("Name"));
17356 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17358 for (i
= gotsym
; i
< symtabno
; i
++)
17360 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17363 if (filedata
->dynamic_symbols
== NULL
)
17364 printf (_("<no dynamic symbols>"));
17365 else if (i
< filedata
->num_dynamic_syms
)
17367 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17369 print_vma (psym
->st_value
, LONG_HEX
);
17370 printf (" %-7s %3s ",
17371 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17372 get_symbol_index_type (filedata
, psym
->st_shndx
));
17374 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17375 print_symbol (sym_width
,
17376 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17378 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17381 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17382 (unsigned long) i
);
17385 if (ent
== (bfd_vma
) -1)
17396 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17399 size_t offset
, rel_offset
;
17400 unsigned long count
, i
;
17401 unsigned char * data
;
17402 int addr_size
, sym_width
;
17403 Elf_Internal_Rela
* rels
;
17405 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17406 if (pltrel
== DT_RELA
)
17408 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17413 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17418 addr_size
= (is_32bit_elf
? 4 : 8);
17419 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17421 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17422 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17423 1, _("Procedure Linkage Table data"));
17427 printf ("\nPLT GOT:\n\n");
17428 printf (_(" Reserved entries:\n"));
17429 printf (_(" %*s %*s Purpose\n"),
17430 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17431 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17432 printf (_(" PLT lazy resolver\n"));
17433 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17434 printf (_(" Module pointer\n"));
17437 printf (_(" Entries:\n"));
17438 printf (" %*s %*s %*s %-7s %3s %s\n",
17439 addr_size
* 2, _("Address"),
17440 addr_size
* 2, _("Initial"),
17441 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17442 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17443 for (i
= 0; i
< count
; i
++)
17445 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17447 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17450 if (idx
>= filedata
->num_dynamic_syms
)
17451 printf (_("<corrupt symbol index: %lu>"), idx
);
17454 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17456 print_vma (psym
->st_value
, LONG_HEX
);
17457 printf (" %-7s %3s ",
17458 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17459 get_symbol_index_type (filedata
, psym
->st_shndx
));
17460 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17461 print_symbol (sym_width
,
17462 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17464 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17479 process_nds32_specific (Filedata
* filedata
)
17481 Elf_Internal_Shdr
*sect
= NULL
;
17483 sect
= find_section (filedata
, ".nds32_e_flags");
17484 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17486 unsigned char *buf
;
17489 printf ("\nNDS32 elf flags section:\n");
17490 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17491 _("NDS32 elf flags section"));
17496 flag
= byte_get (buf
, 4);
17498 switch (flag
& 0x3)
17501 printf ("(VEC_SIZE):\tNo entry.\n");
17504 printf ("(VEC_SIZE):\t4 bytes\n");
17507 printf ("(VEC_SIZE):\t16 bytes\n");
17510 printf ("(VEC_SIZE):\treserved\n");
17519 process_gnu_liblist (Filedata
* filedata
)
17521 Elf_Internal_Shdr
* section
;
17522 Elf_Internal_Shdr
* string_sec
;
17523 Elf32_External_Lib
* elib
;
17525 size_t strtab_size
;
17527 unsigned long num_liblist
;
17529 bfd_boolean res
= TRUE
;
17534 for (i
= 0, section
= filedata
->section_headers
;
17535 i
< filedata
->file_header
.e_shnum
;
17538 switch (section
->sh_type
)
17540 case SHT_GNU_LIBLIST
:
17541 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17544 elib
= (Elf32_External_Lib
*)
17545 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17546 _("liblist section data"));
17554 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17555 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17556 string_sec
->sh_size
,
17557 _("liblist string table"));
17559 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17566 strtab_size
= string_sec
->sh_size
;
17568 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17569 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17570 "\nLibrary list section '%s' contains %lu entries:\n",
17572 printable_section_name (filedata
, section
),
17575 puts (_(" Library Time Stamp Checksum Version Flags"));
17577 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17585 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17586 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17587 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17588 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17589 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17591 tmp
= gmtime (&atime
);
17592 snprintf (timebuf
, sizeof (timebuf
),
17593 "%04u-%02u-%02uT%02u:%02u:%02u",
17594 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17595 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17597 printf ("%3lu: ", (unsigned long) cnt
);
17599 printf ("%-20s", liblist
.l_name
< strtab_size
17600 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17602 printf ("%-20.20s", liblist
.l_name
< strtab_size
17603 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17604 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17605 liblist
.l_version
, liblist
.l_flags
);
17616 static const char *
17617 get_note_type (Filedata
* filedata
, unsigned e_type
)
17619 static char buff
[64];
17621 if (filedata
->file_header
.e_type
== ET_CORE
)
17625 return _("NT_AUXV (auxiliary vector)");
17627 return _("NT_PRSTATUS (prstatus structure)");
17629 return _("NT_FPREGSET (floating point registers)");
17631 return _("NT_PRPSINFO (prpsinfo structure)");
17632 case NT_TASKSTRUCT
:
17633 return _("NT_TASKSTRUCT (task structure)");
17635 return _("NT_PRXFPREG (user_xfpregs structure)");
17637 return _("NT_PPC_VMX (ppc Altivec registers)");
17639 return _("NT_PPC_VSX (ppc VSX registers)");
17641 return _("NT_PPC_TAR (ppc TAR register)");
17643 return _("NT_PPC_PPR (ppc PPR register)");
17645 return _("NT_PPC_DSCR (ppc DSCR register)");
17647 return _("NT_PPC_EBB (ppc EBB registers)");
17649 return _("NT_PPC_PMU (ppc PMU registers)");
17650 case NT_PPC_TM_CGPR
:
17651 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17652 case NT_PPC_TM_CFPR
:
17653 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17654 case NT_PPC_TM_CVMX
:
17655 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17656 case NT_PPC_TM_CVSX
:
17657 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17658 case NT_PPC_TM_SPR
:
17659 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17660 case NT_PPC_TM_CTAR
:
17661 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17662 case NT_PPC_TM_CPPR
:
17663 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17664 case NT_PPC_TM_CDSCR
:
17665 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17667 return _("NT_386_TLS (x86 TLS information)");
17668 case NT_386_IOPERM
:
17669 return _("NT_386_IOPERM (x86 I/O permissions)");
17670 case NT_X86_XSTATE
:
17671 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17672 case NT_S390_HIGH_GPRS
:
17673 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17674 case NT_S390_TIMER
:
17675 return _("NT_S390_TIMER (s390 timer register)");
17676 case NT_S390_TODCMP
:
17677 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17678 case NT_S390_TODPREG
:
17679 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17681 return _("NT_S390_CTRS (s390 control registers)");
17682 case NT_S390_PREFIX
:
17683 return _("NT_S390_PREFIX (s390 prefix register)");
17684 case NT_S390_LAST_BREAK
:
17685 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17686 case NT_S390_SYSTEM_CALL
:
17687 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17689 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17690 case NT_S390_VXRS_LOW
:
17691 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17692 case NT_S390_VXRS_HIGH
:
17693 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17694 case NT_S390_GS_CB
:
17695 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17696 case NT_S390_GS_BC
:
17697 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17699 return _("NT_ARM_VFP (arm VFP registers)");
17701 return _("NT_ARM_TLS (AArch TLS registers)");
17702 case NT_ARM_HW_BREAK
:
17703 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17704 case NT_ARM_HW_WATCH
:
17705 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17707 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17709 return _("NT_PSTATUS (pstatus structure)");
17711 return _("NT_FPREGS (floating point registers)");
17713 return _("NT_PSINFO (psinfo structure)");
17715 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17717 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17718 case NT_WIN32PSTATUS
:
17719 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17721 return _("NT_SIGINFO (siginfo_t data)");
17723 return _("NT_FILE (mapped files)");
17731 return _("NT_VERSION (version)");
17733 return _("NT_ARCH (architecture)");
17734 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17736 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17742 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17747 print_core_note (Elf_Internal_Note
*pnote
)
17749 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17750 bfd_vma count
, page_size
;
17751 unsigned char *descdata
, *filenames
, *descend
;
17753 if (pnote
->type
!= NT_FILE
)
17763 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17764 /* Still "successful". */
17769 if (pnote
->descsz
< 2 * addr_size
)
17771 error (_(" Malformed note - too short for header\n"));
17775 descdata
= (unsigned char *) pnote
->descdata
;
17776 descend
= descdata
+ pnote
->descsz
;
17778 if (descdata
[pnote
->descsz
- 1] != '\0')
17780 error (_(" Malformed note - does not end with \\0\n"));
17784 count
= byte_get (descdata
, addr_size
);
17785 descdata
+= addr_size
;
17787 page_size
= byte_get (descdata
, addr_size
);
17788 descdata
+= addr_size
;
17790 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17791 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17793 error (_(" Malformed note - too short for supplied file count\n"));
17797 printf (_(" Page size: "));
17798 print_vma (page_size
, DEC
);
17801 printf (_(" %*s%*s%*s\n"),
17802 (int) (2 + 2 * addr_size
), _("Start"),
17803 (int) (4 + 2 * addr_size
), _("End"),
17804 (int) (4 + 2 * addr_size
), _("Page Offset"));
17805 filenames
= descdata
+ count
* 3 * addr_size
;
17806 while (count
-- > 0)
17808 bfd_vma start
, end
, file_ofs
;
17810 if (filenames
== descend
)
17812 error (_(" Malformed note - filenames end too early\n"));
17816 start
= byte_get (descdata
, addr_size
);
17817 descdata
+= addr_size
;
17818 end
= byte_get (descdata
, addr_size
);
17819 descdata
+= addr_size
;
17820 file_ofs
= byte_get (descdata
, addr_size
);
17821 descdata
+= addr_size
;
17824 print_vma (start
, FULL_HEX
);
17826 print_vma (end
, FULL_HEX
);
17828 print_vma (file_ofs
, FULL_HEX
);
17829 printf ("\n %s\n", filenames
);
17831 filenames
+= 1 + strlen ((char *) filenames
);
17837 static const char *
17838 get_gnu_elf_note_type (unsigned e_type
)
17840 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17843 case NT_GNU_ABI_TAG
:
17844 return _("NT_GNU_ABI_TAG (ABI version tag)");
17846 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17847 case NT_GNU_BUILD_ID
:
17848 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17849 case NT_GNU_GOLD_VERSION
:
17850 return _("NT_GNU_GOLD_VERSION (gold version)");
17851 case NT_GNU_PROPERTY_TYPE_0
:
17852 return _("NT_GNU_PROPERTY_TYPE_0");
17853 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17854 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17855 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17856 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17859 static char buff
[64];
17861 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17868 decode_x86_compat_isa (unsigned int bitmask
)
17872 unsigned int bit
= bitmask
& (- bitmask
);
17877 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17880 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17883 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17886 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17889 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17892 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17895 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17898 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17901 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17904 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17907 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17910 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17911 printf ("AVX512F");
17913 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17914 printf ("AVX512CD");
17916 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17917 printf ("AVX512ER");
17919 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17920 printf ("AVX512PF");
17922 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17923 printf ("AVX512VL");
17925 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17926 printf ("AVX512DQ");
17928 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17929 printf ("AVX512BW");
17932 printf (_("<unknown: %x>"), bit
);
17941 decode_x86_isa (unsigned int bitmask
)
17945 printf (_("<None>"));
17951 unsigned int bit
= bitmask
& (- bitmask
);
17956 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17959 case GNU_PROPERTY_X86_ISA_1_SSE
:
17962 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17965 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17968 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17971 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17974 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17977 case GNU_PROPERTY_X86_ISA_1_AVX
:
17980 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17983 case GNU_PROPERTY_X86_ISA_1_FMA
:
17986 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17987 printf ("AVX512F");
17989 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17990 printf ("AVX512CD");
17992 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17993 printf ("AVX512ER");
17995 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17996 printf ("AVX512PF");
17998 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17999 printf ("AVX512VL");
18001 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
18002 printf ("AVX512DQ");
18004 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
18005 printf ("AVX512BW");
18007 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
18008 printf ("AVX512_4FMAPS");
18010 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
18011 printf ("AVX512_4VNNIW");
18013 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
18014 printf ("AVX512_BITALG");
18016 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
18017 printf ("AVX512_IFMA");
18019 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
18020 printf ("AVX512_VBMI");
18022 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
18023 printf ("AVX512_VBMI2");
18025 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
18026 printf ("AVX512_VNNI");
18028 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
18029 printf ("AVX512_BF16");
18032 printf (_("<unknown: %x>"), bit
);
18041 decode_x86_feature_1 (unsigned int bitmask
)
18045 printf (_("<None>"));
18051 unsigned int bit
= bitmask
& (- bitmask
);
18056 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18059 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18063 printf (_("<unknown: %x>"), bit
);
18072 decode_x86_feature_2 (unsigned int bitmask
)
18076 printf (_("<None>"));
18082 unsigned int bit
= bitmask
& (- bitmask
);
18087 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18090 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18093 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18096 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18099 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18102 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18105 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18108 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18111 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18112 printf ("XSAVEOPT");
18114 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18118 printf (_("<unknown: %x>"), bit
);
18127 decode_aarch64_feature_1_and (unsigned int bitmask
)
18131 unsigned int bit
= bitmask
& (- bitmask
);
18136 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18140 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18145 printf (_("<unknown: %x>"), bit
);
18154 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18156 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18157 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18158 unsigned int size
= is_32bit_elf
? 4 : 8;
18160 printf (_(" Properties: "));
18162 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18164 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18168 while (ptr
< ptr_end
)
18172 unsigned int datasz
;
18174 if ((size_t) (ptr_end
- ptr
) < 8)
18176 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18180 type
= byte_get (ptr
, 4);
18181 datasz
= byte_get (ptr
+ 4, 4);
18185 if (datasz
> (size_t) (ptr_end
- ptr
))
18187 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18192 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18194 if (filedata
->file_header
.e_machine
== EM_X86_64
18195 || filedata
->file_header
.e_machine
== EM_IAMCU
18196 || filedata
->file_header
.e_machine
== EM_386
)
18198 unsigned int bitmask
;
18201 bitmask
= byte_get (ptr
, 4);
18207 case GNU_PROPERTY_X86_ISA_1_USED
:
18209 printf (_("x86 ISA used: <corrupt length: %#x> "),
18213 printf ("x86 ISA used: ");
18214 decode_x86_isa (bitmask
);
18218 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18220 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18224 printf ("x86 ISA needed: ");
18225 decode_x86_isa (bitmask
);
18229 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18231 printf (_("x86 feature: <corrupt length: %#x> "),
18235 printf ("x86 feature: ");
18236 decode_x86_feature_1 (bitmask
);
18240 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18242 printf (_("x86 feature used: <corrupt length: %#x> "),
18246 printf ("x86 feature used: ");
18247 decode_x86_feature_2 (bitmask
);
18251 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18253 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18256 printf ("x86 feature needed: ");
18257 decode_x86_feature_2 (bitmask
);
18261 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18263 printf (_("x86 ISA used: <corrupt length: %#x> "),
18267 printf ("x86 ISA used: ");
18268 decode_x86_compat_isa (bitmask
);
18272 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18274 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18278 printf ("x86 ISA needed: ");
18279 decode_x86_compat_isa (bitmask
);
18287 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18289 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18291 printf ("AArch64 feature: ");
18293 printf (_("<corrupt length: %#x> "), datasz
);
18295 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18304 case GNU_PROPERTY_STACK_SIZE
:
18305 printf (_("stack size: "));
18306 if (datasz
!= size
)
18307 printf (_("<corrupt length: %#x> "), datasz
);
18309 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18312 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18313 printf ("no copy on protected ");
18315 printf (_("<corrupt length: %#x> "), datasz
);
18323 if (type
< GNU_PROPERTY_LOPROC
)
18324 printf (_("<unknown type %#x data: "), type
);
18325 else if (type
< GNU_PROPERTY_LOUSER
)
18326 printf (_("<procesor-specific type %#x data: "), type
);
18328 printf (_("<application-specific type %#x data: "), type
);
18329 for (j
= 0; j
< datasz
; ++j
)
18330 printf ("%02x ", ptr
[j
] & 0xff);
18334 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18335 if (ptr
== ptr_end
)
18348 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18350 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18351 switch (pnote
->type
)
18353 case NT_GNU_BUILD_ID
:
18357 printf (_(" Build ID: "));
18358 for (i
= 0; i
< pnote
->descsz
; ++i
)
18359 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18364 case NT_GNU_ABI_TAG
:
18366 unsigned long os
, major
, minor
, subminor
;
18367 const char *osname
;
18369 /* PR 17531: file: 030-599401-0.004. */
18370 if (pnote
->descsz
< 16)
18372 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18376 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18377 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18378 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18379 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18383 case GNU_ABI_TAG_LINUX
:
18386 case GNU_ABI_TAG_HURD
:
18389 case GNU_ABI_TAG_SOLARIS
:
18390 osname
= "Solaris";
18392 case GNU_ABI_TAG_FREEBSD
:
18393 osname
= "FreeBSD";
18395 case GNU_ABI_TAG_NETBSD
:
18398 case GNU_ABI_TAG_SYLLABLE
:
18399 osname
= "Syllable";
18401 case GNU_ABI_TAG_NACL
:
18405 osname
= "Unknown";
18409 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18410 major
, minor
, subminor
);
18414 case NT_GNU_GOLD_VERSION
:
18418 printf (_(" Version: "));
18419 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18420 printf ("%c", pnote
->descdata
[i
]);
18427 unsigned long num_entries
, mask
;
18429 /* Hardware capabilities information. Word 0 is the number of entries.
18430 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18431 is a series of entries, where each entry is a single byte followed
18432 by a nul terminated string. The byte gives the bit number to test
18433 if enabled in the bitmask. */
18434 printf (_(" Hardware Capabilities: "));
18435 if (pnote
->descsz
< 8)
18437 error (_("<corrupt GNU_HWCAP>\n"));
18440 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18441 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18442 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18443 /* FIXME: Add code to display the entries... */
18447 case NT_GNU_PROPERTY_TYPE_0
:
18448 print_gnu_property_note (filedata
, pnote
);
18452 /* Handle unrecognised types. An error message should have already been
18453 created by get_gnu_elf_note_type(), so all that we need to do is to
18454 display the data. */
18458 printf (_(" Description data: "));
18459 for (i
= 0; i
< pnote
->descsz
; ++i
)
18460 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18469 static const char *
18470 get_v850_elf_note_type (enum v850_notes n_type
)
18472 static char buff
[64];
18476 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18477 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18478 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18479 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18480 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18481 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18483 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18489 print_v850_note (Elf_Internal_Note
* pnote
)
18493 if (pnote
->descsz
!= 4)
18496 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18500 printf (_("not set\n"));
18504 switch (pnote
->type
)
18506 case V850_NOTE_ALIGNMENT
:
18509 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18510 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18514 case V850_NOTE_DATA_SIZE
:
18517 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18518 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18522 case V850_NOTE_FPU_INFO
:
18525 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18526 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18530 case V850_NOTE_MMU_INFO
:
18531 case V850_NOTE_CACHE_INFO
:
18532 case V850_NOTE_SIMD_INFO
:
18533 if (val
== EF_RH850_SIMD
)
18535 printf (_("yes\n"));
18541 /* An 'unknown note type' message will already have been displayed. */
18545 printf (_("unknown value: %x\n"), val
);
18550 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18552 unsigned int version
;
18554 switch (pnote
->type
)
18556 case NT_NETBSD_IDENT
:
18557 if (pnote
->descsz
< 1)
18559 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18560 if ((version
/ 10000) % 100)
18561 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18562 version
, version
/ 100000000, (version
/ 1000000) % 100,
18563 (version
/ 10000) % 100 > 26 ? "Z" : "",
18564 'A' + (version
/ 10000) % 26);
18566 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18567 version
, version
/ 100000000, (version
/ 1000000) % 100,
18568 (version
/ 100) % 100);
18571 case NT_NETBSD_MARCH
:
18572 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18576 #ifdef NT_NETBSD_PAX
18577 case NT_NETBSD_PAX
:
18578 if (pnote
->descsz
< 1)
18580 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18581 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18582 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18583 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18584 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18585 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18586 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18587 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18592 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18593 pnote
->descsz
, pnote
->type
);
18597 static const char *
18598 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18602 case NT_FREEBSD_THRMISC
:
18603 return _("NT_THRMISC (thrmisc structure)");
18604 case NT_FREEBSD_PROCSTAT_PROC
:
18605 return _("NT_PROCSTAT_PROC (proc data)");
18606 case NT_FREEBSD_PROCSTAT_FILES
:
18607 return _("NT_PROCSTAT_FILES (files data)");
18608 case NT_FREEBSD_PROCSTAT_VMMAP
:
18609 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18610 case NT_FREEBSD_PROCSTAT_GROUPS
:
18611 return _("NT_PROCSTAT_GROUPS (groups data)");
18612 case NT_FREEBSD_PROCSTAT_UMASK
:
18613 return _("NT_PROCSTAT_UMASK (umask data)");
18614 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18615 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18616 case NT_FREEBSD_PROCSTAT_OSREL
:
18617 return _("NT_PROCSTAT_OSREL (osreldate data)");
18618 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18619 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18620 case NT_FREEBSD_PROCSTAT_AUXV
:
18621 return _("NT_PROCSTAT_AUXV (auxv data)");
18622 case NT_FREEBSD_PTLWPINFO
:
18623 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18625 return get_note_type (filedata
, e_type
);
18628 static const char *
18629 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18631 static char buff
[64];
18635 case NT_NETBSDCORE_PROCINFO
:
18636 /* NetBSD core "procinfo" structure. */
18637 return _("NetBSD procinfo structure");
18639 #ifdef NT_NETBSDCORE_AUXV
18640 case NT_NETBSDCORE_AUXV
:
18641 return _("NetBSD ELF auxiliary vector data");
18644 #ifdef NT_NETBSDCORE_LWPSTATUS
18645 case NT_NETBSDCORE_LWPSTATUS
:
18646 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18650 /* As of Jan 2020 there are no other machine-independent notes
18651 defined for NetBSD core files. If the note type is less
18652 than the start of the machine-dependent note types, we don't
18655 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18657 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18663 switch (filedata
->file_header
.e_machine
)
18665 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18666 and PT_GETFPREGS == mach+2. */
18671 case EM_SPARC32PLUS
:
18675 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18676 return _("PT_GETREGS (reg structure)");
18677 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18678 return _("PT_GETFPREGS (fpreg structure)");
18684 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18685 There's also old PT___GETREGS40 == mach + 1 for old reg
18686 structure which lacks GBR. */
18690 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18691 return _("PT___GETREGS40 (old reg structure)");
18692 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18693 return _("PT_GETREGS (reg structure)");
18694 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18695 return _("PT_GETFPREGS (fpreg structure)");
18701 /* On all other arch's, PT_GETREGS == mach+1 and
18702 PT_GETFPREGS == mach+3. */
18706 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18707 return _("PT_GETREGS (reg structure)");
18708 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18709 return _("PT_GETFPREGS (fpreg structure)");
18715 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18716 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18720 static const char *
18721 get_stapsdt_note_type (unsigned e_type
)
18723 static char buff
[64];
18728 return _("NT_STAPSDT (SystemTap probe descriptors)");
18734 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18739 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18741 size_t len
, maxlen
;
18742 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18743 char *data
= pnote
->descdata
;
18744 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18745 bfd_vma pc
, base_addr
, semaphore
;
18746 char *provider
, *probe
, *arg_fmt
;
18748 if (pnote
->descsz
< (addr_size
* 3))
18749 goto stapdt_note_too_small
;
18751 pc
= byte_get ((unsigned char *) data
, addr_size
);
18754 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18757 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18760 if (data
>= data_end
)
18761 goto stapdt_note_too_small
;
18762 maxlen
= data_end
- data
;
18763 len
= strnlen (data
, maxlen
);
18770 goto stapdt_note_too_small
;
18772 if (data
>= data_end
)
18773 goto stapdt_note_too_small
;
18774 maxlen
= data_end
- data
;
18775 len
= strnlen (data
, maxlen
);
18782 goto stapdt_note_too_small
;
18784 if (data
>= data_end
)
18785 goto stapdt_note_too_small
;
18786 maxlen
= data_end
- data
;
18787 len
= strnlen (data
, maxlen
);
18794 goto stapdt_note_too_small
;
18796 printf (_(" Provider: %s\n"), provider
);
18797 printf (_(" Name: %s\n"), probe
);
18798 printf (_(" Location: "));
18799 print_vma (pc
, FULL_HEX
);
18800 printf (_(", Base: "));
18801 print_vma (base_addr
, FULL_HEX
);
18802 printf (_(", Semaphore: "));
18803 print_vma (semaphore
, FULL_HEX
);
18805 printf (_(" Arguments: %s\n"), arg_fmt
);
18807 return data
== data_end
;
18809 stapdt_note_too_small
:
18810 printf (_(" <corrupt - note is too small>\n"));
18811 error (_("corrupt stapdt note - the data size is too small\n"));
18815 static const char *
18816 get_ia64_vms_note_type (unsigned e_type
)
18818 static char buff
[64];
18823 return _("NT_VMS_MHD (module header)");
18825 return _("NT_VMS_LNM (language name)");
18827 return _("NT_VMS_SRC (source files)");
18829 return "NT_VMS_TITLE";
18831 return _("NT_VMS_EIDC (consistency check)");
18832 case NT_VMS_FPMODE
:
18833 return _("NT_VMS_FPMODE (FP mode)");
18834 case NT_VMS_LINKTIME
:
18835 return "NT_VMS_LINKTIME";
18836 case NT_VMS_IMGNAM
:
18837 return _("NT_VMS_IMGNAM (image name)");
18839 return _("NT_VMS_IMGID (image id)");
18840 case NT_VMS_LINKID
:
18841 return _("NT_VMS_LINKID (link id)");
18842 case NT_VMS_IMGBID
:
18843 return _("NT_VMS_IMGBID (build id)");
18844 case NT_VMS_GSTNAM
:
18845 return _("NT_VMS_GSTNAM (sym table name)");
18846 case NT_VMS_ORIG_DYN
:
18847 return "NT_VMS_ORIG_DYN";
18848 case NT_VMS_PATCHTIME
:
18849 return "NT_VMS_PATCHTIME";
18851 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18857 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18859 int maxlen
= pnote
->descsz
;
18861 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18862 goto desc_size_fail
;
18864 switch (pnote
->type
)
18868 goto desc_size_fail
;
18870 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18872 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18873 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18874 if (l
+ 34 < maxlen
)
18876 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18877 if (l
+ 35 < maxlen
)
18878 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18880 printf (_(" Module version : <missing>\n"));
18884 printf (_(" Module name : <missing>\n"));
18885 printf (_(" Module version : <missing>\n"));
18890 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18894 case NT_VMS_FPMODE
:
18895 printf (_(" Floating Point mode: "));
18897 goto desc_size_fail
;
18898 /* FIXME: Generate an error if descsz > 8 ? */
18900 printf ("0x%016" BFD_VMA_FMT
"x\n",
18901 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18904 case NT_VMS_LINKTIME
:
18905 printf (_(" Link time: "));
18907 goto desc_size_fail
;
18908 /* FIXME: Generate an error if descsz > 8 ? */
18911 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18915 case NT_VMS_PATCHTIME
:
18916 printf (_(" Patch time: "));
18918 goto desc_size_fail
;
18919 /* FIXME: Generate an error if descsz > 8 ? */
18922 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18926 case NT_VMS_ORIG_DYN
:
18928 goto desc_size_fail
;
18930 printf (_(" Major id: %u, minor id: %u\n"),
18931 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18932 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18933 printf (_(" Last modified : "));
18935 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18936 printf (_("\n Link flags : "));
18937 printf ("0x%016" BFD_VMA_FMT
"x\n",
18938 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18939 printf (_(" Header flags: 0x%08x\n"),
18940 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18941 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18945 case NT_VMS_IMGNAM
:
18946 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18949 case NT_VMS_GSTNAM
:
18950 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18954 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18957 case NT_VMS_LINKID
:
18958 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18968 printf (_(" <corrupt - data size is too small>\n"));
18969 error (_("corrupt IA64 note: data size is too small\n"));
18973 struct build_attr_cache
{
18974 Filedata
*filedata
;
18976 unsigned long strtablen
;
18977 Elf_Internal_Sym
*symtab
;
18978 unsigned long nsyms
;
18981 /* Find the symbol associated with a build attribute that is attached
18982 to address OFFSET. If PNAME is non-NULL then store the name of
18983 the symbol (if found) in the provided pointer, Returns NULL if a
18984 symbol could not be found. */
18986 static Elf_Internal_Sym
*
18987 get_symbol_for_build_attribute (Filedata
* filedata
,
18988 unsigned long offset
,
18989 bfd_boolean is_open_attr
,
18990 const char ** pname
)
18992 Elf_Internal_Sym
*saved_sym
= NULL
;
18993 Elf_Internal_Sym
*sym
;
18995 if (filedata
->section_headers
!= NULL
18996 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18998 Elf_Internal_Shdr
* symsec
;
19000 free (ba_cache
.strtab
);
19001 ba_cache
.strtab
= NULL
;
19002 free (ba_cache
.symtab
);
19003 ba_cache
.symtab
= NULL
;
19005 /* Load the symbol and string sections. */
19006 for (symsec
= filedata
->section_headers
;
19007 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19010 if (symsec
->sh_type
== SHT_SYMTAB
19011 && get_symtab (filedata
, symsec
,
19012 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19013 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19016 ba_cache
.filedata
= filedata
;
19019 if (ba_cache
.symtab
== NULL
)
19022 /* Find a symbol whose value matches offset. */
19023 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19024 if (sym
->st_value
== offset
)
19026 if (sym
->st_name
>= ba_cache
.strtablen
)
19027 /* Huh ? This should not happen. */
19030 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19033 /* The AArch64 and ARM architectures define mapping symbols
19034 (eg $d, $x, $t) which we want to ignore. */
19035 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19036 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19037 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19042 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19043 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19044 FUNC symbols entirely. */
19045 switch (ELF_ST_TYPE (sym
->st_info
))
19052 /* If the symbol has a size associated
19053 with it then we can stop searching. */
19054 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19059 /* Ignore function symbols. */
19066 switch (ELF_ST_BIND (sym
->st_info
))
19069 if (saved_sym
== NULL
19070 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19075 if (saved_sym
== NULL
)
19085 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19093 if (saved_sym
&& pname
)
19094 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19099 /* Returns true iff addr1 and addr2 are in the same section. */
19102 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19104 Elf_Internal_Shdr
* a1
;
19105 Elf_Internal_Shdr
* a2
;
19107 a1
= find_section_by_address (filedata
, addr1
);
19108 a2
= find_section_by_address (filedata
, addr2
);
19110 return a1
== a2
&& a1
!= NULL
;
19114 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19115 Filedata
* filedata
)
19117 static unsigned long global_offset
= 0;
19118 static unsigned long global_end
= 0;
19119 static unsigned long func_offset
= 0;
19120 static unsigned long func_end
= 0;
19122 Elf_Internal_Sym
* sym
;
19124 unsigned long start
;
19126 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19128 switch (pnote
->descsz
)
19131 /* A zero-length description means that the range of
19132 the previous note of the same type should be used. */
19135 if (global_end
> global_offset
)
19136 printf (_(" Applies to region from %#lx to %#lx\n"),
19137 global_offset
, global_end
);
19139 printf (_(" Applies to region from %#lx\n"), global_offset
);
19143 if (func_end
> func_offset
)
19144 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19146 printf (_(" Applies to region from %#lx\n"), func_offset
);
19151 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19158 /* FIXME: We should check that version 3+ notes are being used here... */
19159 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19160 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19164 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19170 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19171 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19175 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19176 printf (_(" <invalid descsz>"));
19181 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19182 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19183 in order to avoid them being confused with the start address of the
19184 first function in the file... */
19185 if (sym
== NULL
&& is_open_attr
)
19186 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19189 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19190 end
= start
+ sym
->st_size
;
19194 /* FIXME: Need to properly allow for section alignment.
19195 16 is just the alignment used on x86_64. */
19197 && start
> BFD_ALIGN (global_end
, 16)
19198 /* Build notes are not guaranteed to be organised in order of
19199 increasing address, but we should find the all of the notes
19200 for one section in the same place. */
19201 && same_section (filedata
, start
, global_end
))
19202 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19203 global_end
+ 1, start
- 1);
19205 printf (_(" Applies to region from %#lx"), start
);
19206 global_offset
= start
;
19210 printf (_(" to %#lx"), end
);
19216 printf (_(" Applies to region from %#lx"), start
);
19217 func_offset
= start
;
19221 printf (_(" to %#lx"), end
);
19227 printf (_(" (%s)"), name
);
19234 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19236 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19237 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19238 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19240 char name_attribute
;
19241 const char * expected_types
;
19242 const char * name
= pnote
->namedata
;
19246 if (name
== NULL
|| pnote
->namesz
< 2)
19248 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19249 print_symbol (-20, _(" <corrupt name>"));
19258 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19259 if (name
[0] == 'G' && name
[1] == 'A')
19261 if (pnote
->namesz
< 4)
19263 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19264 print_symbol (-20, _(" <corrupt name>"));
19273 switch ((name_type
= * name
))
19275 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19276 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19277 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19278 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19279 printf ("%c", * name
);
19283 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19284 print_symbol (-20, _("<unknown name type>"));
19291 switch ((name_attribute
= * name
))
19293 case GNU_BUILD_ATTRIBUTE_VERSION
:
19294 text
= _("<version>");
19295 expected_types
= string_expected
;
19298 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19299 text
= _("<stack prot>");
19300 expected_types
= "!+*";
19303 case GNU_BUILD_ATTRIBUTE_RELRO
:
19304 text
= _("<relro>");
19305 expected_types
= bool_expected
;
19308 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19309 text
= _("<stack size>");
19310 expected_types
= number_expected
;
19313 case GNU_BUILD_ATTRIBUTE_TOOL
:
19314 text
= _("<tool>");
19315 expected_types
= string_expected
;
19318 case GNU_BUILD_ATTRIBUTE_ABI
:
19320 expected_types
= "$*";
19323 case GNU_BUILD_ATTRIBUTE_PIC
:
19325 expected_types
= number_expected
;
19328 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19329 text
= _("<short enum>");
19330 expected_types
= bool_expected
;
19334 if (ISPRINT (* name
))
19336 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19338 if (len
> left
&& ! do_wide
)
19340 printf ("%.*s:", len
, name
);
19346 static char tmpbuf
[128];
19348 error (_("unrecognised byte in name field: %d\n"), * name
);
19349 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19353 expected_types
= "*$!+";
19358 left
-= printf ("%s", text
);
19360 if (strchr (expected_types
, name_type
) == NULL
)
19361 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19363 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19365 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19366 (unsigned long) pnote
->namesz
,
19367 (long) (name
- pnote
->namedata
));
19371 if (left
< 1 && ! do_wide
)
19376 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19378 unsigned int bytes
;
19379 unsigned long long val
= 0;
19380 unsigned int shift
= 0;
19381 char * decoded
= NULL
;
19383 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19385 /* The -1 is because the name field is always 0 terminated, and we
19386 want to be able to ensure that the shift in the while loop below
19387 will not overflow. */
19390 if (bytes
> sizeof (val
))
19392 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19394 bytes
= sizeof (val
);
19396 /* We do not bother to warn if bytes == 0 as this can
19397 happen with some early versions of the gcc plugin. */
19401 unsigned long byte
= (* name
++) & 0xff;
19403 val
|= byte
<< shift
;
19407 switch (name_attribute
)
19409 case GNU_BUILD_ATTRIBUTE_PIC
:
19412 case 0: decoded
= "static"; break;
19413 case 1: decoded
= "pic"; break;
19414 case 2: decoded
= "PIC"; break;
19415 case 3: decoded
= "pie"; break;
19416 case 4: decoded
= "PIE"; break;
19420 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19423 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19424 case 0: decoded
= "off"; break;
19425 case 1: decoded
= "on"; break;
19426 case 2: decoded
= "all"; break;
19427 case 3: decoded
= "strong"; break;
19428 case 4: decoded
= "explicit"; break;
19436 if (decoded
!= NULL
)
19438 print_symbol (-left
, decoded
);
19449 left
-= printf ("0x%llx", val
);
19451 left
-= printf ("0x%-.*llx", left
, val
);
19455 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19456 left
-= print_symbol (- left
, name
);
19458 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19459 left
-= print_symbol (- left
, "true");
19461 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19462 left
-= print_symbol (- left
, "false");
19466 if (do_wide
&& left
> 0)
19467 printf ("%-*s", left
, " ");
19472 /* Note that by the ELF standard, the name field is already null byte
19473 terminated, and namesz includes the terminating null byte.
19474 I.E. the value of namesz for the name "FSF" is 4.
19476 If the value of namesz is zero, there is no name present. */
19479 process_note (Elf_Internal_Note
* pnote
,
19480 Filedata
* filedata
)
19482 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19485 if (pnote
->namesz
== 0)
19486 /* If there is no note name, then use the default set of
19487 note type strings. */
19488 nt
= get_note_type (filedata
, pnote
->type
);
19490 else if (const_strneq (pnote
->namedata
, "GNU"))
19491 /* GNU-specific object file notes. */
19492 nt
= get_gnu_elf_note_type (pnote
->type
);
19494 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19495 /* FreeBSD-specific core file notes. */
19496 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19498 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19499 /* NetBSD-specific core file notes. */
19500 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19502 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19503 /* NetBSD-specific core file notes. */
19504 return process_netbsd_elf_note (pnote
);
19506 else if (const_strneq (pnote
->namedata
, "PaX"))
19507 /* NetBSD-specific core file notes. */
19508 return process_netbsd_elf_note (pnote
);
19510 else if (strneq (pnote
->namedata
, "SPU/", 4))
19512 /* SPU-specific core file notes. */
19513 nt
= pnote
->namedata
+ 4;
19517 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19518 /* VMS/ia64-specific file notes. */
19519 nt
= get_ia64_vms_note_type (pnote
->type
);
19521 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19522 nt
= get_stapsdt_note_type (pnote
->type
);
19525 /* Don't recognize this note name; just use the default set of
19526 note type strings. */
19527 nt
= get_note_type (filedata
, pnote
->type
);
19531 if (((const_strneq (pnote
->namedata
, "GA")
19532 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19533 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19534 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19535 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19536 print_gnu_build_attribute_name (pnote
);
19538 print_symbol (-20, name
);
19541 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19543 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19545 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19546 return print_ia64_vms_note (pnote
);
19547 else if (const_strneq (pnote
->namedata
, "GNU"))
19548 return print_gnu_note (filedata
, pnote
);
19549 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19550 return print_stapsdt_note (pnote
);
19551 else if (const_strneq (pnote
->namedata
, "CORE"))
19552 return print_core_note (pnote
);
19553 else if (((const_strneq (pnote
->namedata
, "GA")
19554 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19555 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19556 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19557 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19558 return print_gnu_build_attribute_description (pnote
, filedata
);
19564 printf (_(" description data: "));
19565 for (i
= 0; i
< pnote
->descsz
; i
++)
19566 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19578 process_notes_at (Filedata
* filedata
,
19579 Elf_Internal_Shdr
* section
,
19584 Elf_External_Note
* pnotes
;
19585 Elf_External_Note
* external
;
19587 bfd_boolean res
= TRUE
;
19594 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19597 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19605 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19608 if (pnotes
== NULL
)
19614 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19616 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19617 (unsigned long) offset
, (unsigned long) length
);
19619 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19620 specifies that notes should be aligned to 4 bytes in 32-bit
19621 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19622 we also support 4 byte alignment in 64-bit objects. If section
19623 alignment is less than 4, we treate alignment as 4 bytes. */
19626 else if (align
!= 4 && align
!= 8)
19628 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19634 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19636 end
= (char *) pnotes
+ length
;
19637 while ((char *) external
< end
)
19639 Elf_Internal_Note inote
;
19642 char * temp
= NULL
;
19643 size_t data_remaining
= end
- (char *) external
;
19645 if (!is_ia64_vms (filedata
))
19647 /* PR binutils/15191
19648 Make sure that there is enough data to read. */
19649 min_notesz
= offsetof (Elf_External_Note
, name
);
19650 if (data_remaining
< min_notesz
)
19652 warn (ngettext ("Corrupt note: only %ld byte remains, "
19653 "not enough for a full note\n",
19654 "Corrupt note: only %ld bytes remain, "
19655 "not enough for a full note\n",
19657 (long) data_remaining
);
19660 data_remaining
-= min_notesz
;
19662 inote
.type
= BYTE_GET (external
->type
);
19663 inote
.namesz
= BYTE_GET (external
->namesz
);
19664 inote
.namedata
= external
->name
;
19665 inote
.descsz
= BYTE_GET (external
->descsz
);
19666 inote
.descdata
= ((char *) external
19667 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19668 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19669 next
= ((char *) external
19670 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19674 Elf64_External_VMS_Note
*vms_external
;
19676 /* PR binutils/15191
19677 Make sure that there is enough data to read. */
19678 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19679 if (data_remaining
< min_notesz
)
19681 warn (ngettext ("Corrupt note: only %ld byte remains, "
19682 "not enough for a full note\n",
19683 "Corrupt note: only %ld bytes remain, "
19684 "not enough for a full note\n",
19686 (long) data_remaining
);
19689 data_remaining
-= min_notesz
;
19691 vms_external
= (Elf64_External_VMS_Note
*) external
;
19692 inote
.type
= BYTE_GET (vms_external
->type
);
19693 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19694 inote
.namedata
= vms_external
->name
;
19695 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19696 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19697 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19698 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19701 /* PR 17531: file: 3443835e. */
19702 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19703 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19704 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19705 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19706 || ((size_t) (next
- inote
.descdata
)
19707 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19709 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19710 (unsigned long) ((char *) external
- (char *) pnotes
));
19711 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19712 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19716 external
= (Elf_External_Note
*) next
;
19718 /* Verify that name is null terminated. It appears that at least
19719 one version of Linux (RedHat 6.0) generates corefiles that don't
19720 comply with the ELF spec by failing to include the null byte in
19722 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19724 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19726 temp
= (char *) malloc (inote
.namesz
+ 1);
19729 error (_("Out of memory allocating space for inote name\n"));
19734 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19735 inote
.namedata
= temp
;
19737 inote
.namedata
[inote
.namesz
] = 0;
19740 if (! process_note (& inote
, filedata
))
19756 process_corefile_note_segments (Filedata
* filedata
)
19758 Elf_Internal_Phdr
* segment
;
19760 bfd_boolean res
= TRUE
;
19762 if (! get_program_headers (filedata
))
19765 for (i
= 0, segment
= filedata
->program_headers
;
19766 i
< filedata
->file_header
.e_phnum
;
19769 if (segment
->p_type
== PT_NOTE
)
19770 if (! process_notes_at (filedata
, NULL
,
19771 (bfd_vma
) segment
->p_offset
,
19772 (bfd_vma
) segment
->p_filesz
,
19773 (bfd_vma
) segment
->p_align
))
19781 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19783 Elf_External_Note
* pnotes
;
19784 Elf_External_Note
* external
;
19786 bfd_boolean res
= TRUE
;
19791 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19793 if (pnotes
== NULL
)
19797 end
= (char*) pnotes
+ length
;
19799 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19800 (unsigned long) offset
, (unsigned long) length
);
19802 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19804 Elf_External_Note
* next
;
19805 Elf_Internal_Note inote
;
19807 inote
.type
= BYTE_GET (external
->type
);
19808 inote
.namesz
= BYTE_GET (external
->namesz
);
19809 inote
.namedata
= external
->name
;
19810 inote
.descsz
= BYTE_GET (external
->descsz
);
19811 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19812 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19814 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19816 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19817 inote
.descdata
= inote
.namedata
;
19821 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19823 if ( ((char *) next
> end
)
19824 || ((char *) next
< (char *) pnotes
))
19826 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19827 (unsigned long) ((char *) external
- (char *) pnotes
));
19828 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19829 inote
.type
, inote
.namesz
, inote
.descsz
);
19835 /* Prevent out-of-bounds indexing. */
19836 if ( inote
.namedata
+ inote
.namesz
> end
19837 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19839 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19840 (unsigned long) ((char *) external
- (char *) pnotes
));
19841 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19842 inote
.type
, inote
.namesz
, inote
.descsz
);
19846 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19848 if (! print_v850_note (& inote
))
19851 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19852 inote
.namesz
, inote
.descsz
);
19862 process_note_sections (Filedata
* filedata
)
19864 Elf_Internal_Shdr
* section
;
19866 unsigned int n
= 0;
19867 bfd_boolean res
= TRUE
;
19869 for (i
= 0, section
= filedata
->section_headers
;
19870 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19873 if (section
->sh_type
== SHT_NOTE
)
19875 if (! process_notes_at (filedata
, section
,
19876 (bfd_vma
) section
->sh_offset
,
19877 (bfd_vma
) section
->sh_size
,
19878 (bfd_vma
) section
->sh_addralign
))
19883 if (( filedata
->file_header
.e_machine
== EM_V800
19884 || filedata
->file_header
.e_machine
== EM_V850
19885 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19886 && section
->sh_type
== SHT_RENESAS_INFO
)
19888 if (! process_v850_notes (filedata
,
19889 (bfd_vma
) section
->sh_offset
,
19890 (bfd_vma
) section
->sh_size
))
19897 /* Try processing NOTE segments instead. */
19898 return process_corefile_note_segments (filedata
);
19904 process_notes (Filedata
* filedata
)
19906 /* If we have not been asked to display the notes then do nothing. */
19910 if (filedata
->file_header
.e_type
!= ET_CORE
)
19911 return process_note_sections (filedata
);
19913 /* No program headers means no NOTE segment. */
19914 if (filedata
->file_header
.e_phnum
> 0)
19915 return process_corefile_note_segments (filedata
);
19917 printf (_("No note segments present in the core file.\n"));
19921 static unsigned char *
19922 display_public_gnu_attributes (unsigned char * start
,
19923 const unsigned char * const end
)
19925 printf (_(" Unknown GNU attribute: %s\n"), start
);
19927 start
+= strnlen ((char *) start
, end
- start
);
19928 display_raw_attribute (start
, end
);
19930 return (unsigned char *) end
;
19933 static unsigned char *
19934 display_generic_attribute (unsigned char * start
,
19936 const unsigned char * const end
)
19939 return (unsigned char *) end
;
19941 return display_tag_value (tag
, start
, end
);
19945 process_arch_specific (Filedata
* filedata
)
19950 switch (filedata
->file_header
.e_machine
)
19953 case EM_ARC_COMPACT
:
19954 case EM_ARC_COMPACT2
:
19955 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19956 display_arc_attribute
,
19957 display_generic_attribute
);
19959 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19960 display_arm_attribute
,
19961 display_generic_attribute
);
19964 case EM_MIPS_RS3_LE
:
19965 return process_mips_specific (filedata
);
19968 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19969 display_msp430x_attribute
,
19970 display_msp430_gnu_attribute
);
19973 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19974 display_riscv_attribute
,
19975 display_generic_attribute
);
19978 return process_nds32_specific (filedata
);
19982 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19983 display_power_gnu_attribute
);
19987 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19988 display_s390_gnu_attribute
);
19991 case EM_SPARC32PLUS
:
19993 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19994 display_sparc_gnu_attribute
);
19997 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19998 display_tic6x_attribute
,
19999 display_generic_attribute
);
20002 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20003 display_public_gnu_attributes
,
20004 display_generic_attribute
);
20009 get_file_header (Filedata
* filedata
)
20011 /* Read in the identity array. */
20012 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20015 /* Determine how to read the rest of the header. */
20016 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20021 byte_get
= byte_get_little_endian
;
20022 byte_put
= byte_put_little_endian
;
20025 byte_get
= byte_get_big_endian
;
20026 byte_put
= byte_put_big_endian
;
20030 /* For now we only support 32 bit and 64 bit ELF files. */
20031 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20033 /* Read in the rest of the header. */
20036 Elf32_External_Ehdr ehdr32
;
20038 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20041 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20042 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20043 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20044 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20045 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20046 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20047 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20048 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20049 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20050 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20051 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20052 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20053 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20057 Elf64_External_Ehdr ehdr64
;
20059 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20060 we will not be able to cope with the 64bit data found in
20061 64 ELF files. Detect this now and abort before we start
20062 overwriting things. */
20063 if (sizeof (bfd_vma
) < 8)
20065 error (_("This instance of readelf has been built without support for a\n\
20066 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20070 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20073 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20074 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20075 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20076 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20077 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20078 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20079 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20080 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20081 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20082 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20083 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20084 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20085 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20088 if (filedata
->file_header
.e_shoff
)
20090 /* There may be some extensions in the first section header. Don't
20091 bomb if we can't read it. */
20093 get_32bit_section_headers (filedata
, TRUE
);
20095 get_64bit_section_headers (filedata
, TRUE
);
20102 close_file (Filedata
* filedata
)
20106 if (filedata
->handle
)
20107 fclose (filedata
->handle
);
20113 close_debug_file (void * data
)
20115 close_file ((Filedata
*) data
);
20119 open_file (const char * pathname
)
20121 struct stat statbuf
;
20122 Filedata
* filedata
= NULL
;
20124 if (stat (pathname
, & statbuf
) < 0
20125 || ! S_ISREG (statbuf
.st_mode
))
20128 filedata
= calloc (1, sizeof * filedata
);
20129 if (filedata
== NULL
)
20132 filedata
->handle
= fopen (pathname
, "rb");
20133 if (filedata
->handle
== NULL
)
20136 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20137 filedata
->file_name
= pathname
;
20139 if (! get_file_header (filedata
))
20142 if (filedata
->file_header
.e_shoff
)
20146 /* Read the section headers again, this time for real. */
20148 res
= get_32bit_section_headers (filedata
, FALSE
);
20150 res
= get_64bit_section_headers (filedata
, FALSE
);
20161 if (filedata
->handle
)
20162 fclose (filedata
->handle
);
20169 open_debug_file (const char * pathname
)
20171 return open_file (pathname
);
20174 /* Process one ELF object file according to the command line options.
20175 This file may actually be stored in an archive. The file is
20176 positioned at the start of the ELF object. Returns TRUE if no
20177 problems were encountered, FALSE otherwise. */
20180 process_object (Filedata
* filedata
)
20182 bfd_boolean have_separate_files
;
20186 if (! get_file_header (filedata
))
20188 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20192 /* Initialise per file variables. */
20193 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20194 filedata
->version_info
[i
] = 0;
20196 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20197 filedata
->dynamic_info
[i
] = 0;
20198 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20199 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20201 /* Process the file. */
20203 printf (_("\nFile: %s\n"), filedata
->file_name
);
20205 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20206 Note we do this even if cmdline_dump_sects is empty because we
20207 must make sure that the dump_sets array is zeroed out before each
20208 object file is processed. */
20209 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20210 memset (filedata
->dump
.dump_sects
, 0,
20211 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20213 if (cmdline
.num_dump_sects
> 0)
20215 if (filedata
->dump
.num_dump_sects
== 0)
20216 /* A sneaky way of allocating the dump_sects array. */
20217 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20219 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20220 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20221 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20224 if (! process_file_header (filedata
))
20227 if (! process_section_headers (filedata
))
20229 /* Without loaded section headers we cannot process lots of things. */
20230 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20232 if (! do_using_dynamic
)
20233 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20236 if (! process_section_groups (filedata
))
20237 /* Without loaded section groups we cannot process unwind. */
20240 res
= process_program_headers (filedata
);
20242 res
= process_dynamic_section (filedata
);
20244 if (! process_relocs (filedata
))
20247 if (! process_unwind (filedata
))
20250 if (! process_symbol_table (filedata
))
20253 if (! process_syminfo (filedata
))
20256 if (! process_version_sections (filedata
))
20259 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20260 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20262 have_separate_files
= FALSE
;
20264 if (! process_section_contents (filedata
))
20267 if (have_separate_files
)
20271 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20273 if (! process_section_headers (d
->handle
))
20275 else if (! process_section_contents (d
->handle
))
20279 /* The file handles are closed by the call to free_debug_memory() below. */
20282 if (! process_notes (filedata
))
20285 if (! process_gnu_liblist (filedata
))
20288 if (! process_arch_specific (filedata
))
20291 free (filedata
->program_headers
);
20292 filedata
->program_headers
= NULL
;
20294 free (filedata
->section_headers
);
20295 filedata
->section_headers
= NULL
;
20297 free (filedata
->string_table
);
20298 filedata
->string_table
= NULL
;
20299 filedata
->string_table_length
= 0;
20301 if (filedata
->dump
.dump_sects
!= NULL
)
20303 free (filedata
->dump
.dump_sects
);
20304 filedata
->dump
.dump_sects
= NULL
;
20305 filedata
->dump
.num_dump_sects
= 0;
20308 if (filedata
->dynamic_strings
)
20310 free (filedata
->dynamic_strings
);
20311 filedata
->dynamic_strings
= NULL
;
20312 filedata
->dynamic_strings_length
= 0;
20315 if (filedata
->dynamic_symbols
)
20317 free (filedata
->dynamic_symbols
);
20318 filedata
->dynamic_symbols
= NULL
;
20319 filedata
->num_dynamic_syms
= 0;
20322 if (filedata
->dynamic_syminfo
)
20324 free (filedata
->dynamic_syminfo
);
20325 filedata
->dynamic_syminfo
= NULL
;
20328 if (filedata
->dynamic_section
)
20330 free (filedata
->dynamic_section
);
20331 filedata
->dynamic_section
= NULL
;
20334 while (filedata
->symtab_shndx_list
!= NULL
)
20336 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20337 free (filedata
->symtab_shndx_list
);
20338 filedata
->symtab_shndx_list
= next
;
20341 if (filedata
->section_headers_groups
)
20343 free (filedata
->section_headers_groups
);
20344 filedata
->section_headers_groups
= NULL
;
20347 if (filedata
->section_groups
)
20349 struct group_list
* g
;
20350 struct group_list
* next
;
20352 for (i
= 0; i
< filedata
->group_count
; i
++)
20354 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20361 free (filedata
->section_groups
);
20362 filedata
->section_groups
= NULL
;
20365 free_debug_memory ();
20370 /* Process an ELF archive.
20371 On entry the file is positioned just after the ARMAG string.
20372 Returns TRUE upon success, FALSE otherwise. */
20375 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20377 struct archive_info arch
;
20378 struct archive_info nested_arch
;
20380 bfd_boolean ret
= TRUE
;
20384 /* The ARCH structure is used to hold information about this archive. */
20385 arch
.file_name
= NULL
;
20387 arch
.index_array
= NULL
;
20388 arch
.sym_table
= NULL
;
20389 arch
.longnames
= NULL
;
20391 /* The NESTED_ARCH structure is used as a single-item cache of information
20392 about a nested archive (when members of a thin archive reside within
20393 another regular archive file). */
20394 nested_arch
.file_name
= NULL
;
20395 nested_arch
.file
= NULL
;
20396 nested_arch
.index_array
= NULL
;
20397 nested_arch
.sym_table
= NULL
;
20398 nested_arch
.longnames
= NULL
;
20400 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20401 filedata
->file_size
, is_thin_archive
,
20402 do_archive_index
) != 0)
20408 if (do_archive_index
)
20410 if (arch
.sym_table
== NULL
)
20411 error (_("%s: unable to dump the index as none was found\n"),
20412 filedata
->file_name
);
20415 unsigned long i
, l
;
20416 unsigned long current_pos
;
20418 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20419 "in the symbol table)\n"),
20420 filedata
->file_name
, (unsigned long) arch
.index_num
,
20423 current_pos
= ftell (filedata
->handle
);
20425 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20428 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20431 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20434 if (member_name
!= NULL
)
20436 char * qualified_name
20437 = make_qualified_name (&arch
, &nested_arch
,
20440 if (qualified_name
!= NULL
)
20442 printf (_("Contents of binary %s at offset "),
20444 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20446 free (qualified_name
);
20448 free (member_name
);
20452 if (l
>= arch
.sym_size
)
20454 error (_("%s: end of the symbol table reached "
20455 "before the end of the index\n"),
20456 filedata
->file_name
);
20460 /* PR 17531: file: 0b6630b2. */
20461 printf ("\t%.*s\n",
20462 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20463 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20466 if (arch
.uses_64bit_indices
)
20471 if (l
< arch
.sym_size
)
20473 error (ngettext ("%s: %ld byte remains in the symbol table, "
20474 "but without corresponding entries in "
20475 "the index table\n",
20476 "%s: %ld bytes remain in the symbol table, "
20477 "but without corresponding entries in "
20478 "the index table\n",
20479 arch
.sym_size
- l
),
20480 filedata
->file_name
, arch
.sym_size
- l
);
20484 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20486 error (_("%s: failed to seek back to start of object files "
20487 "in the archive\n"),
20488 filedata
->file_name
);
20494 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20495 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20496 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20497 && !do_section_groups
&& !do_dyn_syms
)
20499 ret
= TRUE
; /* Archive index only. */
20508 char * qualified_name
;
20510 /* Read the next archive header. */
20511 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20513 error (_("%s: failed to seek to next archive header\n"),
20518 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20519 if (got
!= sizeof arch
.arhdr
)
20523 /* PR 24049 - we cannot use filedata->file_name as this will
20524 have already been freed. */
20525 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20530 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20532 error (_("%s: did not find a valid archive header\n"),
20538 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20540 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20541 if (filedata
->archive_file_size
& 01)
20542 ++filedata
->archive_file_size
;
20544 name
= get_archive_member_name (&arch
, &nested_arch
);
20547 error (_("%s: bad archive file name\n"), arch
.file_name
);
20551 namelen
= strlen (name
);
20553 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20554 if (qualified_name
== NULL
)
20556 error (_("%s: bad archive file name\n"), arch
.file_name
);
20562 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20564 /* This is a proxy for an external member of a thin archive. */
20565 Filedata
* member_filedata
;
20566 char * member_file_name
= adjust_relative_path
20567 (filedata
->file_name
, name
, namelen
);
20570 if (member_file_name
== NULL
)
20572 free (qualified_name
);
20577 member_filedata
= open_file (member_file_name
);
20578 if (member_filedata
== NULL
)
20580 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20581 free (member_file_name
);
20582 free (qualified_name
);
20587 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20588 member_filedata
->file_name
= qualified_name
;
20590 if (! process_object (member_filedata
))
20593 close_file (member_filedata
);
20594 free (member_file_name
);
20596 else if (is_thin_archive
)
20598 Filedata thin_filedata
;
20600 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20602 /* PR 15140: Allow for corrupt thin archives. */
20603 if (nested_arch
.file
== NULL
)
20605 error (_("%s: contains corrupt thin archive: %s\n"),
20606 qualified_name
, name
);
20607 free (qualified_name
);
20614 /* This is a proxy for a member of a nested archive. */
20615 filedata
->archive_file_offset
20616 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20618 /* The nested archive file will have been opened and setup by
20619 get_archive_member_name. */
20620 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20623 error (_("%s: failed to seek to archive member.\n"),
20624 nested_arch
.file_name
);
20625 free (qualified_name
);
20630 thin_filedata
.handle
= nested_arch
.file
;
20631 thin_filedata
.file_name
= qualified_name
;
20633 if (! process_object (& thin_filedata
))
20639 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20640 filedata
->file_name
= qualified_name
;
20641 if (! process_object (filedata
))
20643 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20644 /* Stop looping with "negative" archive_file_size. */
20645 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20646 arch
.next_arhdr_offset
= -1ul;
20649 free (qualified_name
);
20653 if (nested_arch
.file
!= NULL
)
20654 fclose (nested_arch
.file
);
20655 release_archive (&nested_arch
);
20656 release_archive (&arch
);
20662 process_file (char * file_name
)
20664 Filedata
* filedata
= NULL
;
20665 struct stat statbuf
;
20666 char armag
[SARMAG
];
20667 bfd_boolean ret
= TRUE
;
20669 if (stat (file_name
, &statbuf
) < 0)
20671 if (errno
== ENOENT
)
20672 error (_("'%s': No such file\n"), file_name
);
20674 error (_("Could not locate '%s'. System error message: %s\n"),
20675 file_name
, strerror (errno
));
20679 if (! S_ISREG (statbuf
.st_mode
))
20681 error (_("'%s' is not an ordinary file\n"), file_name
);
20685 filedata
= calloc (1, sizeof * filedata
);
20686 if (filedata
== NULL
)
20688 error (_("Out of memory allocating file data structure\n"));
20692 filedata
->file_name
= file_name
;
20693 filedata
->handle
= fopen (file_name
, "rb");
20694 if (filedata
->handle
== NULL
)
20696 error (_("Input file '%s' is not readable.\n"), file_name
);
20701 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20703 error (_("%s: Failed to read file's magic number\n"), file_name
);
20704 fclose (filedata
->handle
);
20709 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20711 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20713 if (! process_archive (filedata
, FALSE
))
20716 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20718 if ( ! process_archive (filedata
, TRUE
))
20723 if (do_archive_index
&& !check_all
)
20724 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20727 rewind (filedata
->handle
);
20728 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20730 if (! process_object (filedata
))
20734 fclose (filedata
->handle
);
20735 free (filedata
->section_headers
);
20736 free (filedata
->program_headers
);
20737 free (filedata
->string_table
);
20738 free (filedata
->dump
.dump_sects
);
20741 free (ba_cache
.strtab
);
20742 ba_cache
.strtab
= NULL
;
20743 free (ba_cache
.symtab
);
20744 ba_cache
.symtab
= NULL
;
20745 ba_cache
.filedata
= NULL
;
20750 #ifdef SUPPORT_DISASSEMBLY
20751 /* Needed by the i386 disassembler. For extra credit, someone could
20752 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20756 print_address (unsigned int addr
, FILE * outfile
)
20758 fprintf (outfile
,"0x%8.8x", addr
);
20761 /* Needed by the i386 disassembler. */
20764 db_task_printsym (unsigned int addr
)
20766 print_address (addr
, stderr
);
20771 main (int argc
, char ** argv
)
20775 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20776 setlocale (LC_MESSAGES
, "");
20778 #if defined (HAVE_SETLOCALE)
20779 setlocale (LC_CTYPE
, "");
20781 bindtextdomain (PACKAGE
, LOCALEDIR
);
20782 textdomain (PACKAGE
);
20784 expandargv (&argc
, &argv
);
20786 parse_args (& cmdline
, argc
, argv
);
20788 if (optind
< (argc
- 1))
20789 /* When displaying information for more than one file,
20790 prefix the information with the file name. */
20792 else if (optind
>= argc
)
20794 /* Ensure that the warning is always displayed. */
20797 warn (_("Nothing to do.\n"));
20802 while (optind
< argc
)
20803 if (! process_file (argv
[optind
++]))
20806 if (cmdline
.dump_sects
!= NULL
)
20807 free (cmdline
.dump_sects
);
20809 free (dump_ctf_symtab_name
);
20810 free (dump_ctf_strtab_name
);
20811 free (dump_ctf_parent_name
);
20813 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;