1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/csky.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
107 #include "elf/epiphany.h"
108 #include "elf/fr30.h"
110 #include "elf/ft32.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/s12z.h"
126 #include "elf/mcore.h"
128 #include "elf/metag.h"
129 #include "elf/microblaze.h"
130 #include "elf/mips.h"
131 #include "elf/mmix.h"
132 #include "elf/mn10200.h"
133 #include "elf/mn10300.h"
134 #include "elf/moxie.h"
136 #include "elf/msp430.h"
137 #include "elf/nds32.h"
139 #include "elf/nios2.h"
140 #include "elf/or1k.h"
143 #include "elf/ppc64.h"
145 #include "elf/riscv.h"
146 #include "elf/rl78.h"
148 #include "elf/s390.h"
149 #include "elf/score.h"
151 #include "elf/sparc.h"
153 #include "elf/tic6x.h"
154 #include "elf/tilegx.h"
155 #include "elf/tilepro.h"
156 #include "elf/v850.h"
158 #include "elf/visium.h"
159 #include "elf/wasm32.h"
160 #include "elf/x86-64.h"
161 #include "elf/xc16x.h"
162 #include "elf/xgate.h"
163 #include "elf/xstormy16.h"
164 #include "elf/xtensa.h"
168 #include "libiberty.h"
169 #include "safe-ctype.h"
170 #include "filenames.h"
173 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
176 typedef struct elf_section_list
178 Elf_Internal_Shdr
* hdr
;
179 struct elf_section_list
* next
;
182 /* Flag bits indicating particular types of dump. */
183 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
184 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
187 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
190 typedef unsigned char dump_type
;
192 /* A linked list of the section names for which dumps were requested. */
193 struct dump_list_entry
197 struct dump_list_entry
* next
;
200 /* A dynamic array of flags indicating for which sections a dump
201 has been requested via command line switches. */
204 dump_type
* dump_sects
;
205 unsigned int num_dump_sects
;
208 static struct dump_data cmdline
;
210 static struct dump_list_entry
* dump_sects_byname
;
212 char * program_name
= "readelf";
214 static bfd_boolean show_name
= FALSE
;
215 static bfd_boolean do_dynamic
= FALSE
;
216 static bfd_boolean do_syms
= FALSE
;
217 static bfd_boolean do_dyn_syms
= FALSE
;
218 static bfd_boolean do_reloc
= FALSE
;
219 static bfd_boolean do_sections
= FALSE
;
220 static bfd_boolean do_section_groups
= FALSE
;
221 static bfd_boolean do_section_details
= FALSE
;
222 static bfd_boolean do_segments
= FALSE
;
223 static bfd_boolean do_unwind
= FALSE
;
224 static bfd_boolean do_using_dynamic
= FALSE
;
225 static bfd_boolean do_header
= FALSE
;
226 static bfd_boolean do_dump
= FALSE
;
227 static bfd_boolean do_version
= FALSE
;
228 static bfd_boolean do_histogram
= FALSE
;
229 static bfd_boolean do_debugging
= FALSE
;
230 static bfd_boolean do_ctf
= FALSE
;
231 static bfd_boolean do_arch
= FALSE
;
232 static bfd_boolean do_notes
= FALSE
;
233 static bfd_boolean do_archive_index
= FALSE
;
234 static bfd_boolean check_all
= FALSE
;
235 static bfd_boolean is_32bit_elf
= FALSE
;
236 static bfd_boolean decompress_dumps
= FALSE
;
238 static char *dump_ctf_parent_name
;
239 static char *dump_ctf_symtab_name
;
240 static char *dump_ctf_strtab_name
;
244 struct group_list
* next
;
245 unsigned int section_index
;
250 struct group_list
* root
;
251 unsigned int group_index
;
254 typedef struct filedata
256 const char * file_name
;
258 bfd_size_type file_size
;
259 Elf_Internal_Ehdr file_header
;
260 Elf_Internal_Shdr
* section_headers
;
261 Elf_Internal_Phdr
* program_headers
;
263 unsigned long string_table_length
;
264 unsigned long archive_file_offset
;
265 unsigned long archive_file_size
;
266 unsigned long dynamic_addr
;
267 bfd_size_type dynamic_size
;
269 Elf_Internal_Dyn
* dynamic_section
;
270 Elf_Internal_Shdr
* dynamic_strtab_section
;
271 char * dynamic_strings
;
272 unsigned long dynamic_strings_length
;
273 Elf_Internal_Shdr
* dynamic_symtab_section
;
274 unsigned long num_dynamic_syms
;
275 Elf_Internal_Sym
* dynamic_symbols
;
276 bfd_vma version_info
[16];
277 unsigned int dynamic_syminfo_nent
;
278 Elf_Internal_Syminfo
* dynamic_syminfo
;
279 unsigned long dynamic_syminfo_offset
;
280 bfd_size_type nbuckets
;
281 bfd_size_type nchains
;
284 bfd_size_type ngnubuckets
;
285 bfd_size_type ngnuchains
;
286 bfd_vma
* gnubuckets
;
290 char program_interpreter
[PATH_MAX
];
291 bfd_vma dynamic_info
[DT_ENCODING
];
292 bfd_vma dynamic_info_DT_GNU_HASH
;
293 bfd_vma dynamic_info_DT_MIPS_XHASH
;
294 elf_section_list
* symtab_shndx_list
;
296 struct group
* section_groups
;
297 struct group
** section_headers_groups
;
298 /* A dynamic array of flags indicating for which sections a dump of
299 some kind has been requested. It is reset on a per-object file
300 basis and then initialised from the cmdline_dump_sects array,
301 the results of interpreting the -w switch, and the
302 dump_sects_byname list. */
303 struct dump_data dump
;
306 /* How to print a vma value. */
307 typedef enum print_mode
319 /* Versioned symbol info. */
320 enum versioned_symbol_info
327 static const char * get_symbol_version_string
328 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
329 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
333 #define SECTION_NAME(X) \
334 ((X) == NULL ? _("<none>") \
335 : filedata->string_table == NULL ? _("<no-strings>") \
336 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
337 : filedata->string_table + (X)->sh_name))
339 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
341 #define GET_ELF_SYMBOLS(file, section, sym_count) \
342 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
343 : get_64bit_elf_symbols (file, section, sym_count))
345 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
346 (strtab != NULL && offset < strtab_size)
347 #define VALID_DYNAMIC_NAME(filedata, offset) \
348 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
349 filedata->dynamic_strings_length, offset)
350 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
351 already been called and verified that the string exists. */
352 #define GET_DYNAMIC_NAME(filedata, offset) \
353 (filedata->dynamic_strings + offset)
355 #define REMOVE_ARCH_BITS(ADDR) \
358 if (filedata->file_header.e_machine == EM_ARM) \
363 /* Get the correct GNU hash section name. */
364 #define GNU_HASH_SECTION_NAME(filedata) \
365 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
367 /* Print a BFD_VMA to an internal buffer, for use in error messages.
368 BFD_FMA_FMT can't be used in translated strings. */
371 bfd_vmatoa (char *fmtch
, bfd_vma value
)
373 /* bfd_vmatoa is used more then once in a printf call for output.
374 Cycle through an array of buffers. */
375 static int buf_pos
= 0;
376 static struct bfd_vmatoa_buf
383 ret
= buf
[buf_pos
++].place
;
384 buf_pos
%= ARRAY_SIZE (buf
);
386 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
387 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
391 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
392 OFFSET + the offset of the current archive member, if we are examining an
393 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
394 allocate a buffer using malloc and fill that. In either case return the
395 pointer to the start of the retrieved data or NULL if something went wrong.
396 If something does go wrong and REASON is not NULL then emit an error
397 message using REASON as part of the context. */
400 get_data (void * var
,
402 unsigned long offset
,
408 bfd_size_type amt
= size
* nmemb
;
410 if (size
== 0 || nmemb
== 0)
413 /* If the size_t type is smaller than the bfd_size_type, eg because
414 you are building a 32-bit tool on a 64-bit host, then make sure
415 that when the sizes are cast to (size_t) no information is lost. */
416 if ((size_t) size
!= size
417 || (size_t) nmemb
!= nmemb
418 || (size_t) amt
!= amt
)
421 error (_("Size truncation prevents reading %s"
422 " elements of size %s for %s\n"),
423 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
427 /* Check for size overflow. */
428 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
431 error (_("Size overflow prevents reading %s"
432 " elements of size %s for %s\n"),
433 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
437 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
438 attempting to allocate memory when the read is bound to fail. */
439 if (filedata
->archive_file_offset
> filedata
->file_size
440 || offset
> filedata
->file_size
- filedata
->archive_file_offset
441 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
444 error (_("Reading %s bytes extends past end of file for %s\n"),
445 bfd_vmatoa ("u", amt
), reason
);
449 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
453 error (_("Unable to seek to 0x%lx for %s\n"),
454 filedata
->archive_file_offset
+ offset
, reason
);
461 /* + 1 so that we can '\0' terminate invalid string table sections. */
462 mvar
= malloc ((size_t) amt
+ 1);
467 error (_("Out of memory allocating %s bytes for %s\n"),
468 bfd_vmatoa ("u", amt
), reason
);
472 ((char *) mvar
)[amt
] = '\0';
475 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
478 error (_("Unable to read in %s bytes of %s\n"),
479 bfd_vmatoa ("u", amt
), reason
);
488 /* Print a VMA value in the MODE specified.
489 Returns the number of characters displayed. */
492 print_vma (bfd_vma vma
, print_mode mode
)
504 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
511 return printf ("%5" BFD_VMA_FMT
"d", vma
);
517 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
520 return printf ("%" BFD_VMA_FMT
"d", vma
);
523 return printf ("%" BFD_VMA_FMT
"u", vma
);
526 /* FIXME: Report unrecognised mode ? */
531 /* Display a symbol on stdout. Handles the display of control characters and
532 multibye characters (assuming the host environment supports them).
534 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
536 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
537 padding as necessary.
539 Returns the number of emitted characters. */
542 print_symbol (signed int width
, const char *symbol
)
544 bfd_boolean extra_padding
= FALSE
;
545 signed int num_printed
= 0;
546 #ifdef HAVE_MBSTATE_T
549 unsigned int width_remaining
;
553 /* Keep the width positive. This helps the code below. */
555 extra_padding
= TRUE
;
561 /* Set the remaining width to a very large value.
562 This simplifies the code below. */
563 width_remaining
= INT_MAX
;
565 width_remaining
= width
;
567 #ifdef HAVE_MBSTATE_T
568 /* Initialise the multibyte conversion state. */
569 memset (& state
, 0, sizeof (state
));
572 while (width_remaining
)
575 const char c
= *symbol
++;
580 /* Do not print control characters directly as they can affect terminal
581 settings. Such characters usually appear in the names generated
582 by the assembler for local labels. */
585 if (width_remaining
< 2)
588 printf ("^%c", c
+ 0x40);
589 width_remaining
-= 2;
592 else if (ISPRINT (c
))
600 #ifdef HAVE_MBSTATE_T
603 /* Let printf do the hard work of displaying multibyte characters. */
604 printf ("%.1s", symbol
- 1);
608 #ifdef HAVE_MBSTATE_T
609 /* Try to find out how many bytes made up the character that was
610 just printed. Advance the symbol pointer past the bytes that
612 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
616 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
621 if (extra_padding
&& num_printed
< width
)
623 /* Fill in the remaining spaces. */
624 printf ("%-*s", width
- num_printed
, " ");
631 /* Returns a pointer to a static buffer containing a printable version of
632 the given section's name. Like print_symbol, except that it does not try
633 to print multibyte characters, it just interprets them as hex values. */
636 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
638 #define MAX_PRINT_SEC_NAME_LEN 128
639 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
640 const char * name
= SECTION_NAME (sec
);
641 char * buf
= sec_name_buf
;
643 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
645 while ((c
= * name
++) != 0)
656 else if (ISPRINT (c
))
663 static char hex
[17] = "0123456789ABCDEF";
668 * buf
++ = hex
[(c
& 0xf0) >> 4];
669 * buf
++ = hex
[c
& 0x0f];
683 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
685 if (ndx
>= filedata
->file_header
.e_shnum
)
686 return _("<corrupt>");
688 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
691 /* Return a pointer to section NAME, or NULL if no such section exists. */
693 static Elf_Internal_Shdr
*
694 find_section (Filedata
* filedata
, const char * name
)
698 if (filedata
->section_headers
== NULL
)
701 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
702 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
703 return filedata
->section_headers
+ i
;
708 /* Return a pointer to a section containing ADDR, or NULL if no such
711 static Elf_Internal_Shdr
*
712 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
716 if (filedata
->section_headers
== NULL
)
719 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
721 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
723 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
730 static Elf_Internal_Shdr
*
731 find_section_by_type (Filedata
* filedata
, unsigned int type
)
735 if (filedata
->section_headers
== NULL
)
738 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
740 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
742 if (sec
->sh_type
== type
)
749 /* Return a pointer to section NAME, or NULL if no such section exists,
750 restricted to the list of sections given in SET. */
752 static Elf_Internal_Shdr
*
753 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
757 if (filedata
->section_headers
== NULL
)
762 while ((i
= *set
++) > 0)
764 /* See PR 21156 for a reproducer. */
765 if (i
>= filedata
->file_header
.e_shnum
)
766 continue; /* FIXME: Should we issue an error message ? */
768 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
769 return filedata
->section_headers
+ i
;
773 return find_section (filedata
, name
);
776 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
777 This OS has so many departures from the ELF standard that we test it at
780 static inline bfd_boolean
781 is_ia64_vms (Filedata
* filedata
)
783 return filedata
->file_header
.e_machine
== EM_IA_64
784 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
787 /* Guess the relocation size commonly used by the specific machines. */
790 guess_is_rela (unsigned int e_machine
)
794 /* Targets that use REL relocations. */
811 /* Targets that use RELA relocations. */
815 case EM_ADAPTEVA_EPIPHANY
:
817 case EM_ALTERA_NIOS2
:
820 case EM_ARC_COMPACT2
:
841 case EM_LATTICEMICO32
:
850 case EM_CYGNUS_MN10200
:
852 case EM_CYGNUS_MN10300
:
888 case EM_MICROBLAZE_OLD
:
910 warn (_("Don't know about relocations on this machine architecture\n"));
915 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
916 Returns TRUE upon success, FALSE otherwise. If successful then a
917 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
918 and the number of relocs loaded is placed in *NRELASP. It is the caller's
919 responsibility to free the allocated buffer. */
922 slurp_rela_relocs (Filedata
* filedata
,
923 unsigned long rel_offset
,
924 unsigned long rel_size
,
925 Elf_Internal_Rela
** relasp
,
926 unsigned long * nrelasp
)
928 Elf_Internal_Rela
* relas
;
934 Elf32_External_Rela
* erelas
;
936 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
937 rel_size
, _("32-bit relocation data"));
941 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
943 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
944 sizeof (Elf_Internal_Rela
));
949 error (_("out of memory parsing relocs\n"));
953 for (i
= 0; i
< nrelas
; i
++)
955 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
956 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
957 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
964 Elf64_External_Rela
* erelas
;
966 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
967 rel_size
, _("64-bit relocation data"));
971 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
973 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
974 sizeof (Elf_Internal_Rela
));
979 error (_("out of memory parsing relocs\n"));
983 for (i
= 0; i
< nrelas
; i
++)
985 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
986 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
987 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
989 /* The #ifdef BFD64 below is to prevent a compile time
990 warning. We know that if we do not have a 64 bit data
991 type that we will never execute this code anyway. */
993 if (filedata
->file_header
.e_machine
== EM_MIPS
994 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
996 /* In little-endian objects, r_info isn't really a
997 64-bit little-endian value: it has a 32-bit
998 little-endian symbol index followed by four
999 individual byte fields. Reorder INFO
1001 bfd_vma inf
= relas
[i
].r_info
;
1002 inf
= (((inf
& 0xffffffff) << 32)
1003 | ((inf
>> 56) & 0xff)
1004 | ((inf
>> 40) & 0xff00)
1005 | ((inf
>> 24) & 0xff0000)
1006 | ((inf
>> 8) & 0xff000000));
1007 relas
[i
].r_info
= inf
;
1020 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1021 Returns TRUE upon success, FALSE otherwise. If successful then a
1022 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1023 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1024 responsibility to free the allocated buffer. */
1027 slurp_rel_relocs (Filedata
* filedata
,
1028 unsigned long rel_offset
,
1029 unsigned long rel_size
,
1030 Elf_Internal_Rela
** relsp
,
1031 unsigned long * nrelsp
)
1033 Elf_Internal_Rela
* rels
;
1039 Elf32_External_Rel
* erels
;
1041 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1042 rel_size
, _("32-bit relocation data"));
1046 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1048 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1053 error (_("out of memory parsing relocs\n"));
1057 for (i
= 0; i
< nrels
; i
++)
1059 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1060 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1061 rels
[i
].r_addend
= 0;
1068 Elf64_External_Rel
* erels
;
1070 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1071 rel_size
, _("64-bit relocation data"));
1075 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1077 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1082 error (_("out of memory parsing relocs\n"));
1086 for (i
= 0; i
< nrels
; i
++)
1088 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1089 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1090 rels
[i
].r_addend
= 0;
1092 /* The #ifdef BFD64 below is to prevent a compile time
1093 warning. We know that if we do not have a 64 bit data
1094 type that we will never execute this code anyway. */
1096 if (filedata
->file_header
.e_machine
== EM_MIPS
1097 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1099 /* In little-endian objects, r_info isn't really a
1100 64-bit little-endian value: it has a 32-bit
1101 little-endian symbol index followed by four
1102 individual byte fields. Reorder INFO
1104 bfd_vma inf
= rels
[i
].r_info
;
1105 inf
= (((inf
& 0xffffffff) << 32)
1106 | ((inf
>> 56) & 0xff)
1107 | ((inf
>> 40) & 0xff00)
1108 | ((inf
>> 24) & 0xff0000)
1109 | ((inf
>> 8) & 0xff000000));
1110 rels
[i
].r_info
= inf
;
1123 /* Returns the reloc type extracted from the reloc info field. */
1126 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1129 return ELF32_R_TYPE (reloc_info
);
1131 switch (filedata
->file_header
.e_machine
)
1134 /* Note: We assume that reloc_info has already been adjusted for us. */
1135 return ELF64_MIPS_R_TYPE (reloc_info
);
1138 return ELF64_R_TYPE_ID (reloc_info
);
1141 return ELF64_R_TYPE (reloc_info
);
1145 /* Return the symbol index extracted from the reloc info field. */
1148 get_reloc_symindex (bfd_vma reloc_info
)
1150 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1153 static inline bfd_boolean
1154 uses_msp430x_relocs (Filedata
* filedata
)
1157 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1158 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1159 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1160 /* TI compiler uses ELFOSABI_NONE. */
1161 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1164 /* Display the contents of the relocation data found at the specified
1168 dump_relocations (Filedata
* filedata
,
1169 unsigned long rel_offset
,
1170 unsigned long rel_size
,
1171 Elf_Internal_Sym
* symtab
,
1172 unsigned long nsyms
,
1174 unsigned long strtablen
,
1176 bfd_boolean is_dynsym
)
1179 Elf_Internal_Rela
* rels
;
1180 bfd_boolean res
= TRUE
;
1182 if (is_rela
== UNKNOWN
)
1183 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1187 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1192 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1201 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1203 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1208 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1210 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1218 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1220 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1225 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1227 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1231 for (i
= 0; i
< rel_size
; i
++)
1236 bfd_vma symtab_index
;
1239 offset
= rels
[i
].r_offset
;
1240 inf
= rels
[i
].r_info
;
1242 type
= get_reloc_type (filedata
, inf
);
1243 symtab_index
= get_reloc_symindex (inf
);
1247 printf ("%8.8lx %8.8lx ",
1248 (unsigned long) offset
& 0xffffffff,
1249 (unsigned long) inf
& 0xffffffff);
1253 #if BFD_HOST_64BIT_LONG
1255 ? "%16.16lx %16.16lx "
1256 : "%12.12lx %12.12lx ",
1258 #elif BFD_HOST_64BIT_LONG_LONG
1261 ? "%16.16llx %16.16llx "
1262 : "%12.12llx %12.12llx ",
1266 ? "%16.16I64x %16.16I64x "
1267 : "%12.12I64x %12.12I64x ",
1272 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1273 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1274 _bfd_int64_high (offset
),
1275 _bfd_int64_low (offset
),
1276 _bfd_int64_high (inf
),
1277 _bfd_int64_low (inf
));
1281 switch (filedata
->file_header
.e_machine
)
1288 rtype
= elf_aarch64_reloc_type (type
);
1292 case EM_CYGNUS_M32R
:
1293 rtype
= elf_m32r_reloc_type (type
);
1298 rtype
= elf_i386_reloc_type (type
);
1303 rtype
= elf_m68hc11_reloc_type (type
);
1307 rtype
= elf_s12z_reloc_type (type
);
1311 rtype
= elf_m68k_reloc_type (type
);
1315 rtype
= elf_i960_reloc_type (type
);
1320 rtype
= elf_avr_reloc_type (type
);
1323 case EM_OLD_SPARCV9
:
1324 case EM_SPARC32PLUS
:
1327 rtype
= elf_sparc_reloc_type (type
);
1331 rtype
= elf_spu_reloc_type (type
);
1335 rtype
= v800_reloc_type (type
);
1338 case EM_CYGNUS_V850
:
1339 rtype
= v850_reloc_type (type
);
1343 case EM_CYGNUS_D10V
:
1344 rtype
= elf_d10v_reloc_type (type
);
1348 case EM_CYGNUS_D30V
:
1349 rtype
= elf_d30v_reloc_type (type
);
1353 rtype
= elf_dlx_reloc_type (type
);
1357 rtype
= elf_sh_reloc_type (type
);
1361 case EM_CYGNUS_MN10300
:
1362 rtype
= elf_mn10300_reloc_type (type
);
1366 case EM_CYGNUS_MN10200
:
1367 rtype
= elf_mn10200_reloc_type (type
);
1371 case EM_CYGNUS_FR30
:
1372 rtype
= elf_fr30_reloc_type (type
);
1376 rtype
= elf_frv_reloc_type (type
);
1380 rtype
= elf_csky_reloc_type (type
);
1384 rtype
= elf_ft32_reloc_type (type
);
1388 rtype
= elf_mcore_reloc_type (type
);
1392 rtype
= elf_mmix_reloc_type (type
);
1396 rtype
= elf_moxie_reloc_type (type
);
1400 if (uses_msp430x_relocs (filedata
))
1402 rtype
= elf_msp430x_reloc_type (type
);
1407 rtype
= elf_msp430_reloc_type (type
);
1411 rtype
= elf_nds32_reloc_type (type
);
1415 rtype
= elf_ppc_reloc_type (type
);
1419 rtype
= elf_ppc64_reloc_type (type
);
1423 case EM_MIPS_RS3_LE
:
1424 rtype
= elf_mips_reloc_type (type
);
1428 rtype
= elf_riscv_reloc_type (type
);
1432 rtype
= elf_alpha_reloc_type (type
);
1436 rtype
= elf_arm_reloc_type (type
);
1440 case EM_ARC_COMPACT
:
1441 case EM_ARC_COMPACT2
:
1442 rtype
= elf_arc_reloc_type (type
);
1446 rtype
= elf_hppa_reloc_type (type
);
1452 rtype
= elf_h8_reloc_type (type
);
1456 rtype
= elf_or1k_reloc_type (type
);
1461 rtype
= elf_pj_reloc_type (type
);
1464 rtype
= elf_ia64_reloc_type (type
);
1468 rtype
= elf_cris_reloc_type (type
);
1472 rtype
= elf_i860_reloc_type (type
);
1478 rtype
= elf_x86_64_reloc_type (type
);
1482 rtype
= i370_reloc_type (type
);
1487 rtype
= elf_s390_reloc_type (type
);
1491 rtype
= elf_score_reloc_type (type
);
1495 rtype
= elf_xstormy16_reloc_type (type
);
1499 rtype
= elf_crx_reloc_type (type
);
1503 rtype
= elf_vax_reloc_type (type
);
1507 rtype
= elf_visium_reloc_type (type
);
1511 rtype
= elf_bpf_reloc_type (type
);
1514 case EM_ADAPTEVA_EPIPHANY
:
1515 rtype
= elf_epiphany_reloc_type (type
);
1520 rtype
= elf_ip2k_reloc_type (type
);
1524 rtype
= elf_iq2000_reloc_type (type
);
1529 rtype
= elf_xtensa_reloc_type (type
);
1532 case EM_LATTICEMICO32
:
1533 rtype
= elf_lm32_reloc_type (type
);
1538 rtype
= elf_m32c_reloc_type (type
);
1542 rtype
= elf_mt_reloc_type (type
);
1546 rtype
= elf_bfin_reloc_type (type
);
1550 rtype
= elf_mep_reloc_type (type
);
1554 rtype
= elf_cr16_reloc_type (type
);
1558 case EM_MICROBLAZE_OLD
:
1559 rtype
= elf_microblaze_reloc_type (type
);
1563 rtype
= elf_rl78_reloc_type (type
);
1567 rtype
= elf_rx_reloc_type (type
);
1571 rtype
= elf_metag_reloc_type (type
);
1576 rtype
= elf_xc16x_reloc_type (type
);
1580 rtype
= elf_tic6x_reloc_type (type
);
1584 rtype
= elf_tilegx_reloc_type (type
);
1588 rtype
= elf_tilepro_reloc_type (type
);
1591 case EM_WEBASSEMBLY
:
1592 rtype
= elf_wasm32_reloc_type (type
);
1596 rtype
= elf_xgate_reloc_type (type
);
1599 case EM_ALTERA_NIOS2
:
1600 rtype
= elf_nios2_reloc_type (type
);
1604 rtype
= elf_pru_reloc_type (type
);
1608 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1609 rtype
= elf_nfp3200_reloc_type (type
);
1611 rtype
= elf_nfp_reloc_type (type
);
1615 rtype
= elf_z80_reloc_type (type
);
1620 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1622 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1624 if (filedata
->file_header
.e_machine
== EM_ALPHA
1626 && streq (rtype
, "R_ALPHA_LITUSE")
1629 switch (rels
[i
].r_addend
)
1631 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1632 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1633 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1634 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1635 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1636 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1637 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1638 default: rtype
= NULL
;
1642 printf (" (%s)", rtype
);
1646 printf (_("<unknown addend: %lx>"),
1647 (unsigned long) rels
[i
].r_addend
);
1651 else if (symtab_index
)
1653 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1655 error (_(" bad symbol index: %08lx in reloc\n"),
1656 (unsigned long) symtab_index
);
1661 Elf_Internal_Sym
* psym
;
1662 const char * version_string
;
1663 enum versioned_symbol_info sym_info
;
1664 unsigned short vna_other
;
1666 psym
= symtab
+ symtab_index
;
1669 = get_symbol_version_string (filedata
, is_dynsym
,
1678 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1682 unsigned int width
= is_32bit_elf
? 8 : 14;
1684 /* Relocations against GNU_IFUNC symbols do not use the value
1685 of the symbol as the address to relocate against. Instead
1686 they invoke the function named by the symbol and use its
1687 result as the address for relocation.
1689 To indicate this to the user, do not display the value of
1690 the symbol in the "Symbols's Value" field. Instead show
1691 its name followed by () as a hint that the symbol is
1695 || psym
->st_name
== 0
1696 || psym
->st_name
>= strtablen
)
1699 name
= strtab
+ psym
->st_name
;
1701 len
= print_symbol (width
, name
);
1703 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1705 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1709 print_vma (psym
->st_value
, LONG_HEX
);
1711 printf (is_32bit_elf
? " " : " ");
1714 if (psym
->st_name
== 0)
1716 const char * sec_name
= "<null>";
1719 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1721 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1722 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1723 else if (psym
->st_shndx
== SHN_ABS
)
1725 else if (psym
->st_shndx
== SHN_COMMON
)
1726 sec_name
= "COMMON";
1727 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1728 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1729 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1730 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1731 sec_name
= "SCOMMON";
1732 else if (filedata
->file_header
.e_machine
== EM_MIPS
1733 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1734 sec_name
= "SUNDEF";
1735 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1736 || filedata
->file_header
.e_machine
== EM_L1OM
1737 || filedata
->file_header
.e_machine
== EM_K1OM
)
1738 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1739 sec_name
= "LARGE_COMMON";
1740 else if (filedata
->file_header
.e_machine
== EM_IA_64
1741 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1742 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1743 sec_name
= "ANSI_COM";
1744 else if (is_ia64_vms (filedata
)
1745 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1746 sec_name
= "VMS_SYMVEC";
1749 sprintf (name_buf
, "<section 0x%x>",
1750 (unsigned int) psym
->st_shndx
);
1751 sec_name
= name_buf
;
1754 print_symbol (22, sec_name
);
1756 else if (strtab
== NULL
)
1757 printf (_("<string table index: %3ld>"), psym
->st_name
);
1758 else if (psym
->st_name
>= strtablen
)
1760 error (_("<corrupt string table index: %3ld>\n"),
1766 print_symbol (22, strtab
+ psym
->st_name
);
1768 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1774 bfd_vma off
= rels
[i
].r_addend
;
1776 if ((bfd_signed_vma
) off
< 0)
1777 printf (" - %" BFD_VMA_FMT
"x", - off
);
1779 printf (" + %" BFD_VMA_FMT
"x", off
);
1785 bfd_vma off
= rels
[i
].r_addend
;
1787 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1788 if ((bfd_signed_vma
) off
< 0)
1789 printf ("-%" BFD_VMA_FMT
"x", - off
);
1791 printf ("%" BFD_VMA_FMT
"x", off
);
1794 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1796 && streq (rtype
, "R_SPARC_OLO10"))
1797 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1802 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1804 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1805 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1806 const char * rtype2
= elf_mips_reloc_type (type2
);
1807 const char * rtype3
= elf_mips_reloc_type (type3
);
1809 printf (" Type2: ");
1812 printf (_("unrecognized: %-7lx"),
1813 (unsigned long) type2
& 0xffffffff);
1815 printf ("%-17.17s", rtype2
);
1817 printf ("\n Type3: ");
1820 printf (_("unrecognized: %-7lx"),
1821 (unsigned long) type3
& 0xffffffff);
1823 printf ("%-17.17s", rtype3
);
1836 get_aarch64_dynamic_type (unsigned long type
)
1840 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1841 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1842 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1849 get_mips_dynamic_type (unsigned long type
)
1853 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1854 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1855 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1856 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1857 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1858 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1859 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1860 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1861 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1862 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1863 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1864 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1865 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1866 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1867 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1868 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1869 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1870 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1871 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1872 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1873 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1874 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1875 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1876 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1877 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1878 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1879 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1880 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1881 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1882 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1883 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1884 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1885 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1886 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1887 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1888 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1889 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1890 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1891 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1892 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1893 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1894 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1895 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1896 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1897 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1898 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1899 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1906 get_sparc64_dynamic_type (unsigned long type
)
1910 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1917 get_ppc_dynamic_type (unsigned long type
)
1921 case DT_PPC_GOT
: return "PPC_GOT";
1922 case DT_PPC_OPT
: return "PPC_OPT";
1929 get_ppc64_dynamic_type (unsigned long type
)
1933 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1934 case DT_PPC64_OPD
: return "PPC64_OPD";
1935 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1936 case DT_PPC64_OPT
: return "PPC64_OPT";
1943 get_parisc_dynamic_type (unsigned long type
)
1947 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1948 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1949 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1950 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1951 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1952 case DT_HP_PREINIT
: return "HP_PREINIT";
1953 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1954 case DT_HP_NEEDED
: return "HP_NEEDED";
1955 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1956 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1957 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1958 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1959 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1960 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1961 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1962 case DT_HP_FILTERED
: return "HP_FILTERED";
1963 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1964 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1965 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1966 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1967 case DT_PLT
: return "PLT";
1968 case DT_PLT_SIZE
: return "PLT_SIZE";
1969 case DT_DLT
: return "DLT";
1970 case DT_DLT_SIZE
: return "DLT_SIZE";
1977 get_ia64_dynamic_type (unsigned long type
)
1981 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1982 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1983 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1984 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1985 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1986 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1987 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1988 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1989 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1990 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1991 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1992 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1993 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1994 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1995 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1996 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1997 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1998 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1999 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2000 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2001 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2002 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2003 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2004 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2005 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2006 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2007 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2008 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2009 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2010 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2011 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2018 get_solaris_section_type (unsigned long type
)
2022 case 0x6fffffee: return "SUNW_ancillary";
2023 case 0x6fffffef: return "SUNW_capchain";
2024 case 0x6ffffff0: return "SUNW_capinfo";
2025 case 0x6ffffff1: return "SUNW_symsort";
2026 case 0x6ffffff2: return "SUNW_tlssort";
2027 case 0x6ffffff3: return "SUNW_LDYNSYM";
2028 case 0x6ffffff4: return "SUNW_dof";
2029 case 0x6ffffff5: return "SUNW_cap";
2030 case 0x6ffffff6: return "SUNW_SIGNATURE";
2031 case 0x6ffffff7: return "SUNW_ANNOTATE";
2032 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2033 case 0x6ffffff9: return "SUNW_DEBUG";
2034 case 0x6ffffffa: return "SUNW_move";
2035 case 0x6ffffffb: return "SUNW_COMDAT";
2036 case 0x6ffffffc: return "SUNW_syminfo";
2037 case 0x6ffffffd: return "SUNW_verdef";
2038 case 0x6ffffffe: return "SUNW_verneed";
2039 case 0x6fffffff: return "SUNW_versym";
2040 case 0x70000000: return "SPARC_GOTDATA";
2041 default: return NULL
;
2046 get_alpha_dynamic_type (unsigned long type
)
2050 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2051 default: return NULL
;
2056 get_score_dynamic_type (unsigned long type
)
2060 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2061 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2062 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2063 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2064 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2065 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2066 default: return NULL
;
2071 get_tic6x_dynamic_type (unsigned long type
)
2075 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2076 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2077 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2078 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2079 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2080 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2081 default: return NULL
;
2086 get_nios2_dynamic_type (unsigned long type
)
2090 case DT_NIOS2_GP
: return "NIOS2_GP";
2091 default: return NULL
;
2096 get_solaris_dynamic_type (unsigned long type
)
2100 case 0x6000000d: return "SUNW_AUXILIARY";
2101 case 0x6000000e: return "SUNW_RTLDINF";
2102 case 0x6000000f: return "SUNW_FILTER";
2103 case 0x60000010: return "SUNW_CAP";
2104 case 0x60000011: return "SUNW_SYMTAB";
2105 case 0x60000012: return "SUNW_SYMSZ";
2106 case 0x60000013: return "SUNW_SORTENT";
2107 case 0x60000014: return "SUNW_SYMSORT";
2108 case 0x60000015: return "SUNW_SYMSORTSZ";
2109 case 0x60000016: return "SUNW_TLSSORT";
2110 case 0x60000017: return "SUNW_TLSSORTSZ";
2111 case 0x60000018: return "SUNW_CAPINFO";
2112 case 0x60000019: return "SUNW_STRPAD";
2113 case 0x6000001a: return "SUNW_CAPCHAIN";
2114 case 0x6000001b: return "SUNW_LDMACH";
2115 case 0x6000001d: return "SUNW_CAPCHAINENT";
2116 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2117 case 0x60000021: return "SUNW_PARENT";
2118 case 0x60000023: return "SUNW_ASLR";
2119 case 0x60000025: return "SUNW_RELAX";
2120 case 0x60000029: return "SUNW_NXHEAP";
2121 case 0x6000002b: return "SUNW_NXSTACK";
2123 case 0x70000001: return "SPARC_REGISTER";
2124 case 0x7ffffffd: return "AUXILIARY";
2125 case 0x7ffffffe: return "USED";
2126 case 0x7fffffff: return "FILTER";
2128 default: return NULL
;
2133 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2135 static char buff
[64];
2139 case DT_NULL
: return "NULL";
2140 case DT_NEEDED
: return "NEEDED";
2141 case DT_PLTRELSZ
: return "PLTRELSZ";
2142 case DT_PLTGOT
: return "PLTGOT";
2143 case DT_HASH
: return "HASH";
2144 case DT_STRTAB
: return "STRTAB";
2145 case DT_SYMTAB
: return "SYMTAB";
2146 case DT_RELA
: return "RELA";
2147 case DT_RELASZ
: return "RELASZ";
2148 case DT_RELAENT
: return "RELAENT";
2149 case DT_STRSZ
: return "STRSZ";
2150 case DT_SYMENT
: return "SYMENT";
2151 case DT_INIT
: return "INIT";
2152 case DT_FINI
: return "FINI";
2153 case DT_SONAME
: return "SONAME";
2154 case DT_RPATH
: return "RPATH";
2155 case DT_SYMBOLIC
: return "SYMBOLIC";
2156 case DT_REL
: return "REL";
2157 case DT_RELSZ
: return "RELSZ";
2158 case DT_RELENT
: return "RELENT";
2159 case DT_PLTREL
: return "PLTREL";
2160 case DT_DEBUG
: return "DEBUG";
2161 case DT_TEXTREL
: return "TEXTREL";
2162 case DT_JMPREL
: return "JMPREL";
2163 case DT_BIND_NOW
: return "BIND_NOW";
2164 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2165 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2166 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2167 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2168 case DT_RUNPATH
: return "RUNPATH";
2169 case DT_FLAGS
: return "FLAGS";
2171 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2172 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2173 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2175 case DT_CHECKSUM
: return "CHECKSUM";
2176 case DT_PLTPADSZ
: return "PLTPADSZ";
2177 case DT_MOVEENT
: return "MOVEENT";
2178 case DT_MOVESZ
: return "MOVESZ";
2179 case DT_FEATURE
: return "FEATURE";
2180 case DT_POSFLAG_1
: return "POSFLAG_1";
2181 case DT_SYMINSZ
: return "SYMINSZ";
2182 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2184 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2185 case DT_CONFIG
: return "CONFIG";
2186 case DT_DEPAUDIT
: return "DEPAUDIT";
2187 case DT_AUDIT
: return "AUDIT";
2188 case DT_PLTPAD
: return "PLTPAD";
2189 case DT_MOVETAB
: return "MOVETAB";
2190 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2192 case DT_VERSYM
: return "VERSYM";
2194 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2195 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2196 case DT_RELACOUNT
: return "RELACOUNT";
2197 case DT_RELCOUNT
: return "RELCOUNT";
2198 case DT_FLAGS_1
: return "FLAGS_1";
2199 case DT_VERDEF
: return "VERDEF";
2200 case DT_VERDEFNUM
: return "VERDEFNUM";
2201 case DT_VERNEED
: return "VERNEED";
2202 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2204 case DT_AUXILIARY
: return "AUXILIARY";
2205 case DT_USED
: return "USED";
2206 case DT_FILTER
: return "FILTER";
2208 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2209 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2210 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2211 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2212 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2213 case DT_GNU_HASH
: return "GNU_HASH";
2216 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2218 const char * result
;
2220 switch (filedata
->file_header
.e_machine
)
2223 result
= get_aarch64_dynamic_type (type
);
2226 case EM_MIPS_RS3_LE
:
2227 result
= get_mips_dynamic_type (type
);
2230 result
= get_sparc64_dynamic_type (type
);
2233 result
= get_ppc_dynamic_type (type
);
2236 result
= get_ppc64_dynamic_type (type
);
2239 result
= get_ia64_dynamic_type (type
);
2242 result
= get_alpha_dynamic_type (type
);
2245 result
= get_score_dynamic_type (type
);
2248 result
= get_tic6x_dynamic_type (type
);
2250 case EM_ALTERA_NIOS2
:
2251 result
= get_nios2_dynamic_type (type
);
2254 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2255 result
= get_solaris_dynamic_type (type
);
2264 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2266 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2267 || (filedata
->file_header
.e_machine
== EM_PARISC
2268 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2270 const char * result
;
2272 switch (filedata
->file_header
.e_machine
)
2275 result
= get_parisc_dynamic_type (type
);
2278 result
= get_ia64_dynamic_type (type
);
2281 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2282 result
= get_solaris_dynamic_type (type
);
2291 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2295 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2302 get_file_type (unsigned e_type
)
2304 static char buff
[64];
2308 case ET_NONE
: return _("NONE (None)");
2309 case ET_REL
: return _("REL (Relocatable file)");
2310 case ET_EXEC
: return _("EXEC (Executable file)");
2311 case ET_DYN
: return _("DYN (Shared object file)");
2312 case ET_CORE
: return _("CORE (Core file)");
2315 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2316 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2317 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2318 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2320 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2326 get_machine_name (unsigned e_machine
)
2328 static char buff
[64]; /* XXX */
2332 /* Please keep this switch table sorted by increasing EM_ value. */
2334 case EM_NONE
: return _("None");
2335 case EM_M32
: return "WE32100";
2336 case EM_SPARC
: return "Sparc";
2337 case EM_386
: return "Intel 80386";
2338 case EM_68K
: return "MC68000";
2339 case EM_88K
: return "MC88000";
2340 case EM_IAMCU
: return "Intel MCU";
2341 case EM_860
: return "Intel 80860";
2342 case EM_MIPS
: return "MIPS R3000";
2343 case EM_S370
: return "IBM System/370";
2345 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2346 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2347 case EM_PARISC
: return "HPPA";
2348 case EM_VPP550
: return "Fujitsu VPP500";
2349 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2350 case EM_960
: return "Intel 80960";
2351 case EM_PPC
: return "PowerPC";
2353 case EM_PPC64
: return "PowerPC64";
2355 case EM_S390
: return "IBM S/390";
2356 case EM_SPU
: return "SPU";
2358 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2359 case EM_FR20
: return "Fujitsu FR20";
2360 case EM_RH32
: return "TRW RH32";
2361 case EM_MCORE
: return "MCORE";
2363 case EM_ARM
: return "ARM";
2364 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2365 case EM_SH
: return "Renesas / SuperH SH";
2366 case EM_SPARCV9
: return "Sparc v9";
2367 case EM_TRICORE
: return "Siemens Tricore";
2368 case EM_ARC
: return "ARC";
2369 case EM_H8_300
: return "Renesas H8/300";
2370 case EM_H8_300H
: return "Renesas H8/300H";
2371 case EM_H8S
: return "Renesas H8S";
2372 case EM_H8_500
: return "Renesas H8/500";
2374 case EM_IA_64
: return "Intel IA-64";
2375 case EM_MIPS_X
: return "Stanford MIPS-X";
2376 case EM_COLDFIRE
: return "Motorola Coldfire";
2377 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2378 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2379 case EM_PCP
: return "Siemens PCP";
2380 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2381 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2382 case EM_STARCORE
: return "Motorola Star*Core processor";
2383 case EM_ME16
: return "Toyota ME16 processor";
2385 case EM_ST100
: return "STMicroelectronics ST100 processor";
2386 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2387 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2388 case EM_PDSP
: return "Sony DSP processor";
2389 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2390 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2391 case EM_FX66
: return "Siemens FX66 microcontroller";
2392 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2393 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2394 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2396 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2397 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2398 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2399 case EM_SVX
: return "Silicon Graphics SVx";
2400 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2401 case EM_VAX
: return "Digital VAX";
2402 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2403 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2404 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2405 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2407 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2408 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2409 case EM_PRISM
: return "Vitesse Prism";
2411 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2412 case EM_CYGNUS_FR30
:
2413 case EM_FR30
: return "Fujitsu FR30";
2414 case EM_CYGNUS_D10V
:
2415 case EM_D10V
: return "d10v";
2416 case EM_CYGNUS_D30V
:
2417 case EM_D30V
: return "d30v";
2418 case EM_CYGNUS_V850
:
2419 case EM_V850
: return "Renesas V850";
2420 case EM_CYGNUS_M32R
:
2421 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2422 case EM_CYGNUS_MN10300
:
2423 case EM_MN10300
: return "mn10300";
2425 case EM_CYGNUS_MN10200
:
2426 case EM_MN10200
: return "mn10200";
2427 case EM_PJ
: return "picoJava";
2428 case EM_OR1K
: return "OpenRISC 1000";
2429 case EM_ARC_COMPACT
: return "ARCompact";
2431 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2432 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2433 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2434 case EM_NS32K
: return "National Semiconductor 32000 series";
2435 case EM_TPC
: return "Tenor Network TPC processor";
2436 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2438 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2440 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2441 case EM_MAX
: return "MAX Processor";
2442 case EM_CR
: return "National Semiconductor CompactRISC";
2443 case EM_F2MC16
: return "Fujitsu F2MC16";
2444 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2445 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2446 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2447 case EM_SEP
: return "Sharp embedded microprocessor";
2448 case EM_ARCA
: return "Arca RISC microprocessor";
2450 case EM_UNICORE
: return "Unicore";
2451 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2452 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2453 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2454 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2455 case EM_XGATE
: return "Motorola XGATE embedded processor";
2457 case EM_XC16X
: return "Infineon Technologies xc16x";
2458 case EM_M16C
: return "Renesas M16C series microprocessors";
2459 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2460 case EM_CE
: return "Freescale Communication Engine RISC core";
2462 case EM_M32C
: return "Renesas M32c";
2464 case EM_TSK3000
: return "Altium TSK3000 core";
2465 case EM_RS08
: return "Freescale RS08 embedded processor";
2466 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2467 case EM_SCORE
: return "SUNPLUS S+Core";
2468 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2469 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2470 case EM_LATTICEMICO32
: return "Lattice Mico32";
2471 case EM_SE_C17
: return "Seiko Epson C17 family";
2473 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2474 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2475 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2476 case EM_TI_PRU
: return "TI PRU I/O processor";
2478 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2479 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2480 case EM_R32C
: return "Renesas R32C series microprocessors";
2481 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2482 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2483 case EM_8051
: return "Intel 8051 and variants";
2484 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2485 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2486 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2487 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2489 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2490 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2491 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2492 case EM_RX
: return "Renesas RX";
2493 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2494 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2495 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2498 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2499 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2500 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2502 case EM_L1OM
: return "Intel L1OM";
2503 case EM_K1OM
: return "Intel K1OM";
2504 case EM_INTEL182
: return "Intel (reserved)";
2505 case EM_AARCH64
: return "AArch64";
2506 case EM_ARM184
: return "ARM (reserved)";
2507 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2508 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2509 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2510 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2512 case EM_CUDA
: return "NVIDIA CUDA architecture";
2513 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2514 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2515 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2516 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2517 case EM_ARC_COMPACT2
: return "ARCv2";
2518 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2519 case EM_RL78
: return "Renesas RL78";
2520 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2521 case EM_78K0R
: return "Renesas 78K0R";
2523 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2524 case EM_BA1
: return "Beyond BA1 CPU architecture";
2525 case EM_BA2
: return "Beyond BA2 CPU architecture";
2526 case EM_XCORE
: return "XMOS xCORE processor family";
2527 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2529 case EM_KM32
: return "KM211 KM32 32-bit processor";
2530 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2531 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2532 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2533 case EM_KVARC
: return "KM211 KVARC processor";
2534 case EM_CDP
: return "Paneve CDP architecture family";
2535 case EM_COGE
: return "Cognitive Smart Memory Processor";
2536 case EM_COOL
: return "Bluechip Systems CoolEngine";
2537 case EM_NORC
: return "Nanoradio Optimized RISC";
2538 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2540 case EM_Z80
: return "Zilog Z80";
2541 case EM_VISIUM
: return "CDS VISIUMcore processor";
2542 case EM_FT32
: return "FTDI Chip FT32";
2543 case EM_MOXIE
: return "Moxie";
2544 case EM_AMDGPU
: return "AMD GPU";
2545 case EM_RISCV
: return "RISC-V";
2546 case EM_LANAI
: return "Lanai 32-bit processor";
2547 case EM_BPF
: return "Linux BPF";
2548 case EM_NFP
: return "Netronome Flow Processor";
2550 /* Large numbers... */
2551 case EM_MT
: return "Morpho Techologies MT processor";
2552 case EM_ALPHA
: return "Alpha";
2553 case EM_WEBASSEMBLY
: return "Web Assembly";
2554 case EM_DLX
: return "OpenDLX";
2555 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2556 case EM_IQ2000
: return "Vitesse IQ2000";
2558 case EM_NIOS32
: return "Altera Nios";
2559 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2560 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2561 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2562 case EM_S12Z
: return "Freescale S12Z";
2563 case EM_CSKY
: return "C-SKY";
2566 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2572 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2574 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2575 other compilers don't a specific architecture type in the e_flags, and
2576 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2577 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2580 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2581 but also sets a specific architecture type in the e_flags field.
2583 However, when decoding the flags we don't worry if we see an
2584 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2585 ARCEM architecture type. */
2587 switch (e_flags
& EF_ARC_MACH_MSK
)
2589 /* We only expect these to occur for EM_ARC_COMPACT2. */
2590 case EF_ARC_CPU_ARCV2EM
:
2591 strcat (buf
, ", ARC EM");
2593 case EF_ARC_CPU_ARCV2HS
:
2594 strcat (buf
, ", ARC HS");
2597 /* We only expect these to occur for EM_ARC_COMPACT. */
2598 case E_ARC_MACH_ARC600
:
2599 strcat (buf
, ", ARC600");
2601 case E_ARC_MACH_ARC601
:
2602 strcat (buf
, ", ARC601");
2604 case E_ARC_MACH_ARC700
:
2605 strcat (buf
, ", ARC700");
2608 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2609 new ELF with new architecture being read by an old version of
2610 readelf, or (c) An ELF built with non-GNU compiler that does not
2611 set the architecture in the e_flags. */
2613 if (e_machine
== EM_ARC_COMPACT
)
2614 strcat (buf
, ", Unknown ARCompact");
2616 strcat (buf
, ", Unknown ARC");
2620 switch (e_flags
& EF_ARC_OSABI_MSK
)
2622 case E_ARC_OSABI_ORIG
:
2623 strcat (buf
, ", (ABI:legacy)");
2625 case E_ARC_OSABI_V2
:
2626 strcat (buf
, ", (ABI:v2)");
2628 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2629 case E_ARC_OSABI_V3
:
2630 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2632 case E_ARC_OSABI_V4
:
2633 strcat (buf
, ", v4 ABI");
2636 strcat (buf
, ", unrecognised ARC OSABI flag");
2642 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2645 bfd_boolean unknown
= FALSE
;
2647 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2648 e_flags
&= ~ EF_ARM_EABIMASK
;
2650 /* Handle "generic" ARM flags. */
2651 if (e_flags
& EF_ARM_RELEXEC
)
2653 strcat (buf
, ", relocatable executable");
2654 e_flags
&= ~ EF_ARM_RELEXEC
;
2657 if (e_flags
& EF_ARM_PIC
)
2659 strcat (buf
, ", position independent");
2660 e_flags
&= ~ EF_ARM_PIC
;
2663 /* Now handle EABI specific flags. */
2667 strcat (buf
, ", <unrecognized EABI>");
2672 case EF_ARM_EABI_VER1
:
2673 strcat (buf
, ", Version1 EABI");
2678 /* Process flags one bit at a time. */
2679 flag
= e_flags
& - e_flags
;
2684 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2685 strcat (buf
, ", sorted symbol tables");
2695 case EF_ARM_EABI_VER2
:
2696 strcat (buf
, ", Version2 EABI");
2701 /* Process flags one bit at a time. */
2702 flag
= e_flags
& - e_flags
;
2707 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2708 strcat (buf
, ", sorted symbol tables");
2711 case EF_ARM_DYNSYMSUSESEGIDX
:
2712 strcat (buf
, ", dynamic symbols use segment index");
2715 case EF_ARM_MAPSYMSFIRST
:
2716 strcat (buf
, ", mapping symbols precede others");
2726 case EF_ARM_EABI_VER3
:
2727 strcat (buf
, ", Version3 EABI");
2730 case EF_ARM_EABI_VER4
:
2731 strcat (buf
, ", Version4 EABI");
2736 /* Process flags one bit at a time. */
2737 flag
= e_flags
& - e_flags
;
2743 strcat (buf
, ", BE8");
2747 strcat (buf
, ", LE8");
2757 case EF_ARM_EABI_VER5
:
2758 strcat (buf
, ", Version5 EABI");
2763 /* Process flags one bit at a time. */
2764 flag
= e_flags
& - e_flags
;
2770 strcat (buf
, ", BE8");
2774 strcat (buf
, ", LE8");
2777 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2778 strcat (buf
, ", soft-float ABI");
2781 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2782 strcat (buf
, ", hard-float ABI");
2792 case EF_ARM_EABI_UNKNOWN
:
2793 strcat (buf
, ", GNU EABI");
2798 /* Process flags one bit at a time. */
2799 flag
= e_flags
& - e_flags
;
2804 case EF_ARM_INTERWORK
:
2805 strcat (buf
, ", interworking enabled");
2808 case EF_ARM_APCS_26
:
2809 strcat (buf
, ", uses APCS/26");
2812 case EF_ARM_APCS_FLOAT
:
2813 strcat (buf
, ", uses APCS/float");
2817 strcat (buf
, ", position independent");
2821 strcat (buf
, ", 8 bit structure alignment");
2824 case EF_ARM_NEW_ABI
:
2825 strcat (buf
, ", uses new ABI");
2828 case EF_ARM_OLD_ABI
:
2829 strcat (buf
, ", uses old ABI");
2832 case EF_ARM_SOFT_FLOAT
:
2833 strcat (buf
, ", software FP");
2836 case EF_ARM_VFP_FLOAT
:
2837 strcat (buf
, ", VFP");
2840 case EF_ARM_MAVERICK_FLOAT
:
2841 strcat (buf
, ", Maverick FP");
2852 strcat (buf
,_(", <unknown>"));
2856 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2858 --size
; /* Leave space for null terminator. */
2860 switch (e_flags
& EF_AVR_MACH
)
2862 case E_AVR_MACH_AVR1
:
2863 strncat (buf
, ", avr:1", size
);
2865 case E_AVR_MACH_AVR2
:
2866 strncat (buf
, ", avr:2", size
);
2868 case E_AVR_MACH_AVR25
:
2869 strncat (buf
, ", avr:25", size
);
2871 case E_AVR_MACH_AVR3
:
2872 strncat (buf
, ", avr:3", size
);
2874 case E_AVR_MACH_AVR31
:
2875 strncat (buf
, ", avr:31", size
);
2877 case E_AVR_MACH_AVR35
:
2878 strncat (buf
, ", avr:35", size
);
2880 case E_AVR_MACH_AVR4
:
2881 strncat (buf
, ", avr:4", size
);
2883 case E_AVR_MACH_AVR5
:
2884 strncat (buf
, ", avr:5", size
);
2886 case E_AVR_MACH_AVR51
:
2887 strncat (buf
, ", avr:51", size
);
2889 case E_AVR_MACH_AVR6
:
2890 strncat (buf
, ", avr:6", size
);
2892 case E_AVR_MACH_AVRTINY
:
2893 strncat (buf
, ", avr:100", size
);
2895 case E_AVR_MACH_XMEGA1
:
2896 strncat (buf
, ", avr:101", size
);
2898 case E_AVR_MACH_XMEGA2
:
2899 strncat (buf
, ", avr:102", size
);
2901 case E_AVR_MACH_XMEGA3
:
2902 strncat (buf
, ", avr:103", size
);
2904 case E_AVR_MACH_XMEGA4
:
2905 strncat (buf
, ", avr:104", size
);
2907 case E_AVR_MACH_XMEGA5
:
2908 strncat (buf
, ", avr:105", size
);
2910 case E_AVR_MACH_XMEGA6
:
2911 strncat (buf
, ", avr:106", size
);
2913 case E_AVR_MACH_XMEGA7
:
2914 strncat (buf
, ", avr:107", size
);
2917 strncat (buf
, ", avr:<unknown>", size
);
2921 size
-= strlen (buf
);
2922 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2923 strncat (buf
, ", link-relax", size
);
2927 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2933 bfd_boolean has_fpu
= FALSE
;
2936 static const char *ABI_STRINGS
[] =
2938 "ABI v0", /* use r5 as return register; only used in N1213HC */
2939 "ABI v1", /* use r0 as return register */
2940 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2941 "ABI v2fp", /* for FPU */
2945 static const char *VER_STRINGS
[] =
2947 "Andes ELF V1.3 or older",
2951 static const char *ARCH_STRINGS
[] =
2960 abi
= EF_NDS_ABI
& e_flags
;
2961 arch
= EF_NDS_ARCH
& e_flags
;
2962 config
= EF_NDS_INST
& e_flags
;
2963 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2965 memset (buf
, 0, size
);
2972 case E_NDS_ABI_V2FP
:
2973 case E_NDS_ABI_AABI
:
2974 case E_NDS_ABI_V2FP_PLUS
:
2975 /* In case there are holes in the array. */
2976 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2980 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2986 case E_NDS32_ELF_VER_1_2
:
2987 case E_NDS32_ELF_VER_1_3
:
2988 case E_NDS32_ELF_VER_1_4
:
2989 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2993 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2997 if (E_NDS_ABI_V0
== abi
)
2999 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3000 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3001 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3002 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3008 case E_NDS_ARCH_STAR_V1_0
:
3009 case E_NDS_ARCH_STAR_V2_0
:
3010 case E_NDS_ARCH_STAR_V3_0
:
3011 case E_NDS_ARCH_STAR_V3_M
:
3012 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3016 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3017 /* ARCH version determines how the e_flags are interpreted.
3018 If it is unknown, we cannot proceed. */
3022 /* Newer ABI; Now handle architecture specific flags. */
3023 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3025 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3026 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3028 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3029 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3031 if (config
& E_NDS32_HAS_DIV_INST
)
3032 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3034 if (config
& E_NDS32_HAS_16BIT_INST
)
3035 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3039 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3041 if (version
<= E_NDS32_ELF_VER_1_3
)
3042 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3044 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3047 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3048 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3050 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3051 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3053 if (config
& E_NDS32_HAS_16BIT_INST
)
3055 if (version
<= E_NDS32_ELF_VER_1_3
)
3056 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3058 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3062 if (config
& E_NDS32_HAS_EXT_INST
)
3063 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3065 if (config
& E_NDS32_HAS_EXT2_INST
)
3066 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3068 if (config
& E_NDS32_HAS_FPU_INST
)
3071 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3074 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3077 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3080 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3083 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3088 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3090 case E_NDS32_FPU_REG_8SP_4DP
:
3091 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3093 case E_NDS32_FPU_REG_16SP_8DP
:
3094 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3096 case E_NDS32_FPU_REG_32SP_16DP
:
3097 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3099 case E_NDS32_FPU_REG_32SP_32DP
:
3100 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3105 if (config
& E_NDS32_HAS_AUDIO_INST
)
3106 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3108 if (config
& E_NDS32_HAS_STRING_INST
)
3109 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3111 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3112 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3114 if (config
& E_NDS32_HAS_VIDEO_INST
)
3116 if (version
<= E_NDS32_ELF_VER_1_3
)
3117 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3119 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3122 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3123 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3125 if (config
& E_NDS32_HAS_L2C_INST
)
3126 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3130 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3132 static char buf
[1024];
3143 case EM_ARC_COMPACT2
:
3144 case EM_ARC_COMPACT
:
3145 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3149 decode_ARM_machine_flags (e_flags
, buf
);
3153 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3157 if (e_flags
& EF_BFIN_PIC
)
3158 strcat (buf
, ", PIC");
3160 if (e_flags
& EF_BFIN_FDPIC
)
3161 strcat (buf
, ", FDPIC");
3163 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3164 strcat (buf
, ", code in L1");
3166 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3167 strcat (buf
, ", data in L1");
3172 switch (e_flags
& EF_FRV_CPU_MASK
)
3174 case EF_FRV_CPU_GENERIC
:
3178 strcat (buf
, ", fr???");
3181 case EF_FRV_CPU_FR300
:
3182 strcat (buf
, ", fr300");
3185 case EF_FRV_CPU_FR400
:
3186 strcat (buf
, ", fr400");
3188 case EF_FRV_CPU_FR405
:
3189 strcat (buf
, ", fr405");
3192 case EF_FRV_CPU_FR450
:
3193 strcat (buf
, ", fr450");
3196 case EF_FRV_CPU_FR500
:
3197 strcat (buf
, ", fr500");
3199 case EF_FRV_CPU_FR550
:
3200 strcat (buf
, ", fr550");
3203 case EF_FRV_CPU_SIMPLE
:
3204 strcat (buf
, ", simple");
3206 case EF_FRV_CPU_TOMCAT
:
3207 strcat (buf
, ", tomcat");
3213 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3214 strcat (buf
, ", m68000");
3215 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3216 strcat (buf
, ", cpu32");
3217 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3218 strcat (buf
, ", fido_a");
3221 char const * isa
= _("unknown");
3222 char const * mac
= _("unknown mac");
3223 char const * additional
= NULL
;
3225 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3227 case EF_M68K_CF_ISA_A_NODIV
:
3229 additional
= ", nodiv";
3231 case EF_M68K_CF_ISA_A
:
3234 case EF_M68K_CF_ISA_A_PLUS
:
3237 case EF_M68K_CF_ISA_B_NOUSP
:
3239 additional
= ", nousp";
3241 case EF_M68K_CF_ISA_B
:
3244 case EF_M68K_CF_ISA_C
:
3247 case EF_M68K_CF_ISA_C_NODIV
:
3249 additional
= ", nodiv";
3252 strcat (buf
, ", cf, isa ");
3255 strcat (buf
, additional
);
3256 if (e_flags
& EF_M68K_CF_FLOAT
)
3257 strcat (buf
, ", float");
3258 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3263 case EF_M68K_CF_MAC
:
3266 case EF_M68K_CF_EMAC
:
3269 case EF_M68K_CF_EMAC_B
:
3282 switch (e_flags
& EF_MEP_CPU_MASK
)
3284 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3285 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3286 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3287 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3288 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3289 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3290 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3293 switch (e_flags
& EF_MEP_COP_MASK
)
3295 case EF_MEP_COP_NONE
: break;
3296 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3297 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3298 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3299 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3300 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3303 if (e_flags
& EF_MEP_LIBRARY
)
3304 strcat (buf
, ", Built for Library");
3306 if (e_flags
& EF_MEP_INDEX_MASK
)
3307 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3308 e_flags
& EF_MEP_INDEX_MASK
);
3310 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3311 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3312 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3316 if (e_flags
& EF_PPC_EMB
)
3317 strcat (buf
, ", emb");
3319 if (e_flags
& EF_PPC_RELOCATABLE
)
3320 strcat (buf
, _(", relocatable"));
3322 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3323 strcat (buf
, _(", relocatable-lib"));
3327 if (e_flags
& EF_PPC64_ABI
)
3329 char abi
[] = ", abiv0";
3331 abi
[6] += e_flags
& EF_PPC64_ABI
;
3337 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3338 strcat (buf
, ", RH850 ABI");
3340 if (e_flags
& EF_V800_850E3
)
3341 strcat (buf
, ", V3 architecture");
3343 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3344 strcat (buf
, ", FPU not used");
3346 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3347 strcat (buf
, ", regmode: COMMON");
3349 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3350 strcat (buf
, ", r4 not used");
3352 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3353 strcat (buf
, ", r30 not used");
3355 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3356 strcat (buf
, ", r5 not used");
3358 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3359 strcat (buf
, ", r2 not used");
3361 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3363 switch (e_flags
& - e_flags
)
3365 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3366 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3367 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3368 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3369 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3370 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3371 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3372 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3373 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3374 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3375 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3376 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3383 case EM_CYGNUS_V850
:
3384 switch (e_flags
& EF_V850_ARCH
)
3386 case E_V850E3V5_ARCH
:
3387 strcat (buf
, ", v850e3v5");
3389 case E_V850E2V3_ARCH
:
3390 strcat (buf
, ", v850e2v3");
3393 strcat (buf
, ", v850e2");
3396 strcat (buf
, ", v850e1");
3399 strcat (buf
, ", v850e");
3402 strcat (buf
, ", v850");
3405 strcat (buf
, _(", unknown v850 architecture variant"));
3411 case EM_CYGNUS_M32R
:
3412 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3413 strcat (buf
, ", m32r");
3417 case EM_MIPS_RS3_LE
:
3418 if (e_flags
& EF_MIPS_NOREORDER
)
3419 strcat (buf
, ", noreorder");
3421 if (e_flags
& EF_MIPS_PIC
)
3422 strcat (buf
, ", pic");
3424 if (e_flags
& EF_MIPS_CPIC
)
3425 strcat (buf
, ", cpic");
3427 if (e_flags
& EF_MIPS_UCODE
)
3428 strcat (buf
, ", ugen_reserved");
3430 if (e_flags
& EF_MIPS_ABI2
)
3431 strcat (buf
, ", abi2");
3433 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3434 strcat (buf
, ", odk first");
3436 if (e_flags
& EF_MIPS_32BITMODE
)
3437 strcat (buf
, ", 32bitmode");
3439 if (e_flags
& EF_MIPS_NAN2008
)
3440 strcat (buf
, ", nan2008");
3442 if (e_flags
& EF_MIPS_FP64
)
3443 strcat (buf
, ", fp64");
3445 switch ((e_flags
& EF_MIPS_MACH
))
3447 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3448 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3449 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3450 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3451 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3452 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3453 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3454 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3455 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3456 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3457 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3458 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3459 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3460 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3461 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3462 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3463 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3464 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3465 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3466 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3467 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3469 /* We simply ignore the field in this case to avoid confusion:
3470 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3473 default: strcat (buf
, _(", unknown CPU")); break;
3476 switch ((e_flags
& EF_MIPS_ABI
))
3478 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3479 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3480 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3481 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3483 /* We simply ignore the field in this case to avoid confusion:
3484 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3485 This means it is likely to be an o32 file, but not for
3488 default: strcat (buf
, _(", unknown ABI")); break;
3491 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3492 strcat (buf
, ", mdmx");
3494 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3495 strcat (buf
, ", mips16");
3497 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3498 strcat (buf
, ", micromips");
3500 switch ((e_flags
& EF_MIPS_ARCH
))
3502 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3503 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3504 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3505 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3506 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3507 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3508 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3509 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3510 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3511 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3512 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3513 default: strcat (buf
, _(", unknown ISA")); break;
3518 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3522 switch (EF_NFP_MACH (e_flags
))
3524 case E_NFP_MACH_3200
:
3525 strcat (buf
, ", NFP-32xx");
3527 case E_NFP_MACH_6000
:
3528 strcat (buf
, ", NFP-6xxx");
3534 if (e_flags
& EF_RISCV_RVC
)
3535 strcat (buf
, ", RVC");
3537 if (e_flags
& EF_RISCV_RVE
)
3538 strcat (buf
, ", RVE");
3540 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3542 case EF_RISCV_FLOAT_ABI_SOFT
:
3543 strcat (buf
, ", soft-float ABI");
3546 case EF_RISCV_FLOAT_ABI_SINGLE
:
3547 strcat (buf
, ", single-float ABI");
3550 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3551 strcat (buf
, ", double-float ABI");
3554 case EF_RISCV_FLOAT_ABI_QUAD
:
3555 strcat (buf
, ", quad-float ABI");
3561 switch ((e_flags
& EF_SH_MACH_MASK
))
3563 case EF_SH1
: strcat (buf
, ", sh1"); break;
3564 case EF_SH2
: strcat (buf
, ", sh2"); break;
3565 case EF_SH3
: strcat (buf
, ", sh3"); break;
3566 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3567 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3568 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3569 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3570 case EF_SH4
: strcat (buf
, ", sh4"); break;
3571 case EF_SH5
: strcat (buf
, ", sh5"); break;
3572 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3573 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3574 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3575 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3576 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3577 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3578 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3579 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3580 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3581 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3582 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3583 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3584 default: strcat (buf
, _(", unknown ISA")); break;
3587 if (e_flags
& EF_SH_PIC
)
3588 strcat (buf
, ", pic");
3590 if (e_flags
& EF_SH_FDPIC
)
3591 strcat (buf
, ", fdpic");
3595 if (e_flags
& EF_OR1K_NODELAY
)
3596 strcat (buf
, ", no delay");
3600 if (e_flags
& EF_SPARC_32PLUS
)
3601 strcat (buf
, ", v8+");
3603 if (e_flags
& EF_SPARC_SUN_US1
)
3604 strcat (buf
, ", ultrasparcI");
3606 if (e_flags
& EF_SPARC_SUN_US3
)
3607 strcat (buf
, ", ultrasparcIII");
3609 if (e_flags
& EF_SPARC_HAL_R1
)
3610 strcat (buf
, ", halr1");
3612 if (e_flags
& EF_SPARC_LEDATA
)
3613 strcat (buf
, ", ledata");
3615 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3616 strcat (buf
, ", tso");
3618 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3619 strcat (buf
, ", pso");
3621 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3622 strcat (buf
, ", rmo");
3626 switch (e_flags
& EF_PARISC_ARCH
)
3628 case EFA_PARISC_1_0
:
3629 strcpy (buf
, ", PA-RISC 1.0");
3631 case EFA_PARISC_1_1
:
3632 strcpy (buf
, ", PA-RISC 1.1");
3634 case EFA_PARISC_2_0
:
3635 strcpy (buf
, ", PA-RISC 2.0");
3640 if (e_flags
& EF_PARISC_TRAPNIL
)
3641 strcat (buf
, ", trapnil");
3642 if (e_flags
& EF_PARISC_EXT
)
3643 strcat (buf
, ", ext");
3644 if (e_flags
& EF_PARISC_LSB
)
3645 strcat (buf
, ", lsb");
3646 if (e_flags
& EF_PARISC_WIDE
)
3647 strcat (buf
, ", wide");
3648 if (e_flags
& EF_PARISC_NO_KABP
)
3649 strcat (buf
, ", no kabp");
3650 if (e_flags
& EF_PARISC_LAZYSWAP
)
3651 strcat (buf
, ", lazyswap");
3656 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3657 strcat (buf
, ", new calling convention");
3659 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3660 strcat (buf
, ", gnu calling convention");
3664 if ((e_flags
& EF_IA_64_ABI64
))
3665 strcat (buf
, ", 64-bit");
3667 strcat (buf
, ", 32-bit");
3668 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3669 strcat (buf
, ", reduced fp model");
3670 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3671 strcat (buf
, ", no function descriptors, constant gp");
3672 else if ((e_flags
& EF_IA_64_CONS_GP
))
3673 strcat (buf
, ", constant gp");
3674 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3675 strcat (buf
, ", absolute");
3676 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3678 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3679 strcat (buf
, ", vms_linkages");
3680 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3682 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3684 case EF_IA_64_VMS_COMCOD_WARNING
:
3685 strcat (buf
, ", warning");
3687 case EF_IA_64_VMS_COMCOD_ERROR
:
3688 strcat (buf
, ", error");
3690 case EF_IA_64_VMS_COMCOD_ABORT
:
3691 strcat (buf
, ", abort");
3694 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3695 e_flags
& EF_IA_64_VMS_COMCOD
);
3696 strcat (buf
, ", <unknown>");
3702 if ((e_flags
& EF_VAX_NONPIC
))
3703 strcat (buf
, ", non-PIC");
3704 if ((e_flags
& EF_VAX_DFLOAT
))
3705 strcat (buf
, ", D-Float");
3706 if ((e_flags
& EF_VAX_GFLOAT
))
3707 strcat (buf
, ", G-Float");
3711 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3712 strcat (buf
, ", mcm");
3713 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3714 strcat (buf
, ", mcm24");
3715 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3716 strcat (buf
, ", gr6");
3720 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3722 case E_FLAG_RL78_ANY_CPU
: break;
3723 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3724 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3725 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3727 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3728 strcat (buf
, ", 64-bit doubles");
3732 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3733 strcat (buf
, ", 64-bit doubles");
3734 if (e_flags
& E_FLAG_RX_DSP
)
3735 strcat (buf
, ", dsp");
3736 if (e_flags
& E_FLAG_RX_PID
)
3737 strcat (buf
, ", pid");
3738 if (e_flags
& E_FLAG_RX_ABI
)
3739 strcat (buf
, ", RX ABI");
3740 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3741 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3742 ? ", uses String instructions" : ", bans String instructions");
3743 if (e_flags
& E_FLAG_RX_V2
)
3744 strcat (buf
, ", V2");
3745 if (e_flags
& E_FLAG_RX_V3
)
3746 strcat (buf
, ", V3");
3750 if (e_flags
& EF_S390_HIGH_GPRS
)
3751 strcat (buf
, ", highgprs");
3755 if ((e_flags
& EF_C6000_REL
))
3756 strcat (buf
, ", relocatable module");
3760 strcat (buf
, _(": architecture variant: "));
3761 switch (e_flags
& EF_MSP430_MACH
)
3763 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3764 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3765 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3766 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3767 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3768 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3769 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3770 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3771 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3772 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3773 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3774 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3775 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3776 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3777 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3779 strcat (buf
, _(": unknown")); break;
3782 if (e_flags
& ~ EF_MSP430_MACH
)
3783 strcat (buf
, _(": unknown extra flag bits also present"));
3787 switch (e_flags
& EF_Z80_MACH_MSK
)
3789 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3790 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3791 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3792 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3793 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3794 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3795 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3797 strcat (buf
, _(", unknown")); break;
3807 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3809 static char buff
[32];
3813 case ELFOSABI_NONE
: return "UNIX - System V";
3814 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3815 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3816 case ELFOSABI_GNU
: return "UNIX - GNU";
3817 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3818 case ELFOSABI_AIX
: return "UNIX - AIX";
3819 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3820 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3821 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3822 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3823 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3824 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3825 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3826 case ELFOSABI_AROS
: return "AROS";
3827 case ELFOSABI_FENIXOS
: return "FenixOS";
3828 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3829 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3832 switch (filedata
->file_header
.e_machine
)
3837 case ELFOSABI_ARM
: return "ARM";
3838 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3849 case ELFOSABI_STANDALONE
: return _("Standalone App");
3858 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3859 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3868 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3874 get_aarch64_segment_type (unsigned long type
)
3878 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3879 default: return NULL
;
3884 get_arm_segment_type (unsigned long type
)
3888 case PT_ARM_EXIDX
: return "EXIDX";
3889 default: return NULL
;
3894 get_s390_segment_type (unsigned long type
)
3898 case PT_S390_PGSTE
: return "S390_PGSTE";
3899 default: return NULL
;
3904 get_mips_segment_type (unsigned long type
)
3908 case PT_MIPS_REGINFO
: return "REGINFO";
3909 case PT_MIPS_RTPROC
: return "RTPROC";
3910 case PT_MIPS_OPTIONS
: return "OPTIONS";
3911 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3912 default: return NULL
;
3917 get_parisc_segment_type (unsigned long type
)
3921 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3922 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3923 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3924 default: return NULL
;
3929 get_ia64_segment_type (unsigned long type
)
3933 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3934 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3935 default: return NULL
;
3940 get_tic6x_segment_type (unsigned long type
)
3944 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3945 default: return NULL
;
3950 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3952 if (e_machine
== EM_PARISC
)
3955 case PT_HP_TLS
: return "HP_TLS";
3956 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3957 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3958 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3959 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3960 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3961 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3962 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3963 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3964 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3965 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3966 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3967 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3968 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3969 case PT_HP_STACK
: return "HP_STACK";
3970 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3971 default: return NULL
;
3974 if (e_machine
== EM_IA_64
)
3977 case PT_HP_TLS
: return "HP_TLS";
3978 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3979 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3980 case PT_IA_64_HP_STACK
: return "HP_STACK";
3981 default: return NULL
;
3988 get_solaris_segment_type (unsigned long type
)
3992 case 0x6464e550: return "PT_SUNW_UNWIND";
3993 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3994 case 0x6ffffff7: return "PT_LOSUNW";
3995 case 0x6ffffffa: return "PT_SUNWBSS";
3996 case 0x6ffffffb: return "PT_SUNWSTACK";
3997 case 0x6ffffffc: return "PT_SUNWDTRACE";
3998 case 0x6ffffffd: return "PT_SUNWCAP";
3999 case 0x6fffffff: return "PT_HISUNW";
4000 default: return NULL
;
4005 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4007 static char buff
[32];
4011 case PT_NULL
: return "NULL";
4012 case PT_LOAD
: return "LOAD";
4013 case PT_DYNAMIC
: return "DYNAMIC";
4014 case PT_INTERP
: return "INTERP";
4015 case PT_NOTE
: return "NOTE";
4016 case PT_SHLIB
: return "SHLIB";
4017 case PT_PHDR
: return "PHDR";
4018 case PT_TLS
: return "TLS";
4019 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4020 case PT_GNU_STACK
: return "GNU_STACK";
4021 case PT_GNU_RELRO
: return "GNU_RELRO";
4022 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4025 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4027 const char * result
;
4029 switch (filedata
->file_header
.e_machine
)
4032 result
= get_aarch64_segment_type (p_type
);
4035 result
= get_arm_segment_type (p_type
);
4038 case EM_MIPS_RS3_LE
:
4039 result
= get_mips_segment_type (p_type
);
4042 result
= get_parisc_segment_type (p_type
);
4045 result
= get_ia64_segment_type (p_type
);
4048 result
= get_tic6x_segment_type (p_type
);
4052 result
= get_s390_segment_type (p_type
);
4062 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4064 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4066 const char * result
= NULL
;
4068 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4071 case ELFOSABI_FREEBSD
:
4072 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4074 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4079 result
= get_hpux_segment_type (p_type
,
4080 filedata
->file_header
.e_machine
);
4082 case ELFOSABI_SOLARIS
:
4083 result
= get_solaris_segment_type (p_type
);
4091 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4094 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4101 get_arc_section_type_name (unsigned int sh_type
)
4105 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4113 get_mips_section_type_name (unsigned int sh_type
)
4117 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4118 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4119 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4120 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4121 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4122 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4123 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4124 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4125 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4126 case SHT_MIPS_RELD
: return "MIPS_RELD";
4127 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4128 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4129 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4130 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4131 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4132 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4133 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4134 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4135 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4136 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4137 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4138 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4139 case SHT_MIPS_LINE
: return "MIPS_LINE";
4140 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4141 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4142 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4143 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4144 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4145 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4146 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4147 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4148 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4149 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4150 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4151 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4152 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4153 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4154 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4155 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4156 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4157 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4165 get_parisc_section_type_name (unsigned int sh_type
)
4169 case SHT_PARISC_EXT
: return "PARISC_EXT";
4170 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4171 case SHT_PARISC_DOC
: return "PARISC_DOC";
4172 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4173 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4174 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4175 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4176 default: return NULL
;
4181 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4183 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4184 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4185 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4189 case SHT_IA_64_EXT
: return "IA_64_EXT";
4190 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4191 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4192 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4193 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4194 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4195 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4196 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4197 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4198 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4206 get_x86_64_section_type_name (unsigned int sh_type
)
4210 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4211 default: return NULL
;
4216 get_aarch64_section_type_name (unsigned int sh_type
)
4220 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4221 default: return NULL
;
4226 get_arm_section_type_name (unsigned int sh_type
)
4230 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4231 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4232 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4233 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4234 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4235 default: return NULL
;
4240 get_tic6x_section_type_name (unsigned int sh_type
)
4244 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4245 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4246 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4247 case SHT_TI_ICODE
: return "TI_ICODE";
4248 case SHT_TI_XREF
: return "TI_XREF";
4249 case SHT_TI_HANDLER
: return "TI_HANDLER";
4250 case SHT_TI_INITINFO
: return "TI_INITINFO";
4251 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4252 default: return NULL
;
4257 get_msp430x_section_type_name (unsigned int sh_type
)
4261 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4262 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4263 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4264 default: return NULL
;
4269 get_nfp_section_type_name (unsigned int sh_type
)
4273 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4274 case SHT_NFP_INITREG
: return "NFP_INITREG";
4275 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4276 default: return NULL
;
4281 get_v850_section_type_name (unsigned int sh_type
)
4285 case SHT_V850_SCOMMON
: return "V850 Small Common";
4286 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4287 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4288 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4289 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4290 default: return NULL
;
4295 get_riscv_section_type_name (unsigned int sh_type
)
4299 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4300 default: return NULL
;
4305 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4307 static char buff
[32];
4308 const char * result
;
4312 case SHT_NULL
: return "NULL";
4313 case SHT_PROGBITS
: return "PROGBITS";
4314 case SHT_SYMTAB
: return "SYMTAB";
4315 case SHT_STRTAB
: return "STRTAB";
4316 case SHT_RELA
: return "RELA";
4317 case SHT_HASH
: return "HASH";
4318 case SHT_DYNAMIC
: return "DYNAMIC";
4319 case SHT_NOTE
: return "NOTE";
4320 case SHT_NOBITS
: return "NOBITS";
4321 case SHT_REL
: return "REL";
4322 case SHT_SHLIB
: return "SHLIB";
4323 case SHT_DYNSYM
: return "DYNSYM";
4324 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4325 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4326 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4327 case SHT_GNU_HASH
: return "GNU_HASH";
4328 case SHT_GROUP
: return "GROUP";
4329 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4330 case SHT_GNU_verdef
: return "VERDEF";
4331 case SHT_GNU_verneed
: return "VERNEED";
4332 case SHT_GNU_versym
: return "VERSYM";
4333 case 0x6ffffff0: return "VERSYM";
4334 case 0x6ffffffc: return "VERDEF";
4335 case 0x7ffffffd: return "AUXILIARY";
4336 case 0x7fffffff: return "FILTER";
4337 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4340 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4342 switch (filedata
->file_header
.e_machine
)
4345 case EM_ARC_COMPACT
:
4346 case EM_ARC_COMPACT2
:
4347 result
= get_arc_section_type_name (sh_type
);
4350 case EM_MIPS_RS3_LE
:
4351 result
= get_mips_section_type_name (sh_type
);
4354 result
= get_parisc_section_type_name (sh_type
);
4357 result
= get_ia64_section_type_name (filedata
, sh_type
);
4362 result
= get_x86_64_section_type_name (sh_type
);
4365 result
= get_aarch64_section_type_name (sh_type
);
4368 result
= get_arm_section_type_name (sh_type
);
4371 result
= get_tic6x_section_type_name (sh_type
);
4374 result
= get_msp430x_section_type_name (sh_type
);
4377 result
= get_nfp_section_type_name (sh_type
);
4381 case EM_CYGNUS_V850
:
4382 result
= get_v850_section_type_name (sh_type
);
4385 result
= get_riscv_section_type_name (sh_type
);
4395 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4397 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4399 switch (filedata
->file_header
.e_machine
)
4402 result
= get_ia64_section_type_name (filedata
, sh_type
);
4405 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4406 result
= get_solaris_section_type (sh_type
);
4411 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4412 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4413 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4414 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4426 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4428 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4430 switch (filedata
->file_header
.e_machine
)
4434 case EM_CYGNUS_V850
:
4435 result
= get_v850_section_type_name (sh_type
);
4445 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4448 /* This message is probably going to be displayed in a 15
4449 character wide field, so put the hex value first. */
4450 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4456 #define OPTION_DEBUG_DUMP 512
4457 #define OPTION_DYN_SYMS 513
4458 #define OPTION_DWARF_DEPTH 514
4459 #define OPTION_DWARF_START 515
4460 #define OPTION_DWARF_CHECK 516
4461 #define OPTION_CTF_DUMP 517
4462 #define OPTION_CTF_PARENT 518
4463 #define OPTION_CTF_SYMBOLS 519
4464 #define OPTION_CTF_STRINGS 520
4466 static struct option options
[] =
4468 {"all", no_argument
, 0, 'a'},
4469 {"file-header", no_argument
, 0, 'h'},
4470 {"program-headers", no_argument
, 0, 'l'},
4471 {"headers", no_argument
, 0, 'e'},
4472 {"histogram", no_argument
, 0, 'I'},
4473 {"segments", no_argument
, 0, 'l'},
4474 {"sections", no_argument
, 0, 'S'},
4475 {"section-headers", no_argument
, 0, 'S'},
4476 {"section-groups", no_argument
, 0, 'g'},
4477 {"section-details", no_argument
, 0, 't'},
4478 {"full-section-name",no_argument
, 0, 'N'},
4479 {"symbols", no_argument
, 0, 's'},
4480 {"syms", no_argument
, 0, 's'},
4481 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4482 {"relocs", no_argument
, 0, 'r'},
4483 {"notes", no_argument
, 0, 'n'},
4484 {"dynamic", no_argument
, 0, 'd'},
4485 {"lint", no_argument
, 0, 'L'},
4486 {"enable-checks", no_argument
, 0, 'L'},
4487 {"arch-specific", no_argument
, 0, 'A'},
4488 {"version-info", no_argument
, 0, 'V'},
4489 {"use-dynamic", no_argument
, 0, 'D'},
4490 {"unwind", no_argument
, 0, 'u'},
4491 {"archive-index", no_argument
, 0, 'c'},
4492 {"hex-dump", required_argument
, 0, 'x'},
4493 {"relocated-dump", required_argument
, 0, 'R'},
4494 {"string-dump", required_argument
, 0, 'p'},
4495 {"decompress", no_argument
, 0, 'z'},
4496 #ifdef SUPPORT_DISASSEMBLY
4497 {"instruction-dump", required_argument
, 0, 'i'},
4499 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4501 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4502 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4503 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4505 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4507 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4508 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4509 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4511 {"version", no_argument
, 0, 'v'},
4512 {"wide", no_argument
, 0, 'W'},
4513 {"help", no_argument
, 0, 'H'},
4514 {0, no_argument
, 0, 0}
4518 usage (FILE * stream
)
4520 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4521 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4522 fprintf (stream
, _(" Options are:\n\
4523 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4524 -h --file-header Display the ELF file header\n\
4525 -l --program-headers Display the program headers\n\
4526 --segments An alias for --program-headers\n\
4527 -S --section-headers Display the sections' header\n\
4528 --sections An alias for --section-headers\n\
4529 -g --section-groups Display the section groups\n\
4530 -t --section-details Display the section details\n\
4531 -e --headers Equivalent to: -h -l -S\n\
4532 -s --syms Display the symbol table\n\
4533 --symbols An alias for --syms\n\
4534 --dyn-syms Display the dynamic symbol table\n\
4535 -n --notes Display the core notes (if present)\n\
4536 -r --relocs Display the relocations (if present)\n\
4537 -u --unwind Display the unwind info (if present)\n\
4538 -d --dynamic Display the dynamic section (if present)\n\
4539 -V --version-info Display the version sections (if present)\n\
4540 -A --arch-specific Display architecture specific information (if any)\n\
4541 -c --archive-index Display the symbol/file index in an archive\n\
4542 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4543 -L --lint|--enable-checks Display warning messages for possible problems\n\
4544 -x --hex-dump=<number|name>\n\
4545 Dump the contents of section <number|name> as bytes\n\
4546 -p --string-dump=<number|name>\n\
4547 Dump the contents of section <number|name> as strings\n\
4548 -R --relocated-dump=<number|name>\n\
4549 Dump the contents of section <number|name> as relocated bytes\n\
4550 -z --decompress Decompress section before dumping it\n\
4551 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4552 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4553 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4554 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4555 =addr,=cu_index,=links,=follow-links]\n\
4556 Display the contents of DWARF debug sections\n"));
4557 fprintf (stream
, _("\
4558 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4559 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4561 fprintf (stream
, _("\
4562 --ctf=<number|name> Display CTF info from section <number|name>\n\
4563 --ctf-parent=<number|name>\n\
4564 Use section <number|name> as the CTF parent\n\n\
4565 --ctf-symbols=<number|name>\n\
4566 Use section <number|name> as the CTF external symtab\n\n\
4567 --ctf-strings=<number|name>\n\
4568 Use section <number|name> as the CTF external strtab\n\n"));
4570 #ifdef SUPPORT_DISASSEMBLY
4571 fprintf (stream
, _("\
4572 -i --instruction-dump=<number|name>\n\
4573 Disassemble the contents of section <number|name>\n"));
4575 fprintf (stream
, _("\
4576 -I --histogram Display histogram of bucket list lengths\n\
4577 -W --wide Allow output width to exceed 80 characters\n\
4578 @<file> Read options from <file>\n\
4579 -H --help Display this information\n\
4580 -v --version Display the version number of readelf\n"));
4582 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4583 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4585 exit (stream
== stdout
? 0 : 1);
4588 /* Record the fact that the user wants the contents of section number
4589 SECTION to be displayed using the method(s) encoded as flags bits
4590 in TYPE. Note, TYPE can be zero if we are creating the array for
4594 request_dump_bynumber (struct dump_data
*dumpdata
,
4595 unsigned int section
, dump_type type
)
4597 if (section
>= dumpdata
->num_dump_sects
)
4599 dump_type
* new_dump_sects
;
4601 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4602 sizeof (* new_dump_sects
));
4604 if (new_dump_sects
== NULL
)
4605 error (_("Out of memory allocating dump request table.\n"));
4608 if (dumpdata
->dump_sects
)
4610 /* Copy current flag settings. */
4611 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4612 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4614 free (dumpdata
->dump_sects
);
4617 dumpdata
->dump_sects
= new_dump_sects
;
4618 dumpdata
->num_dump_sects
= section
+ 1;
4622 if (dumpdata
->dump_sects
)
4623 dumpdata
->dump_sects
[section
] |= type
;
4626 /* Request a dump by section name. */
4629 request_dump_byname (const char * section
, dump_type type
)
4631 struct dump_list_entry
* new_request
;
4633 new_request
= (struct dump_list_entry
*)
4634 malloc (sizeof (struct dump_list_entry
));
4636 error (_("Out of memory allocating dump request table.\n"));
4638 new_request
->name
= strdup (section
);
4639 if (!new_request
->name
)
4640 error (_("Out of memory allocating dump request table.\n"));
4642 new_request
->type
= type
;
4644 new_request
->next
= dump_sects_byname
;
4645 dump_sects_byname
= new_request
;
4649 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4655 section
= strtoul (optarg
, & cp
, 0);
4657 if (! *cp
&& section
>= 0)
4658 request_dump_bynumber (dumpdata
, section
, type
);
4660 request_dump_byname (optarg
, type
);
4664 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4671 while ((c
= getopt_long
4672 (argc
, argv
, "ADHILNR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4690 do_section_groups
= TRUE
;
4693 do_histogram
= TRUE
;
4698 do_section_groups
= TRUE
;
4703 do_section_details
= TRUE
;
4714 do_using_dynamic
= TRUE
;
4738 do_histogram
= TRUE
;
4744 do_archive_index
= TRUE
;
4750 request_dump (dumpdata
, HEX_DUMP
);
4753 request_dump (dumpdata
, STRING_DUMP
);
4756 request_dump (dumpdata
, RELOC_DUMP
);
4759 decompress_dumps
= TRUE
;
4765 do_debugging
= TRUE
;
4766 dwarf_select_sections_all ();
4770 do_debugging
= FALSE
;
4771 dwarf_select_sections_by_letters (optarg
);
4774 case OPTION_DEBUG_DUMP
:
4777 do_debugging
= TRUE
;
4780 do_debugging
= FALSE
;
4781 dwarf_select_sections_by_names (optarg
);
4784 case OPTION_DWARF_DEPTH
:
4788 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4791 case OPTION_DWARF_START
:
4795 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4798 case OPTION_DWARF_CHECK
:
4801 case OPTION_CTF_DUMP
:
4803 request_dump (dumpdata
, CTF_DUMP
);
4805 case OPTION_CTF_SYMBOLS
:
4806 dump_ctf_symtab_name
= strdup (optarg
);
4808 case OPTION_CTF_STRINGS
:
4809 dump_ctf_strtab_name
= strdup (optarg
);
4811 case OPTION_CTF_PARENT
:
4812 dump_ctf_parent_name
= strdup (optarg
);
4814 case OPTION_DYN_SYMS
:
4817 #ifdef SUPPORT_DISASSEMBLY
4819 request_dump (dumpdata
, DISASS_DUMP
);
4823 print_version (program_name
);
4832 /* xgettext:c-format */
4833 error (_("Invalid option '-%c'\n"), c
);
4840 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4841 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4842 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4843 && !do_section_groups
&& !do_archive_index
4849 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= TRUE
;
4850 do_segments
= do_header
= do_dump
= do_version
= TRUE
;
4851 do_histogram
= do_debugging
= do_arch
= do_notes
= TRUE
;
4852 do_section_groups
= do_archive_index
= do_dyn_syms
= TRUE
;
4860 get_elf_class (unsigned int elf_class
)
4862 static char buff
[32];
4866 case ELFCLASSNONE
: return _("none");
4867 case ELFCLASS32
: return "ELF32";
4868 case ELFCLASS64
: return "ELF64";
4870 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4876 get_data_encoding (unsigned int encoding
)
4878 static char buff
[32];
4882 case ELFDATANONE
: return _("none");
4883 case ELFDATA2LSB
: return _("2's complement, little endian");
4884 case ELFDATA2MSB
: return _("2's complement, big endian");
4886 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4891 /* Decode the data held in 'filedata->file_header'. */
4894 process_file_header (Filedata
* filedata
)
4896 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4898 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4899 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4900 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4901 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4904 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4908 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4914 printf (_("ELF Header:\n"));
4915 printf (_(" Magic: "));
4916 for (i
= 0; i
< EI_NIDENT
; i
++)
4917 printf ("%2.2x ", header
->e_ident
[i
]);
4919 printf (_(" Class: %s\n"),
4920 get_elf_class (header
->e_ident
[EI_CLASS
]));
4921 printf (_(" Data: %s\n"),
4922 get_data_encoding (header
->e_ident
[EI_DATA
]));
4923 printf (_(" Version: %d%s\n"),
4924 header
->e_ident
[EI_VERSION
],
4925 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4927 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4930 printf (_(" OS/ABI: %s\n"),
4931 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4932 printf (_(" ABI Version: %d\n"),
4933 header
->e_ident
[EI_ABIVERSION
]);
4934 printf (_(" Type: %s\n"),
4935 get_file_type (header
->e_type
));
4936 printf (_(" Machine: %s\n"),
4937 get_machine_name (header
->e_machine
));
4938 printf (_(" Version: 0x%lx\n"),
4941 printf (_(" Entry point address: "));
4942 print_vma (header
->e_entry
, PREFIX_HEX
);
4943 printf (_("\n Start of program headers: "));
4944 print_vma (header
->e_phoff
, DEC
);
4945 printf (_(" (bytes into file)\n Start of section headers: "));
4946 print_vma (header
->e_shoff
, DEC
);
4947 printf (_(" (bytes into file)\n"));
4949 printf (_(" Flags: 0x%lx%s\n"),
4951 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4952 printf (_(" Size of this header: %u (bytes)\n"),
4954 printf (_(" Size of program headers: %u (bytes)\n"),
4955 header
->e_phentsize
);
4956 printf (_(" Number of program headers: %u"),
4958 if (filedata
->section_headers
!= NULL
4959 && header
->e_phnum
== PN_XNUM
4960 && filedata
->section_headers
[0].sh_info
!= 0)
4962 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4963 printf (" (%u)", header
->e_phnum
);
4965 putc ('\n', stdout
);
4966 printf (_(" Size of section headers: %u (bytes)\n"),
4967 header
->e_shentsize
);
4968 printf (_(" Number of section headers: %u"),
4970 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4972 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4973 printf (" (%u)", header
->e_shnum
);
4975 putc ('\n', stdout
);
4976 printf (_(" Section header string table index: %u"),
4977 header
->e_shstrndx
);
4978 if (filedata
->section_headers
!= NULL
4979 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4981 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4982 printf (" (%u)", header
->e_shstrndx
);
4984 if (header
->e_shstrndx
!= SHN_UNDEF
4985 && header
->e_shstrndx
>= header
->e_shnum
)
4987 header
->e_shstrndx
= SHN_UNDEF
;
4988 printf (_(" <corrupt: out of range>"));
4990 putc ('\n', stdout
);
4993 if (filedata
->section_headers
!= NULL
)
4995 if (header
->e_phnum
== PN_XNUM
4996 && filedata
->section_headers
[0].sh_info
!= 0)
4997 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4998 if (header
->e_shnum
== SHN_UNDEF
)
4999 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5000 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5001 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5002 if (header
->e_shstrndx
>= header
->e_shnum
)
5003 header
->e_shstrndx
= SHN_UNDEF
;
5004 free (filedata
->section_headers
);
5005 filedata
->section_headers
= NULL
;
5011 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5012 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5015 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5017 Elf32_External_Phdr
* phdrs
;
5018 Elf32_External_Phdr
* external
;
5019 Elf_Internal_Phdr
* internal
;
5021 unsigned int size
= filedata
->file_header
.e_phentsize
;
5022 unsigned int num
= filedata
->file_header
.e_phnum
;
5024 /* PR binutils/17531: Cope with unexpected section header sizes. */
5025 if (size
== 0 || num
== 0)
5027 if (size
< sizeof * phdrs
)
5029 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5032 if (size
> sizeof * phdrs
)
5033 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5035 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5036 size
, num
, _("program headers"));
5040 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5041 i
< filedata
->file_header
.e_phnum
;
5042 i
++, internal
++, external
++)
5044 internal
->p_type
= BYTE_GET (external
->p_type
);
5045 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5046 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5047 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5048 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5049 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5050 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5051 internal
->p_align
= BYTE_GET (external
->p_align
);
5058 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5059 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5062 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5064 Elf64_External_Phdr
* phdrs
;
5065 Elf64_External_Phdr
* external
;
5066 Elf_Internal_Phdr
* internal
;
5068 unsigned int size
= filedata
->file_header
.e_phentsize
;
5069 unsigned int num
= filedata
->file_header
.e_phnum
;
5071 /* PR binutils/17531: Cope with unexpected section header sizes. */
5072 if (size
== 0 || num
== 0)
5074 if (size
< sizeof * phdrs
)
5076 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5079 if (size
> sizeof * phdrs
)
5080 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5082 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5083 size
, num
, _("program headers"));
5087 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5088 i
< filedata
->file_header
.e_phnum
;
5089 i
++, internal
++, external
++)
5091 internal
->p_type
= BYTE_GET (external
->p_type
);
5092 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5093 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5094 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5095 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5096 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5097 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5098 internal
->p_align
= BYTE_GET (external
->p_align
);
5105 /* Returns TRUE if the program headers were read into `program_headers'. */
5108 get_program_headers (Filedata
* filedata
)
5110 Elf_Internal_Phdr
* phdrs
;
5112 /* Check cache of prior read. */
5113 if (filedata
->program_headers
!= NULL
)
5116 /* Be kind to memory checkers by looking for
5117 e_phnum values which we know must be invalid. */
5118 if (filedata
->file_header
.e_phnum
5119 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5120 >= filedata
->file_size
)
5122 error (_("Too many program headers - %#x - the file is not that big\n"),
5123 filedata
->file_header
.e_phnum
);
5127 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5128 sizeof (Elf_Internal_Phdr
));
5131 error (_("Out of memory reading %u program headers\n"),
5132 filedata
->file_header
.e_phnum
);
5137 ? get_32bit_program_headers (filedata
, phdrs
)
5138 : get_64bit_program_headers (filedata
, phdrs
))
5140 filedata
->program_headers
= phdrs
;
5148 /* Returns TRUE if the program headers were loaded. */
5151 process_program_headers (Filedata
* filedata
)
5153 Elf_Internal_Phdr
* segment
;
5155 Elf_Internal_Phdr
* previous_load
= NULL
;
5157 filedata
->dynamic_addr
= 0;
5158 filedata
->dynamic_size
= 0;
5160 if (filedata
->file_header
.e_phnum
== 0)
5162 /* PR binutils/12467. */
5163 if (filedata
->file_header
.e_phoff
!= 0)
5165 warn (_("possibly corrupt ELF header - it has a non-zero program"
5166 " header offset, but no program headers\n"));
5169 else if (do_segments
)
5170 printf (_("\nThere are no program headers in this file.\n"));
5174 if (do_segments
&& !do_header
)
5176 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5177 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5178 printf (ngettext ("There is %d program header, starting at offset %s\n",
5179 "There are %d program headers, starting at offset %s\n",
5180 filedata
->file_header
.e_phnum
),
5181 filedata
->file_header
.e_phnum
,
5182 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5185 if (! get_program_headers (filedata
))
5190 if (filedata
->file_header
.e_phnum
> 1)
5191 printf (_("\nProgram Headers:\n"));
5193 printf (_("\nProgram Headers:\n"));
5197 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5200 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5204 (_(" Type Offset VirtAddr PhysAddr\n"));
5206 (_(" FileSiz MemSiz Flags Align\n"));
5210 for (i
= 0, segment
= filedata
->program_headers
;
5211 i
< filedata
->file_header
.e_phnum
;
5216 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5220 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5221 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5222 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5223 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5224 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5226 (segment
->p_flags
& PF_R
? 'R' : ' '),
5227 (segment
->p_flags
& PF_W
? 'W' : ' '),
5228 (segment
->p_flags
& PF_X
? 'E' : ' '));
5229 printf ("%#lx", (unsigned long) segment
->p_align
);
5233 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5234 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5237 print_vma (segment
->p_offset
, FULL_HEX
);
5241 print_vma (segment
->p_vaddr
, FULL_HEX
);
5243 print_vma (segment
->p_paddr
, FULL_HEX
);
5246 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5247 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5250 print_vma (segment
->p_filesz
, FULL_HEX
);
5254 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5255 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5258 print_vma (segment
->p_memsz
, FULL_HEX
);
5262 (segment
->p_flags
& PF_R
? 'R' : ' '),
5263 (segment
->p_flags
& PF_W
? 'W' : ' '),
5264 (segment
->p_flags
& PF_X
? 'E' : ' '));
5266 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5267 printf ("%#lx", (unsigned long) segment
->p_align
);
5270 print_vma (segment
->p_align
, PREFIX_HEX
);
5275 print_vma (segment
->p_offset
, FULL_HEX
);
5277 print_vma (segment
->p_vaddr
, FULL_HEX
);
5279 print_vma (segment
->p_paddr
, FULL_HEX
);
5281 print_vma (segment
->p_filesz
, FULL_HEX
);
5283 print_vma (segment
->p_memsz
, FULL_HEX
);
5285 (segment
->p_flags
& PF_R
? 'R' : ' '),
5286 (segment
->p_flags
& PF_W
? 'W' : ' '),
5287 (segment
->p_flags
& PF_X
? 'E' : ' '));
5288 print_vma (segment
->p_align
, PREFIX_HEX
);
5291 putc ('\n', stdout
);
5294 switch (segment
->p_type
)
5297 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5298 required by the ELF standard, several programs, including the Linux
5299 kernel, make use of non-ordered segments. */
5301 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5302 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5304 if (segment
->p_memsz
< segment
->p_filesz
)
5305 error (_("the segment's file size is larger than its memory size\n"));
5306 previous_load
= segment
;
5310 /* PR 20815 - Verify that the program header is loaded into memory. */
5311 if (i
> 0 && previous_load
!= NULL
)
5312 error (_("the PHDR segment must occur before any LOAD segment\n"));
5313 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5317 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5319 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5320 if (load
->p_type
== PT_LOAD
5321 && load
->p_offset
<= segment
->p_offset
5322 && (load
->p_offset
+ load
->p_filesz
5323 >= segment
->p_offset
+ segment
->p_filesz
)
5324 && load
->p_vaddr
<= segment
->p_vaddr
5325 && (load
->p_vaddr
+ load
->p_filesz
5326 >= segment
->p_vaddr
+ segment
->p_filesz
))
5329 if (j
== filedata
->file_header
.e_phnum
)
5330 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5335 if (filedata
->dynamic_addr
)
5336 error (_("more than one dynamic segment\n"));
5338 /* By default, assume that the .dynamic section is the first
5339 section in the DYNAMIC segment. */
5340 filedata
->dynamic_addr
= segment
->p_offset
;
5341 filedata
->dynamic_size
= segment
->p_filesz
;
5343 /* Try to locate the .dynamic section. If there is
5344 a section header table, we can easily locate it. */
5345 if (filedata
->section_headers
!= NULL
)
5347 Elf_Internal_Shdr
* sec
;
5349 sec
= find_section (filedata
, ".dynamic");
5350 if (sec
== NULL
|| sec
->sh_size
== 0)
5352 /* A corresponding .dynamic section is expected, but on
5353 IA-64/OpenVMS it is OK for it to be missing. */
5354 if (!is_ia64_vms (filedata
))
5355 error (_("no .dynamic section in the dynamic segment\n"));
5359 if (sec
->sh_type
== SHT_NOBITS
)
5361 filedata
->dynamic_size
= 0;
5365 filedata
->dynamic_addr
= sec
->sh_offset
;
5366 filedata
->dynamic_size
= sec
->sh_size
;
5368 /* The PT_DYNAMIC segment, which is used by the run-time
5369 loader, should exactly match the .dynamic section. */
5371 && (filedata
->dynamic_addr
!= segment
->p_offset
5372 || filedata
->dynamic_size
!= segment
->p_filesz
))
5374 the .dynamic section is not the same as the dynamic segment\n"));
5377 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5378 segment. Check this after matching against the section headers
5379 so we don't warn on debuginfo file (which have NOBITS .dynamic
5381 if (filedata
->dynamic_addr
> filedata
->file_size
5382 || (filedata
->dynamic_size
5383 > filedata
->file_size
- filedata
->dynamic_addr
))
5385 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5386 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5391 if (fseek (filedata
->handle
,
5392 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5394 error (_("Unable to find program interpreter name\n"));
5398 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5400 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5401 error (_("Internal error: failed to create format string to display program interpreter\n"));
5403 filedata
->program_interpreter
[0] = 0;
5404 if (fscanf (filedata
->handle
, fmt
,
5405 filedata
->program_interpreter
) <= 0)
5406 error (_("Unable to read program interpreter name\n"));
5409 printf (_(" [Requesting program interpreter: %s]\n"),
5410 filedata
->program_interpreter
);
5417 && filedata
->section_headers
!= NULL
5418 && filedata
->string_table
!= NULL
)
5420 printf (_("\n Section to Segment mapping:\n"));
5421 printf (_(" Segment Sections...\n"));
5423 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5426 Elf_Internal_Shdr
* section
;
5428 segment
= filedata
->program_headers
+ i
;
5429 section
= filedata
->section_headers
+ 1;
5431 printf (" %2.2d ", i
);
5433 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5435 if (!ELF_TBSS_SPECIAL (section
, segment
)
5436 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5437 printf ("%s ", printable_section_name (filedata
, section
));
5448 /* Find the file offset corresponding to VMA by using the program headers. */
5451 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5453 Elf_Internal_Phdr
* seg
;
5455 if (! get_program_headers (filedata
))
5457 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5461 for (seg
= filedata
->program_headers
;
5462 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5465 if (seg
->p_type
!= PT_LOAD
)
5468 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5469 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5470 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5473 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5474 (unsigned long) vma
);
5479 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5480 If PROBE is true, this is just a probe and we do not generate any error
5481 messages if the load fails. */
5484 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5486 Elf32_External_Shdr
* shdrs
;
5487 Elf_Internal_Shdr
* internal
;
5489 unsigned int size
= filedata
->file_header
.e_shentsize
;
5490 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5492 /* PR binutils/17531: Cope with unexpected section header sizes. */
5493 if (size
== 0 || num
== 0)
5495 if (size
< sizeof * shdrs
)
5498 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5501 if (!probe
&& size
> sizeof * shdrs
)
5502 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5504 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5506 probe
? NULL
: _("section headers"));
5510 free (filedata
->section_headers
);
5511 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5512 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5513 if (filedata
->section_headers
== NULL
)
5516 error (_("Out of memory reading %u section headers\n"), num
);
5521 for (i
= 0, internal
= filedata
->section_headers
;
5525 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5526 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5527 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5528 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5529 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5530 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5531 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5532 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5533 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5534 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5535 if (!probe
&& internal
->sh_link
> num
)
5536 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5537 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5538 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5545 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5548 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5550 Elf64_External_Shdr
* shdrs
;
5551 Elf_Internal_Shdr
* internal
;
5553 unsigned int size
= filedata
->file_header
.e_shentsize
;
5554 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5556 /* PR binutils/17531: Cope with unexpected section header sizes. */
5557 if (size
== 0 || num
== 0)
5560 if (size
< sizeof * shdrs
)
5563 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5567 if (! probe
&& size
> sizeof * shdrs
)
5568 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5570 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5571 filedata
->file_header
.e_shoff
,
5573 probe
? NULL
: _("section headers"));
5577 free (filedata
->section_headers
);
5578 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5579 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5580 if (filedata
->section_headers
== NULL
)
5583 error (_("Out of memory reading %u section headers\n"), num
);
5588 for (i
= 0, internal
= filedata
->section_headers
;
5592 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5593 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5594 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5595 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5596 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5597 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5598 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5599 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5600 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5601 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5602 if (!probe
&& internal
->sh_link
> num
)
5603 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5604 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5605 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5612 static Elf_Internal_Sym
*
5613 get_32bit_elf_symbols (Filedata
* filedata
,
5614 Elf_Internal_Shdr
* section
,
5615 unsigned long * num_syms_return
)
5617 unsigned long number
= 0;
5618 Elf32_External_Sym
* esyms
= NULL
;
5619 Elf_External_Sym_Shndx
* shndx
= NULL
;
5620 Elf_Internal_Sym
* isyms
= NULL
;
5621 Elf_Internal_Sym
* psym
;
5623 elf_section_list
* entry
;
5625 if (section
->sh_size
== 0)
5627 if (num_syms_return
!= NULL
)
5628 * num_syms_return
= 0;
5632 /* Run some sanity checks first. */
5633 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5635 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5636 printable_section_name (filedata
, section
),
5637 (unsigned long) section
->sh_entsize
);
5641 if (section
->sh_size
> filedata
->file_size
)
5643 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5644 printable_section_name (filedata
, section
),
5645 (unsigned long) section
->sh_size
);
5649 number
= section
->sh_size
/ section
->sh_entsize
;
5651 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5653 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5654 (unsigned long) section
->sh_size
,
5655 printable_section_name (filedata
, section
),
5656 (unsigned long) section
->sh_entsize
);
5660 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5661 section
->sh_size
, _("symbols"));
5666 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5668 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5673 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5677 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5678 entry
->hdr
->sh_offset
,
5679 1, entry
->hdr
->sh_size
,
5680 _("symbol table section indices"));
5684 /* PR17531: file: heap-buffer-overflow */
5685 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5687 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5688 printable_section_name (filedata
, entry
->hdr
),
5689 (unsigned long) entry
->hdr
->sh_size
,
5690 (unsigned long) section
->sh_size
);
5695 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5699 error (_("Out of memory reading %lu symbols\n"),
5700 (unsigned long) number
);
5704 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5706 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5707 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5708 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5709 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5710 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5712 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5713 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5714 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5715 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5716 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5723 if (num_syms_return
!= NULL
)
5724 * num_syms_return
= isyms
== NULL
? 0 : number
;
5729 static Elf_Internal_Sym
*
5730 get_64bit_elf_symbols (Filedata
* filedata
,
5731 Elf_Internal_Shdr
* section
,
5732 unsigned long * num_syms_return
)
5734 unsigned long number
= 0;
5735 Elf64_External_Sym
* esyms
= NULL
;
5736 Elf_External_Sym_Shndx
* shndx
= NULL
;
5737 Elf_Internal_Sym
* isyms
= NULL
;
5738 Elf_Internal_Sym
* psym
;
5740 elf_section_list
* entry
;
5742 if (section
->sh_size
== 0)
5744 if (num_syms_return
!= NULL
)
5745 * num_syms_return
= 0;
5749 /* Run some sanity checks first. */
5750 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5752 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5753 printable_section_name (filedata
, section
),
5754 (unsigned long) section
->sh_entsize
);
5758 if (section
->sh_size
> filedata
->file_size
)
5760 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5761 printable_section_name (filedata
, section
),
5762 (unsigned long) section
->sh_size
);
5766 number
= section
->sh_size
/ section
->sh_entsize
;
5768 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5770 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5771 (unsigned long) section
->sh_size
,
5772 printable_section_name (filedata
, section
),
5773 (unsigned long) section
->sh_entsize
);
5777 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5778 section
->sh_size
, _("symbols"));
5783 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5785 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5790 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5794 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5795 entry
->hdr
->sh_offset
,
5796 1, entry
->hdr
->sh_size
,
5797 _("symbol table section indices"));
5801 /* PR17531: file: heap-buffer-overflow */
5802 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5804 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5805 printable_section_name (filedata
, entry
->hdr
),
5806 (unsigned long) entry
->hdr
->sh_size
,
5807 (unsigned long) section
->sh_size
);
5812 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5816 error (_("Out of memory reading %lu symbols\n"),
5817 (unsigned long) number
);
5821 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5823 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5824 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5825 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5826 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5828 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5830 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5831 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5832 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5834 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5835 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5842 if (num_syms_return
!= NULL
)
5843 * num_syms_return
= isyms
== NULL
? 0 : number
;
5849 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5851 static char buff
[1024];
5853 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5855 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5856 bfd_vma os_flags
= 0;
5857 bfd_vma proc_flags
= 0;
5858 bfd_vma unknown_flags
= 0;
5866 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5867 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5868 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5869 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5870 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5871 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5872 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5873 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5874 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5875 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5876 /* IA-64 specific. */
5877 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5878 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5879 /* IA-64 OpenVMS specific. */
5880 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5881 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5882 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5883 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5884 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5885 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5887 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5888 /* SPARC specific. */
5889 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5890 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5892 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5893 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5894 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5896 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5898 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5901 if (do_section_details
)
5903 sprintf (buff
, "[%*.*lx]: ",
5904 field_size
, field_size
, (unsigned long) sh_flags
);
5905 p
+= field_size
+ 4;
5912 flag
= sh_flags
& - sh_flags
;
5915 if (do_section_details
)
5919 case SHF_WRITE
: sindex
= 0; break;
5920 case SHF_ALLOC
: sindex
= 1; break;
5921 case SHF_EXECINSTR
: sindex
= 2; break;
5922 case SHF_MERGE
: sindex
= 3; break;
5923 case SHF_STRINGS
: sindex
= 4; break;
5924 case SHF_INFO_LINK
: sindex
= 5; break;
5925 case SHF_LINK_ORDER
: sindex
= 6; break;
5926 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5927 case SHF_GROUP
: sindex
= 8; break;
5928 case SHF_TLS
: sindex
= 9; break;
5929 case SHF_EXCLUDE
: sindex
= 18; break;
5930 case SHF_COMPRESSED
: sindex
= 20; break;
5931 case SHF_GNU_MBIND
: sindex
= 24; break;
5935 switch (filedata
->file_header
.e_machine
)
5938 if (flag
== SHF_IA_64_SHORT
)
5940 else if (flag
== SHF_IA_64_NORECOV
)
5943 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5946 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5947 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5948 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5949 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5950 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5951 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5962 case EM_OLD_SPARCV9
:
5963 case EM_SPARC32PLUS
:
5966 if (flag
== SHF_ORDERED
)
5973 case SHF_ENTRYSECT
: sindex
= 21; break;
5974 case SHF_ARM_PURECODE
: sindex
= 22; break;
5975 case SHF_COMDEF
: sindex
= 23; break;
5980 if (flag
== SHF_PPC_VLE
)
5991 if (p
!= buff
+ field_size
+ 4)
5993 if (size
< (10 + 2))
5995 warn (_("Internal error: not enough buffer room for section flag info"));
5996 return _("<unknown>");
6003 size
-= flags
[sindex
].len
;
6004 p
= stpcpy (p
, flags
[sindex
].str
);
6006 else if (flag
& SHF_MASKOS
)
6008 else if (flag
& SHF_MASKPROC
)
6011 unknown_flags
|= flag
;
6017 case SHF_WRITE
: *p
= 'W'; break;
6018 case SHF_ALLOC
: *p
= 'A'; break;
6019 case SHF_EXECINSTR
: *p
= 'X'; break;
6020 case SHF_MERGE
: *p
= 'M'; break;
6021 case SHF_STRINGS
: *p
= 'S'; break;
6022 case SHF_INFO_LINK
: *p
= 'I'; break;
6023 case SHF_LINK_ORDER
: *p
= 'L'; break;
6024 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6025 case SHF_GROUP
: *p
= 'G'; break;
6026 case SHF_TLS
: *p
= 'T'; break;
6027 case SHF_EXCLUDE
: *p
= 'E'; break;
6028 case SHF_COMPRESSED
: *p
= 'C'; break;
6029 case SHF_GNU_MBIND
: *p
= 'D'; break;
6032 if ((filedata
->file_header
.e_machine
== EM_X86_64
6033 || filedata
->file_header
.e_machine
== EM_L1OM
6034 || filedata
->file_header
.e_machine
== EM_K1OM
)
6035 && flag
== SHF_X86_64_LARGE
)
6037 else if (filedata
->file_header
.e_machine
== EM_ARM
6038 && flag
== SHF_ARM_PURECODE
)
6040 else if (filedata
->file_header
.e_machine
== EM_PPC
6041 && flag
== SHF_PPC_VLE
)
6043 else if (flag
& SHF_MASKOS
)
6046 sh_flags
&= ~ SHF_MASKOS
;
6048 else if (flag
& SHF_MASKPROC
)
6051 sh_flags
&= ~ SHF_MASKPROC
;
6061 if (do_section_details
)
6065 size
-= 5 + field_size
;
6066 if (p
!= buff
+ field_size
+ 4)
6070 warn (_("Internal error: not enough buffer room for section flag info"));
6071 return _("<unknown>");
6077 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6078 (unsigned long) os_flags
);
6079 p
+= 5 + field_size
;
6083 size
-= 7 + 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
, "PROC (%*.*lx)", field_size
, field_size
,
6096 (unsigned long) proc_flags
);
6097 p
+= 7 + field_size
;
6101 size
-= 10 + 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
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6114 (unsigned long) unknown_flags
);
6115 p
+= 10 + field_size
;
6123 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6124 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6128 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6130 if (size
< sizeof (* echdr
))
6132 error (_("Compressed section is too small even for a compression header\n"));
6136 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6137 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6138 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6139 return sizeof (*echdr
);
6143 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6145 if (size
< sizeof (* echdr
))
6147 error (_("Compressed section is too small even for a compression header\n"));
6151 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6152 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6153 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6154 return sizeof (*echdr
);
6159 process_section_headers (Filedata
* filedata
)
6161 Elf_Internal_Shdr
* section
;
6164 free (filedata
->section_headers
);
6165 filedata
->section_headers
= NULL
;
6166 free (filedata
->dynamic_symbols
);
6167 filedata
->dynamic_symbols
= NULL
;
6168 filedata
->num_dynamic_syms
= 0;
6169 free (filedata
->dynamic_strings
);
6170 filedata
->dynamic_strings
= NULL
;
6171 filedata
->dynamic_strings_length
= 0;
6172 free (filedata
->dynamic_syminfo
);
6173 filedata
->dynamic_syminfo
= NULL
;
6174 while (filedata
->symtab_shndx_list
!= NULL
)
6176 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6177 free (filedata
->symtab_shndx_list
);
6178 filedata
->symtab_shndx_list
= next
;
6181 if (filedata
->file_header
.e_shnum
== 0)
6183 /* PR binutils/12467. */
6184 if (filedata
->file_header
.e_shoff
!= 0)
6186 warn (_("possibly corrupt ELF file header - it has a non-zero"
6187 " section header offset, but no section headers\n"));
6190 else if (do_sections
)
6191 printf (_("\nThere are no sections in this file.\n"));
6196 if (do_sections
&& !do_header
)
6197 printf (ngettext ("There is %d section header, "
6198 "starting at offset 0x%lx:\n",
6199 "There are %d section headers, "
6200 "starting at offset 0x%lx:\n",
6201 filedata
->file_header
.e_shnum
),
6202 filedata
->file_header
.e_shnum
,
6203 (unsigned long) filedata
->file_header
.e_shoff
);
6207 if (! get_32bit_section_headers (filedata
, FALSE
))
6212 if (! get_64bit_section_headers (filedata
, FALSE
))
6216 /* Read in the string table, so that we have names to display. */
6217 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6218 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6220 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6222 if (section
->sh_size
!= 0)
6224 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6225 1, section
->sh_size
,
6228 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6232 /* Scan the sections for the dynamic symbol table
6233 and dynamic string table and debug sections. */
6234 eh_addr_size
= is_32bit_elf
? 4 : 8;
6235 switch (filedata
->file_header
.e_machine
)
6238 case EM_MIPS_RS3_LE
:
6239 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6240 FDE addresses. However, the ABI also has a semi-official ILP32
6241 variant for which the normal FDE address size rules apply.
6243 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6244 section, where XX is the size of longs in bits. Unfortunately,
6245 earlier compilers provided no way of distinguishing ILP32 objects
6246 from LP64 objects, so if there's any doubt, we should assume that
6247 the official LP64 form is being used. */
6248 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6249 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6255 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6257 case E_H8_MACH_H8300
:
6258 case E_H8_MACH_H8300HN
:
6259 case E_H8_MACH_H8300SN
:
6260 case E_H8_MACH_H8300SXN
:
6263 case E_H8_MACH_H8300H
:
6264 case E_H8_MACH_H8300S
:
6265 case E_H8_MACH_H8300SX
:
6273 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6275 case EF_M32C_CPU_M16C
:
6282 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6285 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6286 if (section->sh_entsize != expected_entsize) \
6289 sprintf_vma (buf, section->sh_entsize); \
6290 /* Note: coded this way so that there is a single string for \
6292 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6293 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6294 (unsigned) expected_entsize); \
6295 section->sh_entsize = expected_entsize; \
6300 #define CHECK_ENTSIZE(section, i, type) \
6301 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6302 sizeof (Elf64_External_##type))
6304 for (i
= 0, section
= filedata
->section_headers
;
6305 i
< filedata
->file_header
.e_shnum
;
6308 char * name
= SECTION_NAME (section
);
6310 /* Run some sanity checks on the headers and
6311 possibly fill in some file data as well. */
6312 switch (section
->sh_type
)
6315 if (filedata
->dynamic_symbols
!= NULL
)
6317 error (_("File contains multiple dynamic symbol tables\n"));
6321 CHECK_ENTSIZE (section
, i
, Sym
);
6322 filedata
->dynamic_symbols
6323 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6324 filedata
->dynamic_symtab_section
= section
;
6328 if (streq (name
, ".dynstr"))
6330 if (filedata
->dynamic_strings
!= NULL
)
6332 error (_("File contains multiple dynamic string tables\n"));
6336 filedata
->dynamic_strings
6337 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6338 1, section
->sh_size
, _("dynamic strings"));
6339 filedata
->dynamic_strings_length
6340 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6341 filedata
->dynamic_strtab_section
= section
;
6345 case SHT_SYMTAB_SHNDX
:
6347 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6349 entry
->hdr
= section
;
6350 entry
->next
= filedata
->symtab_shndx_list
;
6351 filedata
->symtab_shndx_list
= entry
;
6356 CHECK_ENTSIZE (section
, i
, Sym
);
6360 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6364 CHECK_ENTSIZE (section
, i
, Rel
);
6365 if (do_checks
&& section
->sh_size
== 0)
6366 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6370 CHECK_ENTSIZE (section
, i
, Rela
);
6371 if (do_checks
&& section
->sh_size
== 0)
6372 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6377 /* Having a zero sized section is not illegal according to the
6378 ELF standard, but it might be an indication that something
6379 is wrong. So issue a warning if we are running in lint mode. */
6380 if (do_checks
&& section
->sh_size
== 0)
6381 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6388 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6389 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6390 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6391 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6392 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6393 && (const_strneq (name
, ".debug_")
6394 || const_strneq (name
, ".zdebug_")))
6397 name
+= sizeof (".zdebug_") - 1;
6399 name
+= sizeof (".debug_") - 1;
6402 || (do_debug_info
&& const_strneq (name
, "info"))
6403 || (do_debug_info
&& const_strneq (name
, "types"))
6404 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6405 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6406 || (do_debug_lines
&& const_strneq (name
, "line."))
6407 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6408 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6409 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6410 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6411 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6412 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6413 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6414 || (do_debug_frames
&& const_strneq (name
, "frame"))
6415 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6416 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6417 || (do_debug_str
&& const_strneq (name
, "str"))
6418 || (do_debug_loc
&& const_strneq (name
, "loc"))
6419 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6420 || (do_debug_addr
&& const_strneq (name
, "addr"))
6421 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6422 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6424 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6426 /* Linkonce section to be combined with .debug_info at link time. */
6427 else if ((do_debugging
|| do_debug_info
)
6428 && const_strneq (name
, ".gnu.linkonce.wi."))
6429 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6430 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6431 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6432 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6433 || streq (name
, ".debug_names")))
6434 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6435 /* Trace sections for Itanium VMS. */
6436 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6437 || do_trace_aranges
)
6438 && const_strneq (name
, ".trace_"))
6440 name
+= sizeof (".trace_") - 1;
6443 || (do_trace_info
&& streq (name
, "info"))
6444 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6445 || (do_trace_aranges
&& streq (name
, "aranges"))
6447 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6449 else if ((do_debugging
|| do_debug_links
)
6450 && (const_strneq (name
, ".gnu_debuglink")
6451 || const_strneq (name
, ".gnu_debugaltlink")))
6452 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6458 if (filedata
->file_header
.e_shnum
> 1)
6459 printf (_("\nSection Headers:\n"));
6461 printf (_("\nSection Header:\n"));
6465 if (do_section_details
)
6467 printf (_(" [Nr] Name\n"));
6468 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6472 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6476 if (do_section_details
)
6478 printf (_(" [Nr] Name\n"));
6479 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6483 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6487 if (do_section_details
)
6489 printf (_(" [Nr] Name\n"));
6490 printf (_(" Type Address Offset Link\n"));
6491 printf (_(" Size EntSize Info Align\n"));
6495 printf (_(" [Nr] Name Type Address Offset\n"));
6496 printf (_(" Size EntSize Flags Link Info Align\n"));
6500 if (do_section_details
)
6501 printf (_(" Flags\n"));
6503 for (i
= 0, section
= filedata
->section_headers
;
6504 i
< filedata
->file_header
.e_shnum
;
6507 /* Run some sanity checks on the section header. */
6509 /* Check the sh_link field. */
6510 switch (section
->sh_type
)
6514 if (section
->sh_link
== 0
6515 && (filedata
->file_header
.e_type
== ET_EXEC
6516 || filedata
->file_header
.e_type
== ET_DYN
))
6517 /* A dynamic relocation section where all entries use a
6518 zero symbol index need not specify a symtab section. */
6521 case SHT_SYMTAB_SHNDX
:
6525 case SHT_GNU_versym
:
6526 if (section
->sh_link
== 0
6527 || section
->sh_link
>= filedata
->file_header
.e_shnum
6528 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6529 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6530 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6531 i
, section
->sh_link
);
6537 case SHT_GNU_verneed
:
6538 case SHT_GNU_verdef
:
6539 case SHT_GNU_LIBLIST
:
6540 if (section
->sh_link
== 0
6541 || section
->sh_link
>= filedata
->file_header
.e_shnum
6542 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6543 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6544 i
, section
->sh_link
);
6547 case SHT_INIT_ARRAY
:
6548 case SHT_FINI_ARRAY
:
6549 case SHT_PREINIT_ARRAY
:
6550 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6551 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6552 i
, section
->sh_link
);
6556 /* FIXME: Add support for target specific section types. */
6557 #if 0 /* Currently we do not check other section types as there are too
6558 many special cases. Stab sections for example have a type
6559 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6561 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6562 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6563 i
, section
->sh_link
);
6568 /* Check the sh_info field. */
6569 switch (section
->sh_type
)
6573 if (section
->sh_info
== 0
6574 && (filedata
->file_header
.e_type
== ET_EXEC
6575 || filedata
->file_header
.e_type
== ET_DYN
))
6576 /* Dynamic relocations apply to segments, so they do not
6577 need to specify the section they relocate. */
6579 if (section
->sh_info
== 0
6580 || section
->sh_info
>= filedata
->file_header
.e_shnum
6581 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6582 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6583 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6584 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6585 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6586 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6587 /* FIXME: Are other section types valid ? */
6588 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6589 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6590 i
, section
->sh_info
);
6595 case SHT_SYMTAB_SHNDX
:
6596 case SHT_INIT_ARRAY
:
6597 case SHT_FINI_ARRAY
:
6598 case SHT_PREINIT_ARRAY
:
6599 if (section
->sh_info
!= 0)
6600 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6601 i
, section
->sh_info
);
6607 /* A symbol index - we assume that it is valid. */
6611 /* FIXME: Add support for target specific section types. */
6612 if (section
->sh_type
== SHT_NOBITS
)
6613 /* NOBITS section headers with non-zero sh_info fields can be
6614 created when a binary is stripped of everything but its debug
6615 information. The stripped sections have their headers
6616 preserved but their types set to SHT_NOBITS. So do not check
6617 this type of section. */
6619 else if (section
->sh_flags
& SHF_INFO_LINK
)
6621 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6622 warn (_("[%2u]: Expected link to another section in info field"), i
);
6624 else if (section
->sh_type
< SHT_LOOS
6625 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6626 && section
->sh_info
!= 0)
6627 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6628 i
, section
->sh_info
);
6632 /* Check the sh_size field. */
6633 if (section
->sh_size
> filedata
->file_size
6634 && section
->sh_type
!= SHT_NOBITS
6635 && section
->sh_type
!= SHT_NULL
6636 && section
->sh_type
< SHT_LOOS
)
6637 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6639 printf (" [%2u] ", i
);
6640 if (do_section_details
)
6641 printf ("%s\n ", printable_section_name (filedata
, section
));
6643 print_symbol (-17, SECTION_NAME (section
));
6645 printf (do_wide
? " %-15s " : " %-15.15s ",
6646 get_section_type_name (filedata
, section
->sh_type
));
6650 const char * link_too_big
= NULL
;
6652 print_vma (section
->sh_addr
, LONG_HEX
);
6654 printf ( " %6.6lx %6.6lx %2.2lx",
6655 (unsigned long) section
->sh_offset
,
6656 (unsigned long) section
->sh_size
,
6657 (unsigned long) section
->sh_entsize
);
6659 if (do_section_details
)
6660 fputs (" ", stdout
);
6662 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6664 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6667 /* The sh_link value is out of range. Normally this indicates
6668 an error but it can have special values in Solaris binaries. */
6669 switch (filedata
->file_header
.e_machine
)
6676 case EM_OLD_SPARCV9
:
6677 case EM_SPARC32PLUS
:
6680 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6681 link_too_big
= "BEFORE";
6682 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6683 link_too_big
= "AFTER";
6690 if (do_section_details
)
6692 if (link_too_big
!= NULL
&& * link_too_big
)
6693 printf ("<%s> ", link_too_big
);
6695 printf ("%2u ", section
->sh_link
);
6696 printf ("%3u %2lu\n", section
->sh_info
,
6697 (unsigned long) section
->sh_addralign
);
6700 printf ("%2u %3u %2lu\n",
6703 (unsigned long) section
->sh_addralign
);
6705 if (link_too_big
&& ! * link_too_big
)
6706 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6707 i
, section
->sh_link
);
6711 print_vma (section
->sh_addr
, LONG_HEX
);
6713 if ((long) section
->sh_offset
== section
->sh_offset
)
6714 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6718 print_vma (section
->sh_offset
, LONG_HEX
);
6721 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6722 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6726 print_vma (section
->sh_size
, LONG_HEX
);
6729 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6730 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6734 print_vma (section
->sh_entsize
, LONG_HEX
);
6737 if (do_section_details
)
6738 fputs (" ", stdout
);
6740 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6742 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6744 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6745 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6748 print_vma (section
->sh_addralign
, DEC
);
6752 else if (do_section_details
)
6755 print_vma (section
->sh_addr
, LONG_HEX
);
6756 if ((long) section
->sh_offset
== section
->sh_offset
)
6757 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6761 print_vma (section
->sh_offset
, LONG_HEX
);
6763 printf (" %u\n ", section
->sh_link
);
6764 print_vma (section
->sh_size
, LONG_HEX
);
6766 print_vma (section
->sh_entsize
, LONG_HEX
);
6768 printf (" %-16u %lu\n",
6770 (unsigned long) section
->sh_addralign
);
6775 print_vma (section
->sh_addr
, LONG_HEX
);
6776 if ((long) section
->sh_offset
== section
->sh_offset
)
6777 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6781 print_vma (section
->sh_offset
, LONG_HEX
);
6784 print_vma (section
->sh_size
, LONG_HEX
);
6786 print_vma (section
->sh_entsize
, LONG_HEX
);
6788 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6790 printf (" %2u %3u %lu\n",
6793 (unsigned long) section
->sh_addralign
);
6796 if (do_section_details
)
6798 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6799 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6801 /* Minimum section size is 12 bytes for 32-bit compression
6802 header + 12 bytes for compressed data header. */
6803 unsigned char buf
[24];
6805 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6806 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6807 sizeof (buf
), _("compression header")))
6809 Elf_Internal_Chdr chdr
;
6811 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6812 printf (_(" [<corrupt>]\n"));
6815 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6818 printf (_(" [<unknown>: 0x%x], "),
6820 print_vma (chdr
.ch_size
, LONG_HEX
);
6821 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6828 if (!do_section_details
)
6830 /* The ordering of the letters shown here matches the ordering of the
6831 corresponding SHF_xxx values, and hence the order in which these
6832 letters will be displayed to the user. */
6833 printf (_("Key to Flags:\n\
6834 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6835 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6836 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6837 if (filedata
->file_header
.e_machine
== EM_X86_64
6838 || filedata
->file_header
.e_machine
== EM_L1OM
6839 || filedata
->file_header
.e_machine
== EM_K1OM
)
6840 printf (_("l (large), "));
6841 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6842 printf (_("y (purecode), "));
6843 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6844 printf (_("v (VLE), "));
6845 printf ("p (processor specific)\n");
6852 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6853 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6854 char **strtab
, unsigned long *strtablen
)
6858 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6860 if (*symtab
== NULL
)
6863 if (symsec
->sh_link
!= 0)
6865 Elf_Internal_Shdr
*strsec
;
6867 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6869 error (_("Bad sh_link in symbol table section\n"));
6876 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6878 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6879 1, strsec
->sh_size
, _("string table"));
6880 if (*strtab
== NULL
)
6887 *strtablen
= strsec
->sh_size
;
6893 get_group_flags (unsigned int flags
)
6895 static char buff
[128];
6899 else if (flags
== GRP_COMDAT
)
6902 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6904 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6905 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6906 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6907 ? _("<unknown>") : ""));
6913 process_section_groups (Filedata
* filedata
)
6915 Elf_Internal_Shdr
* section
;
6917 struct group
* group
;
6918 Elf_Internal_Shdr
* symtab_sec
;
6919 Elf_Internal_Shdr
* strtab_sec
;
6920 Elf_Internal_Sym
* symtab
;
6921 unsigned long num_syms
;
6925 /* Don't process section groups unless needed. */
6926 if (!do_unwind
&& !do_section_groups
)
6929 if (filedata
->file_header
.e_shnum
== 0)
6931 if (do_section_groups
)
6932 printf (_("\nThere are no sections to group in this file.\n"));
6937 if (filedata
->section_headers
== NULL
)
6939 error (_("Section headers are not available!\n"));
6940 /* PR 13622: This can happen with a corrupt ELF header. */
6944 filedata
->section_headers_groups
6945 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6946 sizeof (struct group
*));
6948 if (filedata
->section_headers_groups
== NULL
)
6950 error (_("Out of memory reading %u section group headers\n"),
6951 filedata
->file_header
.e_shnum
);
6955 /* Scan the sections for the group section. */
6956 filedata
->group_count
= 0;
6957 for (i
= 0, section
= filedata
->section_headers
;
6958 i
< filedata
->file_header
.e_shnum
;
6960 if (section
->sh_type
== SHT_GROUP
)
6961 filedata
->group_count
++;
6963 if (filedata
->group_count
== 0)
6965 if (do_section_groups
)
6966 printf (_("\nThere are no section groups in this file.\n"));
6971 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
6972 sizeof (struct group
));
6974 if (filedata
->section_groups
== NULL
)
6976 error (_("Out of memory reading %lu groups\n"),
6977 (unsigned long) filedata
->group_count
);
6987 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
6988 i
< filedata
->file_header
.e_shnum
;
6991 if (section
->sh_type
== SHT_GROUP
)
6993 const char * name
= printable_section_name (filedata
, section
);
6994 const char * group_name
;
6995 unsigned char * start
;
6996 unsigned char * indices
;
6997 unsigned int entry
, j
, size
;
6998 Elf_Internal_Shdr
* sec
;
6999 Elf_Internal_Sym
* sym
;
7001 /* Get the symbol table. */
7002 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7003 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7006 error (_("Bad sh_link in group section `%s'\n"), name
);
7010 if (symtab_sec
!= sec
)
7015 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7020 error (_("Corrupt header in group section `%s'\n"), name
);
7024 if (section
->sh_info
>= num_syms
)
7026 error (_("Bad sh_info in group section `%s'\n"), name
);
7030 sym
= symtab
+ section
->sh_info
;
7032 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7034 if (sym
->st_shndx
== 0
7035 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7037 error (_("Bad sh_info in group section `%s'\n"), name
);
7041 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
7050 /* Get the string table. */
7051 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7060 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7066 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7067 1, strtab_sec
->sh_size
,
7069 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7071 group_name
= sym
->st_name
< strtab_size
7072 ? strtab
+ sym
->st_name
: _("<corrupt>");
7075 /* PR 17531: file: loop. */
7076 if (section
->sh_entsize
> section
->sh_size
)
7078 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7079 printable_section_name (filedata
, section
),
7080 (unsigned long) section
->sh_entsize
,
7081 (unsigned long) section
->sh_size
);
7085 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7086 1, section
->sh_size
,
7092 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7093 entry
= byte_get (indices
, 4);
7096 if (do_section_groups
)
7098 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7099 get_group_flags (entry
), i
, name
, group_name
, size
);
7101 printf (_(" [Index] Name\n"));
7104 group
->group_index
= i
;
7106 for (j
= 0; j
< size
; j
++)
7108 struct group_list
* g
;
7110 entry
= byte_get (indices
, 4);
7113 if (entry
>= filedata
->file_header
.e_shnum
)
7115 static unsigned num_group_errors
= 0;
7117 if (num_group_errors
++ < 10)
7119 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7120 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7121 if (num_group_errors
== 10)
7122 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7127 if (filedata
->section_headers_groups
[entry
] != NULL
)
7131 static unsigned num_errs
= 0;
7133 if (num_errs
++ < 10)
7135 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7137 filedata
->section_headers_groups
[entry
]->group_index
);
7139 warn (_("Further error messages about already contained group sections suppressed\n"));
7145 /* Intel C/C++ compiler may put section 0 in a
7146 section group. We just warn it the first time
7147 and ignore it afterwards. */
7148 static bfd_boolean warned
= FALSE
;
7151 error (_("section 0 in group section [%5u]\n"),
7152 filedata
->section_headers_groups
[entry
]->group_index
);
7158 filedata
->section_headers_groups
[entry
] = group
;
7160 if (do_section_groups
)
7162 sec
= filedata
->section_headers
+ entry
;
7163 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7166 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7167 g
->section_index
= entry
;
7168 g
->next
= group
->root
;
7186 /* Data used to display dynamic fixups. */
7188 struct ia64_vms_dynfixup
7190 bfd_vma needed_ident
; /* Library ident number. */
7191 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7192 bfd_vma fixup_needed
; /* Index of the library. */
7193 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7194 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7197 /* Data used to display dynamic relocations. */
7199 struct ia64_vms_dynimgrela
7201 bfd_vma img_rela_cnt
; /* Number of relocations. */
7202 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7205 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7209 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7210 struct ia64_vms_dynfixup
* fixup
,
7211 const char * strtab
,
7212 unsigned int strtab_sz
)
7214 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7216 const char * lib_name
;
7218 imfs
= get_data (NULL
, filedata
,
7219 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7220 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7221 _("dynamic section image fixups"));
7225 if (fixup
->needed
< strtab_sz
)
7226 lib_name
= strtab
+ fixup
->needed
;
7229 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7230 (unsigned long) fixup
->needed
);
7234 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7235 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7237 (_("Seg Offset Type SymVec DataType\n"));
7239 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7244 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7245 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7246 type
= BYTE_GET (imfs
[i
].type
);
7247 rtype
= elf_ia64_reloc_type (type
);
7249 printf (" 0x%08x ", type
);
7251 printf (" %-32s ", rtype
);
7252 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7253 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7260 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7263 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7265 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7268 imrs
= get_data (NULL
, filedata
,
7269 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7270 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7271 _("dynamic section image relocations"));
7275 printf (_("\nImage relocs\n"));
7277 (_("Seg Offset Type Addend Seg Sym Off\n"));
7279 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7284 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7285 printf ("%08" BFD_VMA_FMT
"x ",
7286 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7287 type
= BYTE_GET (imrs
[i
].type
);
7288 rtype
= elf_ia64_reloc_type (type
);
7290 printf ("0x%08x ", type
);
7292 printf ("%-31s ", rtype
);
7293 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7294 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7295 printf ("%08" BFD_VMA_FMT
"x\n",
7296 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7303 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7306 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7308 struct ia64_vms_dynfixup fixup
;
7309 struct ia64_vms_dynimgrela imgrela
;
7310 Elf_Internal_Dyn
*entry
;
7311 bfd_vma strtab_off
= 0;
7312 bfd_vma strtab_sz
= 0;
7313 char *strtab
= NULL
;
7314 bfd_boolean res
= TRUE
;
7316 memset (&fixup
, 0, sizeof (fixup
));
7317 memset (&imgrela
, 0, sizeof (imgrela
));
7319 /* Note: the order of the entries is specified by the OpenVMS specs. */
7320 for (entry
= filedata
->dynamic_section
;
7321 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7324 switch (entry
->d_tag
)
7326 case DT_IA_64_VMS_STRTAB_OFFSET
:
7327 strtab_off
= entry
->d_un
.d_val
;
7330 strtab_sz
= entry
->d_un
.d_val
;
7332 strtab
= get_data (NULL
, filedata
,
7333 filedata
->dynamic_addr
+ strtab_off
,
7334 1, strtab_sz
, _("dynamic string section"));
7339 case DT_IA_64_VMS_NEEDED_IDENT
:
7340 fixup
.needed_ident
= entry
->d_un
.d_val
;
7343 fixup
.needed
= entry
->d_un
.d_val
;
7345 case DT_IA_64_VMS_FIXUP_NEEDED
:
7346 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7348 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7349 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7351 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7352 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7353 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7356 case DT_IA_64_VMS_IMG_RELA_CNT
:
7357 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7359 case DT_IA_64_VMS_IMG_RELA_OFF
:
7360 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7361 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7383 dynamic_relocations
[] =
7385 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7386 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7387 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7390 /* Process the reloc section. */
7393 process_relocs (Filedata
* filedata
)
7395 unsigned long rel_size
;
7396 unsigned long rel_offset
;
7401 if (do_using_dynamic
)
7405 bfd_boolean has_dynamic_reloc
;
7408 has_dynamic_reloc
= FALSE
;
7410 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7412 is_rela
= dynamic_relocations
[i
].rela
;
7413 name
= dynamic_relocations
[i
].name
;
7414 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7415 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7418 has_dynamic_reloc
= TRUE
;
7420 if (is_rela
== UNKNOWN
)
7422 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7423 switch (filedata
->dynamic_info
[DT_PLTREL
])
7437 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7438 name
, rel_offset
, rel_size
);
7440 dump_relocations (filedata
,
7441 offset_from_vma (filedata
, rel_offset
, rel_size
),
7443 filedata
->dynamic_symbols
,
7444 filedata
->num_dynamic_syms
,
7445 filedata
->dynamic_strings
,
7446 filedata
->dynamic_strings_length
,
7447 is_rela
, TRUE
/* is_dynamic */);
7451 if (is_ia64_vms (filedata
))
7452 if (process_ia64_vms_dynamic_relocs (filedata
))
7453 has_dynamic_reloc
= TRUE
;
7455 if (! has_dynamic_reloc
)
7456 printf (_("\nThere are no dynamic relocations in this file.\n"));
7460 Elf_Internal_Shdr
* section
;
7462 bfd_boolean found
= FALSE
;
7464 for (i
= 0, section
= filedata
->section_headers
;
7465 i
< filedata
->file_header
.e_shnum
;
7468 if ( section
->sh_type
!= SHT_RELA
7469 && section
->sh_type
!= SHT_REL
)
7472 rel_offset
= section
->sh_offset
;
7473 rel_size
= section
->sh_size
;
7478 unsigned long num_rela
;
7480 printf (_("\nRelocation section "));
7482 if (filedata
->string_table
== NULL
)
7483 printf ("%d", section
->sh_name
);
7485 printf ("'%s'", printable_section_name (filedata
, section
));
7487 num_rela
= rel_size
/ section
->sh_entsize
;
7488 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7489 " at offset 0x%lx contains %lu entries:\n",
7491 rel_offset
, num_rela
);
7493 is_rela
= section
->sh_type
== SHT_RELA
;
7495 if (section
->sh_link
!= 0
7496 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7498 Elf_Internal_Shdr
* symsec
;
7499 Elf_Internal_Sym
* symtab
;
7500 unsigned long nsyms
;
7501 unsigned long strtablen
= 0;
7502 char * strtab
= NULL
;
7504 symsec
= filedata
->section_headers
+ section
->sh_link
;
7505 if (symsec
->sh_type
!= SHT_SYMTAB
7506 && symsec
->sh_type
!= SHT_DYNSYM
)
7509 if (!get_symtab (filedata
, symsec
,
7510 &symtab
, &nsyms
, &strtab
, &strtablen
))
7513 dump_relocations (filedata
, rel_offset
, rel_size
,
7514 symtab
, nsyms
, strtab
, strtablen
,
7516 symsec
->sh_type
== SHT_DYNSYM
);
7522 dump_relocations (filedata
, rel_offset
, rel_size
,
7523 NULL
, 0, NULL
, 0, is_rela
,
7524 FALSE
/* is_dynamic */);
7532 /* Users sometimes forget the -D option, so try to be helpful. */
7533 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7535 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7537 printf (_("\nThere are no static relocations in this file."));
7538 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7543 if (i
== ARRAY_SIZE (dynamic_relocations
))
7544 printf (_("\nThere are no relocations in this file.\n"));
7551 /* An absolute address consists of a section and an offset. If the
7552 section is NULL, the offset itself is the address, otherwise, the
7553 address equals to LOAD_ADDRESS(section) + offset. */
7557 unsigned short section
;
7561 /* Find the nearest symbol at or below ADDR. Returns the symbol
7562 name, if found, and the offset from the symbol to ADDR. */
7565 find_symbol_for_address (Filedata
* filedata
,
7566 Elf_Internal_Sym
* symtab
,
7567 unsigned long nsyms
,
7568 const char * strtab
,
7569 unsigned long strtab_size
,
7570 struct absaddr addr
,
7571 const char ** symname
,
7574 bfd_vma dist
= 0x100000;
7575 Elf_Internal_Sym
* sym
;
7576 Elf_Internal_Sym
* beg
;
7577 Elf_Internal_Sym
* end
;
7578 Elf_Internal_Sym
* best
= NULL
;
7580 REMOVE_ARCH_BITS (addr
.offset
);
7582 end
= symtab
+ nsyms
;
7588 sym
= beg
+ (end
- beg
) / 2;
7590 value
= sym
->st_value
;
7591 REMOVE_ARCH_BITS (value
);
7593 if (sym
->st_name
!= 0
7594 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7595 && addr
.offset
>= value
7596 && addr
.offset
- value
< dist
)
7599 dist
= addr
.offset
- value
;
7604 if (addr
.offset
< value
)
7612 *symname
= (best
->st_name
>= strtab_size
7613 ? _("<corrupt>") : strtab
+ best
->st_name
);
7619 *offset
= addr
.offset
;
7622 static /* signed */ int
7623 symcmp (const void *p
, const void *q
)
7625 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7626 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7628 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7631 /* Process the unwind section. */
7633 #include "unwind-ia64.h"
7635 struct ia64_unw_table_entry
7637 struct absaddr start
;
7639 struct absaddr info
;
7642 struct ia64_unw_aux_info
7644 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7645 unsigned long table_len
; /* Length of unwind table. */
7646 unsigned char * info
; /* Unwind info. */
7647 unsigned long info_size
; /* Size of unwind info. */
7648 bfd_vma info_addr
; /* Starting address of unwind info. */
7649 bfd_vma seg_base
; /* Starting address of segment. */
7650 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7651 unsigned long nsyms
; /* Number of symbols. */
7652 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7653 unsigned long nfuns
; /* Number of entries in funtab. */
7654 char * strtab
; /* The string table. */
7655 unsigned long strtab_size
; /* Size of string table. */
7659 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7661 struct ia64_unw_table_entry
* tp
;
7662 unsigned long j
, nfuns
;
7664 bfd_boolean res
= TRUE
;
7666 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7667 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7668 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7669 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7671 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7673 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7677 const unsigned char * dp
;
7678 const unsigned char * head
;
7679 const unsigned char * end
;
7680 const char * procname
;
7682 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7683 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7685 fputs ("\n<", stdout
);
7689 fputs (procname
, stdout
);
7692 printf ("+%lx", (unsigned long) offset
);
7695 fputs (">: [", stdout
);
7696 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7697 fputc ('-', stdout
);
7698 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7699 printf ("], info at +0x%lx\n",
7700 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7702 /* PR 17531: file: 86232b32. */
7703 if (aux
->info
== NULL
)
7706 offset
= tp
->info
.offset
;
7707 if (tp
->info
.section
)
7709 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7711 warn (_("Invalid section %u in table entry %ld\n"),
7712 tp
->info
.section
, (long) (tp
- aux
->table
));
7716 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7718 offset
-= aux
->info_addr
;
7719 /* PR 17531: file: 0997b4d1. */
7720 if (offset
>= aux
->info_size
7721 || aux
->info_size
- offset
< 8)
7723 warn (_("Invalid offset %lx in table entry %ld\n"),
7724 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7729 head
= aux
->info
+ offset
;
7730 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7732 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7733 (unsigned) UNW_VER (stamp
),
7734 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7735 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7736 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7737 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7739 if (UNW_VER (stamp
) != 1)
7741 printf (_("\tUnknown version.\n"));
7746 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7747 /* PR 17531: file: 16ceda89. */
7748 if (end
> aux
->info
+ aux
->info_size
)
7749 end
= aux
->info
+ aux
->info_size
;
7750 for (dp
= head
+ 8; dp
< end
;)
7751 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7760 slurp_ia64_unwind_table (Filedata
* filedata
,
7761 struct ia64_unw_aux_info
* aux
,
7762 Elf_Internal_Shdr
* sec
)
7764 unsigned long size
, nrelas
, i
;
7765 Elf_Internal_Phdr
* seg
;
7766 struct ia64_unw_table_entry
* tep
;
7767 Elf_Internal_Shdr
* relsec
;
7768 Elf_Internal_Rela
* rela
;
7769 Elf_Internal_Rela
* rp
;
7770 unsigned char * table
;
7772 Elf_Internal_Sym
* sym
;
7773 const char * relname
;
7777 /* First, find the starting address of the segment that includes
7780 if (filedata
->file_header
.e_phnum
)
7782 if (! get_program_headers (filedata
))
7785 for (seg
= filedata
->program_headers
;
7786 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7789 if (seg
->p_type
!= PT_LOAD
)
7792 if (sec
->sh_addr
>= seg
->p_vaddr
7793 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7795 aux
->seg_base
= seg
->p_vaddr
;
7801 /* Second, build the unwind table from the contents of the unwind section: */
7802 size
= sec
->sh_size
;
7803 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7808 aux
->table_len
= size
/ (3 * eh_addr_size
);
7809 aux
->table
= (struct ia64_unw_table_entry
*)
7810 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7813 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7815 tep
->start
.section
= SHN_UNDEF
;
7816 tep
->end
.section
= SHN_UNDEF
;
7817 tep
->info
.section
= SHN_UNDEF
;
7818 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7819 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7820 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7821 tep
->start
.offset
+= aux
->seg_base
;
7822 tep
->end
.offset
+= aux
->seg_base
;
7823 tep
->info
.offset
+= aux
->seg_base
;
7827 /* Third, apply any relocations to the unwind table: */
7828 for (relsec
= filedata
->section_headers
;
7829 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7832 if (relsec
->sh_type
!= SHT_RELA
7833 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7834 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7837 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7846 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7848 unsigned int sym_ndx
;
7849 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7850 relname
= elf_ia64_reloc_type (r_type
);
7852 /* PR 17531: file: 9fa67536. */
7853 if (relname
== NULL
)
7855 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7859 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7861 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7865 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7867 /* PR 17531: file: 5bc8d9bf. */
7868 if (i
>= aux
->table_len
)
7870 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7874 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7875 if (sym_ndx
>= aux
->nsyms
)
7877 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7881 sym
= aux
->symtab
+ sym_ndx
;
7883 switch (rp
->r_offset
/ eh_addr_size
% 3)
7886 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7887 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7890 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7891 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7894 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7895 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7909 ia64_process_unwind (Filedata
* filedata
)
7911 Elf_Internal_Shdr
* sec
;
7912 Elf_Internal_Shdr
* unwsec
= NULL
;
7913 unsigned long i
, unwcount
= 0, unwstart
= 0;
7914 struct ia64_unw_aux_info aux
;
7915 bfd_boolean res
= TRUE
;
7917 memset (& aux
, 0, sizeof (aux
));
7919 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7921 if (sec
->sh_type
== SHT_SYMTAB
)
7925 error (_("Multiple symbol tables encountered\n"));
7931 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7932 &aux
.strtab
, &aux
.strtab_size
))
7935 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7940 printf (_("\nThere are no unwind sections in this file.\n"));
7942 while (unwcount
-- > 0)
7947 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7948 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7949 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7954 /* We have already counted the number of SHT_IA64_UNWIND
7955 sections so the loop above should never fail. */
7956 assert (unwsec
!= NULL
);
7959 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7961 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7963 /* We need to find which section group it is in. */
7964 struct group_list
* g
;
7966 if (filedata
->section_headers_groups
== NULL
7967 || filedata
->section_headers_groups
[i
] == NULL
)
7968 i
= filedata
->file_header
.e_shnum
;
7971 g
= filedata
->section_headers_groups
[i
]->root
;
7973 for (; g
!= NULL
; g
= g
->next
)
7975 sec
= filedata
->section_headers
+ g
->section_index
;
7977 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7982 i
= filedata
->file_header
.e_shnum
;
7985 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7987 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7988 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7989 suffix
= SECTION_NAME (unwsec
) + len
;
7990 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7992 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7993 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7998 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7999 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8000 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8001 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8003 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
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
, len2
)
8008 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8012 if (i
== filedata
->file_header
.e_shnum
)
8014 printf (_("\nCould not find unwind info section for "));
8016 if (filedata
->string_table
== NULL
)
8017 printf ("%d", unwsec
->sh_name
);
8019 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8023 aux
.info_addr
= sec
->sh_addr
;
8024 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8027 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8029 printf (_("\nUnwind section "));
8031 if (filedata
->string_table
== NULL
)
8032 printf ("%d", unwsec
->sh_name
);
8034 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8036 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8037 (unsigned long) unwsec
->sh_offset
,
8038 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8040 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8041 && aux
.table_len
> 0)
8042 dump_ia64_unwind (filedata
, & aux
);
8045 free ((char *) aux
.table
);
8047 free ((char *) aux
.info
);
8056 free ((char *) aux
.strtab
);
8061 struct hppa_unw_table_entry
8063 struct absaddr start
;
8065 unsigned int Cannot_unwind
:1; /* 0 */
8066 unsigned int Millicode
:1; /* 1 */
8067 unsigned int Millicode_save_sr0
:1; /* 2 */
8068 unsigned int Region_description
:2; /* 3..4 */
8069 unsigned int reserved1
:1; /* 5 */
8070 unsigned int Entry_SR
:1; /* 6 */
8071 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8072 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8073 unsigned int Args_stored
:1; /* 16 */
8074 unsigned int Variable_Frame
:1; /* 17 */
8075 unsigned int Separate_Package_Body
:1; /* 18 */
8076 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8077 unsigned int Stack_Overflow_Check
:1; /* 20 */
8078 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8079 unsigned int Ada_Region
:1; /* 22 */
8080 unsigned int cxx_info
:1; /* 23 */
8081 unsigned int cxx_try_catch
:1; /* 24 */
8082 unsigned int sched_entry_seq
:1; /* 25 */
8083 unsigned int reserved2
:1; /* 26 */
8084 unsigned int Save_SP
:1; /* 27 */
8085 unsigned int Save_RP
:1; /* 28 */
8086 unsigned int Save_MRP_in_frame
:1; /* 29 */
8087 unsigned int extn_ptr_defined
:1; /* 30 */
8088 unsigned int Cleanup_defined
:1; /* 31 */
8090 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8091 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8092 unsigned int Large_frame
:1; /* 2 */
8093 unsigned int Pseudo_SP_Set
:1; /* 3 */
8094 unsigned int reserved4
:1; /* 4 */
8095 unsigned int Total_frame_size
:27; /* 5..31 */
8098 struct hppa_unw_aux_info
8100 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8101 unsigned long table_len
; /* Length of unwind table. */
8102 bfd_vma seg_base
; /* Starting address of segment. */
8103 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8104 unsigned long nsyms
; /* Number of symbols. */
8105 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8106 unsigned long nfuns
; /* Number of entries in funtab. */
8107 char * strtab
; /* The string table. */
8108 unsigned long strtab_size
; /* Size of string table. */
8112 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8114 struct hppa_unw_table_entry
* tp
;
8115 unsigned long j
, nfuns
;
8116 bfd_boolean res
= TRUE
;
8118 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8119 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8120 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8121 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8123 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8125 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8128 const char * procname
;
8130 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8131 aux
->strtab_size
, tp
->start
, &procname
,
8134 fputs ("\n<", stdout
);
8138 fputs (procname
, stdout
);
8141 printf ("+%lx", (unsigned long) offset
);
8144 fputs (">: [", stdout
);
8145 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8146 fputc ('-', stdout
);
8147 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8150 #define PF(_m) if (tp->_m) printf (#_m " ");
8151 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8154 PF(Millicode_save_sr0
);
8155 /* PV(Region_description); */
8161 PF(Separate_Package_Body
);
8162 PF(Frame_Extension_Millicode
);
8163 PF(Stack_Overflow_Check
);
8164 PF(Two_Instruction_SP_Increment
);
8168 PF(sched_entry_seq
);
8171 PF(Save_MRP_in_frame
);
8172 PF(extn_ptr_defined
);
8173 PF(Cleanup_defined
);
8174 PF(MPE_XL_interrupt_marker
);
8175 PF(HP_UX_interrupt_marker
);
8178 PV(Total_frame_size
);
8191 slurp_hppa_unwind_table (Filedata
* filedata
,
8192 struct hppa_unw_aux_info
* aux
,
8193 Elf_Internal_Shdr
* sec
)
8195 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8196 Elf_Internal_Phdr
* seg
;
8197 struct hppa_unw_table_entry
* tep
;
8198 Elf_Internal_Shdr
* relsec
;
8199 Elf_Internal_Rela
* rela
;
8200 Elf_Internal_Rela
* rp
;
8201 unsigned char * table
;
8203 Elf_Internal_Sym
* sym
;
8204 const char * relname
;
8206 /* First, find the starting address of the segment that includes
8208 if (filedata
->file_header
.e_phnum
)
8210 if (! get_program_headers (filedata
))
8213 for (seg
= filedata
->program_headers
;
8214 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8217 if (seg
->p_type
!= PT_LOAD
)
8220 if (sec
->sh_addr
>= seg
->p_vaddr
8221 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8223 aux
->seg_base
= seg
->p_vaddr
;
8229 /* Second, build the unwind table from the contents of the unwind
8231 size
= sec
->sh_size
;
8232 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8238 nentries
= size
/ unw_ent_size
;
8239 size
= unw_ent_size
* nentries
;
8241 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8242 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8244 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8246 unsigned int tmp1
, tmp2
;
8248 tep
->start
.section
= SHN_UNDEF
;
8249 tep
->end
.section
= SHN_UNDEF
;
8251 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8252 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8253 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8254 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8256 tep
->start
.offset
+= aux
->seg_base
;
8257 tep
->end
.offset
+= aux
->seg_base
;
8259 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8260 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8261 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8262 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8263 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8264 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8265 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8266 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8267 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8268 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8269 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8270 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8271 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8272 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8273 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8274 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8275 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8276 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8277 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8278 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8279 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8280 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8281 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8282 tep
->Cleanup_defined
= tmp1
& 0x1;
8284 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8285 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8286 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8287 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8288 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8289 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8293 /* Third, apply any relocations to the unwind table. */
8294 for (relsec
= filedata
->section_headers
;
8295 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8298 if (relsec
->sh_type
!= SHT_RELA
8299 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8300 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8303 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8307 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8309 unsigned int sym_ndx
;
8310 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8311 relname
= elf_hppa_reloc_type (r_type
);
8313 if (relname
== NULL
)
8315 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8319 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8320 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8322 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8326 i
= rp
->r_offset
/ unw_ent_size
;
8327 if (i
>= aux
->table_len
)
8329 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8333 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8334 if (sym_ndx
>= aux
->nsyms
)
8336 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8340 sym
= aux
->symtab
+ sym_ndx
;
8342 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8345 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8346 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8349 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8350 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8360 aux
->table_len
= nentries
;
8366 hppa_process_unwind (Filedata
* filedata
)
8368 struct hppa_unw_aux_info aux
;
8369 Elf_Internal_Shdr
* unwsec
= NULL
;
8370 Elf_Internal_Shdr
* sec
;
8372 bfd_boolean res
= TRUE
;
8374 if (filedata
->string_table
== NULL
)
8377 memset (& aux
, 0, sizeof (aux
));
8379 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8381 if (sec
->sh_type
== SHT_SYMTAB
)
8385 error (_("Multiple symbol tables encountered\n"));
8391 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8392 &aux
.strtab
, &aux
.strtab_size
))
8395 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8400 printf (_("\nThere are no unwind sections in this file.\n"));
8402 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8404 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8406 unsigned long num_unwind
= sec
->sh_size
/ 16;
8408 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8409 "contains %lu entry:\n",
8410 "\nUnwind section '%s' at offset 0x%lx "
8411 "contains %lu entries:\n",
8413 printable_section_name (filedata
, sec
),
8414 (unsigned long) sec
->sh_offset
,
8417 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8420 if (res
&& aux
.table_len
> 0)
8422 if (! dump_hppa_unwind (filedata
, &aux
))
8427 free ((char *) aux
.table
);
8435 free ((char *) aux
.strtab
);
8442 unsigned char * data
; /* The unwind data. */
8443 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8444 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8445 unsigned long nrelas
; /* The number of relocations. */
8446 unsigned int rel_type
; /* REL or RELA ? */
8447 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8450 struct arm_unw_aux_info
8452 Filedata
* filedata
; /* The file containing the unwind sections. */
8453 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8454 unsigned long nsyms
; /* Number of symbols. */
8455 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8456 unsigned long nfuns
; /* Number of these symbols. */
8457 char * strtab
; /* The file's string table. */
8458 unsigned long strtab_size
; /* Size of string table. */
8462 arm_print_vma_and_name (Filedata
* filedata
,
8463 struct arm_unw_aux_info
* aux
,
8465 struct absaddr addr
)
8467 const char *procname
;
8470 if (addr
.section
== SHN_UNDEF
)
8473 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8474 aux
->strtab_size
, addr
, &procname
,
8477 print_vma (fn
, PREFIX_HEX
);
8481 fputs (" <", stdout
);
8482 fputs (procname
, stdout
);
8485 printf ("+0x%lx", (unsigned long) sym_offset
);
8486 fputc ('>', stdout
);
8493 arm_free_section (struct arm_section
*arm_sec
)
8495 if (arm_sec
->data
!= NULL
)
8496 free (arm_sec
->data
);
8498 if (arm_sec
->rela
!= NULL
)
8499 free (arm_sec
->rela
);
8502 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8503 cached section and install SEC instead.
8504 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8505 and return its valued in * WORDP, relocating if necessary.
8506 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8507 relocation's offset in ADDR.
8508 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8509 into the string table of the symbol associated with the reloc. If no
8510 reloc was applied store -1 there.
8511 5) Return TRUE upon success, FALSE otherwise. */
8514 get_unwind_section_word (Filedata
* filedata
,
8515 struct arm_unw_aux_info
* aux
,
8516 struct arm_section
* arm_sec
,
8517 Elf_Internal_Shdr
* sec
,
8518 bfd_vma word_offset
,
8519 unsigned int * wordp
,
8520 struct absaddr
* addr
,
8523 Elf_Internal_Rela
*rp
;
8524 Elf_Internal_Sym
*sym
;
8525 const char * relname
;
8527 bfd_boolean wrapped
;
8529 if (sec
== NULL
|| arm_sec
== NULL
)
8532 addr
->section
= SHN_UNDEF
;
8535 if (sym_name
!= NULL
)
8536 *sym_name
= (bfd_vma
) -1;
8538 /* If necessary, update the section cache. */
8539 if (sec
!= arm_sec
->sec
)
8541 Elf_Internal_Shdr
*relsec
;
8543 arm_free_section (arm_sec
);
8546 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8547 sec
->sh_size
, _("unwind data"));
8548 arm_sec
->rela
= NULL
;
8549 arm_sec
->nrelas
= 0;
8551 for (relsec
= filedata
->section_headers
;
8552 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8555 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8556 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8557 /* PR 15745: Check the section type as well. */
8558 || (relsec
->sh_type
!= SHT_REL
8559 && relsec
->sh_type
!= SHT_RELA
))
8562 arm_sec
->rel_type
= relsec
->sh_type
;
8563 if (relsec
->sh_type
== SHT_REL
)
8565 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8567 & arm_sec
->rela
, & arm_sec
->nrelas
))
8570 else /* relsec->sh_type == SHT_RELA */
8572 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8574 & arm_sec
->rela
, & arm_sec
->nrelas
))
8580 arm_sec
->next_rela
= arm_sec
->rela
;
8583 /* If there is no unwind data we can do nothing. */
8584 if (arm_sec
->data
== NULL
)
8587 /* If the offset is invalid then fail. */
8588 if (/* PR 21343 *//* PR 18879 */
8590 || word_offset
> (sec
->sh_size
- 4)
8591 || ((bfd_signed_vma
) word_offset
) < 0)
8594 /* Get the word at the required offset. */
8595 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8597 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8598 if (arm_sec
->rela
== NULL
)
8604 /* Look through the relocs to find the one that applies to the provided offset. */
8606 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8608 bfd_vma prelval
, offset
;
8610 if (rp
->r_offset
> word_offset
&& !wrapped
)
8615 if (rp
->r_offset
> word_offset
)
8618 if (rp
->r_offset
& 3)
8620 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8621 (unsigned long) rp
->r_offset
);
8625 if (rp
->r_offset
< word_offset
)
8628 /* PR 17531: file: 027-161405-0.004 */
8629 if (aux
->symtab
== NULL
)
8632 if (arm_sec
->rel_type
== SHT_REL
)
8634 offset
= word
& 0x7fffffff;
8635 if (offset
& 0x40000000)
8636 offset
|= ~ (bfd_vma
) 0x7fffffff;
8638 else if (arm_sec
->rel_type
== SHT_RELA
)
8639 offset
= rp
->r_addend
;
8642 error (_("Unknown section relocation type %d encountered\n"),
8647 /* PR 17531 file: 027-1241568-0.004. */
8648 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8650 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8651 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8655 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8656 offset
+= sym
->st_value
;
8657 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8659 /* Check that we are processing the expected reloc type. */
8660 if (filedata
->file_header
.e_machine
== EM_ARM
)
8662 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8663 if (relname
== NULL
)
8665 warn (_("Skipping unknown ARM relocation type: %d\n"),
8666 (int) ELF32_R_TYPE (rp
->r_info
));
8670 if (streq (relname
, "R_ARM_NONE"))
8673 if (! streq (relname
, "R_ARM_PREL31"))
8675 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8679 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8681 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8682 if (relname
== NULL
)
8684 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8685 (int) ELF32_R_TYPE (rp
->r_info
));
8689 if (streq (relname
, "R_C6000_NONE"))
8692 if (! streq (relname
, "R_C6000_PREL31"))
8694 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8702 /* This function currently only supports ARM and TI unwinders. */
8703 warn (_("Only TI and ARM unwinders are currently supported\n"));
8707 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8708 addr
->section
= sym
->st_shndx
;
8709 addr
->offset
= offset
;
8712 * sym_name
= sym
->st_name
;
8717 arm_sec
->next_rela
= rp
;
8722 static const char *tic6x_unwind_regnames
[16] =
8724 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8725 "A14", "A13", "A12", "A11", "A10",
8726 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8730 decode_tic6x_unwind_regmask (unsigned int mask
)
8734 for (i
= 12; mask
; mask
>>= 1, i
--)
8738 fputs (tic6x_unwind_regnames
[i
], stdout
);
8740 fputs (", ", stdout
);
8746 if (remaining == 0 && more_words) \
8749 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8750 data_offset, & word, & addr, NULL)) \
8756 #define GET_OP(OP) \
8761 (OP) = word >> 24; \
8766 printf (_("[Truncated opcode]\n")); \
8769 printf ("0x%02x ", OP)
8772 decode_arm_unwind_bytecode (Filedata
* filedata
,
8773 struct arm_unw_aux_info
* aux
,
8775 unsigned int remaining
,
8776 unsigned int more_words
,
8777 bfd_vma data_offset
,
8778 Elf_Internal_Shdr
* data_sec
,
8779 struct arm_section
* data_arm_sec
)
8781 struct absaddr addr
;
8782 bfd_boolean res
= TRUE
;
8784 /* Decode the unwinding instructions. */
8787 unsigned int op
, op2
;
8796 printf (" 0x%02x ", op
);
8798 if ((op
& 0xc0) == 0x00)
8800 int offset
= ((op
& 0x3f) << 2) + 4;
8802 printf (" vsp = vsp + %d", offset
);
8804 else if ((op
& 0xc0) == 0x40)
8806 int offset
= ((op
& 0x3f) << 2) + 4;
8808 printf (" vsp = vsp - %d", offset
);
8810 else if ((op
& 0xf0) == 0x80)
8813 if (op
== 0x80 && op2
== 0)
8814 printf (_("Refuse to unwind"));
8817 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8818 bfd_boolean first
= TRUE
;
8822 for (i
= 0; i
< 12; i
++)
8823 if (mask
& (1 << i
))
8829 printf ("r%d", 4 + i
);
8834 else if ((op
& 0xf0) == 0x90)
8836 if (op
== 0x9d || op
== 0x9f)
8837 printf (_(" [Reserved]"));
8839 printf (" vsp = r%d", op
& 0x0f);
8841 else if ((op
& 0xf0) == 0xa0)
8843 int end
= 4 + (op
& 0x07);
8844 bfd_boolean first
= TRUE
;
8848 for (i
= 4; i
<= end
; i
++)
8864 else if (op
== 0xb0)
8865 printf (_(" finish"));
8866 else if (op
== 0xb1)
8869 if (op2
== 0 || (op2
& 0xf0) != 0)
8870 printf (_("[Spare]"));
8873 unsigned int mask
= op2
& 0x0f;
8874 bfd_boolean first
= TRUE
;
8878 for (i
= 0; i
< 12; i
++)
8879 if (mask
& (1 << i
))
8890 else if (op
== 0xb2)
8892 unsigned char buf
[9];
8893 unsigned int i
, len
;
8894 unsigned long offset
;
8896 for (i
= 0; i
< sizeof (buf
); i
++)
8899 if ((buf
[i
] & 0x80) == 0)
8902 if (i
== sizeof (buf
))
8904 error (_("corrupt change to vsp\n"));
8909 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8910 assert (len
== i
+ 1);
8911 offset
= offset
* 4 + 0x204;
8912 printf ("vsp = vsp + %ld", offset
);
8915 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8917 unsigned int first
, last
;
8924 printf ("pop {D%d", first
);
8926 printf ("-D%d", first
+ last
);
8929 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8931 unsigned int count
= op
& 0x07;
8935 printf ("-D%d", 8 + count
);
8938 else if (op
>= 0xc0 && op
<= 0xc5)
8940 unsigned int count
= op
& 0x07;
8942 printf (" pop {wR10");
8944 printf ("-wR%d", 10 + count
);
8947 else if (op
== 0xc6)
8949 unsigned int first
, last
;
8954 printf ("pop {wR%d", first
);
8956 printf ("-wR%d", first
+ last
);
8959 else if (op
== 0xc7)
8962 if (op2
== 0 || (op2
& 0xf0) != 0)
8963 printf (_("[Spare]"));
8966 unsigned int mask
= op2
& 0x0f;
8967 bfd_boolean first
= TRUE
;
8971 for (i
= 0; i
< 4; i
++)
8972 if (mask
& (1 << i
))
8978 printf ("wCGR%d", i
);
8985 printf (_(" [unsupported opcode]"));
8996 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8997 struct arm_unw_aux_info
* aux
,
8999 unsigned int remaining
,
9000 unsigned int more_words
,
9001 bfd_vma data_offset
,
9002 Elf_Internal_Shdr
* data_sec
,
9003 struct arm_section
* data_arm_sec
)
9005 struct absaddr addr
;
9007 /* Decode the unwinding instructions. */
9010 unsigned int op
, op2
;
9019 printf (" 0x%02x ", op
);
9021 if ((op
& 0xc0) == 0x00)
9023 int offset
= ((op
& 0x3f) << 3) + 8;
9024 printf (" sp = sp + %d", offset
);
9026 else if ((op
& 0xc0) == 0x80)
9029 if (op
== 0x80 && op2
== 0)
9030 printf (_("Refuse to unwind"));
9033 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9035 printf ("pop compact {");
9039 decode_tic6x_unwind_regmask (mask
);
9043 else if ((op
& 0xf0) == 0xc0)
9051 unsigned int offset
;
9055 /* Scan entire instruction first so that GET_OP output is not
9056 interleaved with disassembly. */
9058 for (i
= 0; nregs
< (op
& 0xf); i
++)
9064 regpos
[nregs
].offset
= i
* 2;
9065 regpos
[nregs
].reg
= reg
;
9072 regpos
[nregs
].offset
= i
* 2 + 1;
9073 regpos
[nregs
].reg
= reg
;
9078 printf (_("pop frame {"));
9081 printf (_("*corrupt* - no registers specified"));
9086 for (i
= i
* 2; i
> 0; i
--)
9088 if (regpos
[reg
].offset
== i
- 1)
9090 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9097 fputs (name
, stdout
);
9105 else if (op
== 0xd0)
9106 printf (" MOV FP, SP");
9107 else if (op
== 0xd1)
9108 printf (" __c6xabi_pop_rts");
9109 else if (op
== 0xd2)
9111 unsigned char buf
[9];
9112 unsigned int i
, len
;
9113 unsigned long offset
;
9115 for (i
= 0; i
< sizeof (buf
); i
++)
9118 if ((buf
[i
] & 0x80) == 0)
9121 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9122 if (i
== sizeof (buf
))
9124 warn (_("Corrupt stack pointer adjustment detected\n"));
9128 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9129 assert (len
== i
+ 1);
9130 offset
= offset
* 8 + 0x408;
9131 printf (_("sp = sp + %ld"), offset
);
9133 else if ((op
& 0xf0) == 0xe0)
9135 if ((op
& 0x0f) == 7)
9138 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9142 printf (_(" [unsupported opcode]"));
9151 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9155 offset
= word
& 0x7fffffff;
9156 if (offset
& 0x40000000)
9157 offset
|= ~ (bfd_vma
) 0x7fffffff;
9159 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9162 return offset
+ where
;
9166 decode_arm_unwind (Filedata
* filedata
,
9167 struct arm_unw_aux_info
* aux
,
9169 unsigned int remaining
,
9170 bfd_vma data_offset
,
9171 Elf_Internal_Shdr
* data_sec
,
9172 struct arm_section
* data_arm_sec
)
9175 unsigned int more_words
= 0;
9176 struct absaddr addr
;
9177 bfd_vma sym_name
= (bfd_vma
) -1;
9178 bfd_boolean res
= TRUE
;
9182 /* Fetch the first word.
9183 Note - when decoding an object file the address extracted
9184 here will always be 0. So we also pass in the sym_name
9185 parameter so that we can find the symbol associated with
9186 the personality routine. */
9187 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9188 & word
, & addr
, & sym_name
))
9195 addr
.section
= SHN_UNDEF
;
9199 if ((word
& 0x80000000) == 0)
9201 /* Expand prel31 for personality routine. */
9203 const char *procname
;
9205 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9206 printf (_(" Personality routine: "));
9208 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9209 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9211 procname
= aux
->strtab
+ sym_name
;
9212 print_vma (fn
, PREFIX_HEX
);
9215 fputs (" <", stdout
);
9216 fputs (procname
, stdout
);
9217 fputc ('>', stdout
);
9221 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9222 fputc ('\n', stdout
);
9224 /* The GCC personality routines use the standard compact
9225 encoding, starting with one byte giving the number of
9227 if (procname
!= NULL
9228 && (const_strneq (procname
, "__gcc_personality_v0")
9229 || const_strneq (procname
, "__gxx_personality_v0")
9230 || const_strneq (procname
, "__gcj_personality_v0")
9231 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9238 printf (_(" [Truncated data]\n"));
9241 more_words
= word
>> 24;
9251 /* ARM EHABI Section 6.3:
9253 An exception-handling table entry for the compact model looks like:
9257 1 0 index Data for personalityRoutine[index] */
9259 if (filedata
->file_header
.e_machine
== EM_ARM
9260 && (word
& 0x70000000))
9262 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9266 per_index
= (word
>> 24) & 0x7f;
9267 printf (_(" Compact model index: %d\n"), per_index
);
9274 else if (per_index
< 3)
9276 more_words
= (word
>> 16) & 0xff;
9282 switch (filedata
->file_header
.e_machine
)
9287 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9288 data_offset
, data_sec
, data_arm_sec
))
9293 warn (_("Unknown ARM compact model index encountered\n"));
9294 printf (_(" [reserved]\n"));
9302 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9303 data_offset
, data_sec
, data_arm_sec
))
9306 else if (per_index
< 5)
9308 if (((word
>> 17) & 0x7f) == 0x7f)
9309 printf (_(" Restore stack from frame pointer\n"));
9311 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9312 printf (_(" Registers restored: "));
9314 printf (" (compact) ");
9315 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9317 printf (_(" Return register: %s\n"),
9318 tic6x_unwind_regnames
[word
& 0xf]);
9321 printf (_(" [reserved (%d)]\n"), per_index
);
9325 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9326 filedata
->file_header
.e_machine
);
9330 /* Decode the descriptors. Not implemented. */
9336 dump_arm_unwind (Filedata
* filedata
,
9337 struct arm_unw_aux_info
* aux
,
9338 Elf_Internal_Shdr
* exidx_sec
)
9340 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9341 unsigned int i
, exidx_len
;
9342 unsigned long j
, nfuns
;
9343 bfd_boolean res
= TRUE
;
9345 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9346 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9347 exidx_len
= exidx_sec
->sh_size
/ 8;
9349 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9350 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9351 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9352 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9354 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9356 for (i
= 0; i
< exidx_len
; i
++)
9358 unsigned int exidx_fn
, exidx_entry
;
9359 struct absaddr fn_addr
, entry_addr
;
9362 fputc ('\n', stdout
);
9364 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9365 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9366 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9367 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9370 arm_free_section (& exidx_arm_sec
);
9371 arm_free_section (& extab_arm_sec
);
9375 /* ARM EHABI, Section 5:
9376 An index table entry consists of 2 words.
9377 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9378 if (exidx_fn
& 0x80000000)
9380 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9384 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9386 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9387 fputs (": ", stdout
);
9389 if (exidx_entry
== 1)
9391 print_vma (exidx_entry
, PREFIX_HEX
);
9392 fputs (" [cantunwind]\n", stdout
);
9394 else if (exidx_entry
& 0x80000000)
9396 print_vma (exidx_entry
, PREFIX_HEX
);
9397 fputc ('\n', stdout
);
9398 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9402 bfd_vma table
, table_offset
= 0;
9403 Elf_Internal_Shdr
*table_sec
;
9405 fputs ("@", stdout
);
9406 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9407 print_vma (table
, PREFIX_HEX
);
9410 /* Locate the matching .ARM.extab. */
9411 if (entry_addr
.section
!= SHN_UNDEF
9412 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9414 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9415 table_offset
= entry_addr
.offset
;
9417 if (table_offset
> table_sec
->sh_size
9418 || ((bfd_signed_vma
) table_offset
) < 0)
9420 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9421 (unsigned long) table_offset
,
9422 printable_section_name (filedata
, table_sec
));
9429 table_sec
= find_section_by_address (filedata
, table
);
9430 if (table_sec
!= NULL
)
9431 table_offset
= table
- table_sec
->sh_addr
;
9434 if (table_sec
== NULL
)
9436 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9437 (unsigned long) table
);
9442 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9451 arm_free_section (&exidx_arm_sec
);
9452 arm_free_section (&extab_arm_sec
);
9457 /* Used for both ARM and C6X unwinding tables. */
9460 arm_process_unwind (Filedata
* filedata
)
9462 struct arm_unw_aux_info aux
;
9463 Elf_Internal_Shdr
*unwsec
= NULL
;
9464 Elf_Internal_Shdr
*sec
;
9466 unsigned int sec_type
;
9467 bfd_boolean res
= TRUE
;
9469 switch (filedata
->file_header
.e_machine
)
9472 sec_type
= SHT_ARM_EXIDX
;
9476 sec_type
= SHT_C6000_UNWIND
;
9480 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9481 filedata
->file_header
.e_machine
);
9485 if (filedata
->string_table
== NULL
)
9488 memset (& aux
, 0, sizeof (aux
));
9489 aux
.filedata
= filedata
;
9491 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9493 if (sec
->sh_type
== SHT_SYMTAB
)
9497 error (_("Multiple symbol tables encountered\n"));
9503 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9504 &aux
.strtab
, &aux
.strtab_size
))
9507 else if (sec
->sh_type
== sec_type
)
9512 printf (_("\nThere are no unwind sections in this file.\n"));
9514 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9516 if (sec
->sh_type
== sec_type
)
9518 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9519 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9520 "contains %lu entry:\n",
9521 "\nUnwind section '%s' at offset 0x%lx "
9522 "contains %lu entries:\n",
9524 printable_section_name (filedata
, sec
),
9525 (unsigned long) sec
->sh_offset
,
9528 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9536 free ((char *) aux
.strtab
);
9542 process_unwind (Filedata
* filedata
)
9544 struct unwind_handler
9546 unsigned int machtype
;
9547 bfd_boolean (* handler
)(Filedata
*);
9550 { EM_ARM
, arm_process_unwind
},
9551 { EM_IA_64
, ia64_process_unwind
},
9552 { EM_PARISC
, hppa_process_unwind
},
9553 { EM_TI_C6000
, arm_process_unwind
},
9561 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9562 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9563 return handlers
[i
].handler (filedata
);
9565 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9566 get_machine_name (filedata
->file_header
.e_machine
));
9571 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9573 switch (entry
->d_tag
)
9575 case DT_AARCH64_BTI_PLT
:
9576 case DT_AARCH64_PAC_PLT
:
9579 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9586 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9588 switch (entry
->d_tag
)
9591 if (entry
->d_un
.d_val
== 0)
9595 static const char * opts
[] =
9597 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9598 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9599 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9600 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9604 bfd_boolean first
= TRUE
;
9606 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9607 if (entry
->d_un
.d_val
& (1 << cnt
))
9609 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9615 case DT_MIPS_IVERSION
:
9616 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9617 printf (_("Interface Version: %s"),
9618 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9622 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9623 /* Note: coded this way so that there is a single string for translation. */
9624 printf (_("<corrupt: %s>"), buf
);
9628 case DT_MIPS_TIME_STAMP
:
9632 time_t atime
= entry
->d_un
.d_val
;
9634 tmp
= gmtime (&atime
);
9635 /* PR 17531: file: 6accc532. */
9637 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9639 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9640 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9641 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9642 printf (_("Time Stamp: %s"), timebuf
);
9646 case DT_MIPS_RLD_VERSION
:
9647 case DT_MIPS_LOCAL_GOTNO
:
9648 case DT_MIPS_CONFLICTNO
:
9649 case DT_MIPS_LIBLISTNO
:
9650 case DT_MIPS_SYMTABNO
:
9651 case DT_MIPS_UNREFEXTNO
:
9652 case DT_MIPS_HIPAGENO
:
9653 case DT_MIPS_DELTA_CLASS_NO
:
9654 case DT_MIPS_DELTA_INSTANCE_NO
:
9655 case DT_MIPS_DELTA_RELOC_NO
:
9656 case DT_MIPS_DELTA_SYM_NO
:
9657 case DT_MIPS_DELTA_CLASSSYM_NO
:
9658 case DT_MIPS_COMPACT_SIZE
:
9659 print_vma (entry
->d_un
.d_val
, DEC
);
9663 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9664 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9665 /* Falls through. */
9668 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9674 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9676 switch (entry
->d_tag
)
9678 case DT_HP_DLD_FLAGS
:
9687 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9688 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9689 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9690 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9691 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9692 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9693 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9694 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9695 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9696 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9697 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9698 { DT_HP_GST
, "HP_GST" },
9699 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9700 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9701 { DT_HP_NODELETE
, "HP_NODELETE" },
9702 { DT_HP_GROUP
, "HP_GROUP" },
9703 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9705 bfd_boolean first
= TRUE
;
9707 bfd_vma val
= entry
->d_un
.d_val
;
9709 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9710 if (val
& flags
[cnt
].bit
)
9714 fputs (flags
[cnt
].str
, stdout
);
9716 val
^= flags
[cnt
].bit
;
9719 if (val
!= 0 || first
)
9723 print_vma (val
, HEX
);
9729 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9737 /* VMS vs Unix time offset and factor. */
9739 #define VMS_EPOCH_OFFSET 35067168000000000LL
9740 #define VMS_GRANULARITY_FACTOR 10000000
9742 /* Display a VMS time in a human readable format. */
9745 print_vms_time (bfd_int64_t vmstime
)
9750 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9751 tm
= gmtime (&unxtime
);
9752 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9753 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9754 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9759 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9761 switch (entry
->d_tag
)
9763 case DT_IA_64_PLT_RESERVE
:
9764 /* First 3 slots reserved. */
9765 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9767 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9770 case DT_IA_64_VMS_LINKTIME
:
9772 print_vms_time (entry
->d_un
.d_val
);
9776 case DT_IA_64_VMS_LNKFLAGS
:
9777 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9778 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9779 printf (" CALL_DEBUG");
9780 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9781 printf (" NOP0BUFS");
9782 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9783 printf (" P0IMAGE");
9784 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9785 printf (" MKTHREADS");
9786 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9787 printf (" UPCALLS");
9788 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9790 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9791 printf (" INITIALIZE");
9792 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9794 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9795 printf (" EXE_INIT");
9796 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9797 printf (" TBK_IN_IMG");
9798 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9799 printf (" DBG_IN_IMG");
9800 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9801 printf (" TBK_IN_DSF");
9802 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9803 printf (" DBG_IN_DSF");
9804 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9805 printf (" SIGNATURES");
9806 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9807 printf (" REL_SEG_OFF");
9811 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9818 get_32bit_dynamic_section (Filedata
* filedata
)
9820 Elf32_External_Dyn
* edyn
;
9821 Elf32_External_Dyn
* ext
;
9822 Elf_Internal_Dyn
* entry
;
9824 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9825 filedata
->dynamic_addr
, 1,
9826 filedata
->dynamic_size
,
9827 _("dynamic section"));
9831 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9832 might not have the luxury of section headers. Look for the DT_NULL
9833 terminator to determine the number of entries. */
9834 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9835 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9838 filedata
->dynamic_nent
++;
9839 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9843 filedata
->dynamic_section
9844 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9845 if (filedata
->dynamic_section
== NULL
)
9847 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9848 (unsigned long) filedata
->dynamic_nent
);
9853 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9854 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9857 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9858 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9867 get_64bit_dynamic_section (Filedata
* filedata
)
9869 Elf64_External_Dyn
* edyn
;
9870 Elf64_External_Dyn
* ext
;
9871 Elf_Internal_Dyn
* entry
;
9873 /* Read in the data. */
9874 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9875 filedata
->dynamic_addr
, 1,
9876 filedata
->dynamic_size
,
9877 _("dynamic section"));
9881 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9882 might not have the luxury of section headers. Look for the DT_NULL
9883 terminator to determine the number of entries. */
9884 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9885 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9886 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9889 filedata
->dynamic_nent
++;
9890 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9894 filedata
->dynamic_section
9895 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9896 if (filedata
->dynamic_section
== NULL
)
9898 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9899 (unsigned long) filedata
->dynamic_nent
);
9904 /* Convert from external to internal formats. */
9905 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9906 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9909 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9910 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9919 print_dynamic_flags (bfd_vma flags
)
9921 bfd_boolean first
= TRUE
;
9927 flag
= flags
& - flags
;
9937 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9938 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9939 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9940 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9941 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9942 default: fputs (_("unknown"), stdout
); break;
9949 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9951 unsigned char * e_data
;
9954 /* If the size_t type is smaller than the bfd_size_type, eg because
9955 you are building a 32-bit tool on a 64-bit host, then make sure
9956 that when (number) is cast to (size_t) no information is lost. */
9957 if (sizeof (size_t) < sizeof (bfd_size_type
)
9958 && (bfd_size_type
) ((size_t) number
) != number
)
9960 error (_("Size truncation prevents reading %s elements of size %u\n"),
9961 bfd_vmatoa ("u", number
), ent_size
);
9965 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9966 attempting to allocate memory when the read is bound to fail. */
9967 if (ent_size
* number
> filedata
->file_size
)
9969 error (_("Invalid number of dynamic entries: %s\n"),
9970 bfd_vmatoa ("u", number
));
9974 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9977 error (_("Out of memory reading %s dynamic entries\n"),
9978 bfd_vmatoa ("u", number
));
9982 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9984 error (_("Unable to read in %s bytes of dynamic data\n"),
9985 bfd_vmatoa ("u", number
* ent_size
));
9990 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
9993 error (_("Out of memory allocating space for %s dynamic entries\n"),
9994 bfd_vmatoa ("u", number
));
10000 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10007 static unsigned long
10008 get_num_dynamic_syms (Filedata
* filedata
)
10010 unsigned long num_of_syms
= 0;
10012 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10013 return num_of_syms
;
10015 if (filedata
->dynamic_info
[DT_HASH
])
10017 unsigned char nb
[8];
10018 unsigned char nc
[8];
10019 unsigned int hash_ent_size
= 4;
10021 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10022 || filedata
->file_header
.e_machine
== EM_S390
10023 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10024 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10027 if (fseek (filedata
->handle
,
10028 (filedata
->archive_file_offset
10029 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10030 sizeof nb
+ sizeof nc
)),
10033 error (_("Unable to seek to start of dynamic information\n"));
10037 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10039 error (_("Failed to read in number of buckets\n"));
10043 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10045 error (_("Failed to read in number of chains\n"));
10049 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10050 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10052 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10054 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10056 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10059 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10060 num_of_syms
= filedata
->nchains
;
10063 if (num_of_syms
== 0)
10065 if (filedata
->buckets
)
10067 free (filedata
->buckets
);
10068 filedata
->buckets
= NULL
;
10070 if (filedata
->chains
)
10072 free (filedata
->chains
);
10073 filedata
->chains
= NULL
;
10075 filedata
->nbuckets
= 0;
10079 if (filedata
->dynamic_info_DT_GNU_HASH
)
10081 unsigned char nb
[16];
10082 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10083 bfd_vma buckets_vma
;
10086 if (fseek (filedata
->handle
,
10087 (filedata
->archive_file_offset
10088 + offset_from_vma (filedata
,
10089 filedata
->dynamic_info_DT_GNU_HASH
,
10093 error (_("Unable to seek to start of dynamic information\n"));
10097 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10099 error (_("Failed to read in number of buckets\n"));
10103 filedata
->ngnubuckets
= byte_get (nb
, 4);
10104 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10105 bitmaskwords
= byte_get (nb
+ 8, 4);
10106 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10108 buckets_vma
+= bitmaskwords
* 4;
10110 buckets_vma
+= bitmaskwords
* 8;
10112 if (fseek (filedata
->handle
,
10113 (filedata
->archive_file_offset
10114 + offset_from_vma (filedata
, buckets_vma
, 4)),
10117 error (_("Unable to seek to start of dynamic information\n"));
10121 filedata
->gnubuckets
10122 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10124 if (filedata
->gnubuckets
== NULL
)
10127 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10128 if (filedata
->gnubuckets
[i
] != 0)
10130 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10133 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10134 maxchain
= filedata
->gnubuckets
[i
];
10137 if (maxchain
== 0xffffffff)
10140 maxchain
-= filedata
->gnusymidx
;
10142 if (fseek (filedata
->handle
,
10143 (filedata
->archive_file_offset
10144 + offset_from_vma (filedata
,
10145 buckets_vma
+ 4 * (filedata
->ngnubuckets
10150 error (_("Unable to seek to start of dynamic information\n"));
10156 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10158 error (_("Failed to determine last chain length\n"));
10162 if (maxchain
+ 1 == 0)
10167 while ((byte_get (nb
, 4) & 1) == 0);
10169 if (fseek (filedata
->handle
,
10170 (filedata
->archive_file_offset
10171 + offset_from_vma (filedata
, (buckets_vma
10172 + 4 * filedata
->ngnubuckets
),
10176 error (_("Unable to seek to start of dynamic information\n"));
10180 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10181 filedata
->ngnuchains
= maxchain
;
10183 if (filedata
->gnuchains
== NULL
)
10186 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10188 if (fseek (filedata
->handle
,
10189 (filedata
->archive_file_offset
10190 + offset_from_vma (filedata
, (buckets_vma
10191 + 4 * (filedata
->ngnubuckets
10195 error (_("Unable to seek to start of dynamic information\n"));
10199 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10200 if (filedata
->mipsxlat
== NULL
)
10204 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10205 if (filedata
->gnubuckets
[hn
] != 0)
10207 bfd_vma si
= filedata
->gnubuckets
[hn
];
10208 bfd_vma off
= si
- filedata
->gnusymidx
;
10212 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10214 if (off
< filedata
->ngnuchains
10215 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10216 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10220 if (si
>= num_of_syms
)
10221 num_of_syms
= si
+ 1;
10225 while (off
< filedata
->ngnuchains
10226 && (filedata
->gnuchains
[off
++] & 1) == 0);
10229 if (num_of_syms
== 0)
10232 if (filedata
->mipsxlat
)
10234 free (filedata
->mipsxlat
);
10235 filedata
->mipsxlat
= NULL
;
10237 if (filedata
->gnuchains
)
10239 free (filedata
->gnuchains
);
10240 filedata
->gnuchains
= NULL
;
10242 if (filedata
->gnubuckets
)
10244 free (filedata
->gnubuckets
);
10245 filedata
->gnubuckets
= NULL
;
10247 filedata
->ngnubuckets
= 0;
10248 filedata
->ngnuchains
= 0;
10252 return num_of_syms
;
10255 /* Parse and display the contents of the dynamic section. */
10258 process_dynamic_section (Filedata
* filedata
)
10260 Elf_Internal_Dyn
* entry
;
10262 if (filedata
->dynamic_size
== 0)
10265 printf (_("\nThere is no dynamic section in this file.\n"));
10272 if (! get_32bit_dynamic_section (filedata
))
10277 if (! get_64bit_dynamic_section (filedata
))
10281 /* Find the appropriate symbol table. */
10282 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10284 unsigned long num_of_syms
;
10286 for (entry
= filedata
->dynamic_section
;
10287 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10289 if (entry
->d_tag
== DT_SYMTAB
)
10290 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10291 else if (entry
->d_tag
== DT_SYMENT
)
10292 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10293 else if (entry
->d_tag
== DT_HASH
)
10294 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10295 else if (entry
->d_tag
== DT_GNU_HASH
)
10296 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10297 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10298 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10299 && entry
->d_tag
== DT_MIPS_XHASH
)
10301 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10302 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10305 num_of_syms
= get_num_dynamic_syms (filedata
);
10307 if (num_of_syms
!= 0
10308 && filedata
->dynamic_symbols
== NULL
10309 && filedata
->dynamic_info
[DT_SYMTAB
]
10310 && filedata
->dynamic_info
[DT_SYMENT
])
10312 Elf_Internal_Phdr
*seg
;
10313 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10315 if (! get_program_headers (filedata
))
10317 error (_("Cannot interpret virtual addresses "
10318 "without program headers.\n"));
10322 for (seg
= filedata
->program_headers
;
10323 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10326 if (seg
->p_type
!= PT_LOAD
)
10329 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10331 /* See PR 21379 for a reproducer. */
10332 error (_("Invalid PT_LOAD entry\n"));
10336 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10337 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10339 /* Since we do not know how big the symbol table is,
10340 we default to reading in up to the end of PT_LOAD
10341 segment and processing that. This is overkill, I
10342 know, but it should work. */
10343 Elf_Internal_Shdr section
;
10344 section
.sh_offset
= (vma
- seg
->p_vaddr
10346 section
.sh_size
= (num_of_syms
10347 * filedata
->dynamic_info
[DT_SYMENT
]);
10348 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10351 && filedata
->dynamic_symtab_section
!= NULL
10352 && ((filedata
->dynamic_symtab_section
->sh_offset
10353 != section
.sh_offset
)
10354 || (filedata
->dynamic_symtab_section
->sh_size
10355 != section
.sh_size
)
10356 || (filedata
->dynamic_symtab_section
->sh_entsize
10357 != section
.sh_entsize
)))
10359 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10361 section
.sh_name
= filedata
->string_table_length
;
10362 filedata
->dynamic_symbols
10363 = GET_ELF_SYMBOLS (filedata
, §ion
,
10364 &filedata
->num_dynamic_syms
);
10365 if (filedata
->dynamic_symbols
== NULL
10366 || filedata
->num_dynamic_syms
!= num_of_syms
)
10368 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10377 /* Similarly find a string table. */
10378 if (filedata
->dynamic_strings
== NULL
)
10379 for (entry
= filedata
->dynamic_section
;
10380 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10383 if (entry
->d_tag
== DT_STRTAB
)
10384 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10386 if (entry
->d_tag
== DT_STRSZ
)
10387 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10389 if (filedata
->dynamic_info
[DT_STRTAB
]
10390 && filedata
->dynamic_info
[DT_STRSZ
])
10392 unsigned long offset
;
10393 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10395 offset
= offset_from_vma (filedata
,
10396 filedata
->dynamic_info
[DT_STRTAB
],
10399 && filedata
->dynamic_strtab_section
10400 && ((filedata
->dynamic_strtab_section
->sh_offset
10401 != (file_ptr
) offset
)
10402 || (filedata
->dynamic_strtab_section
->sh_size
10405 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10407 filedata
->dynamic_strings
10408 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10409 _("dynamic string table"));
10410 if (filedata
->dynamic_strings
== NULL
)
10412 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10416 filedata
->dynamic_strings_length
= str_tab_len
;
10421 /* And find the syminfo section if available. */
10422 if (filedata
->dynamic_syminfo
== NULL
)
10424 unsigned long syminsz
= 0;
10426 for (entry
= filedata
->dynamic_section
;
10427 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10430 if (entry
->d_tag
== DT_SYMINENT
)
10432 /* Note: these braces are necessary to avoid a syntax
10433 error from the SunOS4 C compiler. */
10434 /* PR binutils/17531: A corrupt file can trigger this test.
10435 So do not use an assert, instead generate an error message. */
10436 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10437 error (_("Bad value (%d) for SYMINENT entry\n"),
10438 (int) entry
->d_un
.d_val
);
10440 else if (entry
->d_tag
== DT_SYMINSZ
)
10441 syminsz
= entry
->d_un
.d_val
;
10442 else if (entry
->d_tag
== DT_SYMINFO
)
10443 filedata
->dynamic_syminfo_offset
10444 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10447 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10449 Elf_External_Syminfo
* extsyminfo
;
10450 Elf_External_Syminfo
* extsym
;
10451 Elf_Internal_Syminfo
* syminfo
;
10453 /* There is a syminfo section. Read the data. */
10454 extsyminfo
= (Elf_External_Syminfo
*)
10455 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10456 1, syminsz
, _("symbol information"));
10460 if (filedata
->dynamic_syminfo
!= NULL
)
10462 error (_("Multiple dynamic symbol information sections found\n"));
10463 free (filedata
->dynamic_syminfo
);
10465 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10466 if (filedata
->dynamic_syminfo
== NULL
)
10468 error (_("Out of memory allocating %lu bytes "
10469 "for dynamic symbol info\n"),
10470 (unsigned long) syminsz
);
10474 filedata
->dynamic_syminfo_nent
10475 = syminsz
/ sizeof (Elf_External_Syminfo
);
10476 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10477 syminfo
< (filedata
->dynamic_syminfo
10478 + filedata
->dynamic_syminfo_nent
);
10479 ++syminfo
, ++extsym
)
10481 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10482 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10489 if (do_dynamic
&& filedata
->dynamic_addr
)
10490 printf (ngettext ("\nDynamic section at offset 0x%lx "
10491 "contains %lu entry:\n",
10492 "\nDynamic section at offset 0x%lx "
10493 "contains %lu entries:\n",
10494 filedata
->dynamic_nent
),
10495 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10497 printf (_(" Tag Type Name/Value\n"));
10499 for (entry
= filedata
->dynamic_section
;
10500 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10505 const char * dtype
;
10508 print_vma (entry
->d_tag
, FULL_HEX
);
10509 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10510 printf (" (%s)%*s", dtype
,
10511 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10514 switch (entry
->d_tag
)
10518 print_dynamic_flags (entry
->d_un
.d_val
);
10528 switch (entry
->d_tag
)
10531 printf (_("Auxiliary library"));
10535 printf (_("Filter library"));
10539 printf (_("Configuration file"));
10543 printf (_("Dependency audit library"));
10547 printf (_("Audit library"));
10551 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10552 printf (": [%s]\n",
10553 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10557 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10566 printf (_("Flags:"));
10568 if (entry
->d_un
.d_val
== 0)
10569 printf (_(" None\n"));
10572 unsigned long int val
= entry
->d_un
.d_val
;
10574 if (val
& DTF_1_PARINIT
)
10576 printf (" PARINIT");
10577 val
^= DTF_1_PARINIT
;
10579 if (val
& DTF_1_CONFEXP
)
10581 printf (" CONFEXP");
10582 val
^= DTF_1_CONFEXP
;
10585 printf (" %lx", val
);
10594 printf (_("Flags:"));
10596 if (entry
->d_un
.d_val
== 0)
10597 printf (_(" None\n"));
10600 unsigned long int val
= entry
->d_un
.d_val
;
10602 if (val
& DF_P1_LAZYLOAD
)
10604 printf (" LAZYLOAD");
10605 val
^= DF_P1_LAZYLOAD
;
10607 if (val
& DF_P1_GROUPPERM
)
10609 printf (" GROUPPERM");
10610 val
^= DF_P1_GROUPPERM
;
10613 printf (" %lx", val
);
10622 printf (_("Flags:"));
10623 if (entry
->d_un
.d_val
== 0)
10624 printf (_(" None\n"));
10627 unsigned long int val
= entry
->d_un
.d_val
;
10629 if (val
& DF_1_NOW
)
10634 if (val
& DF_1_GLOBAL
)
10636 printf (" GLOBAL");
10637 val
^= DF_1_GLOBAL
;
10639 if (val
& DF_1_GROUP
)
10644 if (val
& DF_1_NODELETE
)
10646 printf (" NODELETE");
10647 val
^= DF_1_NODELETE
;
10649 if (val
& DF_1_LOADFLTR
)
10651 printf (" LOADFLTR");
10652 val
^= DF_1_LOADFLTR
;
10654 if (val
& DF_1_INITFIRST
)
10656 printf (" INITFIRST");
10657 val
^= DF_1_INITFIRST
;
10659 if (val
& DF_1_NOOPEN
)
10661 printf (" NOOPEN");
10662 val
^= DF_1_NOOPEN
;
10664 if (val
& DF_1_ORIGIN
)
10666 printf (" ORIGIN");
10667 val
^= DF_1_ORIGIN
;
10669 if (val
& DF_1_DIRECT
)
10671 printf (" DIRECT");
10672 val
^= DF_1_DIRECT
;
10674 if (val
& DF_1_TRANS
)
10679 if (val
& DF_1_INTERPOSE
)
10681 printf (" INTERPOSE");
10682 val
^= DF_1_INTERPOSE
;
10684 if (val
& DF_1_NODEFLIB
)
10686 printf (" NODEFLIB");
10687 val
^= DF_1_NODEFLIB
;
10689 if (val
& DF_1_NODUMP
)
10691 printf (" NODUMP");
10692 val
^= DF_1_NODUMP
;
10694 if (val
& DF_1_CONFALT
)
10696 printf (" CONFALT");
10697 val
^= DF_1_CONFALT
;
10699 if (val
& DF_1_ENDFILTEE
)
10701 printf (" ENDFILTEE");
10702 val
^= DF_1_ENDFILTEE
;
10704 if (val
& DF_1_DISPRELDNE
)
10706 printf (" DISPRELDNE");
10707 val
^= DF_1_DISPRELDNE
;
10709 if (val
& DF_1_DISPRELPND
)
10711 printf (" DISPRELPND");
10712 val
^= DF_1_DISPRELPND
;
10714 if (val
& DF_1_NODIRECT
)
10716 printf (" NODIRECT");
10717 val
^= DF_1_NODIRECT
;
10719 if (val
& DF_1_IGNMULDEF
)
10721 printf (" IGNMULDEF");
10722 val
^= DF_1_IGNMULDEF
;
10724 if (val
& DF_1_NOKSYMS
)
10726 printf (" NOKSYMS");
10727 val
^= DF_1_NOKSYMS
;
10729 if (val
& DF_1_NOHDR
)
10734 if (val
& DF_1_EDITED
)
10736 printf (" EDITED");
10737 val
^= DF_1_EDITED
;
10739 if (val
& DF_1_NORELOC
)
10741 printf (" NORELOC");
10742 val
^= DF_1_NORELOC
;
10744 if (val
& DF_1_SYMINTPOSE
)
10746 printf (" SYMINTPOSE");
10747 val
^= DF_1_SYMINTPOSE
;
10749 if (val
& DF_1_GLOBAUDIT
)
10751 printf (" GLOBAUDIT");
10752 val
^= DF_1_GLOBAUDIT
;
10754 if (val
& DF_1_SINGLETON
)
10756 printf (" SINGLETON");
10757 val
^= DF_1_SINGLETON
;
10759 if (val
& DF_1_STUB
)
10764 if (val
& DF_1_PIE
)
10769 if (val
& DF_1_KMOD
)
10774 if (val
& DF_1_WEAKFILTER
)
10776 printf (" WEAKFILTER");
10777 val
^= DF_1_WEAKFILTER
;
10779 if (val
& DF_1_NOCOMMON
)
10781 printf (" NOCOMMON");
10782 val
^= DF_1_NOCOMMON
;
10785 printf (" %lx", val
);
10792 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10794 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10814 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10820 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10821 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10827 switch (entry
->d_tag
)
10830 printf (_("Shared library: [%s]"), name
);
10832 if (streq (name
, filedata
->program_interpreter
))
10833 printf (_(" program interpreter"));
10837 printf (_("Library soname: [%s]"), name
);
10841 printf (_("Library rpath: [%s]"), name
);
10845 printf (_("Library runpath: [%s]"), name
);
10849 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10854 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10867 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10868 /* Fall through. */
10872 case DT_INIT_ARRAYSZ
:
10873 case DT_FINI_ARRAYSZ
:
10874 case DT_GNU_CONFLICTSZ
:
10875 case DT_GNU_LIBLISTSZ
:
10878 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10879 printf (_(" (bytes)\n"));
10884 case DT_VERNEEDNUM
:
10889 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10898 case DT_INIT_ARRAY
:
10899 case DT_FINI_ARRAY
:
10902 if (entry
->d_tag
== DT_USED
10903 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10905 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10909 printf (_("Not needed object: [%s]\n"), name
);
10914 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10920 /* The value of this entry is ignored. */
10925 case DT_GNU_PRELINKED
:
10929 time_t atime
= entry
->d_un
.d_val
;
10931 tmp
= gmtime (&atime
);
10932 /* PR 17533 file: 041-1244816-0.004. */
10934 printf (_("<corrupt time val: %lx"),
10935 (unsigned long) atime
);
10937 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10938 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10939 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10945 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10948 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10954 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10955 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10956 = entry
->d_un
.d_val
;
10960 switch (filedata
->file_header
.e_machine
)
10963 dynamic_section_aarch64_val (entry
);
10966 case EM_MIPS_RS3_LE
:
10967 dynamic_section_mips_val (filedata
, entry
);
10970 dynamic_section_parisc_val (entry
);
10973 dynamic_section_ia64_val (entry
);
10976 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10988 get_ver_flags (unsigned int flags
)
10990 static char buff
[128];
10997 if (flags
& VER_FLG_BASE
)
10998 strcat (buff
, "BASE");
11000 if (flags
& VER_FLG_WEAK
)
11002 if (flags
& VER_FLG_BASE
)
11003 strcat (buff
, " | ");
11005 strcat (buff
, "WEAK");
11008 if (flags
& VER_FLG_INFO
)
11010 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11011 strcat (buff
, " | ");
11013 strcat (buff
, "INFO");
11016 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11018 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11019 strcat (buff
, " | ");
11021 strcat (buff
, _("<unknown>"));
11027 /* Display the contents of the version sections. */
11030 process_version_sections (Filedata
* filedata
)
11032 Elf_Internal_Shdr
* section
;
11034 bfd_boolean found
= FALSE
;
11039 for (i
= 0, section
= filedata
->section_headers
;
11040 i
< filedata
->file_header
.e_shnum
;
11043 switch (section
->sh_type
)
11045 case SHT_GNU_verdef
:
11047 Elf_External_Verdef
* edefs
;
11054 printf (ngettext ("\nVersion definition section '%s' "
11055 "contains %u entry:\n",
11056 "\nVersion definition section '%s' "
11057 "contains %u entries:\n",
11059 printable_section_name (filedata
, section
),
11062 printf (_(" Addr: 0x"));
11063 printf_vma (section
->sh_addr
);
11064 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11065 (unsigned long) section
->sh_offset
, section
->sh_link
,
11066 printable_section_name_from_index (filedata
, section
->sh_link
));
11068 edefs
= (Elf_External_Verdef
*)
11069 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11070 _("version definition section"));
11073 endbuf
= (char *) edefs
+ section
->sh_size
;
11075 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11078 Elf_External_Verdef
* edef
;
11079 Elf_Internal_Verdef ent
;
11080 Elf_External_Verdaux
* eaux
;
11081 Elf_Internal_Verdaux aux
;
11082 unsigned long isum
;
11085 vstart
= ((char *) edefs
) + idx
;
11086 if (vstart
+ sizeof (*edef
) > endbuf
)
11089 edef
= (Elf_External_Verdef
*) vstart
;
11091 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11092 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11093 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11094 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11095 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11096 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11097 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11099 printf (_(" %#06lx: Rev: %d Flags: %s"),
11100 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11102 printf (_(" Index: %d Cnt: %d "),
11103 ent
.vd_ndx
, ent
.vd_cnt
);
11105 /* Check for overflow. */
11106 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11109 vstart
+= ent
.vd_aux
;
11111 if (vstart
+ sizeof (*eaux
) > endbuf
)
11113 eaux
= (Elf_External_Verdaux
*) vstart
;
11115 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11116 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11118 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11119 printf (_("Name: %s\n"),
11120 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11122 printf (_("Name index: %ld\n"), aux
.vda_name
);
11124 isum
= idx
+ ent
.vd_aux
;
11126 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11128 if (aux
.vda_next
< sizeof (*eaux
)
11129 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11131 warn (_("Invalid vda_next field of %lx\n"),
11136 /* Check for overflow. */
11137 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11140 isum
+= aux
.vda_next
;
11141 vstart
+= aux
.vda_next
;
11143 if (vstart
+ sizeof (*eaux
) > endbuf
)
11145 eaux
= (Elf_External_Verdaux
*) vstart
;
11147 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11148 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11150 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11151 printf (_(" %#06lx: Parent %d: %s\n"),
11153 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11155 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11156 isum
, j
, aux
.vda_name
);
11159 if (j
< ent
.vd_cnt
)
11160 printf (_(" Version def aux past end of section\n"));
11163 file: id:000001,src:000172+005151,op:splice,rep:2. */
11164 if (ent
.vd_next
< sizeof (*edef
)
11165 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11167 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11168 cnt
= section
->sh_info
;
11171 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11174 idx
+= ent
.vd_next
;
11177 if (cnt
< section
->sh_info
)
11178 printf (_(" Version definition past end of section\n"));
11184 case SHT_GNU_verneed
:
11186 Elf_External_Verneed
* eneed
;
11193 printf (ngettext ("\nVersion needs section '%s' "
11194 "contains %u entry:\n",
11195 "\nVersion needs section '%s' "
11196 "contains %u entries:\n",
11198 printable_section_name (filedata
, section
), section
->sh_info
);
11200 printf (_(" Addr: 0x"));
11201 printf_vma (section
->sh_addr
);
11202 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11203 (unsigned long) section
->sh_offset
, section
->sh_link
,
11204 printable_section_name_from_index (filedata
, section
->sh_link
));
11206 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11207 section
->sh_offset
, 1,
11209 _("Version Needs section"));
11212 endbuf
= (char *) eneed
+ section
->sh_size
;
11214 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11216 Elf_External_Verneed
* entry
;
11217 Elf_Internal_Verneed ent
;
11218 unsigned long isum
;
11222 vstart
= ((char *) eneed
) + idx
;
11223 if (vstart
+ sizeof (*entry
) > endbuf
)
11226 entry
= (Elf_External_Verneed
*) vstart
;
11228 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11229 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11230 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11231 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11232 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11234 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11236 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11237 printf (_(" File: %s"),
11238 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11240 printf (_(" File: %lx"), ent
.vn_file
);
11242 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11244 /* Check for overflow. */
11245 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11247 vstart
+= ent
.vn_aux
;
11249 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11251 Elf_External_Vernaux
* eaux
;
11252 Elf_Internal_Vernaux aux
;
11254 if (vstart
+ sizeof (*eaux
) > endbuf
)
11256 eaux
= (Elf_External_Vernaux
*) vstart
;
11258 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11259 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11260 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11261 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11262 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11264 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11265 printf (_(" %#06lx: Name: %s"),
11266 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11268 printf (_(" %#06lx: Name index: %lx"),
11269 isum
, aux
.vna_name
);
11271 printf (_(" Flags: %s Version: %d\n"),
11272 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11274 if (aux
.vna_next
< sizeof (*eaux
)
11275 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11277 warn (_("Invalid vna_next field of %lx\n"),
11282 /* Check for overflow. */
11283 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11285 isum
+= aux
.vna_next
;
11286 vstart
+= aux
.vna_next
;
11289 if (j
< ent
.vn_cnt
)
11290 warn (_("Missing Version Needs auxillary information\n"));
11292 if (ent
.vn_next
< sizeof (*entry
)
11293 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11295 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11296 cnt
= section
->sh_info
;
11299 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11301 idx
+= ent
.vn_next
;
11304 if (cnt
< section
->sh_info
)
11305 warn (_("Missing Version Needs information\n"));
11311 case SHT_GNU_versym
:
11313 Elf_Internal_Shdr
* link_section
;
11316 unsigned char * edata
;
11317 unsigned short * data
;
11319 Elf_Internal_Sym
* symbols
;
11320 Elf_Internal_Shdr
* string_sec
;
11321 unsigned long num_syms
;
11324 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11327 link_section
= filedata
->section_headers
+ section
->sh_link
;
11328 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11330 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11335 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11336 if (symbols
== NULL
)
11339 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11341 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11342 string_sec
->sh_size
,
11343 _("version string table"));
11350 printf (ngettext ("\nVersion symbols section '%s' "
11351 "contains %lu entry:\n",
11352 "\nVersion symbols section '%s' "
11353 "contains %lu entries:\n",
11355 printable_section_name (filedata
, section
), (unsigned long) total
);
11357 printf (_(" Addr: 0x"));
11358 printf_vma (section
->sh_addr
);
11359 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11360 (unsigned long) section
->sh_offset
, section
->sh_link
,
11361 printable_section_name (filedata
, link_section
));
11363 off
= offset_from_vma (filedata
,
11364 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11365 total
* sizeof (short));
11366 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11367 sizeof (short), total
,
11368 _("version symbol data"));
11376 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11378 for (cnt
= total
; cnt
--;)
11379 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11384 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11388 char *invalid
= _("*invalid*");
11390 printf (" %03x:", cnt
);
11392 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11393 switch (data
[cnt
+ j
])
11396 fputs (_(" 0 (*local*) "), stdout
);
11400 fputs (_(" 1 (*global*) "), stdout
);
11404 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11405 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11407 /* If this index value is greater than the size of the symbols
11408 array, break to avoid an out-of-bounds read. */
11409 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11411 warn (_("invalid index into symbol array\n"));
11416 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11418 Elf_Internal_Verneed ivn
;
11419 unsigned long offset
;
11421 offset
= offset_from_vma
11423 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11424 sizeof (Elf_External_Verneed
));
11428 Elf_Internal_Vernaux ivna
;
11429 Elf_External_Verneed evn
;
11430 Elf_External_Vernaux evna
;
11431 unsigned long a_off
;
11433 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11434 _("version need")) == NULL
)
11437 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11438 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11440 a_off
= offset
+ ivn
.vn_aux
;
11444 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11445 1, _("version need aux (2)")) == NULL
)
11448 ivna
.vna_other
= 0;
11452 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11453 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11456 a_off
+= ivna
.vna_next
;
11458 while (ivna
.vna_other
!= data
[cnt
+ j
]
11459 && ivna
.vna_next
!= 0);
11461 if (ivna
.vna_other
== data
[cnt
+ j
])
11463 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11465 if (ivna
.vna_name
>= string_sec
->sh_size
)
11468 name
= strtab
+ ivna
.vna_name
;
11472 offset
+= ivn
.vn_next
;
11474 while (ivn
.vn_next
);
11477 if (data
[cnt
+ j
] != 0x8001
11478 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11480 Elf_Internal_Verdef ivd
;
11481 Elf_External_Verdef evd
;
11482 unsigned long offset
;
11484 offset
= offset_from_vma
11486 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11491 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11492 _("version def")) == NULL
)
11495 /* PR 17531: file: 046-1082287-0.004. */
11496 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11501 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11502 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11505 offset
+= ivd
.vd_next
;
11507 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11508 && ivd
.vd_next
!= 0);
11510 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11512 Elf_External_Verdaux evda
;
11513 Elf_Internal_Verdaux ivda
;
11515 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11517 if (get_data (&evda
, filedata
,
11518 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11520 _("version def aux")) == NULL
)
11523 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11525 if (ivda
.vda_name
>= string_sec
->sh_size
)
11527 else if (name
!= NULL
&& name
!= invalid
)
11528 name
= _("*both*");
11530 name
= strtab
+ ivda
.vda_name
;
11534 nn
+= printf ("(%s%-*s",
11536 12 - (int) strlen (name
),
11540 printf ("%*c", 18 - nn
, ' ');
11558 printf (_("\nNo version information found in this file.\n"));
11563 static const char *
11564 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11566 static char buff
[64];
11570 case STB_LOCAL
: return "LOCAL";
11571 case STB_GLOBAL
: return "GLOBAL";
11572 case STB_WEAK
: return "WEAK";
11574 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11575 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11577 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11579 if (binding
== STB_GNU_UNIQUE
11580 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11582 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11585 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11590 static const char *
11591 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11593 static char buff
[64];
11597 case STT_NOTYPE
: return "NOTYPE";
11598 case STT_OBJECT
: return "OBJECT";
11599 case STT_FUNC
: return "FUNC";
11600 case STT_SECTION
: return "SECTION";
11601 case STT_FILE
: return "FILE";
11602 case STT_COMMON
: return "COMMON";
11603 case STT_TLS
: return "TLS";
11604 case STT_RELC
: return "RELC";
11605 case STT_SRELC
: return "SRELC";
11607 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11609 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11610 return "THUMB_FUNC";
11612 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11615 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11616 return "PARISC_MILLI";
11618 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11620 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11622 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11624 if (type
== STT_HP_OPAQUE
)
11625 return "HP_OPAQUE";
11626 if (type
== STT_HP_STUB
)
11630 if (type
== STT_GNU_IFUNC
11631 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11632 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11635 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11638 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11643 static const char *
11644 get_symbol_visibility (unsigned int visibility
)
11646 switch (visibility
)
11648 case STV_DEFAULT
: return "DEFAULT";
11649 case STV_INTERNAL
: return "INTERNAL";
11650 case STV_HIDDEN
: return "HIDDEN";
11651 case STV_PROTECTED
: return "PROTECTED";
11653 error (_("Unrecognized visibility value: %u\n"), visibility
);
11654 return _("<unknown>");
11658 static const char *
11659 get_alpha_symbol_other (unsigned int other
)
11663 case STO_ALPHA_NOPV
: return "NOPV";
11664 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11666 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11667 return _("<unknown>");
11671 static const char *
11672 get_solaris_symbol_visibility (unsigned int visibility
)
11674 switch (visibility
)
11676 case 4: return "EXPORTED";
11677 case 5: return "SINGLETON";
11678 case 6: return "ELIMINATE";
11679 default: return get_symbol_visibility (visibility
);
11683 static const char *
11684 get_aarch64_symbol_other (unsigned int other
)
11686 static char buf
[32];
11688 if (other
& STO_AARCH64_VARIANT_PCS
)
11690 other
&= ~STO_AARCH64_VARIANT_PCS
;
11692 return "VARIANT_PCS";
11693 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11699 static const char *
11700 get_mips_symbol_other (unsigned int other
)
11704 case STO_OPTIONAL
: return "OPTIONAL";
11705 case STO_MIPS_PLT
: return "MIPS PLT";
11706 case STO_MIPS_PIC
: return "MIPS PIC";
11707 case STO_MICROMIPS
: return "MICROMIPS";
11708 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11709 case STO_MIPS16
: return "MIPS16";
11710 default: return NULL
;
11714 static const char *
11715 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11717 if (is_ia64_vms (filedata
))
11719 static char res
[32];
11723 /* Function types is for images and .STB files only. */
11724 switch (filedata
->file_header
.e_type
)
11728 switch (VMS_ST_FUNC_TYPE (other
))
11730 case VMS_SFT_CODE_ADDR
:
11731 strcat (res
, " CA");
11733 case VMS_SFT_SYMV_IDX
:
11734 strcat (res
, " VEC");
11737 strcat (res
, " FD");
11739 case VMS_SFT_RESERVE
:
11740 strcat (res
, " RSV");
11743 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11744 VMS_ST_FUNC_TYPE (other
));
11745 strcat (res
, " <unknown>");
11752 switch (VMS_ST_LINKAGE (other
))
11754 case VMS_STL_IGNORE
:
11755 strcat (res
, " IGN");
11757 case VMS_STL_RESERVE
:
11758 strcat (res
, " RSV");
11761 strcat (res
, " STD");
11764 strcat (res
, " LNK");
11767 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11768 VMS_ST_LINKAGE (other
));
11769 strcat (res
, " <unknown>");
11781 static const char *
11782 get_ppc64_symbol_other (unsigned int other
)
11784 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11787 other
>>= STO_PPC64_LOCAL_BIT
;
11790 static char buf
[64];
11792 other
= ppc64_decode_local_entry (other
);
11793 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11799 static const char *
11800 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11802 const char * result
= NULL
;
11803 static char buff
[64];
11808 switch (filedata
->file_header
.e_machine
)
11811 result
= get_alpha_symbol_other (other
);
11814 result
= get_aarch64_symbol_other (other
);
11817 result
= get_mips_symbol_other (other
);
11820 result
= get_ia64_symbol_other (filedata
, other
);
11823 result
= get_ppc64_symbol_other (other
);
11833 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11837 static const char *
11838 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11840 static char buff
[32];
11844 case SHN_UNDEF
: return "UND";
11845 case SHN_ABS
: return "ABS";
11846 case SHN_COMMON
: return "COM";
11848 if (type
== SHN_IA_64_ANSI_COMMON
11849 && filedata
->file_header
.e_machine
== EM_IA_64
11850 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11852 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11853 || filedata
->file_header
.e_machine
== EM_L1OM
11854 || filedata
->file_header
.e_machine
== EM_K1OM
)
11855 && type
== SHN_X86_64_LCOMMON
)
11856 return "LARGE_COM";
11857 else if ((type
== SHN_MIPS_SCOMMON
11858 && filedata
->file_header
.e_machine
== EM_MIPS
)
11859 || (type
== SHN_TIC6X_SCOMMON
11860 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11862 else if (type
== SHN_MIPS_SUNDEFINED
11863 && filedata
->file_header
.e_machine
== EM_MIPS
)
11865 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11866 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11867 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11868 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11869 else if (type
>= SHN_LORESERVE
)
11870 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11871 else if (filedata
->file_header
.e_shnum
!= 0
11872 && type
>= filedata
->file_header
.e_shnum
)
11873 sprintf (buff
, _("bad section index[%3d]"), type
);
11875 sprintf (buff
, "%3d", type
);
11882 static const char *
11883 get_symbol_version_string (Filedata
* filedata
,
11884 bfd_boolean is_dynsym
,
11885 const char * strtab
,
11886 unsigned long int strtab_size
,
11888 Elf_Internal_Sym
* psym
,
11889 enum versioned_symbol_info
* sym_info
,
11890 unsigned short * vna_other
)
11892 unsigned char data
[2];
11893 unsigned short vers_data
;
11894 unsigned long offset
;
11895 unsigned short max_vd_ndx
;
11898 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11901 offset
= offset_from_vma (filedata
,
11902 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11903 sizeof data
+ si
* sizeof (vers_data
));
11905 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11906 sizeof (data
), 1, _("version data")) == NULL
)
11909 vers_data
= byte_get (data
, 2);
11911 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11914 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11917 /* Usually we'd only see verdef for defined symbols, and verneed for
11918 undefined symbols. However, symbols defined by the linker in
11919 .dynbss for variables copied from a shared library in order to
11920 avoid text relocations are defined yet have verneed. We could
11921 use a heuristic to detect the special case, for example, check
11922 for verneed first on symbols defined in SHT_NOBITS sections, but
11923 it is simpler and more reliable to just look for both verdef and
11924 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11926 if (psym
->st_shndx
!= SHN_UNDEF
11927 && vers_data
!= 0x8001
11928 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11930 Elf_Internal_Verdef ivd
;
11931 Elf_Internal_Verdaux ivda
;
11932 Elf_External_Verdaux evda
;
11935 off
= offset_from_vma (filedata
,
11936 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11937 sizeof (Elf_External_Verdef
));
11941 Elf_External_Verdef evd
;
11943 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11944 _("version def")) == NULL
)
11953 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11954 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11955 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11956 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11959 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11960 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11962 off
+= ivd
.vd_next
;
11964 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11966 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11968 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11971 off
-= ivd
.vd_next
;
11974 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11975 _("version def aux")) != NULL
)
11977 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11979 if (psym
->st_name
!= ivda
.vda_name
)
11980 return (ivda
.vda_name
< strtab_size
11981 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11986 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11988 Elf_External_Verneed evn
;
11989 Elf_Internal_Verneed ivn
;
11990 Elf_Internal_Vernaux ivna
;
11992 offset
= offset_from_vma (filedata
,
11993 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11997 unsigned long vna_off
;
11999 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12000 _("version need")) == NULL
)
12003 ivna
.vna_other
= 0;
12008 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12009 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12011 vna_off
= offset
+ ivn
.vn_aux
;
12015 Elf_External_Vernaux evna
;
12017 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12018 _("version need aux (3)")) == NULL
)
12021 ivna
.vna_other
= 0;
12026 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12027 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12028 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12031 vna_off
+= ivna
.vna_next
;
12033 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12035 if (ivna
.vna_other
== vers_data
)
12038 offset
+= ivn
.vn_next
;
12040 while (ivn
.vn_next
!= 0);
12042 if (ivna
.vna_other
== vers_data
)
12044 *sym_info
= symbol_undefined
;
12045 *vna_other
= ivna
.vna_other
;
12046 return (ivna
.vna_name
< strtab_size
12047 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12049 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12050 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12051 return _("<corrupt>");
12057 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12058 Elf_Internal_Sym
*symtab
,
12059 Elf_Internal_Shdr
*section
,
12060 char *strtab
, size_t strtab_size
)
12062 const char *version_string
;
12063 enum versioned_symbol_info sym_info
;
12064 unsigned short vna_other
;
12065 Elf_Internal_Sym
*psym
= symtab
+ si
;
12067 printf ("%6ld: ", si
);
12068 print_vma (psym
->st_value
, LONG_HEX
);
12070 print_vma (psym
->st_size
, DEC_5
);
12071 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12072 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12073 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12074 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12077 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12079 printf (" %-7s", get_symbol_visibility (vis
));
12080 /* Check to see if any other bits in the st_other field are set.
12081 Note - displaying this information disrupts the layout of the
12082 table being generated, but for the moment this case is very rare. */
12083 if (psym
->st_other
^ vis
)
12084 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12086 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12087 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
12089 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12092 = get_symbol_version_string (filedata
,
12094 || section
->sh_type
== SHT_DYNSYM
),
12095 strtab
, strtab_size
, si
,
12096 psym
, &sym_info
, &vna_other
);
12097 if (version_string
)
12099 if (sym_info
== symbol_undefined
)
12100 printf ("@%s (%d)", version_string
, vna_other
);
12102 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12108 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12110 && si
>= section
->sh_info
12111 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12112 && filedata
->file_header
.e_machine
!= EM_MIPS
12113 /* Solaris binaries have been found to violate this requirement as
12114 well. Not sure if this is a bug or an ABI requirement. */
12115 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12116 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12117 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12120 /* Dump the symbol table. */
12122 process_symbol_table (Filedata
* filedata
)
12124 Elf_Internal_Shdr
* section
;
12126 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12129 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12131 && do_using_dynamic
12132 && filedata
->dynamic_strings
!= NULL
12133 && filedata
->dynamic_symbols
!= NULL
)
12137 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12138 "\nSymbol table for image contains %lu entries:\n",
12139 filedata
->num_dynamic_syms
),
12140 filedata
->num_dynamic_syms
);
12142 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12144 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12146 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12147 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12148 filedata
->dynamic_strings
,
12149 filedata
->dynamic_strings_length
);
12151 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12152 && filedata
->section_headers
!= NULL
)
12156 for (i
= 0, section
= filedata
->section_headers
;
12157 i
< filedata
->file_header
.e_shnum
;
12160 char * strtab
= NULL
;
12161 unsigned long int strtab_size
= 0;
12162 Elf_Internal_Sym
* symtab
;
12163 unsigned long si
, num_syms
;
12165 if ((section
->sh_type
!= SHT_SYMTAB
12166 && section
->sh_type
!= SHT_DYNSYM
)
12168 && section
->sh_type
== SHT_SYMTAB
))
12171 if (section
->sh_entsize
== 0)
12173 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12174 printable_section_name (filedata
, section
));
12178 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12179 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12180 "\nSymbol table '%s' contains %lu entries:\n",
12182 printable_section_name (filedata
, section
),
12186 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12188 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12190 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12191 if (symtab
== NULL
)
12194 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12196 strtab
= filedata
->string_table
;
12197 strtab_size
= filedata
->string_table_length
;
12199 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12201 Elf_Internal_Shdr
* string_sec
;
12203 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12205 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12206 1, string_sec
->sh_size
,
12207 _("string table"));
12208 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12211 for (si
= 0; si
< num_syms
; si
++)
12212 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12213 strtab
, strtab_size
);
12216 if (strtab
!= filedata
->string_table
)
12222 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12224 if (do_histogram
&& filedata
->buckets
!= NULL
)
12226 unsigned long * lengths
;
12227 unsigned long * counts
;
12230 unsigned long maxlength
= 0;
12231 unsigned long nzero_counts
= 0;
12232 unsigned long nsyms
= 0;
12235 printf (ngettext ("\nHistogram for bucket list length "
12236 "(total of %lu bucket):\n",
12237 "\nHistogram for bucket list length "
12238 "(total of %lu buckets):\n",
12239 (unsigned long) filedata
->nbuckets
),
12240 (unsigned long) filedata
->nbuckets
);
12242 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12243 sizeof (*lengths
));
12244 if (lengths
== NULL
)
12246 error (_("Out of memory allocating space for histogram buckets\n"));
12249 visited
= xcmalloc (filedata
->nchains
, 1);
12250 memset (visited
, 0, filedata
->nchains
);
12252 printf (_(" Length Number %% of total Coverage\n"));
12253 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12255 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12258 if (maxlength
< ++lengths
[hn
])
12260 if (si
>= filedata
->nchains
|| visited
[si
])
12262 error (_("histogram chain is corrupt\n"));
12270 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12271 if (counts
== NULL
)
12274 error (_("Out of memory allocating space for histogram counts\n"));
12278 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12279 ++counts
[lengths
[hn
]];
12281 if (filedata
->nbuckets
> 0)
12284 printf (" 0 %-10lu (%5.1f%%)\n",
12285 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12286 for (i
= 1; i
<= maxlength
; ++i
)
12288 nzero_counts
+= counts
[i
] * i
;
12289 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12290 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12291 (nzero_counts
* 100.0) / nsyms
);
12299 free (filedata
->buckets
);
12300 filedata
->buckets
= NULL
;
12301 filedata
->nbuckets
= 0;
12302 free (filedata
->chains
);
12303 filedata
->chains
= NULL
;
12305 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12307 unsigned long * lengths
;
12308 unsigned long * counts
;
12310 unsigned long maxlength
= 0;
12311 unsigned long nzero_counts
= 0;
12312 unsigned long nsyms
= 0;
12314 printf (ngettext ("\nHistogram for `%s' bucket list length "
12315 "(total of %lu bucket):\n",
12316 "\nHistogram for `%s' bucket list length "
12317 "(total of %lu buckets):\n",
12318 (unsigned long) filedata
->ngnubuckets
),
12319 GNU_HASH_SECTION_NAME (filedata
),
12320 (unsigned long) filedata
->ngnubuckets
);
12322 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12323 sizeof (*lengths
));
12324 if (lengths
== NULL
)
12326 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12330 printf (_(" Length Number %% of total Coverage\n"));
12332 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12333 if (filedata
->gnubuckets
[hn
] != 0)
12335 bfd_vma off
, length
= 1;
12337 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12338 /* PR 17531 file: 010-77222-0.004. */
12339 off
< filedata
->ngnuchains
12340 && (filedata
->gnuchains
[off
] & 1) == 0;
12343 lengths
[hn
] = length
;
12344 if (length
> maxlength
)
12345 maxlength
= length
;
12349 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12350 if (counts
== NULL
)
12353 error (_("Out of memory allocating space for gnu histogram counts\n"));
12357 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12358 ++counts
[lengths
[hn
]];
12360 if (filedata
->ngnubuckets
> 0)
12363 printf (" 0 %-10lu (%5.1f%%)\n",
12364 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12365 for (j
= 1; j
<= maxlength
; ++j
)
12367 nzero_counts
+= counts
[j
] * j
;
12368 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12369 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12370 (nzero_counts
* 100.0) / nsyms
);
12377 free (filedata
->gnubuckets
);
12378 filedata
->gnubuckets
= NULL
;
12379 filedata
->ngnubuckets
= 0;
12380 free (filedata
->gnuchains
);
12381 filedata
->gnuchains
= NULL
;
12382 filedata
->ngnuchains
= 0;
12383 free (filedata
->mipsxlat
);
12384 filedata
->mipsxlat
= NULL
;
12388 free (filedata
->gnubuckets
);
12389 filedata
->gnubuckets
= NULL
;
12390 filedata
->ngnubuckets
= 0;
12391 free (filedata
->gnuchains
);
12392 filedata
->gnuchains
= NULL
;
12393 filedata
->ngnuchains
= 0;
12394 free (filedata
->mipsxlat
);
12395 filedata
->mipsxlat
= NULL
;
12396 free (filedata
->buckets
);
12397 filedata
->buckets
= NULL
;
12398 filedata
->nbuckets
= 0;
12399 free (filedata
->chains
);
12400 filedata
->chains
= NULL
;
12405 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12409 if (filedata
->dynamic_syminfo
== NULL
12411 /* No syminfo, this is ok. */
12414 /* There better should be a dynamic symbol section. */
12415 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12418 if (filedata
->dynamic_addr
)
12419 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12420 "contains %d entry:\n",
12421 "\nDynamic info segment at offset 0x%lx "
12422 "contains %d entries:\n",
12423 filedata
->dynamic_syminfo_nent
),
12424 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12426 printf (_(" Num: Name BoundTo Flags\n"));
12427 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12429 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12431 printf ("%4d: ", i
);
12432 if (i
>= filedata
->num_dynamic_syms
)
12433 printf (_("<corrupt index>"));
12434 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12435 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12436 filedata
->dynamic_symbols
[i
].st_name
));
12438 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12441 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12443 case SYMINFO_BT_SELF
:
12444 fputs ("SELF ", stdout
);
12446 case SYMINFO_BT_PARENT
:
12447 fputs ("PARENT ", stdout
);
12450 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12451 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12452 && VALID_DYNAMIC_NAME (filedata
,
12453 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12455 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12456 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12460 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12464 if (flags
& SYMINFO_FLG_DIRECT
)
12465 printf (" DIRECT");
12466 if (flags
& SYMINFO_FLG_PASSTHRU
)
12467 printf (" PASSTHRU");
12468 if (flags
& SYMINFO_FLG_COPY
)
12470 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12471 printf (" LAZYLOAD");
12479 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12480 is contained by the region START .. END. The types of ADDR, START
12481 and END should all be the same. Note both ADDR + NELEM and END
12482 point to just beyond the end of the regions that are being tested. */
12483 #define IN_RANGE(START,END,ADDR,NELEM) \
12484 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12486 /* Check to see if the given reloc needs to be handled in a target specific
12487 manner. If so then process the reloc and return TRUE otherwise return
12490 If called with reloc == NULL, then this is a signal that reloc processing
12491 for the current section has finished, and any saved state should be
12495 target_specific_reloc_handling (Filedata
* filedata
,
12496 Elf_Internal_Rela
* reloc
,
12497 unsigned char * start
,
12498 unsigned char * end
,
12499 Elf_Internal_Sym
* symtab
,
12500 unsigned long num_syms
)
12502 unsigned int reloc_type
= 0;
12503 unsigned long sym_index
= 0;
12507 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12508 sym_index
= get_reloc_symindex (reloc
->r_info
);
12511 switch (filedata
->file_header
.e_machine
)
12514 case EM_MSP430_OLD
:
12516 static Elf_Internal_Sym
* saved_sym
= NULL
;
12524 switch (reloc_type
)
12526 case 10: /* R_MSP430_SYM_DIFF */
12527 if (uses_msp430x_relocs (filedata
))
12529 /* Fall through. */
12530 case 21: /* R_MSP430X_SYM_DIFF */
12532 if (sym_index
>= num_syms
)
12533 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12536 saved_sym
= symtab
+ sym_index
;
12539 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12540 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12541 goto handle_sym_diff
;
12543 case 5: /* R_MSP430_16_BYTE */
12544 case 9: /* R_MSP430_8 */
12545 if (uses_msp430x_relocs (filedata
))
12547 goto handle_sym_diff
;
12549 case 2: /* R_MSP430_ABS16 */
12550 case 15: /* R_MSP430X_ABS16 */
12551 if (! uses_msp430x_relocs (filedata
))
12553 goto handle_sym_diff
;
12556 if (saved_sym
!= NULL
)
12558 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12561 if (sym_index
>= num_syms
)
12562 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12566 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12567 - saved_sym
->st_value
);
12569 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12570 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12573 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12574 (long) reloc
->r_offset
);
12583 if (saved_sym
!= NULL
)
12584 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12591 case EM_CYGNUS_MN10300
:
12593 static Elf_Internal_Sym
* saved_sym
= NULL
;
12601 switch (reloc_type
)
12603 case 34: /* R_MN10300_ALIGN */
12605 case 33: /* R_MN10300_SYM_DIFF */
12606 if (sym_index
>= num_syms
)
12607 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12610 saved_sym
= symtab
+ sym_index
;
12613 case 1: /* R_MN10300_32 */
12614 case 2: /* R_MN10300_16 */
12615 if (saved_sym
!= NULL
)
12617 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12620 if (sym_index
>= num_syms
)
12621 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12625 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12626 - saved_sym
->st_value
);
12628 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12629 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12631 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12632 (long) reloc
->r_offset
);
12640 if (saved_sym
!= NULL
)
12641 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12649 static bfd_vma saved_sym1
= 0;
12650 static bfd_vma saved_sym2
= 0;
12651 static bfd_vma value
;
12655 saved_sym1
= saved_sym2
= 0;
12659 switch (reloc_type
)
12661 case 0x80: /* R_RL78_SYM. */
12662 saved_sym1
= saved_sym2
;
12663 if (sym_index
>= num_syms
)
12664 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12668 saved_sym2
= symtab
[sym_index
].st_value
;
12669 saved_sym2
+= reloc
->r_addend
;
12673 case 0x83: /* R_RL78_OPsub. */
12674 value
= saved_sym1
- saved_sym2
;
12675 saved_sym2
= saved_sym1
= 0;
12679 case 0x41: /* R_RL78_ABS32. */
12680 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12681 byte_put (start
+ reloc
->r_offset
, value
, 4);
12683 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12684 (long) reloc
->r_offset
);
12688 case 0x43: /* R_RL78_ABS16. */
12689 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12690 byte_put (start
+ reloc
->r_offset
, value
, 2);
12692 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12693 (long) reloc
->r_offset
);
12707 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12708 DWARF debug sections. This is a target specific test. Note - we do not
12709 go through the whole including-target-headers-multiple-times route, (as
12710 we have already done with <elf/h8.h>) because this would become very
12711 messy and even then this function would have to contain target specific
12712 information (the names of the relocs instead of their numeric values).
12713 FIXME: This is not the correct way to solve this problem. The proper way
12714 is to have target specific reloc sizing and typing functions created by
12715 the reloc-macros.h header, in the same way that it already creates the
12716 reloc naming functions. */
12719 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12721 /* Please keep this table alpha-sorted for ease of visual lookup. */
12722 switch (filedata
->file_header
.e_machine
)
12726 return reloc_type
== 1; /* R_386_32. */
12728 return reloc_type
== 1; /* R_68K_32. */
12730 return reloc_type
== 1; /* R_860_32. */
12732 return reloc_type
== 2; /* R_960_32. */
12734 return (reloc_type
== 258
12735 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12737 return reloc_type
== 11; /* R_BPF_DATA_32 */
12738 case EM_ADAPTEVA_EPIPHANY
:
12739 return reloc_type
== 3;
12741 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12743 return reloc_type
== 1; /* R_ARC_32. */
12744 case EM_ARC_COMPACT
:
12745 case EM_ARC_COMPACT2
:
12746 return reloc_type
== 4; /* R_ARC_32. */
12748 return reloc_type
== 2; /* R_ARM_ABS32 */
12751 return reloc_type
== 1;
12753 return reloc_type
== 0x12; /* R_byte4_data. */
12755 return reloc_type
== 3; /* R_CRIS_32. */
12757 return reloc_type
== 3; /* R_CR16_NUM32. */
12759 return reloc_type
== 15; /* R_CRX_NUM32. */
12761 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12762 case EM_CYGNUS_FRV
:
12763 return reloc_type
== 1;
12764 case EM_CYGNUS_D10V
:
12766 return reloc_type
== 6; /* R_D10V_32. */
12767 case EM_CYGNUS_D30V
:
12769 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12771 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12772 case EM_CYGNUS_FR30
:
12774 return reloc_type
== 3; /* R_FR30_32. */
12776 return reloc_type
== 1; /* R_FT32_32. */
12780 return reloc_type
== 1; /* R_H8_DIR32. */
12782 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12783 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12784 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12785 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12788 return reloc_type
== 2; /* R_IP2K_32. */
12790 return reloc_type
== 2; /* R_IQ2000_32. */
12791 case EM_LATTICEMICO32
:
12792 return reloc_type
== 3; /* R_LM32_32. */
12795 return reloc_type
== 3; /* R_M32C_32. */
12797 return reloc_type
== 34; /* R_M32R_32_RELA. */
12800 return reloc_type
== 6; /* R_M68HC11_32. */
12802 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12803 reloc_type
== 6; /* R_S12Z_CW32. */
12805 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12806 case EM_CYGNUS_MEP
:
12807 return reloc_type
== 4; /* R_MEP_32. */
12809 return reloc_type
== 2; /* R_METAG_ADDR32. */
12810 case EM_MICROBLAZE
:
12811 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12813 return reloc_type
== 2; /* R_MIPS_32. */
12815 return reloc_type
== 4; /* R_MMIX_32. */
12816 case EM_CYGNUS_MN10200
:
12818 return reloc_type
== 1; /* R_MN10200_32. */
12819 case EM_CYGNUS_MN10300
:
12821 return reloc_type
== 1; /* R_MN10300_32. */
12823 return reloc_type
== 1; /* R_MOXIE_32. */
12824 case EM_MSP430_OLD
:
12826 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12828 return reloc_type
== 2; /* R_MT_32. */
12830 return reloc_type
== 20; /* R_NDS32_RELA. */
12831 case EM_ALTERA_NIOS2
:
12832 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12834 return reloc_type
== 1; /* R_NIOS_32. */
12836 return reloc_type
== 1; /* R_OR1K_32. */
12838 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12839 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12840 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12843 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12845 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12847 return reloc_type
== 1; /* R_PPC_ADDR32. */
12849 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12851 return reloc_type
== 1; /* R_RISCV_32. */
12853 return reloc_type
== 1; /* R_RL78_DIR32. */
12855 return reloc_type
== 1; /* R_RX_DIR32. */
12857 return reloc_type
== 1; /* R_I370_ADDR31. */
12860 return reloc_type
== 4; /* R_S390_32. */
12862 return reloc_type
== 8; /* R_SCORE_ABS32. */
12864 return reloc_type
== 1; /* R_SH_DIR32. */
12865 case EM_SPARC32PLUS
:
12868 return reloc_type
== 3 /* R_SPARC_32. */
12869 || reloc_type
== 23; /* R_SPARC_UA32. */
12871 return reloc_type
== 6; /* R_SPU_ADDR32 */
12873 return reloc_type
== 1; /* R_C6000_ABS32. */
12875 return reloc_type
== 2; /* R_TILEGX_32. */
12877 return reloc_type
== 1; /* R_TILEPRO_32. */
12878 case EM_CYGNUS_V850
:
12880 return reloc_type
== 6; /* R_V850_ABS32. */
12882 return reloc_type
== 0x33; /* R_V810_WORD. */
12884 return reloc_type
== 1; /* R_VAX_32. */
12886 return reloc_type
== 3; /* R_VISIUM_32. */
12887 case EM_WEBASSEMBLY
:
12888 return reloc_type
== 1; /* R_WASM32_32. */
12892 return reloc_type
== 10; /* R_X86_64_32. */
12895 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12897 return reloc_type
== 4; /* R_XGATE_32. */
12899 return reloc_type
== 1; /* R_XSTROMY16_32. */
12900 case EM_XTENSA_OLD
:
12902 return reloc_type
== 1; /* R_XTENSA_32. */
12904 return reloc_type
== 6; /* R_Z80_32. */
12907 static unsigned int prev_warn
= 0;
12909 /* Avoid repeating the same warning multiple times. */
12910 if (prev_warn
!= filedata
->file_header
.e_machine
)
12911 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12912 filedata
->file_header
.e_machine
);
12913 prev_warn
= filedata
->file_header
.e_machine
;
12919 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12920 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12923 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12925 switch (filedata
->file_header
.e_machine
)
12926 /* Please keep this table alpha-sorted for ease of visual lookup. */
12930 return reloc_type
== 2; /* R_386_PC32. */
12932 return reloc_type
== 4; /* R_68K_PC32. */
12934 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12935 case EM_ADAPTEVA_EPIPHANY
:
12936 return reloc_type
== 6;
12938 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12939 case EM_ARC_COMPACT
:
12940 case EM_ARC_COMPACT2
:
12941 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12943 return reloc_type
== 3; /* R_ARM_REL32 */
12946 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12947 case EM_MICROBLAZE
:
12948 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12950 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12952 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12954 return reloc_type
== 26; /* R_PPC_REL32. */
12956 return reloc_type
== 26; /* R_PPC64_REL32. */
12958 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12961 return reloc_type
== 5; /* R_390_PC32. */
12963 return reloc_type
== 2; /* R_SH_REL32. */
12964 case EM_SPARC32PLUS
:
12967 return reloc_type
== 6; /* R_SPARC_DISP32. */
12969 return reloc_type
== 13; /* R_SPU_REL32. */
12971 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12973 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12975 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12979 return reloc_type
== 2; /* R_X86_64_PC32. */
12981 return reloc_type
== 4; /* R_VAX_PCREL32. */
12982 case EM_XTENSA_OLD
:
12984 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12986 /* Do not abort or issue an error message here. Not all targets use
12987 pc-relative 32-bit relocs in their DWARF debug information and we
12988 have already tested for target coverage in is_32bit_abs_reloc. A
12989 more helpful warning message will be generated by apply_relocations
12990 anyway, so just return. */
12995 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12996 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12999 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13001 switch (filedata
->file_header
.e_machine
)
13004 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13006 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13008 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13009 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13011 return reloc_type
== 80; /* R_PARISC_DIR64. */
13013 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13015 return reloc_type
== 2; /* R_RISCV_64. */
13016 case EM_SPARC32PLUS
:
13019 return reloc_type
== 32 /* R_SPARC_64. */
13020 || reloc_type
== 54; /* R_SPARC_UA64. */
13024 return reloc_type
== 1; /* R_X86_64_64. */
13027 return reloc_type
== 22; /* R_S390_64. */
13029 return reloc_type
== 1; /* R_TILEGX_64. */
13031 return reloc_type
== 18; /* R_MIPS_64. */
13037 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13038 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13041 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13043 switch (filedata
->file_header
.e_machine
)
13046 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13048 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13050 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13051 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13053 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13055 return reloc_type
== 44; /* R_PPC64_REL64. */
13056 case EM_SPARC32PLUS
:
13059 return reloc_type
== 46; /* R_SPARC_DISP64. */
13063 return reloc_type
== 24; /* R_X86_64_PC64. */
13066 return reloc_type
== 23; /* R_S390_PC64. */
13068 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13074 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13075 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13078 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13080 switch (filedata
->file_header
.e_machine
)
13082 case EM_CYGNUS_MN10200
:
13084 return reloc_type
== 4; /* R_MN10200_24. */
13086 return reloc_type
== 5; /* R_FT32_20. */
13088 return reloc_type
== 5; /* R_Z80_24. */
13094 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13095 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13098 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13100 /* Please keep this table alpha-sorted for ease of visual lookup. */
13101 switch (filedata
->file_header
.e_machine
)
13104 case EM_ARC_COMPACT
:
13105 case EM_ARC_COMPACT2
:
13106 return reloc_type
== 2; /* R_ARC_16. */
13107 case EM_ADAPTEVA_EPIPHANY
:
13108 return reloc_type
== 5;
13111 return reloc_type
== 4; /* R_AVR_16. */
13112 case EM_CYGNUS_D10V
:
13114 return reloc_type
== 3; /* R_D10V_16. */
13116 return reloc_type
== 2; /* R_FT32_16. */
13120 return reloc_type
== R_H8_DIR16
;
13123 return reloc_type
== 1; /* R_IP2K_16. */
13126 return reloc_type
== 1; /* R_M32C_16 */
13127 case EM_CYGNUS_MN10200
:
13129 return reloc_type
== 2; /* R_MN10200_16. */
13130 case EM_CYGNUS_MN10300
:
13132 return reloc_type
== 2; /* R_MN10300_16. */
13134 if (uses_msp430x_relocs (filedata
))
13135 return reloc_type
== 2; /* R_MSP430_ABS16. */
13136 /* Fall through. */
13137 case EM_MSP430_OLD
:
13138 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13140 return reloc_type
== 19; /* R_NDS32_RELA. */
13141 case EM_ALTERA_NIOS2
:
13142 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13144 return reloc_type
== 9; /* R_NIOS_16. */
13146 return reloc_type
== 2; /* R_OR1K_16. */
13148 return reloc_type
== 55; /* R_RISCV_SET16. */
13150 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13152 return reloc_type
== 2; /* R_C6000_ABS16. */
13154 return reloc_type
== 2; /* R_VISIUM_16. */
13157 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13159 return reloc_type
== 3; /* R_XGATE_16. */
13161 return reloc_type
== 4; /* R_Z80_16. */
13167 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13168 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13171 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13173 switch (filedata
->file_header
.e_machine
)
13176 return reloc_type
== 54; /* R_RISCV_SET8. */
13178 return reloc_type
== 1; /* R_Z80_8. */
13184 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13185 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13188 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13190 switch (filedata
->file_header
.e_machine
)
13193 return reloc_type
== 53; /* R_RISCV_SET6. */
13199 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13200 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13203 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13205 /* Please keep this table alpha-sorted for ease of visual lookup. */
13206 switch (filedata
->file_header
.e_machine
)
13209 return reloc_type
== 35; /* R_RISCV_ADD32. */
13215 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13216 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13219 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13221 /* Please keep this table alpha-sorted for ease of visual lookup. */
13222 switch (filedata
->file_header
.e_machine
)
13225 return reloc_type
== 39; /* R_RISCV_SUB32. */
13231 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13232 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13235 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13237 /* Please keep this table alpha-sorted for ease of visual lookup. */
13238 switch (filedata
->file_header
.e_machine
)
13241 return reloc_type
== 36; /* R_RISCV_ADD64. */
13247 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13248 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13251 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13253 /* Please keep this table alpha-sorted for ease of visual lookup. */
13254 switch (filedata
->file_header
.e_machine
)
13257 return reloc_type
== 40; /* R_RISCV_SUB64. */
13263 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13264 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13267 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13269 /* Please keep this table alpha-sorted for ease of visual lookup. */
13270 switch (filedata
->file_header
.e_machine
)
13273 return reloc_type
== 34; /* R_RISCV_ADD16. */
13279 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13280 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13283 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13285 /* Please keep this table alpha-sorted for ease of visual lookup. */
13286 switch (filedata
->file_header
.e_machine
)
13289 return reloc_type
== 38; /* R_RISCV_SUB16. */
13295 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13296 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13299 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13301 /* Please keep this table alpha-sorted for ease of visual lookup. */
13302 switch (filedata
->file_header
.e_machine
)
13305 return reloc_type
== 33; /* R_RISCV_ADD8. */
13311 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13312 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13315 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13317 /* Please keep this table alpha-sorted for ease of visual lookup. */
13318 switch (filedata
->file_header
.e_machine
)
13321 return reloc_type
== 37; /* R_RISCV_SUB8. */
13327 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13328 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13331 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13333 switch (filedata
->file_header
.e_machine
)
13336 return reloc_type
== 52; /* R_RISCV_SUB6. */
13342 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13343 relocation entries (possibly formerly used for SHT_GROUP sections). */
13346 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13348 switch (filedata
->file_header
.e_machine
)
13350 case EM_386
: /* R_386_NONE. */
13351 case EM_68K
: /* R_68K_NONE. */
13352 case EM_ADAPTEVA_EPIPHANY
:
13353 case EM_ALPHA
: /* R_ALPHA_NONE. */
13354 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13355 case EM_ARC
: /* R_ARC_NONE. */
13356 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13357 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13358 case EM_ARM
: /* R_ARM_NONE. */
13359 case EM_C166
: /* R_XC16X_NONE. */
13360 case EM_CRIS
: /* R_CRIS_NONE. */
13361 case EM_FT32
: /* R_FT32_NONE. */
13362 case EM_IA_64
: /* R_IA64_NONE. */
13363 case EM_K1OM
: /* R_X86_64_NONE. */
13364 case EM_L1OM
: /* R_X86_64_NONE. */
13365 case EM_M32R
: /* R_M32R_NONE. */
13366 case EM_MIPS
: /* R_MIPS_NONE. */
13367 case EM_MN10300
: /* R_MN10300_NONE. */
13368 case EM_MOXIE
: /* R_MOXIE_NONE. */
13369 case EM_NIOS32
: /* R_NIOS_NONE. */
13370 case EM_OR1K
: /* R_OR1K_NONE. */
13371 case EM_PARISC
: /* R_PARISC_NONE. */
13372 case EM_PPC64
: /* R_PPC64_NONE. */
13373 case EM_PPC
: /* R_PPC_NONE. */
13374 case EM_RISCV
: /* R_RISCV_NONE. */
13375 case EM_S390
: /* R_390_NONE. */
13377 case EM_SH
: /* R_SH_NONE. */
13378 case EM_SPARC32PLUS
:
13379 case EM_SPARC
: /* R_SPARC_NONE. */
13381 case EM_TILEGX
: /* R_TILEGX_NONE. */
13382 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13383 case EM_TI_C6000
:/* R_C6000_NONE. */
13384 case EM_X86_64
: /* R_X86_64_NONE. */
13386 case EM_Z80
: /* R_Z80_NONE. */
13387 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13388 return reloc_type
== 0;
13391 return reloc_type
== 0 || reloc_type
== 256;
13394 return (reloc_type
== 0 /* R_AVR_NONE. */
13395 || reloc_type
== 30 /* R_AVR_DIFF8. */
13396 || reloc_type
== 31 /* R_AVR_DIFF16. */
13397 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13399 return reloc_type
== 3; /* R_METAG_NONE. */
13401 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13402 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13403 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13404 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13405 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13407 return (reloc_type
== 0 /* R_PRU_NONE. */
13408 || reloc_type
== 65 /* R_PRU_DIFF8. */
13409 || reloc_type
== 66 /* R_PRU_DIFF16. */
13410 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13411 case EM_XTENSA_OLD
:
13413 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13414 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13415 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13416 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13417 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13418 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13419 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13420 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13421 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13422 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13427 /* Returns TRUE if there is a relocation against
13428 section NAME at OFFSET bytes. */
13431 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13433 Elf_Internal_Rela
* relocs
;
13434 Elf_Internal_Rela
* rp
;
13436 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13439 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13441 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13442 if (rp
->r_offset
== offset
)
13448 /* Apply relocations to a section.
13449 Returns TRUE upon success, FALSE otherwise.
13450 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13451 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13452 will be set to the number of relocs loaded.
13454 Note: So far support has been added only for those relocations
13455 which can be found in debug sections. FIXME: Add support for
13456 more relocations ? */
13459 apply_relocations (Filedata
* filedata
,
13460 const Elf_Internal_Shdr
* section
,
13461 unsigned char * start
,
13462 bfd_size_type size
,
13463 void ** relocs_return
,
13464 unsigned long * num_relocs_return
)
13466 Elf_Internal_Shdr
* relsec
;
13467 unsigned char * end
= start
+ size
;
13469 if (relocs_return
!= NULL
)
13471 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13472 * num_relocs_return
= 0;
13475 if (filedata
->file_header
.e_type
!= ET_REL
)
13476 /* No relocs to apply. */
13479 /* Find the reloc section associated with the section. */
13480 for (relsec
= filedata
->section_headers
;
13481 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13484 bfd_boolean is_rela
;
13485 unsigned long num_relocs
;
13486 Elf_Internal_Rela
* relocs
;
13487 Elf_Internal_Rela
* rp
;
13488 Elf_Internal_Shdr
* symsec
;
13489 Elf_Internal_Sym
* symtab
;
13490 unsigned long num_syms
;
13491 Elf_Internal_Sym
* sym
;
13493 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13494 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13495 || filedata
->section_headers
+ relsec
->sh_info
!= section
13496 || relsec
->sh_size
== 0
13497 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13500 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13501 if (symsec
->sh_type
!= SHT_SYMTAB
13502 && symsec
->sh_type
!= SHT_DYNSYM
)
13505 is_rela
= relsec
->sh_type
== SHT_RELA
;
13509 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13510 relsec
->sh_size
, & relocs
, & num_relocs
))
13515 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13516 relsec
->sh_size
, & relocs
, & num_relocs
))
13520 /* SH uses RELA but uses in place value instead of the addend field. */
13521 if (filedata
->file_header
.e_machine
== EM_SH
)
13524 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13526 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13529 unsigned int reloc_type
;
13530 unsigned int reloc_size
;
13531 bfd_boolean reloc_inplace
= FALSE
;
13532 bfd_boolean reloc_subtract
= FALSE
;
13533 unsigned char * rloc
;
13534 unsigned long sym_index
;
13536 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13538 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13540 else if (is_none_reloc (filedata
, reloc_type
))
13542 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13543 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13545 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13546 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13548 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13550 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13552 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13553 || is_6bit_abs_reloc (filedata
, reloc_type
))
13555 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13557 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13560 reloc_inplace
= TRUE
;
13562 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13564 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13567 reloc_inplace
= TRUE
;
13569 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13571 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13574 reloc_inplace
= TRUE
;
13576 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13578 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13581 reloc_inplace
= TRUE
;
13583 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13587 reloc_inplace
= TRUE
;
13591 static unsigned int prev_reloc
= 0;
13593 if (reloc_type
!= prev_reloc
)
13594 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13595 reloc_type
, printable_section_name (filedata
, section
));
13596 prev_reloc
= reloc_type
;
13600 rloc
= start
+ rp
->r_offset
;
13601 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13603 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13604 (unsigned long) rp
->r_offset
,
13605 printable_section_name (filedata
, section
));
13609 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13610 if (sym_index
>= num_syms
)
13612 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13613 sym_index
, printable_section_name (filedata
, section
));
13616 sym
= symtab
+ sym_index
;
13618 /* If the reloc has a symbol associated with it,
13619 make sure that it is of an appropriate type.
13621 Relocations against symbols without type can happen.
13622 Gcc -feliminate-dwarf2-dups may generate symbols
13623 without type for debug info.
13625 Icc generates relocations against function symbols
13626 instead of local labels.
13628 Relocations against object symbols can happen, eg when
13629 referencing a global array. For an example of this see
13630 the _clz.o binary in libgcc.a. */
13632 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13633 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13635 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13636 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13637 printable_section_name (filedata
, relsec
),
13638 (long int)(rp
- relocs
));
13644 addend
+= rp
->r_addend
;
13645 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13646 partial_inplace. */
13648 || (filedata
->file_header
.e_machine
== EM_XTENSA
13649 && reloc_type
== 1)
13650 || ((filedata
->file_header
.e_machine
== EM_PJ
13651 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13652 && reloc_type
== 1)
13653 || ((filedata
->file_header
.e_machine
== EM_D30V
13654 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13655 && reloc_type
== 12)
13658 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13659 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13661 addend
+= byte_get (rloc
, reloc_size
);
13664 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13665 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13667 /* On HPPA, all pc-relative relocations are biased by 8. */
13668 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13670 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13673 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13674 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13676 if (reloc_subtract
)
13677 addend
-= sym
->st_value
;
13679 addend
+= sym
->st_value
;
13680 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13681 byte_put (rloc
, addend
, reloc_size
);
13683 else if (reloc_subtract
)
13684 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13686 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13690 /* Let the target specific reloc processing code know that
13691 we have finished with these relocs. */
13692 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13696 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13697 * num_relocs_return
= num_relocs
;
13708 #ifdef SUPPORT_DISASSEMBLY
13710 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13712 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13714 /* FIXME: XXX -- to be done --- XXX */
13720 /* Reads in the contents of SECTION from FILE, returning a pointer
13721 to a malloc'ed buffer or NULL if something went wrong. */
13724 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13726 bfd_size_type num_bytes
= section
->sh_size
;
13728 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13730 printf (_("Section '%s' has no data to dump.\n"),
13731 printable_section_name (filedata
, section
));
13735 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13736 _("section contents"));
13739 /* Uncompresses a section that was compressed using zlib, in place. */
13742 uncompress_section_contents (unsigned char ** buffer
,
13743 dwarf_size_type uncompressed_size
,
13744 dwarf_size_type
* size
)
13746 dwarf_size_type compressed_size
= *size
;
13747 unsigned char * compressed_buffer
= *buffer
;
13748 unsigned char * uncompressed_buffer
;
13752 /* It is possible the section consists of several compressed
13753 buffers concatenated together, so we uncompress in a loop. */
13754 /* PR 18313: The state field in the z_stream structure is supposed
13755 to be invisible to the user (ie us), but some compilers will
13756 still complain about it being used without initialisation. So
13757 we first zero the entire z_stream structure and then set the fields
13759 memset (& strm
, 0, sizeof strm
);
13760 strm
.avail_in
= compressed_size
;
13761 strm
.next_in
= (Bytef
*) compressed_buffer
;
13762 strm
.avail_out
= uncompressed_size
;
13763 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13765 rc
= inflateInit (& strm
);
13766 while (strm
.avail_in
> 0)
13770 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13771 + (uncompressed_size
- strm
.avail_out
));
13772 rc
= inflate (&strm
, Z_FINISH
);
13773 if (rc
!= Z_STREAM_END
)
13775 rc
= inflateReset (& strm
);
13777 rc
= inflateEnd (& strm
);
13779 || strm
.avail_out
!= 0)
13782 *buffer
= uncompressed_buffer
;
13783 *size
= uncompressed_size
;
13787 free (uncompressed_buffer
);
13788 /* Indicate decompression failure. */
13794 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13796 Elf_Internal_Shdr
* relsec
;
13797 bfd_size_type num_bytes
;
13798 unsigned char * data
;
13799 unsigned char * end
;
13800 unsigned char * real_start
;
13801 unsigned char * start
;
13802 bfd_boolean some_strings_shown
;
13804 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13806 /* PR 21820: Do not fail if the section was empty. */
13807 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13809 num_bytes
= section
->sh_size
;
13811 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13813 if (decompress_dumps
)
13815 dwarf_size_type new_size
= num_bytes
;
13816 dwarf_size_type uncompressed_size
= 0;
13818 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13820 Elf_Internal_Chdr chdr
;
13821 unsigned int compression_header_size
13822 = get_compression_header (& chdr
, (unsigned char *) start
,
13824 if (compression_header_size
== 0)
13825 /* An error message will have already been generated
13826 by get_compression_header. */
13829 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13831 warn (_("section '%s' has unsupported compress type: %d\n"),
13832 printable_section_name (filedata
, section
), chdr
.ch_type
);
13835 uncompressed_size
= chdr
.ch_size
;
13836 start
+= compression_header_size
;
13837 new_size
-= compression_header_size
;
13839 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13841 /* Read the zlib header. In this case, it should be "ZLIB"
13842 followed by the uncompressed section size, 8 bytes in
13843 big-endian order. */
13844 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13845 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13846 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13847 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13848 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13849 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13850 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13851 uncompressed_size
+= start
[11];
13856 if (uncompressed_size
)
13858 if (uncompress_section_contents (& start
,
13859 uncompressed_size
, & new_size
))
13860 num_bytes
= new_size
;
13863 error (_("Unable to decompress section %s\n"),
13864 printable_section_name (filedata
, section
));
13869 start
= real_start
;
13872 /* If the section being dumped has relocations against it the user might
13873 be expecting these relocations to have been applied. Check for this
13874 case and issue a warning message in order to avoid confusion.
13875 FIXME: Maybe we ought to have an option that dumps a section with
13876 relocs applied ? */
13877 for (relsec
= filedata
->section_headers
;
13878 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13881 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13882 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13883 || filedata
->section_headers
+ relsec
->sh_info
!= section
13884 || relsec
->sh_size
== 0
13885 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13888 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13893 end
= start
+ num_bytes
;
13894 some_strings_shown
= FALSE
;
13896 #ifdef HAVE_MBSTATE_T
13898 /* Initialise the multibyte conversion state. */
13899 memset (& state
, 0, sizeof (state
));
13902 bfd_boolean continuing
= FALSE
;
13906 while (!ISPRINT (* data
))
13907 if (++ data
>= end
)
13912 size_t maxlen
= end
- data
;
13917 continuing
= FALSE
;
13922 /* PR 11128: Use two separate invocations in order to work
13923 around bugs in the Solaris 8 implementation of printf. */
13924 printf (" [%6tx] ", data
- start
);
13926 printf (" [%6Ix] ", (size_t) (data
- start
));
13941 /* PR 25543: Treat new-lines as string-ending characters. */
13950 /* Do not print control characters directly as they can affect terminal
13951 settings. Such characters usually appear in the names generated
13952 by the assembler for local labels. */
13955 printf ("^%c", c
+ 0x40);
13957 else if (ISPRINT (c
))
13964 #ifdef HAVE_MBSTATE_T
13967 /* Let printf do the hard work of displaying multibyte characters. */
13968 printf ("%.1s", data
- 1);
13969 #ifdef HAVE_MBSTATE_T
13970 /* Try to find out how many bytes made up the character that was
13971 just printed. Advance the symbol pointer past the bytes that
13973 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13977 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13987 printf (_("<corrupt>\n"));
13990 some_strings_shown
= TRUE
;
13994 if (! some_strings_shown
)
13995 printf (_(" No strings found in this section."));
14008 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
14009 Filedata
* filedata
,
14010 bfd_boolean relocate
)
14012 Elf_Internal_Shdr
* relsec
;
14013 bfd_size_type bytes
;
14014 bfd_size_type section_size
;
14016 unsigned char * data
;
14017 unsigned char * real_start
;
14018 unsigned char * start
;
14020 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14022 /* PR 21820: Do not fail if the section was empty. */
14023 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14025 section_size
= section
->sh_size
;
14027 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
14029 if (decompress_dumps
)
14031 dwarf_size_type new_size
= section_size
;
14032 dwarf_size_type uncompressed_size
= 0;
14034 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14036 Elf_Internal_Chdr chdr
;
14037 unsigned int compression_header_size
14038 = get_compression_header (& chdr
, start
, section_size
);
14040 if (compression_header_size
== 0)
14041 /* An error message will have already been generated
14042 by get_compression_header. */
14045 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14047 warn (_("section '%s' has unsupported compress type: %d\n"),
14048 printable_section_name (filedata
, section
), chdr
.ch_type
);
14051 uncompressed_size
= chdr
.ch_size
;
14052 start
+= compression_header_size
;
14053 new_size
-= compression_header_size
;
14055 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14057 /* Read the zlib header. In this case, it should be "ZLIB"
14058 followed by the uncompressed section size, 8 bytes in
14059 big-endian order. */
14060 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14061 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14062 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14063 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14064 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14065 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14066 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14067 uncompressed_size
+= start
[11];
14072 if (uncompressed_size
)
14074 if (uncompress_section_contents (& start
, uncompressed_size
,
14077 section_size
= new_size
;
14081 error (_("Unable to decompress section %s\n"),
14082 printable_section_name (filedata
, section
));
14083 /* FIXME: Print the section anyway ? */
14088 start
= real_start
;
14093 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14098 /* If the section being dumped has relocations against it the user might
14099 be expecting these relocations to have been applied. Check for this
14100 case and issue a warning message in order to avoid confusion.
14101 FIXME: Maybe we ought to have an option that dumps a section with
14102 relocs applied ? */
14103 for (relsec
= filedata
->section_headers
;
14104 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14107 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14108 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14109 || filedata
->section_headers
+ relsec
->sh_info
!= section
14110 || relsec
->sh_size
== 0
14111 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14114 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14119 addr
= section
->sh_addr
;
14120 bytes
= section_size
;
14129 lbytes
= (bytes
> 16 ? 16 : bytes
);
14131 printf (" 0x%8.8lx ", (unsigned long) addr
);
14133 for (j
= 0; j
< 16; j
++)
14136 printf ("%2.2x", data
[j
]);
14144 for (j
= 0; j
< lbytes
; j
++)
14147 if (k
>= ' ' && k
< 0x7f)
14170 static ctf_sect_t
*
14171 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14173 buf
->cts_name
= SECTION_NAME (shdr
);
14174 buf
->cts_size
= shdr
->sh_size
;
14175 buf
->cts_entsize
= shdr
->sh_entsize
;
14180 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14181 it is passed, or a pointer to newly-allocated storage, in which case
14182 dump_ctf() will free it when it no longer needs it. */
14184 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14185 char *s
, void *arg
)
14187 const char *blanks
= arg
;
14190 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14196 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14198 Elf_Internal_Shdr
* parent_sec
= NULL
;
14199 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14200 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14201 void * data
= NULL
;
14202 void * symdata
= NULL
;
14203 void * strdata
= NULL
;
14204 void * parentdata
= NULL
;
14205 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14206 ctf_sect_t
* symsectp
= NULL
;
14207 ctf_sect_t
* strsectp
= NULL
;
14208 ctf_file_t
* ctf
= NULL
;
14209 ctf_file_t
* parent
= NULL
;
14211 const char *things
[] = {"Header", "Labels", "Data objects",
14212 "Function objects", "Variables", "Types", "Strings",
14214 const char **thing
;
14216 bfd_boolean ret
= FALSE
;
14219 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14220 data
= get_section_contents (section
, filedata
);
14221 ctfsect
.cts_data
= data
;
14223 if (!dump_ctf_symtab_name
)
14224 dump_ctf_symtab_name
= strdup (".symtab");
14226 if (!dump_ctf_strtab_name
)
14227 dump_ctf_strtab_name
= strdup (".strtab");
14229 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14231 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14233 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14236 if ((symdata
= (void *) get_data (NULL
, filedata
,
14237 symtab_sec
->sh_offset
, 1,
14238 symtab_sec
->sh_size
,
14239 _("symbols"))) == NULL
)
14241 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14242 symsect
.cts_data
= symdata
;
14244 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14246 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14248 error (_("No string table section named %s\n"),
14249 dump_ctf_strtab_name
);
14252 if ((strdata
= (void *) get_data (NULL
, filedata
,
14253 strtab_sec
->sh_offset
, 1,
14254 strtab_sec
->sh_size
,
14255 _("strings"))) == NULL
)
14257 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14258 strsect
.cts_data
= strdata
;
14260 if (dump_ctf_parent_name
)
14262 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14264 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14267 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14268 parent_sec
->sh_offset
, 1,
14269 parent_sec
->sh_size
,
14270 _("CTF parent"))) == NULL
)
14272 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14273 parentsect
.cts_data
= parentdata
;
14276 /* Load the CTF file and dump it. */
14278 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14280 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14286 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14288 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14292 ctf_import (ctf
, parent
);
14297 printf (_("\nDump of CTF section '%s':\n"),
14298 printable_section_name (filedata
, section
));
14300 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14302 ctf_dump_state_t
*s
= NULL
;
14305 printf ("\n %s:\n", *thing
);
14306 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14307 (void *) " ")) != NULL
)
14309 printf ("%s\n", item
);
14313 if (ctf_errno (ctf
))
14315 error (_("Iteration failed: %s, %s\n"), *thing
,
14316 ctf_errmsg (ctf_errno (ctf
)));
14322 ctf_file_close (ctf
);
14323 ctf_file_close (parent
);
14332 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14333 const Elf_Internal_Shdr
* sec
,
14336 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14338 Filedata
* filedata
= (Filedata
*) data
;
14340 if (section
->start
!= NULL
)
14342 /* If it is already loaded, do nothing. */
14343 if (streq (section
->filename
, filedata
->file_name
))
14345 free (section
->start
);
14348 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14349 section
->address
= sec
->sh_addr
;
14350 section
->user_data
= NULL
;
14351 section
->filename
= filedata
->file_name
;
14352 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14354 sec
->sh_size
, buf
);
14355 if (section
->start
== NULL
)
14359 unsigned char *start
= section
->start
;
14360 dwarf_size_type size
= sec
->sh_size
;
14361 dwarf_size_type uncompressed_size
= 0;
14363 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14365 Elf_Internal_Chdr chdr
;
14366 unsigned int compression_header_size
;
14368 if (size
< (is_32bit_elf
14369 ? sizeof (Elf32_External_Chdr
)
14370 : sizeof (Elf64_External_Chdr
)))
14372 warn (_("compressed section %s is too small to contain a compression header\n"),
14377 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14378 if (compression_header_size
== 0)
14379 /* An error message will have already been generated
14380 by get_compression_header. */
14383 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14385 warn (_("section '%s' has unsupported compress type: %d\n"),
14386 section
->name
, chdr
.ch_type
);
14389 uncompressed_size
= chdr
.ch_size
;
14390 start
+= compression_header_size
;
14391 size
-= compression_header_size
;
14393 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14395 /* Read the zlib header. In this case, it should be "ZLIB"
14396 followed by the uncompressed section size, 8 bytes in
14397 big-endian order. */
14398 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14399 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14400 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14401 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14402 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14403 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14404 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14405 uncompressed_size
+= start
[11];
14410 if (uncompressed_size
)
14412 if (uncompress_section_contents (&start
, uncompressed_size
,
14415 /* Free the compressed buffer, update the section buffer
14416 and the section size if uncompress is successful. */
14417 free (section
->start
);
14418 section
->start
= start
;
14422 error (_("Unable to decompress section %s\n"),
14423 printable_section_name (filedata
, sec
));
14428 section
->size
= size
;
14431 if (section
->start
== NULL
)
14434 if (debug_displays
[debug
].relocate
)
14436 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14437 & section
->reloc_info
, & section
->num_relocs
))
14442 section
->reloc_info
= NULL
;
14443 section
->num_relocs
= 0;
14449 #if HAVE_LIBDEBUGINFOD
14450 /* Return a hex string representation of the build-id. */
14452 get_build_id (void * data
)
14454 Filedata
* filedata
= (Filedata
*)data
;
14455 Elf_Internal_Shdr
* shdr
;
14458 /* Iterate through notes to find note.gnu.build-id.
14459 FIXME: Only the first note in any note section is examined. */
14460 for (i
= 0, shdr
= filedata
->section_headers
;
14461 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14464 if (shdr
->sh_type
!= SHT_NOTE
)
14469 size_t data_remaining
;
14471 Elf_External_Note
* enote
;
14472 Elf_Internal_Note inote
;
14474 bfd_vma offset
= shdr
->sh_offset
;
14475 bfd_vma align
= shdr
->sh_addralign
;
14476 bfd_vma length
= shdr
->sh_size
;
14478 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14484 else if (align
!= 4 && align
!= 8)
14490 end
= (char *) enote
+ length
;
14491 data_remaining
= end
- (char *) enote
;
14493 if (!is_ia64_vms (filedata
))
14495 min_notesz
= offsetof (Elf_External_Note
, name
);
14496 if (data_remaining
< min_notesz
)
14499 malformed note encountered in section %s whilst scanning for build-id note\n"),
14500 printable_section_name (filedata
, shdr
));
14504 data_remaining
-= min_notesz
;
14506 inote
.type
= BYTE_GET (enote
->type
);
14507 inote
.namesz
= BYTE_GET (enote
->namesz
);
14508 inote
.namedata
= enote
->name
;
14509 inote
.descsz
= BYTE_GET (enote
->descsz
);
14510 inote
.descdata
= ((char *) enote
14511 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14512 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14513 next
= ((char *) enote
14514 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14518 Elf64_External_VMS_Note
*vms_enote
;
14520 /* PR binutils/15191
14521 Make sure that there is enough data to read. */
14522 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14523 if (data_remaining
< min_notesz
)
14526 malformed note encountered in section %s whilst scanning for build-id note\n"),
14527 printable_section_name (filedata
, shdr
));
14531 data_remaining
-= min_notesz
;
14533 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14534 inote
.type
= BYTE_GET (vms_enote
->type
);
14535 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14536 inote
.namedata
= vms_enote
->name
;
14537 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14538 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14539 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14540 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14543 /* Skip malformed notes. */
14544 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14545 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14546 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14547 || ((size_t) (next
- inote
.descdata
)
14548 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14551 malformed note encountered in section %s whilst scanning for build-id note\n"),
14552 printable_section_name (filedata
, shdr
));
14557 /* Check if this is the build-id note. If so then convert the build-id
14558 bytes to a hex string. */
14559 if (inote
.namesz
> 0
14560 && const_strneq (inote
.namedata
, "GNU")
14561 && inote
.type
== NT_GNU_BUILD_ID
)
14566 build_id
= malloc (inote
.descsz
* 2 + 1);
14567 if (build_id
== NULL
)
14573 for (j
= 0; j
< inote
.descsz
; ++j
)
14574 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14575 build_id
[inote
.descsz
* 2] = '\0';
14578 return (unsigned char *) build_id
;
14585 #endif /* HAVE_LIBDEBUGINFOD */
14587 /* If this is not NULL, load_debug_section will only look for sections
14588 within the list of sections given here. */
14589 static unsigned int * section_subset
= NULL
;
14592 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14594 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14595 Elf_Internal_Shdr
* sec
;
14596 Filedata
* filedata
= (Filedata
*) data
;
14598 /* Without section headers we cannot find any sections. */
14599 if (filedata
->section_headers
== NULL
)
14602 if (filedata
->string_table
== NULL
14603 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14604 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14606 Elf_Internal_Shdr
* strs
;
14608 /* Read in the string table, so that we have section names to scan. */
14609 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14611 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14613 filedata
->string_table
14614 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14615 1, strs
->sh_size
, _("string table"));
14617 filedata
->string_table_length
14618 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14622 /* Locate the debug section. */
14623 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14625 section
->name
= section
->uncompressed_name
;
14628 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14630 section
->name
= section
->compressed_name
;
14635 /* If we're loading from a subset of sections, and we've loaded
14636 a section matching this name before, it's likely that it's a
14638 if (section_subset
!= NULL
)
14639 free_debug_section (debug
);
14641 return load_specific_debug_section (debug
, sec
, data
);
14645 free_debug_section (enum dwarf_section_display_enum debug
)
14647 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14649 if (section
->start
== NULL
)
14652 free ((char *) section
->start
);
14653 section
->start
= NULL
;
14654 section
->address
= 0;
14657 if (section
->reloc_info
!= NULL
)
14659 free (section
->reloc_info
);
14660 section
->reloc_info
= NULL
;
14661 section
->num_relocs
= 0;
14666 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14668 char * name
= SECTION_NAME (section
);
14669 const char * print_name
= printable_section_name (filedata
, section
);
14670 bfd_size_type length
;
14671 bfd_boolean result
= TRUE
;
14674 length
= section
->sh_size
;
14677 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14680 if (section
->sh_type
== SHT_NOBITS
)
14682 /* There is no point in dumping the contents of a debugging section
14683 which has the NOBITS type - the bits in the file will be random.
14684 This can happen when a file containing a .eh_frame section is
14685 stripped with the --only-keep-debug command line option. */
14686 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14691 if (const_strneq (name
, ".gnu.linkonce.wi."))
14692 name
= ".debug_info";
14694 /* See if we know how to display the contents of this section. */
14695 for (i
= 0; i
< max
; i
++)
14697 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14698 struct dwarf_section_display
* display
= debug_displays
+ i
;
14699 struct dwarf_section
* sec
= & display
->section
;
14701 if (streq (sec
->uncompressed_name
, name
)
14702 || (id
== line
&& const_strneq (name
, ".debug_line."))
14703 || streq (sec
->compressed_name
, name
))
14705 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14708 free_debug_section (id
);
14710 if (i
== line
&& const_strneq (name
, ".debug_line."))
14712 else if (streq (sec
->uncompressed_name
, name
))
14713 sec
->name
= sec
->uncompressed_name
;
14715 sec
->name
= sec
->compressed_name
;
14717 if (load_specific_debug_section (id
, section
, filedata
))
14719 /* If this debug section is part of a CU/TU set in a .dwp file,
14720 restrict load_debug_section to the sections in that set. */
14721 section_subset
= find_cu_tu_set (filedata
, shndx
);
14723 result
&= display
->display (sec
, filedata
);
14725 section_subset
= NULL
;
14727 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14728 free_debug_section (id
);
14736 printf (_("Unrecognized debug section: %s\n"), print_name
);
14743 /* Set DUMP_SECTS for all sections where dumps were requested
14744 based on section name. */
14747 initialise_dumps_byname (Filedata
* filedata
)
14749 struct dump_list_entry
* cur
;
14751 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14754 bfd_boolean any
= FALSE
;
14756 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14757 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14759 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14764 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14770 process_section_contents (Filedata
* filedata
)
14772 Elf_Internal_Shdr
* section
;
14774 bfd_boolean res
= TRUE
;
14779 initialise_dumps_byname (filedata
);
14781 for (i
= 0, section
= filedata
->section_headers
;
14782 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14785 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14787 #ifdef SUPPORT_DISASSEMBLY
14788 if (dump
& DISASS_DUMP
)
14790 if (! disassemble_section (section
, filedata
))
14794 if (dump
& HEX_DUMP
)
14796 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14800 if (dump
& RELOC_DUMP
)
14802 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14806 if (dump
& STRING_DUMP
)
14808 if (! dump_section_as_strings (section
, filedata
))
14812 if (dump
& DEBUG_DUMP
)
14814 if (! display_debug_section (i
, section
, filedata
))
14818 if (dump
& CTF_DUMP
)
14820 if (! dump_section_as_ctf (section
, filedata
))
14825 /* Check to see if the user requested a
14826 dump of a section that does not exist. */
14827 while (i
< filedata
->dump
.num_dump_sects
)
14829 if (filedata
->dump
.dump_sects
[i
])
14831 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14841 process_mips_fpe_exception (int mask
)
14845 bfd_boolean first
= TRUE
;
14847 if (mask
& OEX_FPU_INEX
)
14848 fputs ("INEX", stdout
), first
= FALSE
;
14849 if (mask
& OEX_FPU_UFLO
)
14850 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14851 if (mask
& OEX_FPU_OFLO
)
14852 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14853 if (mask
& OEX_FPU_DIV0
)
14854 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14855 if (mask
& OEX_FPU_INVAL
)
14856 printf ("%sINVAL", first
? "" : "|");
14859 fputs ("0", stdout
);
14862 /* Display's the value of TAG at location P. If TAG is
14863 greater than 0 it is assumed to be an unknown tag, and
14864 a message is printed to this effect. Otherwise it is
14865 assumed that a message has already been printed.
14867 If the bottom bit of TAG is set it assumed to have a
14868 string value, otherwise it is assumed to have an integer
14871 Returns an updated P pointing to the first unread byte
14872 beyond the end of TAG's value.
14874 Reads at or beyond END will not be made. */
14876 static unsigned char *
14877 display_tag_value (signed int tag
,
14879 const unsigned char * const end
)
14884 printf (" Tag_unknown_%d: ", tag
);
14888 warn (_("<corrupt tag>\n"));
14892 /* PR 17531 file: 027-19978-0.004. */
14893 size_t maxlen
= (end
- p
) - 1;
14898 print_symbol ((int) maxlen
, (const char *) p
);
14899 p
+= strnlen ((char *) p
, maxlen
) + 1;
14903 printf (_("<corrupt string tag>"));
14904 p
= (unsigned char *) end
;
14910 READ_ULEB (val
, p
, end
);
14911 printf ("%ld (0x%lx)\n", val
, val
);
14918 /* ARC ABI attributes section. */
14920 static unsigned char *
14921 display_arc_attribute (unsigned char * p
,
14922 const unsigned char * const end
)
14927 READ_ULEB (tag
, p
, end
);
14931 case Tag_ARC_PCS_config
:
14932 READ_ULEB (val
, p
, end
);
14933 printf (" Tag_ARC_PCS_config: ");
14937 printf (_("Absent/Non standard\n"));
14940 printf (_("Bare metal/mwdt\n"));
14943 printf (_("Bare metal/newlib\n"));
14946 printf (_("Linux/uclibc\n"));
14949 printf (_("Linux/glibc\n"));
14952 printf (_("Unknown\n"));
14957 case Tag_ARC_CPU_base
:
14958 READ_ULEB (val
, p
, end
);
14959 printf (" Tag_ARC_CPU_base: ");
14964 printf (_("Absent\n"));
14966 case TAG_CPU_ARC6xx
:
14967 printf ("ARC6xx\n");
14969 case TAG_CPU_ARC7xx
:
14970 printf ("ARC7xx\n");
14972 case TAG_CPU_ARCEM
:
14973 printf ("ARCEM\n");
14975 case TAG_CPU_ARCHS
:
14976 printf ("ARCHS\n");
14981 case Tag_ARC_CPU_variation
:
14982 READ_ULEB (val
, p
, end
);
14983 printf (" Tag_ARC_CPU_variation: ");
14987 if (val
> 0 && val
< 16)
14988 printf ("Core%d\n", val
);
14990 printf ("Unknown\n");
14994 printf (_("Absent\n"));
14999 case Tag_ARC_CPU_name
:
15000 printf (" Tag_ARC_CPU_name: ");
15001 p
= display_tag_value (-1, p
, end
);
15004 case Tag_ARC_ABI_rf16
:
15005 READ_ULEB (val
, p
, end
);
15006 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15009 case Tag_ARC_ABI_osver
:
15010 READ_ULEB (val
, p
, end
);
15011 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15014 case Tag_ARC_ABI_pic
:
15015 case Tag_ARC_ABI_sda
:
15016 READ_ULEB (val
, p
, end
);
15017 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15018 : " Tag_ARC_ABI_pic: ");
15022 printf (_("Absent\n"));
15031 printf (_("Unknown\n"));
15036 case Tag_ARC_ABI_tls
:
15037 READ_ULEB (val
, p
, end
);
15038 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15041 case Tag_ARC_ABI_enumsize
:
15042 READ_ULEB (val
, p
, end
);
15043 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15047 case Tag_ARC_ABI_exceptions
:
15048 READ_ULEB (val
, p
, end
);
15049 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15053 case Tag_ARC_ABI_double_size
:
15054 READ_ULEB (val
, p
, end
);
15055 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15058 case Tag_ARC_ISA_config
:
15059 printf (" Tag_ARC_ISA_config: ");
15060 p
= display_tag_value (-1, p
, end
);
15063 case Tag_ARC_ISA_apex
:
15064 printf (" Tag_ARC_ISA_apex: ");
15065 p
= display_tag_value (-1, p
, end
);
15068 case Tag_ARC_ISA_mpy_option
:
15069 READ_ULEB (val
, p
, end
);
15070 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15073 case Tag_ARC_ATR_version
:
15074 READ_ULEB (val
, p
, end
);
15075 printf (" Tag_ARC_ATR_version: %d\n", val
);
15079 return display_tag_value (tag
& 1, p
, end
);
15085 /* ARM EABI attributes section. */
15090 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15092 const char ** table
;
15093 } arm_attr_public_tag
;
15095 static const char * arm_attr_tag_CPU_arch
[] =
15096 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15097 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15098 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15099 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15100 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15101 {"No", "Thumb-1", "Thumb-2", "Yes"};
15102 static const char * arm_attr_tag_FP_arch
[] =
15103 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15104 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15105 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15106 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15107 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15108 "NEON for ARMv8.1"};
15109 static const char * arm_attr_tag_PCS_config
[] =
15110 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15111 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15112 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15113 {"V6", "SB", "TLS", "Unused"};
15114 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15115 {"Absolute", "PC-relative", "SB-relative", "None"};
15116 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15117 {"Absolute", "PC-relative", "None"};
15118 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15119 {"None", "direct", "GOT-indirect"};
15120 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15121 {"None", "??? 1", "2", "??? 3", "4"};
15122 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15123 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15124 {"Unused", "Needed", "Sign only"};
15125 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15126 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15127 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15128 {"Unused", "Finite", "RTABI", "IEEE 754"};
15129 static const char * arm_attr_tag_ABI_enum_size
[] =
15130 {"Unused", "small", "int", "forced to int"};
15131 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15132 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15133 static const char * arm_attr_tag_ABI_VFP_args
[] =
15134 {"AAPCS", "VFP registers", "custom", "compatible"};
15135 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15136 {"AAPCS", "WMMX registers", "custom"};
15137 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15138 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15139 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15140 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15141 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15142 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15143 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15144 static const char * arm_attr_tag_FP_HP_extension
[] =
15145 {"Not Allowed", "Allowed"};
15146 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15147 {"None", "IEEE 754", "Alternative Format"};
15148 static const char * arm_attr_tag_DSP_extension
[] =
15149 {"Follow architecture", "Allowed"};
15150 static const char * arm_attr_tag_MPextension_use
[] =
15151 {"Not Allowed", "Allowed"};
15152 static const char * arm_attr_tag_DIV_use
[] =
15153 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15154 "Allowed in v7-A with integer division extension"};
15155 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15156 static const char * arm_attr_tag_Virtualization_use
[] =
15157 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15158 "TrustZone and Virtualization Extensions"};
15159 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15160 {"Not Allowed", "Allowed"};
15162 static const char * arm_attr_tag_MVE_arch
[] =
15163 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15165 #define LOOKUP(id, name) \
15166 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15167 static arm_attr_public_tag arm_attr_public_tags
[] =
15169 {4, "CPU_raw_name", 1, NULL
},
15170 {5, "CPU_name", 1, NULL
},
15171 LOOKUP(6, CPU_arch
),
15172 {7, "CPU_arch_profile", 0, NULL
},
15173 LOOKUP(8, ARM_ISA_use
),
15174 LOOKUP(9, THUMB_ISA_use
),
15175 LOOKUP(10, FP_arch
),
15176 LOOKUP(11, WMMX_arch
),
15177 LOOKUP(12, Advanced_SIMD_arch
),
15178 LOOKUP(13, PCS_config
),
15179 LOOKUP(14, ABI_PCS_R9_use
),
15180 LOOKUP(15, ABI_PCS_RW_data
),
15181 LOOKUP(16, ABI_PCS_RO_data
),
15182 LOOKUP(17, ABI_PCS_GOT_use
),
15183 LOOKUP(18, ABI_PCS_wchar_t
),
15184 LOOKUP(19, ABI_FP_rounding
),
15185 LOOKUP(20, ABI_FP_denormal
),
15186 LOOKUP(21, ABI_FP_exceptions
),
15187 LOOKUP(22, ABI_FP_user_exceptions
),
15188 LOOKUP(23, ABI_FP_number_model
),
15189 {24, "ABI_align_needed", 0, NULL
},
15190 {25, "ABI_align_preserved", 0, NULL
},
15191 LOOKUP(26, ABI_enum_size
),
15192 LOOKUP(27, ABI_HardFP_use
),
15193 LOOKUP(28, ABI_VFP_args
),
15194 LOOKUP(29, ABI_WMMX_args
),
15195 LOOKUP(30, ABI_optimization_goals
),
15196 LOOKUP(31, ABI_FP_optimization_goals
),
15197 {32, "compatibility", 0, NULL
},
15198 LOOKUP(34, CPU_unaligned_access
),
15199 LOOKUP(36, FP_HP_extension
),
15200 LOOKUP(38, ABI_FP_16bit_format
),
15201 LOOKUP(42, MPextension_use
),
15202 LOOKUP(44, DIV_use
),
15203 LOOKUP(46, DSP_extension
),
15204 LOOKUP(48, MVE_arch
),
15205 {64, "nodefaults", 0, NULL
},
15206 {65, "also_compatible_with", 0, NULL
},
15207 LOOKUP(66, T2EE_use
),
15208 {67, "conformance", 1, NULL
},
15209 LOOKUP(68, Virtualization_use
),
15210 LOOKUP(70, MPextension_use_legacy
)
15214 static unsigned char *
15215 display_arm_attribute (unsigned char * p
,
15216 const unsigned char * const end
)
15220 arm_attr_public_tag
* attr
;
15224 READ_ULEB (tag
, p
, end
);
15226 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15228 if (arm_attr_public_tags
[i
].tag
== tag
)
15230 attr
= &arm_attr_public_tags
[i
];
15237 printf (" Tag_%s: ", attr
->name
);
15238 switch (attr
->type
)
15243 case 7: /* Tag_CPU_arch_profile. */
15244 READ_ULEB (val
, p
, end
);
15247 case 0: printf (_("None\n")); break;
15248 case 'A': printf (_("Application\n")); break;
15249 case 'R': printf (_("Realtime\n")); break;
15250 case 'M': printf (_("Microcontroller\n")); break;
15251 case 'S': printf (_("Application or Realtime\n")); break;
15252 default: printf ("??? (%d)\n", val
); break;
15256 case 24: /* Tag_align_needed. */
15257 READ_ULEB (val
, p
, end
);
15260 case 0: printf (_("None\n")); break;
15261 case 1: printf (_("8-byte\n")); break;
15262 case 2: printf (_("4-byte\n")); break;
15263 case 3: printf ("??? 3\n"); break;
15266 printf (_("8-byte and up to %d-byte extended\n"),
15269 printf ("??? (%d)\n", val
);
15274 case 25: /* Tag_align_preserved. */
15275 READ_ULEB (val
, p
, end
);
15278 case 0: printf (_("None\n")); break;
15279 case 1: printf (_("8-byte, except leaf SP\n")); break;
15280 case 2: printf (_("8-byte\n")); break;
15281 case 3: printf ("??? 3\n"); break;
15284 printf (_("8-byte and up to %d-byte extended\n"),
15287 printf ("??? (%d)\n", val
);
15292 case 32: /* Tag_compatibility. */
15294 READ_ULEB (val
, p
, end
);
15295 printf (_("flag = %d, vendor = "), val
);
15298 size_t maxlen
= (end
- p
) - 1;
15300 print_symbol ((int) maxlen
, (const char *) p
);
15301 p
+= strnlen ((char *) p
, maxlen
) + 1;
15305 printf (_("<corrupt>"));
15306 p
= (unsigned char *) end
;
15312 case 64: /* Tag_nodefaults. */
15313 /* PR 17531: file: 001-505008-0.01. */
15316 printf (_("True\n"));
15319 case 65: /* Tag_also_compatible_with. */
15320 READ_ULEB (val
, p
, end
);
15321 if (val
== 6 /* Tag_CPU_arch. */)
15323 READ_ULEB (val
, p
, end
);
15324 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15325 printf ("??? (%d)\n", val
);
15327 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15331 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15336 printf (_("<unknown: %d>\n"), tag
);
15342 return display_tag_value (-1, p
, end
);
15344 return display_tag_value (0, p
, end
);
15347 assert (attr
->type
& 0x80);
15348 READ_ULEB (val
, p
, end
);
15349 type
= attr
->type
& 0x7f;
15351 printf ("??? (%d)\n", val
);
15353 printf ("%s\n", attr
->table
[val
]);
15358 return display_tag_value (tag
, p
, end
);
15361 static unsigned char *
15362 display_gnu_attribute (unsigned char * p
,
15363 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15364 const unsigned char * const end
)
15369 READ_ULEB (tag
, p
, end
);
15371 /* Tag_compatibility is the only generic GNU attribute defined at
15375 READ_ULEB (val
, p
, end
);
15377 printf (_("flag = %d, vendor = "), val
);
15380 printf (_("<corrupt>\n"));
15381 warn (_("corrupt vendor attribute\n"));
15387 size_t maxlen
= (end
- p
) - 1;
15389 print_symbol ((int) maxlen
, (const char *) p
);
15390 p
+= strnlen ((char *) p
, maxlen
) + 1;
15394 printf (_("<corrupt>"));
15395 p
= (unsigned char *) end
;
15402 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15403 return display_proc_gnu_attribute (p
, tag
, end
);
15405 return display_tag_value (tag
, p
, end
);
15408 static unsigned char *
15409 display_power_gnu_attribute (unsigned char * p
,
15411 const unsigned char * const end
)
15415 if (tag
== Tag_GNU_Power_ABI_FP
)
15417 printf (" Tag_GNU_Power_ABI_FP: ");
15420 printf (_("<corrupt>\n"));
15423 READ_ULEB (val
, p
, end
);
15426 printf ("(%#x), ", val
);
15431 printf (_("unspecified hard/soft float, "));
15434 printf (_("hard float, "));
15437 printf (_("soft float, "));
15440 printf (_("single-precision hard float, "));
15447 printf (_("unspecified long double\n"));
15450 printf (_("128-bit IBM long double\n"));
15453 printf (_("64-bit long double\n"));
15456 printf (_("128-bit IEEE long double\n"));
15462 if (tag
== Tag_GNU_Power_ABI_Vector
)
15464 printf (" Tag_GNU_Power_ABI_Vector: ");
15467 printf (_("<corrupt>\n"));
15470 READ_ULEB (val
, p
, end
);
15473 printf ("(%#x), ", val
);
15478 printf (_("unspecified\n"));
15481 printf (_("generic\n"));
15484 printf ("AltiVec\n");
15493 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15495 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15498 printf (_("<corrupt>\n"));
15501 READ_ULEB (val
, p
, end
);
15504 printf ("(%#x), ", val
);
15509 printf (_("unspecified\n"));
15512 printf ("r3/r4\n");
15515 printf (_("memory\n"));
15524 return display_tag_value (tag
& 1, p
, end
);
15527 static unsigned char *
15528 display_s390_gnu_attribute (unsigned char * p
,
15530 const unsigned char * const end
)
15534 if (tag
== Tag_GNU_S390_ABI_Vector
)
15536 printf (" Tag_GNU_S390_ABI_Vector: ");
15537 READ_ULEB (val
, p
, end
);
15542 printf (_("any\n"));
15545 printf (_("software\n"));
15548 printf (_("hardware\n"));
15551 printf ("??? (%d)\n", val
);
15557 return display_tag_value (tag
& 1, p
, end
);
15561 display_sparc_hwcaps (unsigned int mask
)
15565 bfd_boolean first
= TRUE
;
15567 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15568 fputs ("mul32", stdout
), first
= FALSE
;
15569 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15570 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15571 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15572 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15573 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15574 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15575 if (mask
& ELF_SPARC_HWCAP_POPC
)
15576 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15577 if (mask
& ELF_SPARC_HWCAP_VIS
)
15578 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15579 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15580 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15581 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15582 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15583 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15584 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15585 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15586 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15587 if (mask
& ELF_SPARC_HWCAP_HPC
)
15588 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15589 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15590 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15591 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15592 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15593 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15594 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15595 if (mask
& ELF_SPARC_HWCAP_IMA
)
15596 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15597 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15598 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15601 fputc ('0', stdout
);
15602 fputc ('\n', stdout
);
15606 display_sparc_hwcaps2 (unsigned int mask
)
15610 bfd_boolean first
= TRUE
;
15612 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15613 fputs ("fjathplus", stdout
), first
= FALSE
;
15614 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15615 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15616 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15617 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15618 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15619 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15620 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15621 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15622 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15623 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15624 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15625 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15626 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15627 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15628 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15629 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15630 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15631 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15632 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15633 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15636 fputc ('0', stdout
);
15637 fputc ('\n', stdout
);
15640 static unsigned char *
15641 display_sparc_gnu_attribute (unsigned char * p
,
15643 const unsigned char * const end
)
15647 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15649 READ_ULEB (val
, p
, end
);
15650 printf (" Tag_GNU_Sparc_HWCAPS: ");
15651 display_sparc_hwcaps (val
);
15654 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15656 READ_ULEB (val
, p
, end
);
15657 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15658 display_sparc_hwcaps2 (val
);
15662 return display_tag_value (tag
, p
, end
);
15666 print_mips_fp_abi_value (unsigned int val
)
15670 case Val_GNU_MIPS_ABI_FP_ANY
:
15671 printf (_("Hard or soft float\n"));
15673 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15674 printf (_("Hard float (double precision)\n"));
15676 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15677 printf (_("Hard float (single precision)\n"));
15679 case Val_GNU_MIPS_ABI_FP_SOFT
:
15680 printf (_("Soft float\n"));
15682 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15683 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15685 case Val_GNU_MIPS_ABI_FP_XX
:
15686 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15688 case Val_GNU_MIPS_ABI_FP_64
:
15689 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15691 case Val_GNU_MIPS_ABI_FP_64A
:
15692 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15694 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15695 printf (_("NaN 2008 compatibility\n"));
15698 printf ("??? (%d)\n", val
);
15703 static unsigned char *
15704 display_mips_gnu_attribute (unsigned char * p
,
15706 const unsigned char * const end
)
15708 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15712 printf (" Tag_GNU_MIPS_ABI_FP: ");
15713 READ_ULEB (val
, p
, end
);
15714 print_mips_fp_abi_value (val
);
15718 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15722 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15723 READ_ULEB (val
, p
, end
);
15727 case Val_GNU_MIPS_ABI_MSA_ANY
:
15728 printf (_("Any MSA or not\n"));
15730 case Val_GNU_MIPS_ABI_MSA_128
:
15731 printf (_("128-bit MSA\n"));
15734 printf ("??? (%d)\n", val
);
15740 return display_tag_value (tag
& 1, p
, end
);
15743 static unsigned char *
15744 display_tic6x_attribute (unsigned char * p
,
15745 const unsigned char * const end
)
15750 READ_ULEB (tag
, p
, end
);
15755 printf (" Tag_ISA: ");
15756 READ_ULEB (val
, p
, end
);
15760 case C6XABI_Tag_ISA_none
:
15761 printf (_("None\n"));
15763 case C6XABI_Tag_ISA_C62X
:
15766 case C6XABI_Tag_ISA_C67X
:
15769 case C6XABI_Tag_ISA_C67XP
:
15770 printf ("C67x+\n");
15772 case C6XABI_Tag_ISA_C64X
:
15775 case C6XABI_Tag_ISA_C64XP
:
15776 printf ("C64x+\n");
15778 case C6XABI_Tag_ISA_C674X
:
15779 printf ("C674x\n");
15782 printf ("??? (%d)\n", val
);
15787 case Tag_ABI_wchar_t
:
15788 printf (" Tag_ABI_wchar_t: ");
15789 READ_ULEB (val
, p
, end
);
15793 printf (_("Not used\n"));
15796 printf (_("2 bytes\n"));
15799 printf (_("4 bytes\n"));
15802 printf ("??? (%d)\n", val
);
15807 case Tag_ABI_stack_align_needed
:
15808 printf (" Tag_ABI_stack_align_needed: ");
15809 READ_ULEB (val
, p
, end
);
15813 printf (_("8-byte\n"));
15816 printf (_("16-byte\n"));
15819 printf ("??? (%d)\n", val
);
15824 case Tag_ABI_stack_align_preserved
:
15825 READ_ULEB (val
, p
, end
);
15826 printf (" Tag_ABI_stack_align_preserved: ");
15830 printf (_("8-byte\n"));
15833 printf (_("16-byte\n"));
15836 printf ("??? (%d)\n", val
);
15842 READ_ULEB (val
, p
, end
);
15843 printf (" Tag_ABI_DSBT: ");
15847 printf (_("DSBT addressing not used\n"));
15850 printf (_("DSBT addressing used\n"));
15853 printf ("??? (%d)\n", val
);
15859 READ_ULEB (val
, p
, end
);
15860 printf (" Tag_ABI_PID: ");
15864 printf (_("Data addressing position-dependent\n"));
15867 printf (_("Data addressing position-independent, GOT near DP\n"));
15870 printf (_("Data addressing position-independent, GOT far from DP\n"));
15873 printf ("??? (%d)\n", val
);
15879 READ_ULEB (val
, p
, end
);
15880 printf (" Tag_ABI_PIC: ");
15884 printf (_("Code addressing position-dependent\n"));
15887 printf (_("Code addressing position-independent\n"));
15890 printf ("??? (%d)\n", val
);
15895 case Tag_ABI_array_object_alignment
:
15896 READ_ULEB (val
, p
, end
);
15897 printf (" Tag_ABI_array_object_alignment: ");
15901 printf (_("8-byte\n"));
15904 printf (_("4-byte\n"));
15907 printf (_("16-byte\n"));
15910 printf ("??? (%d)\n", val
);
15915 case Tag_ABI_array_object_align_expected
:
15916 READ_ULEB (val
, p
, end
);
15917 printf (" Tag_ABI_array_object_align_expected: ");
15921 printf (_("8-byte\n"));
15924 printf (_("4-byte\n"));
15927 printf (_("16-byte\n"));
15930 printf ("??? (%d)\n", val
);
15935 case Tag_ABI_compatibility
:
15937 READ_ULEB (val
, p
, end
);
15938 printf (" Tag_ABI_compatibility: ");
15939 printf (_("flag = %d, vendor = "), val
);
15942 size_t maxlen
= (end
- p
) - 1;
15944 print_symbol ((int) maxlen
, (const char *) p
);
15945 p
+= strnlen ((char *) p
, maxlen
) + 1;
15949 printf (_("<corrupt>"));
15950 p
= (unsigned char *) end
;
15956 case Tag_ABI_conformance
:
15958 printf (" Tag_ABI_conformance: \"");
15961 size_t maxlen
= (end
- p
) - 1;
15963 print_symbol ((int) maxlen
, (const char *) p
);
15964 p
+= strnlen ((char *) p
, maxlen
) + 1;
15968 printf (_("<corrupt>"));
15969 p
= (unsigned char *) end
;
15976 return display_tag_value (tag
, p
, end
);
15980 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15982 unsigned long addr
= 0;
15983 size_t bytes
= end
- p
;
15990 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15992 printf (" 0x%8.8lx ", addr
);
15994 for (j
= 0; j
< 16; j
++)
15997 printf ("%2.2x", p
[j
]);
16005 for (j
= 0; j
< lbytes
; j
++)
16008 if (k
>= ' ' && k
< 0x7f)
16024 static unsigned char *
16025 display_msp430x_attribute (unsigned char * p
,
16026 const unsigned char * const end
)
16031 READ_ULEB (tag
, p
, end
);
16035 case OFBA_MSPABI_Tag_ISA
:
16036 printf (" Tag_ISA: ");
16037 READ_ULEB (val
, p
, end
);
16040 case 0: printf (_("None\n")); break;
16041 case 1: printf (_("MSP430\n")); break;
16042 case 2: printf (_("MSP430X\n")); break;
16043 default: printf ("??? (%d)\n", val
); break;
16047 case OFBA_MSPABI_Tag_Code_Model
:
16048 printf (" Tag_Code_Model: ");
16049 READ_ULEB (val
, p
, end
);
16052 case 0: printf (_("None\n")); break;
16053 case 1: printf (_("Small\n")); break;
16054 case 2: printf (_("Large\n")); break;
16055 default: printf ("??? (%d)\n", val
); break;
16059 case OFBA_MSPABI_Tag_Data_Model
:
16060 printf (" Tag_Data_Model: ");
16061 READ_ULEB (val
, p
, end
);
16064 case 0: printf (_("None\n")); break;
16065 case 1: printf (_("Small\n")); break;
16066 case 2: printf (_("Large\n")); break;
16067 case 3: printf (_("Restricted Large\n")); break;
16068 default: printf ("??? (%d)\n", val
); break;
16073 printf (_(" <unknown tag %d>: "), tag
);
16080 size_t maxlen
= (end
- p
) - 1;
16082 print_symbol ((int) maxlen
, (const char *) p
);
16083 p
+= strnlen ((char *) p
, maxlen
) + 1;
16087 printf (_("<corrupt>"));
16088 p
= (unsigned char *) end
;
16094 READ_ULEB (val
, p
, end
);
16095 printf ("%d (0x%x)\n", val
, val
);
16104 static unsigned char *
16105 display_msp430_gnu_attribute (unsigned char * p
,
16107 const unsigned char * const end
)
16109 if (tag
== Tag_GNU_MSP430_Data_Region
)
16113 printf (" Tag_GNU_MSP430_Data_Region: ");
16114 READ_ULEB (val
, p
, end
);
16118 case Val_GNU_MSP430_Data_Region_Any
:
16119 printf (_("Any Region\n"));
16121 case Val_GNU_MSP430_Data_Region_Lower
:
16122 printf (_("Lower Region Only\n"));
16125 printf ("??? (%u)\n", val
);
16129 return display_tag_value (tag
& 1, p
, end
);
16132 struct riscv_attr_tag_t
{
16137 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16139 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16142 T(priv_spec_minor
),
16143 T(priv_spec_revision
),
16144 T(unaligned_access
),
16149 static unsigned char *
16150 display_riscv_attribute (unsigned char *p
,
16151 const unsigned char * const end
)
16155 struct riscv_attr_tag_t
*attr
= NULL
;
16158 READ_ULEB (tag
, p
, end
);
16160 /* Find the name of attribute. */
16161 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16163 if (riscv_attr_tag
[i
].tag
== tag
)
16165 attr
= &riscv_attr_tag
[i
];
16171 printf (" %s: ", attr
->name
);
16173 return display_tag_value (tag
, p
, end
);
16177 case Tag_RISCV_priv_spec
:
16178 case Tag_RISCV_priv_spec_minor
:
16179 case Tag_RISCV_priv_spec_revision
:
16180 READ_ULEB (val
, p
, end
);
16181 printf (_("%u\n"), val
);
16183 case Tag_RISCV_unaligned_access
:
16184 READ_ULEB (val
, p
, end
);
16188 printf (_("No unaligned access\n"));
16191 printf (_("Unaligned access\n"));
16195 case Tag_RISCV_stack_align
:
16196 READ_ULEB (val
, p
, end
);
16197 printf (_("%u-bytes\n"), val
);
16199 case Tag_RISCV_arch
:
16200 p
= display_tag_value (-1, p
, end
);
16203 return display_tag_value (tag
, p
, end
);
16210 process_attributes (Filedata
* filedata
,
16211 const char * public_name
,
16212 unsigned int proc_type
,
16213 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16214 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16216 Elf_Internal_Shdr
* sect
;
16218 bfd_boolean res
= TRUE
;
16220 /* Find the section header so that we get the size. */
16221 for (i
= 0, sect
= filedata
->section_headers
;
16222 i
< filedata
->file_header
.e_shnum
;
16225 unsigned char * contents
;
16228 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16231 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16232 sect
->sh_size
, _("attributes"));
16233 if (contents
== NULL
)
16240 /* The first character is the version of the attributes.
16241 Currently only version 1, (aka 'A') is recognised here. */
16244 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16249 bfd_vma section_len
;
16251 section_len
= sect
->sh_size
- 1;
16254 while (section_len
> 0)
16257 unsigned int namelen
;
16258 bfd_boolean public_section
;
16259 bfd_boolean gnu_section
;
16261 if (section_len
<= 4)
16263 error (_("Tag section ends prematurely\n"));
16267 attr_len
= byte_get (p
, 4);
16270 if (attr_len
> section_len
)
16272 error (_("Bad attribute length (%u > %u)\n"),
16273 (unsigned) attr_len
, (unsigned) section_len
);
16274 attr_len
= section_len
;
16277 /* PR 17531: file: 001-101425-0.004 */
16278 else if (attr_len
< 5)
16280 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16285 section_len
-= attr_len
;
16288 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16289 if (namelen
== 0 || namelen
>= attr_len
)
16291 error (_("Corrupt attribute section name\n"));
16296 printf (_("Attribute Section: "));
16297 print_symbol (INT_MAX
, (const char *) p
);
16300 if (public_name
&& streq ((char *) p
, public_name
))
16301 public_section
= TRUE
;
16303 public_section
= FALSE
;
16305 if (streq ((char *) p
, "gnu"))
16306 gnu_section
= TRUE
;
16308 gnu_section
= FALSE
;
16311 attr_len
-= namelen
;
16313 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16318 unsigned char * end
;
16320 /* PR binutils/17531: Safe handling of corrupt files. */
16323 error (_("Unused bytes at end of section\n"));
16330 size
= byte_get (p
, 4);
16331 if (size
> attr_len
)
16333 error (_("Bad subsection length (%u > %u)\n"),
16334 (unsigned) size
, (unsigned) attr_len
);
16338 /* PR binutils/17531: Safe handling of corrupt files. */
16341 error (_("Bad subsection length (%u < 6)\n"),
16349 end
= p
+ size
- 1;
16350 assert (end
<= contents
+ sect
->sh_size
);
16356 printf (_("File Attributes\n"));
16359 printf (_("Section Attributes:"));
16362 printf (_("Symbol Attributes:"));
16363 /* Fall through. */
16367 READ_ULEB (val
, p
, end
);
16370 printf (" %d", val
);
16375 printf (_("Unknown tag: %d\n"), tag
);
16376 public_section
= FALSE
;
16380 if (public_section
&& display_pub_attribute
!= NULL
)
16383 p
= display_pub_attribute (p
, end
);
16386 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16389 p
= display_gnu_attribute (p
,
16390 display_proc_gnu_attribute
,
16396 printf (_(" Unknown attribute:\n"));
16397 display_raw_attribute (p
, end
);
16412 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16413 Print the Address, Access and Initial fields of an entry at VMA ADDR
16414 and return the VMA of the next entry, or -1 if there was a problem.
16415 Does not read from DATA_END or beyond. */
16418 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16419 unsigned char * data_end
)
16422 print_vma (addr
, LONG_HEX
);
16424 if (addr
< pltgot
+ 0xfff0)
16425 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16427 printf ("%10s", "");
16430 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16434 unsigned char * from
= data
+ addr
- pltgot
;
16436 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16438 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16439 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16440 return (bfd_vma
) -1;
16444 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16445 print_vma (entry
, LONG_HEX
);
16448 return addr
+ (is_32bit_elf
? 4 : 8);
16451 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16452 PLTGOT. Print the Address and Initial fields of an entry at VMA
16453 ADDR and return the VMA of the next entry. */
16456 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16459 print_vma (addr
, LONG_HEX
);
16462 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16467 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16468 print_vma (entry
, LONG_HEX
);
16470 return addr
+ (is_32bit_elf
? 4 : 8);
16474 print_mips_ases (unsigned int mask
)
16476 if (mask
& AFL_ASE_DSP
)
16477 fputs ("\n\tDSP ASE", stdout
);
16478 if (mask
& AFL_ASE_DSPR2
)
16479 fputs ("\n\tDSP R2 ASE", stdout
);
16480 if (mask
& AFL_ASE_DSPR3
)
16481 fputs ("\n\tDSP R3 ASE", stdout
);
16482 if (mask
& AFL_ASE_EVA
)
16483 fputs ("\n\tEnhanced VA Scheme", stdout
);
16484 if (mask
& AFL_ASE_MCU
)
16485 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16486 if (mask
& AFL_ASE_MDMX
)
16487 fputs ("\n\tMDMX ASE", stdout
);
16488 if (mask
& AFL_ASE_MIPS3D
)
16489 fputs ("\n\tMIPS-3D ASE", stdout
);
16490 if (mask
& AFL_ASE_MT
)
16491 fputs ("\n\tMT ASE", stdout
);
16492 if (mask
& AFL_ASE_SMARTMIPS
)
16493 fputs ("\n\tSmartMIPS ASE", stdout
);
16494 if (mask
& AFL_ASE_VIRT
)
16495 fputs ("\n\tVZ ASE", stdout
);
16496 if (mask
& AFL_ASE_MSA
)
16497 fputs ("\n\tMSA ASE", stdout
);
16498 if (mask
& AFL_ASE_MIPS16
)
16499 fputs ("\n\tMIPS16 ASE", stdout
);
16500 if (mask
& AFL_ASE_MICROMIPS
)
16501 fputs ("\n\tMICROMIPS ASE", stdout
);
16502 if (mask
& AFL_ASE_XPA
)
16503 fputs ("\n\tXPA ASE", stdout
);
16504 if (mask
& AFL_ASE_MIPS16E2
)
16505 fputs ("\n\tMIPS16e2 ASE", stdout
);
16506 if (mask
& AFL_ASE_CRC
)
16507 fputs ("\n\tCRC ASE", stdout
);
16508 if (mask
& AFL_ASE_GINV
)
16509 fputs ("\n\tGINV ASE", stdout
);
16510 if (mask
& AFL_ASE_LOONGSON_MMI
)
16511 fputs ("\n\tLoongson MMI ASE", stdout
);
16512 if (mask
& AFL_ASE_LOONGSON_CAM
)
16513 fputs ("\n\tLoongson CAM ASE", stdout
);
16514 if (mask
& AFL_ASE_LOONGSON_EXT
)
16515 fputs ("\n\tLoongson EXT ASE", stdout
);
16516 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16517 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16519 fprintf (stdout
, "\n\t%s", _("None"));
16520 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16521 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16525 print_mips_isa_ext (unsigned int isa_ext
)
16530 fputs (_("None"), stdout
);
16533 fputs ("RMI XLR", stdout
);
16535 case AFL_EXT_OCTEON3
:
16536 fputs ("Cavium Networks Octeon3", stdout
);
16538 case AFL_EXT_OCTEON2
:
16539 fputs ("Cavium Networks Octeon2", stdout
);
16541 case AFL_EXT_OCTEONP
:
16542 fputs ("Cavium Networks OcteonP", stdout
);
16544 case AFL_EXT_OCTEON
:
16545 fputs ("Cavium Networks Octeon", stdout
);
16548 fputs ("Toshiba R5900", stdout
);
16551 fputs ("MIPS R4650", stdout
);
16554 fputs ("LSI R4010", stdout
);
16557 fputs ("NEC VR4100", stdout
);
16560 fputs ("Toshiba R3900", stdout
);
16562 case AFL_EXT_10000
:
16563 fputs ("MIPS R10000", stdout
);
16566 fputs ("Broadcom SB-1", stdout
);
16569 fputs ("NEC VR4111/VR4181", stdout
);
16572 fputs ("NEC VR4120", stdout
);
16575 fputs ("NEC VR5400", stdout
);
16578 fputs ("NEC VR5500", stdout
);
16580 case AFL_EXT_LOONGSON_2E
:
16581 fputs ("ST Microelectronics Loongson 2E", stdout
);
16583 case AFL_EXT_LOONGSON_2F
:
16584 fputs ("ST Microelectronics Loongson 2F", stdout
);
16586 case AFL_EXT_INTERAPTIV_MR2
:
16587 fputs ("Imagination interAptiv MR2", stdout
);
16590 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16595 get_mips_reg_size (int reg_size
)
16597 return (reg_size
== AFL_REG_NONE
) ? 0
16598 : (reg_size
== AFL_REG_32
) ? 32
16599 : (reg_size
== AFL_REG_64
) ? 64
16600 : (reg_size
== AFL_REG_128
) ? 128
16605 process_mips_specific (Filedata
* filedata
)
16607 Elf_Internal_Dyn
* entry
;
16608 Elf_Internal_Shdr
*sect
= NULL
;
16609 size_t liblist_offset
= 0;
16610 size_t liblistno
= 0;
16611 size_t conflictsno
= 0;
16612 size_t options_offset
= 0;
16613 size_t conflicts_offset
= 0;
16614 size_t pltrelsz
= 0;
16616 bfd_vma pltgot
= 0;
16617 bfd_vma mips_pltgot
= 0;
16618 bfd_vma jmprel
= 0;
16619 bfd_vma local_gotno
= 0;
16620 bfd_vma gotsym
= 0;
16621 bfd_vma symtabno
= 0;
16622 bfd_boolean res
= TRUE
;
16624 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16625 display_mips_gnu_attribute
))
16628 sect
= find_section (filedata
, ".MIPS.abiflags");
16632 Elf_External_ABIFlags_v0
*abiflags_ext
;
16633 Elf_Internal_ABIFlags_v0 abiflags_in
;
16635 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16637 error (_("Corrupt MIPS ABI Flags section.\n"));
16642 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16643 sect
->sh_size
, _("MIPS ABI Flags section"));
16646 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16647 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16648 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16649 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16650 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16651 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16652 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16653 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16654 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16655 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16656 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16658 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16659 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16660 if (abiflags_in
.isa_rev
> 1)
16661 printf ("r%d", abiflags_in
.isa_rev
);
16662 printf ("\nGPR size: %d",
16663 get_mips_reg_size (abiflags_in
.gpr_size
));
16664 printf ("\nCPR1 size: %d",
16665 get_mips_reg_size (abiflags_in
.cpr1_size
));
16666 printf ("\nCPR2 size: %d",
16667 get_mips_reg_size (abiflags_in
.cpr2_size
));
16668 fputs ("\nFP ABI: ", stdout
);
16669 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16670 fputs ("ISA Extension: ", stdout
);
16671 print_mips_isa_ext (abiflags_in
.isa_ext
);
16672 fputs ("\nASEs:", stdout
);
16673 print_mips_ases (abiflags_in
.ases
);
16674 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16675 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16676 fputc ('\n', stdout
);
16677 free (abiflags_ext
);
16682 /* We have a lot of special sections. Thanks SGI! */
16683 if (filedata
->dynamic_section
== NULL
)
16685 /* No dynamic information available. See if there is static GOT. */
16686 sect
= find_section (filedata
, ".got");
16689 unsigned char *data_end
;
16690 unsigned char *data
;
16694 pltgot
= sect
->sh_addr
;
16697 addr_size
= (is_32bit_elf
? 4 : 8);
16698 end
= pltgot
+ sect
->sh_size
;
16700 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16702 _("Global Offset Table data"));
16703 /* PR 12855: Null data is handled gracefully throughout. */
16704 data_end
= data
+ (end
- pltgot
);
16706 printf (_("\nStatic GOT:\n"));
16707 printf (_(" Canonical gp value: "));
16708 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16711 /* In a dynamic binary GOT[0] is reserved for the dynamic
16712 loader to store the lazy resolver pointer, however in
16713 a static binary it may well have been omitted and GOT
16714 reduced to a table of addresses.
16715 PR 21344: Check for the entry being fully available
16716 before fetching it. */
16718 && data
+ ent
- pltgot
+ addr_size
<= data_end
16719 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16721 printf (_(" Reserved entries:\n"));
16722 printf (_(" %*s %10s %*s\n"),
16723 addr_size
* 2, _("Address"), _("Access"),
16724 addr_size
* 2, _("Value"));
16725 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16727 if (ent
== (bfd_vma
) -1)
16728 goto sgot_print_fail
;
16730 /* Check for the MSB of GOT[1] being set, identifying a
16731 GNU object. This entry will be used by some runtime
16732 loaders, to store the module pointer. Otherwise this
16733 is an ordinary local entry.
16734 PR 21344: Check for the entry being fully available
16735 before fetching it. */
16737 && data
+ ent
- pltgot
+ addr_size
<= data_end
16738 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16739 >> (addr_size
* 8 - 1)) != 0)
16741 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16743 if (ent
== (bfd_vma
) -1)
16744 goto sgot_print_fail
;
16749 if (data
!= NULL
&& ent
< end
)
16751 printf (_(" Local entries:\n"));
16752 printf (" %*s %10s %*s\n",
16753 addr_size
* 2, _("Address"), _("Access"),
16754 addr_size
* 2, _("Value"));
16757 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16759 if (ent
== (bfd_vma
) -1)
16760 goto sgot_print_fail
;
16772 for (entry
= filedata
->dynamic_section
;
16773 /* PR 17531 file: 012-50589-0.004. */
16774 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16775 && entry
->d_tag
!= DT_NULL
);
16777 switch (entry
->d_tag
)
16779 case DT_MIPS_LIBLIST
:
16781 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16782 liblistno
* sizeof (Elf32_External_Lib
));
16784 case DT_MIPS_LIBLISTNO
:
16785 liblistno
= entry
->d_un
.d_val
;
16787 case DT_MIPS_OPTIONS
:
16788 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16790 case DT_MIPS_CONFLICT
:
16792 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16793 conflictsno
* sizeof (Elf32_External_Conflict
));
16795 case DT_MIPS_CONFLICTNO
:
16796 conflictsno
= entry
->d_un
.d_val
;
16799 pltgot
= entry
->d_un
.d_ptr
;
16801 case DT_MIPS_LOCAL_GOTNO
:
16802 local_gotno
= entry
->d_un
.d_val
;
16804 case DT_MIPS_GOTSYM
:
16805 gotsym
= entry
->d_un
.d_val
;
16807 case DT_MIPS_SYMTABNO
:
16808 symtabno
= entry
->d_un
.d_val
;
16810 case DT_MIPS_PLTGOT
:
16811 mips_pltgot
= entry
->d_un
.d_ptr
;
16814 pltrel
= entry
->d_un
.d_val
;
16817 pltrelsz
= entry
->d_un
.d_val
;
16820 jmprel
= entry
->d_un
.d_ptr
;
16826 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16828 Elf32_External_Lib
* elib
;
16831 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16832 sizeof (Elf32_External_Lib
),
16834 _("liblist section data"));
16837 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16838 "\nSection '.liblist' contains %lu entries:\n",
16839 (unsigned long) liblistno
),
16840 (unsigned long) liblistno
);
16841 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16844 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16851 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16852 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16853 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16854 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16855 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16857 tmp
= gmtime (&atime
);
16858 snprintf (timebuf
, sizeof (timebuf
),
16859 "%04u-%02u-%02uT%02u:%02u:%02u",
16860 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16861 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16863 printf ("%3lu: ", (unsigned long) cnt
);
16864 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
16865 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
16867 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16868 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16869 liblist
.l_version
);
16871 if (liblist
.l_flags
== 0)
16875 static const struct
16882 { " EXACT_MATCH", LL_EXACT_MATCH
},
16883 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16884 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16885 { " EXPORTS", LL_EXPORTS
},
16886 { " DELAY_LOAD", LL_DELAY_LOAD
},
16887 { " DELTA", LL_DELTA
}
16889 int flags
= liblist
.l_flags
;
16892 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16893 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16895 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16896 flags
^= l_flags_vals
[fcnt
].bit
;
16899 printf (" %#x", (unsigned int) flags
);
16911 if (options_offset
!= 0)
16913 Elf_External_Options
* eopt
;
16916 sect
= filedata
->section_headers
;
16918 /* Find the section header so that we get the size. */
16919 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16920 /* PR 17533 file: 012-277276-0.004. */
16923 error (_("No MIPS_OPTIONS header found\n"));
16927 if (sect
->sh_size
< sizeof (* eopt
))
16929 error (_("The MIPS options section is too small.\n"));
16933 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16934 sect
->sh_size
, _("options"));
16937 Elf_Internal_Options
* iopt
;
16938 Elf_Internal_Options
* option
;
16939 Elf_Internal_Options
* iopt_end
;
16941 iopt
= (Elf_Internal_Options
*)
16942 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16945 error (_("Out of memory allocating space for MIPS options\n"));
16952 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16954 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16956 Elf_External_Options
* eoption
;
16958 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16960 option
->kind
= BYTE_GET (eoption
->kind
);
16961 option
->size
= BYTE_GET (eoption
->size
);
16962 option
->section
= BYTE_GET (eoption
->section
);
16963 option
->info
= BYTE_GET (eoption
->info
);
16965 /* PR 17531: file: ffa0fa3b. */
16966 if (option
->size
< sizeof (* eopt
)
16967 || offset
+ option
->size
> sect
->sh_size
)
16969 error (_("Invalid size (%u) for MIPS option\n"),
16975 offset
+= option
->size
;
16981 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16982 "\nSection '%s' contains %d entries:\n",
16984 printable_section_name (filedata
, sect
), cnt
);
16993 switch (option
->kind
)
16996 /* This shouldn't happen. */
16997 printf (" NULL %d %lx", option
->section
, option
->info
);
17001 printf (" REGINFO ");
17002 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17004 Elf32_External_RegInfo
* ereg
;
17005 Elf32_RegInfo reginfo
;
17008 if (option
+ 2 > iopt_end
)
17010 printf (_("<corrupt>\n"));
17011 error (_("Truncated MIPS REGINFO option\n"));
17016 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
17018 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17019 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17020 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17021 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17022 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17023 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17025 printf ("GPR %08lx GP 0x%lx\n",
17026 reginfo
.ri_gprmask
,
17027 (unsigned long) reginfo
.ri_gp_value
);
17028 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
17029 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17030 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17035 Elf64_External_RegInfo
* ereg
;
17036 Elf64_Internal_RegInfo reginfo
;
17038 if (option
+ 2 > iopt_end
)
17040 printf (_("<corrupt>\n"));
17041 error (_("Truncated MIPS REGINFO option\n"));
17046 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
17047 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17048 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17049 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17050 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17051 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17052 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17054 printf ("GPR %08lx GP 0x",
17055 reginfo
.ri_gprmask
);
17056 printf_vma (reginfo
.ri_gp_value
);
17059 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
17060 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17061 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17066 case ODK_EXCEPTIONS
:
17067 fputs (" EXCEPTIONS fpe_min(", stdout
);
17068 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
17069 fputs (") fpe_max(", stdout
);
17070 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
17071 fputs (")", stdout
);
17073 if (option
->info
& OEX_PAGE0
)
17074 fputs (" PAGE0", stdout
);
17075 if (option
->info
& OEX_SMM
)
17076 fputs (" SMM", stdout
);
17077 if (option
->info
& OEX_FPDBUG
)
17078 fputs (" FPDBUG", stdout
);
17079 if (option
->info
& OEX_DISMISS
)
17080 fputs (" DISMISS", stdout
);
17084 fputs (" PAD ", stdout
);
17085 if (option
->info
& OPAD_PREFIX
)
17086 fputs (" PREFIX", stdout
);
17087 if (option
->info
& OPAD_POSTFIX
)
17088 fputs (" POSTFIX", stdout
);
17089 if (option
->info
& OPAD_SYMBOL
)
17090 fputs (" SYMBOL", stdout
);
17094 fputs (" HWPATCH ", stdout
);
17095 if (option
->info
& OHW_R4KEOP
)
17096 fputs (" R4KEOP", stdout
);
17097 if (option
->info
& OHW_R8KPFETCH
)
17098 fputs (" R8KPFETCH", stdout
);
17099 if (option
->info
& OHW_R5KEOP
)
17100 fputs (" R5KEOP", stdout
);
17101 if (option
->info
& OHW_R5KCVTL
)
17102 fputs (" R5KCVTL", stdout
);
17106 fputs (" FILL ", stdout
);
17107 /* XXX Print content of info word? */
17111 fputs (" TAGS ", stdout
);
17112 /* XXX Print content of info word? */
17116 fputs (" HWAND ", stdout
);
17117 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17118 fputs (" R4KEOP_CHECKED", stdout
);
17119 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17120 fputs (" R4KEOP_CLEAN", stdout
);
17124 fputs (" HWOR ", stdout
);
17125 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17126 fputs (" R4KEOP_CHECKED", stdout
);
17127 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17128 fputs (" R4KEOP_CLEAN", stdout
);
17132 printf (" GP_GROUP %#06lx self-contained %#06lx",
17133 option
->info
& OGP_GROUP
,
17134 (option
->info
& OGP_SELF
) >> 16);
17138 printf (" IDENT %#06lx self-contained %#06lx",
17139 option
->info
& OGP_GROUP
,
17140 (option
->info
& OGP_SELF
) >> 16);
17144 /* This shouldn't happen. */
17145 printf (" %3d ??? %d %lx",
17146 option
->kind
, option
->section
, option
->info
);
17150 len
= sizeof (* eopt
);
17151 while (len
< option
->size
)
17153 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17155 if (ISPRINT (datum
))
17156 printf ("%c", datum
);
17158 printf ("\\%03o", datum
);
17161 fputs ("\n", stdout
);
17163 offset
+= option
->size
;
17173 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17175 Elf32_Conflict
* iconf
;
17178 if (filedata
->dynamic_symbols
== NULL
)
17180 error (_("conflict list found without a dynamic symbol table\n"));
17184 /* PR 21345 - print a slightly more helpful error message
17185 if we are sure that the cmalloc will fail. */
17186 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17188 error (_("Overlarge number of conflicts detected: %lx\n"),
17189 (long) conflictsno
);
17193 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17196 error (_("Out of memory allocating space for dynamic conflicts\n"));
17202 Elf32_External_Conflict
* econf32
;
17204 econf32
= (Elf32_External_Conflict
*)
17205 get_data (NULL
, filedata
, conflicts_offset
,
17206 sizeof (*econf32
), conflictsno
, _("conflict"));
17213 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17214 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17220 Elf64_External_Conflict
* econf64
;
17222 econf64
= (Elf64_External_Conflict
*)
17223 get_data (NULL
, filedata
, conflicts_offset
,
17224 sizeof (*econf64
), conflictsno
, _("conflict"));
17231 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17232 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17237 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17238 "\nSection '.conflict' contains %lu entries:\n",
17239 (unsigned long) conflictsno
),
17240 (unsigned long) conflictsno
);
17241 puts (_(" Num: Index Value Name"));
17243 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17245 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17247 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17248 printf (_("<corrupt symbol index>"));
17251 Elf_Internal_Sym
* psym
;
17253 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17254 print_vma (psym
->st_value
, FULL_HEX
);
17256 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17257 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17259 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17267 if (pltgot
!= 0 && local_gotno
!= 0)
17269 bfd_vma ent
, local_end
, global_end
;
17271 unsigned char * data
;
17272 unsigned char * data_end
;
17276 addr_size
= (is_32bit_elf
? 4 : 8);
17277 local_end
= pltgot
+ local_gotno
* addr_size
;
17279 /* PR binutils/17533 file: 012-111227-0.004 */
17280 if (symtabno
< gotsym
)
17282 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17283 (unsigned long) gotsym
, (unsigned long) symtabno
);
17287 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17288 /* PR 17531: file: 54c91a34. */
17289 if (global_end
< local_end
)
17291 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17295 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17296 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17297 global_end
- pltgot
, 1,
17298 _("Global Offset Table data"));
17299 /* PR 12855: Null data is handled gracefully throughout. */
17300 data_end
= data
+ (global_end
- pltgot
);
17302 printf (_("\nPrimary GOT:\n"));
17303 printf (_(" Canonical gp value: "));
17304 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17307 printf (_(" Reserved entries:\n"));
17308 printf (_(" %*s %10s %*s Purpose\n"),
17309 addr_size
* 2, _("Address"), _("Access"),
17310 addr_size
* 2, _("Initial"));
17311 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17312 printf (_(" Lazy resolver\n"));
17313 if (ent
== (bfd_vma
) -1)
17314 goto got_print_fail
;
17316 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17317 This entry will be used by some runtime loaders, to store the
17318 module pointer. Otherwise this is an ordinary local entry.
17319 PR 21344: Check for the entry being fully available before
17322 && data
+ ent
- pltgot
+ addr_size
<= data_end
17323 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17324 >> (addr_size
* 8 - 1)) != 0)
17326 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17327 printf (_(" Module pointer (GNU extension)\n"));
17328 if (ent
== (bfd_vma
) -1)
17329 goto got_print_fail
;
17333 if (data
!= NULL
&& ent
< local_end
)
17335 printf (_(" Local entries:\n"));
17336 printf (" %*s %10s %*s\n",
17337 addr_size
* 2, _("Address"), _("Access"),
17338 addr_size
* 2, _("Initial"));
17339 while (ent
< local_end
)
17341 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17343 if (ent
== (bfd_vma
) -1)
17344 goto got_print_fail
;
17349 if (data
!= NULL
&& gotsym
< symtabno
)
17353 printf (_(" Global entries:\n"));
17354 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17355 addr_size
* 2, _("Address"),
17357 addr_size
* 2, _("Initial"),
17358 addr_size
* 2, _("Sym.Val."),
17360 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17361 _("Ndx"), _("Name"));
17363 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17365 for (i
= gotsym
; i
< symtabno
; i
++)
17367 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17370 if (filedata
->dynamic_symbols
== NULL
)
17371 printf (_("<no dynamic symbols>"));
17372 else if (i
< filedata
->num_dynamic_syms
)
17374 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17376 print_vma (psym
->st_value
, LONG_HEX
);
17377 printf (" %-7s %3s ",
17378 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17379 get_symbol_index_type (filedata
, psym
->st_shndx
));
17381 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17382 print_symbol (sym_width
,
17383 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17385 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17388 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17389 (unsigned long) i
);
17392 if (ent
== (bfd_vma
) -1)
17403 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17406 size_t offset
, rel_offset
;
17407 unsigned long count
, i
;
17408 unsigned char * data
;
17409 int addr_size
, sym_width
;
17410 Elf_Internal_Rela
* rels
;
17412 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17413 if (pltrel
== DT_RELA
)
17415 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17420 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17425 addr_size
= (is_32bit_elf
? 4 : 8);
17426 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17428 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17429 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17430 1, _("Procedure Linkage Table data"));
17434 printf ("\nPLT GOT:\n\n");
17435 printf (_(" Reserved entries:\n"));
17436 printf (_(" %*s %*s Purpose\n"),
17437 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17438 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17439 printf (_(" PLT lazy resolver\n"));
17440 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17441 printf (_(" Module pointer\n"));
17444 printf (_(" Entries:\n"));
17445 printf (" %*s %*s %*s %-7s %3s %s\n",
17446 addr_size
* 2, _("Address"),
17447 addr_size
* 2, _("Initial"),
17448 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17449 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17450 for (i
= 0; i
< count
; i
++)
17452 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17454 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17457 if (idx
>= filedata
->num_dynamic_syms
)
17458 printf (_("<corrupt symbol index: %lu>"), idx
);
17461 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17463 print_vma (psym
->st_value
, LONG_HEX
);
17464 printf (" %-7s %3s ",
17465 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17466 get_symbol_index_type (filedata
, psym
->st_shndx
));
17467 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17468 print_symbol (sym_width
,
17469 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17471 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17486 process_nds32_specific (Filedata
* filedata
)
17488 Elf_Internal_Shdr
*sect
= NULL
;
17490 sect
= find_section (filedata
, ".nds32_e_flags");
17491 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17493 unsigned char *buf
;
17496 printf ("\nNDS32 elf flags section:\n");
17497 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17498 _("NDS32 elf flags section"));
17503 flag
= byte_get (buf
, 4);
17505 switch (flag
& 0x3)
17508 printf ("(VEC_SIZE):\tNo entry.\n");
17511 printf ("(VEC_SIZE):\t4 bytes\n");
17514 printf ("(VEC_SIZE):\t16 bytes\n");
17517 printf ("(VEC_SIZE):\treserved\n");
17526 process_gnu_liblist (Filedata
* filedata
)
17528 Elf_Internal_Shdr
* section
;
17529 Elf_Internal_Shdr
* string_sec
;
17530 Elf32_External_Lib
* elib
;
17532 size_t strtab_size
;
17534 unsigned long num_liblist
;
17536 bfd_boolean res
= TRUE
;
17541 for (i
= 0, section
= filedata
->section_headers
;
17542 i
< filedata
->file_header
.e_shnum
;
17545 switch (section
->sh_type
)
17547 case SHT_GNU_LIBLIST
:
17548 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17551 elib
= (Elf32_External_Lib
*)
17552 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17553 _("liblist section data"));
17561 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17562 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17563 string_sec
->sh_size
,
17564 _("liblist string table"));
17566 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17573 strtab_size
= string_sec
->sh_size
;
17575 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17576 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17577 "\nLibrary list section '%s' contains %lu entries:\n",
17579 printable_section_name (filedata
, section
),
17582 puts (_(" Library Time Stamp Checksum Version Flags"));
17584 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17592 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17593 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17594 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17595 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17596 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17598 tmp
= gmtime (&atime
);
17599 snprintf (timebuf
, sizeof (timebuf
),
17600 "%04u-%02u-%02uT%02u:%02u:%02u",
17601 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17602 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17604 printf ("%3lu: ", (unsigned long) cnt
);
17606 printf ("%-20s", liblist
.l_name
< strtab_size
17607 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17609 printf ("%-20.20s", liblist
.l_name
< strtab_size
17610 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17611 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17612 liblist
.l_version
, liblist
.l_flags
);
17623 static const char *
17624 get_note_type (Filedata
* filedata
, unsigned e_type
)
17626 static char buff
[64];
17628 if (filedata
->file_header
.e_type
== ET_CORE
)
17632 return _("NT_AUXV (auxiliary vector)");
17634 return _("NT_PRSTATUS (prstatus structure)");
17636 return _("NT_FPREGSET (floating point registers)");
17638 return _("NT_PRPSINFO (prpsinfo structure)");
17639 case NT_TASKSTRUCT
:
17640 return _("NT_TASKSTRUCT (task structure)");
17642 return _("NT_PRXFPREG (user_xfpregs structure)");
17644 return _("NT_PPC_VMX (ppc Altivec registers)");
17646 return _("NT_PPC_VSX (ppc VSX registers)");
17648 return _("NT_PPC_TAR (ppc TAR register)");
17650 return _("NT_PPC_PPR (ppc PPR register)");
17652 return _("NT_PPC_DSCR (ppc DSCR register)");
17654 return _("NT_PPC_EBB (ppc EBB registers)");
17656 return _("NT_PPC_PMU (ppc PMU registers)");
17657 case NT_PPC_TM_CGPR
:
17658 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17659 case NT_PPC_TM_CFPR
:
17660 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17661 case NT_PPC_TM_CVMX
:
17662 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17663 case NT_PPC_TM_CVSX
:
17664 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17665 case NT_PPC_TM_SPR
:
17666 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17667 case NT_PPC_TM_CTAR
:
17668 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17669 case NT_PPC_TM_CPPR
:
17670 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17671 case NT_PPC_TM_CDSCR
:
17672 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17674 return _("NT_386_TLS (x86 TLS information)");
17675 case NT_386_IOPERM
:
17676 return _("NT_386_IOPERM (x86 I/O permissions)");
17677 case NT_X86_XSTATE
:
17678 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17679 case NT_S390_HIGH_GPRS
:
17680 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17681 case NT_S390_TIMER
:
17682 return _("NT_S390_TIMER (s390 timer register)");
17683 case NT_S390_TODCMP
:
17684 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17685 case NT_S390_TODPREG
:
17686 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17688 return _("NT_S390_CTRS (s390 control registers)");
17689 case NT_S390_PREFIX
:
17690 return _("NT_S390_PREFIX (s390 prefix register)");
17691 case NT_S390_LAST_BREAK
:
17692 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17693 case NT_S390_SYSTEM_CALL
:
17694 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17696 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17697 case NT_S390_VXRS_LOW
:
17698 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17699 case NT_S390_VXRS_HIGH
:
17700 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17701 case NT_S390_GS_CB
:
17702 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17703 case NT_S390_GS_BC
:
17704 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17706 return _("NT_ARM_VFP (arm VFP registers)");
17708 return _("NT_ARM_TLS (AArch TLS registers)");
17709 case NT_ARM_HW_BREAK
:
17710 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17711 case NT_ARM_HW_WATCH
:
17712 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17714 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17716 return _("NT_PSTATUS (pstatus structure)");
17718 return _("NT_FPREGS (floating point registers)");
17720 return _("NT_PSINFO (psinfo structure)");
17722 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17724 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17725 case NT_WIN32PSTATUS
:
17726 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17728 return _("NT_SIGINFO (siginfo_t data)");
17730 return _("NT_FILE (mapped files)");
17738 return _("NT_VERSION (version)");
17740 return _("NT_ARCH (architecture)");
17741 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17743 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17749 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17754 print_core_note (Elf_Internal_Note
*pnote
)
17756 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17757 bfd_vma count
, page_size
;
17758 unsigned char *descdata
, *filenames
, *descend
;
17760 if (pnote
->type
!= NT_FILE
)
17770 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17771 /* Still "successful". */
17776 if (pnote
->descsz
< 2 * addr_size
)
17778 error (_(" Malformed note - too short for header\n"));
17782 descdata
= (unsigned char *) pnote
->descdata
;
17783 descend
= descdata
+ pnote
->descsz
;
17785 if (descdata
[pnote
->descsz
- 1] != '\0')
17787 error (_(" Malformed note - does not end with \\0\n"));
17791 count
= byte_get (descdata
, addr_size
);
17792 descdata
+= addr_size
;
17794 page_size
= byte_get (descdata
, addr_size
);
17795 descdata
+= addr_size
;
17797 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17798 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17800 error (_(" Malformed note - too short for supplied file count\n"));
17804 printf (_(" Page size: "));
17805 print_vma (page_size
, DEC
);
17808 printf (_(" %*s%*s%*s\n"),
17809 (int) (2 + 2 * addr_size
), _("Start"),
17810 (int) (4 + 2 * addr_size
), _("End"),
17811 (int) (4 + 2 * addr_size
), _("Page Offset"));
17812 filenames
= descdata
+ count
* 3 * addr_size
;
17813 while (count
-- > 0)
17815 bfd_vma start
, end
, file_ofs
;
17817 if (filenames
== descend
)
17819 error (_(" Malformed note - filenames end too early\n"));
17823 start
= byte_get (descdata
, addr_size
);
17824 descdata
+= addr_size
;
17825 end
= byte_get (descdata
, addr_size
);
17826 descdata
+= addr_size
;
17827 file_ofs
= byte_get (descdata
, addr_size
);
17828 descdata
+= addr_size
;
17831 print_vma (start
, FULL_HEX
);
17833 print_vma (end
, FULL_HEX
);
17835 print_vma (file_ofs
, FULL_HEX
);
17836 printf ("\n %s\n", filenames
);
17838 filenames
+= 1 + strlen ((char *) filenames
);
17844 static const char *
17845 get_gnu_elf_note_type (unsigned e_type
)
17847 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17850 case NT_GNU_ABI_TAG
:
17851 return _("NT_GNU_ABI_TAG (ABI version tag)");
17853 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17854 case NT_GNU_BUILD_ID
:
17855 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17856 case NT_GNU_GOLD_VERSION
:
17857 return _("NT_GNU_GOLD_VERSION (gold version)");
17858 case NT_GNU_PROPERTY_TYPE_0
:
17859 return _("NT_GNU_PROPERTY_TYPE_0");
17860 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17861 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17862 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17863 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17866 static char buff
[64];
17868 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17875 decode_x86_compat_isa (unsigned int bitmask
)
17879 unsigned int bit
= bitmask
& (- bitmask
);
17884 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17887 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17890 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17893 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17896 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17899 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17902 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17905 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17908 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17911 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17914 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17917 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17918 printf ("AVX512F");
17920 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17921 printf ("AVX512CD");
17923 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17924 printf ("AVX512ER");
17926 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17927 printf ("AVX512PF");
17929 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17930 printf ("AVX512VL");
17932 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17933 printf ("AVX512DQ");
17935 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17936 printf ("AVX512BW");
17939 printf (_("<unknown: %x>"), bit
);
17948 decode_x86_isa (unsigned int bitmask
)
17952 printf (_("<None>"));
17958 unsigned int bit
= bitmask
& (- bitmask
);
17963 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17966 case GNU_PROPERTY_X86_ISA_1_SSE
:
17969 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17972 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17975 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17978 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17981 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17984 case GNU_PROPERTY_X86_ISA_1_AVX
:
17987 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17990 case GNU_PROPERTY_X86_ISA_1_FMA
:
17993 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17994 printf ("AVX512F");
17996 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17997 printf ("AVX512CD");
17999 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
18000 printf ("AVX512ER");
18002 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
18003 printf ("AVX512PF");
18005 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
18006 printf ("AVX512VL");
18008 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
18009 printf ("AVX512DQ");
18011 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
18012 printf ("AVX512BW");
18014 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
18015 printf ("AVX512_4FMAPS");
18017 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
18018 printf ("AVX512_4VNNIW");
18020 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
18021 printf ("AVX512_BITALG");
18023 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
18024 printf ("AVX512_IFMA");
18026 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
18027 printf ("AVX512_VBMI");
18029 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
18030 printf ("AVX512_VBMI2");
18032 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
18033 printf ("AVX512_VNNI");
18035 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
18036 printf ("AVX512_BF16");
18039 printf (_("<unknown: %x>"), bit
);
18048 decode_x86_feature_1 (unsigned int bitmask
)
18052 printf (_("<None>"));
18058 unsigned int bit
= bitmask
& (- bitmask
);
18063 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18066 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18070 printf (_("<unknown: %x>"), bit
);
18079 decode_x86_feature_2 (unsigned int bitmask
)
18083 printf (_("<None>"));
18089 unsigned int bit
= bitmask
& (- bitmask
);
18094 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18097 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18100 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18103 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18106 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18109 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18112 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18115 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18118 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18119 printf ("XSAVEOPT");
18121 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18125 printf (_("<unknown: %x>"), bit
);
18134 decode_aarch64_feature_1_and (unsigned int bitmask
)
18138 unsigned int bit
= bitmask
& (- bitmask
);
18143 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18147 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18152 printf (_("<unknown: %x>"), bit
);
18161 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18163 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18164 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18165 unsigned int size
= is_32bit_elf
? 4 : 8;
18167 printf (_(" Properties: "));
18169 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18171 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18175 while (ptr
< ptr_end
)
18179 unsigned int datasz
;
18181 if ((size_t) (ptr_end
- ptr
) < 8)
18183 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18187 type
= byte_get (ptr
, 4);
18188 datasz
= byte_get (ptr
+ 4, 4);
18192 if (datasz
> (size_t) (ptr_end
- ptr
))
18194 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18199 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18201 if (filedata
->file_header
.e_machine
== EM_X86_64
18202 || filedata
->file_header
.e_machine
== EM_IAMCU
18203 || filedata
->file_header
.e_machine
== EM_386
)
18205 unsigned int bitmask
;
18208 bitmask
= byte_get (ptr
, 4);
18214 case GNU_PROPERTY_X86_ISA_1_USED
:
18216 printf (_("x86 ISA used: <corrupt length: %#x> "),
18220 printf ("x86 ISA used: ");
18221 decode_x86_isa (bitmask
);
18225 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18227 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18231 printf ("x86 ISA needed: ");
18232 decode_x86_isa (bitmask
);
18236 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18238 printf (_("x86 feature: <corrupt length: %#x> "),
18242 printf ("x86 feature: ");
18243 decode_x86_feature_1 (bitmask
);
18247 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18249 printf (_("x86 feature used: <corrupt length: %#x> "),
18253 printf ("x86 feature used: ");
18254 decode_x86_feature_2 (bitmask
);
18258 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18260 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18263 printf ("x86 feature needed: ");
18264 decode_x86_feature_2 (bitmask
);
18268 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18270 printf (_("x86 ISA used: <corrupt length: %#x> "),
18274 printf ("x86 ISA used: ");
18275 decode_x86_compat_isa (bitmask
);
18279 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18281 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18285 printf ("x86 ISA needed: ");
18286 decode_x86_compat_isa (bitmask
);
18294 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18296 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18298 printf ("AArch64 feature: ");
18300 printf (_("<corrupt length: %#x> "), datasz
);
18302 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18311 case GNU_PROPERTY_STACK_SIZE
:
18312 printf (_("stack size: "));
18313 if (datasz
!= size
)
18314 printf (_("<corrupt length: %#x> "), datasz
);
18316 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18319 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18320 printf ("no copy on protected ");
18322 printf (_("<corrupt length: %#x> "), datasz
);
18330 if (type
< GNU_PROPERTY_LOPROC
)
18331 printf (_("<unknown type %#x data: "), type
);
18332 else if (type
< GNU_PROPERTY_LOUSER
)
18333 printf (_("<procesor-specific type %#x data: "), type
);
18335 printf (_("<application-specific type %#x data: "), type
);
18336 for (j
= 0; j
< datasz
; ++j
)
18337 printf ("%02x ", ptr
[j
] & 0xff);
18341 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18342 if (ptr
== ptr_end
)
18355 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18357 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18358 switch (pnote
->type
)
18360 case NT_GNU_BUILD_ID
:
18364 printf (_(" Build ID: "));
18365 for (i
= 0; i
< pnote
->descsz
; ++i
)
18366 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18371 case NT_GNU_ABI_TAG
:
18373 unsigned long os
, major
, minor
, subminor
;
18374 const char *osname
;
18376 /* PR 17531: file: 030-599401-0.004. */
18377 if (pnote
->descsz
< 16)
18379 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18383 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18384 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18385 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18386 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18390 case GNU_ABI_TAG_LINUX
:
18393 case GNU_ABI_TAG_HURD
:
18396 case GNU_ABI_TAG_SOLARIS
:
18397 osname
= "Solaris";
18399 case GNU_ABI_TAG_FREEBSD
:
18400 osname
= "FreeBSD";
18402 case GNU_ABI_TAG_NETBSD
:
18405 case GNU_ABI_TAG_SYLLABLE
:
18406 osname
= "Syllable";
18408 case GNU_ABI_TAG_NACL
:
18412 osname
= "Unknown";
18416 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18417 major
, minor
, subminor
);
18421 case NT_GNU_GOLD_VERSION
:
18425 printf (_(" Version: "));
18426 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18427 printf ("%c", pnote
->descdata
[i
]);
18434 unsigned long num_entries
, mask
;
18436 /* Hardware capabilities information. Word 0 is the number of entries.
18437 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18438 is a series of entries, where each entry is a single byte followed
18439 by a nul terminated string. The byte gives the bit number to test
18440 if enabled in the bitmask. */
18441 printf (_(" Hardware Capabilities: "));
18442 if (pnote
->descsz
< 8)
18444 error (_("<corrupt GNU_HWCAP>\n"));
18447 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18448 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18449 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18450 /* FIXME: Add code to display the entries... */
18454 case NT_GNU_PROPERTY_TYPE_0
:
18455 print_gnu_property_note (filedata
, pnote
);
18459 /* Handle unrecognised types. An error message should have already been
18460 created by get_gnu_elf_note_type(), so all that we need to do is to
18461 display the data. */
18465 printf (_(" Description data: "));
18466 for (i
= 0; i
< pnote
->descsz
; ++i
)
18467 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18476 static const char *
18477 get_v850_elf_note_type (enum v850_notes n_type
)
18479 static char buff
[64];
18483 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18484 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18485 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18486 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18487 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18488 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18490 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18496 print_v850_note (Elf_Internal_Note
* pnote
)
18500 if (pnote
->descsz
!= 4)
18503 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18507 printf (_("not set\n"));
18511 switch (pnote
->type
)
18513 case V850_NOTE_ALIGNMENT
:
18516 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18517 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18521 case V850_NOTE_DATA_SIZE
:
18524 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18525 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18529 case V850_NOTE_FPU_INFO
:
18532 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18533 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18537 case V850_NOTE_MMU_INFO
:
18538 case V850_NOTE_CACHE_INFO
:
18539 case V850_NOTE_SIMD_INFO
:
18540 if (val
== EF_RH850_SIMD
)
18542 printf (_("yes\n"));
18548 /* An 'unknown note type' message will already have been displayed. */
18552 printf (_("unknown value: %x\n"), val
);
18557 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18559 unsigned int version
;
18561 switch (pnote
->type
)
18563 case NT_NETBSD_IDENT
:
18564 if (pnote
->descsz
< 1)
18566 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18567 if ((version
/ 10000) % 100)
18568 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18569 version
, version
/ 100000000, (version
/ 1000000) % 100,
18570 (version
/ 10000) % 100 > 26 ? "Z" : "",
18571 'A' + (version
/ 10000) % 26);
18573 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18574 version
, version
/ 100000000, (version
/ 1000000) % 100,
18575 (version
/ 100) % 100);
18578 case NT_NETBSD_MARCH
:
18579 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18583 #ifdef NT_NETBSD_PAX
18584 case NT_NETBSD_PAX
:
18585 if (pnote
->descsz
< 1)
18587 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18588 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18589 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18590 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18591 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18592 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18593 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18594 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18599 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18600 pnote
->descsz
, pnote
->type
);
18604 static const char *
18605 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18609 case NT_FREEBSD_THRMISC
:
18610 return _("NT_THRMISC (thrmisc structure)");
18611 case NT_FREEBSD_PROCSTAT_PROC
:
18612 return _("NT_PROCSTAT_PROC (proc data)");
18613 case NT_FREEBSD_PROCSTAT_FILES
:
18614 return _("NT_PROCSTAT_FILES (files data)");
18615 case NT_FREEBSD_PROCSTAT_VMMAP
:
18616 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18617 case NT_FREEBSD_PROCSTAT_GROUPS
:
18618 return _("NT_PROCSTAT_GROUPS (groups data)");
18619 case NT_FREEBSD_PROCSTAT_UMASK
:
18620 return _("NT_PROCSTAT_UMASK (umask data)");
18621 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18622 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18623 case NT_FREEBSD_PROCSTAT_OSREL
:
18624 return _("NT_PROCSTAT_OSREL (osreldate data)");
18625 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18626 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18627 case NT_FREEBSD_PROCSTAT_AUXV
:
18628 return _("NT_PROCSTAT_AUXV (auxv data)");
18629 case NT_FREEBSD_PTLWPINFO
:
18630 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18632 return get_note_type (filedata
, e_type
);
18635 static const char *
18636 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18638 static char buff
[64];
18642 case NT_NETBSDCORE_PROCINFO
:
18643 /* NetBSD core "procinfo" structure. */
18644 return _("NetBSD procinfo structure");
18646 #ifdef NT_NETBSDCORE_AUXV
18647 case NT_NETBSDCORE_AUXV
:
18648 return _("NetBSD ELF auxiliary vector data");
18651 #ifdef NT_NETBSDCORE_LWPSTATUS
18652 case NT_NETBSDCORE_LWPSTATUS
:
18653 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18657 /* As of Jan 2020 there are no other machine-independent notes
18658 defined for NetBSD core files. If the note type is less
18659 than the start of the machine-dependent note types, we don't
18662 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18664 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18670 switch (filedata
->file_header
.e_machine
)
18672 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18673 and PT_GETFPREGS == mach+2. */
18678 case EM_SPARC32PLUS
:
18682 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18683 return _("PT_GETREGS (reg structure)");
18684 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18685 return _("PT_GETFPREGS (fpreg structure)");
18691 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18692 There's also old PT___GETREGS40 == mach + 1 for old reg
18693 structure which lacks GBR. */
18697 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18698 return _("PT___GETREGS40 (old reg structure)");
18699 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18700 return _("PT_GETREGS (reg structure)");
18701 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18702 return _("PT_GETFPREGS (fpreg structure)");
18708 /* On all other arch's, PT_GETREGS == mach+1 and
18709 PT_GETFPREGS == mach+3. */
18713 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18714 return _("PT_GETREGS (reg structure)");
18715 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18716 return _("PT_GETFPREGS (fpreg structure)");
18722 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18723 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18727 static const char *
18728 get_stapsdt_note_type (unsigned e_type
)
18730 static char buff
[64];
18735 return _("NT_STAPSDT (SystemTap probe descriptors)");
18741 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18746 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18748 size_t len
, maxlen
;
18749 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18750 char *data
= pnote
->descdata
;
18751 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18752 bfd_vma pc
, base_addr
, semaphore
;
18753 char *provider
, *probe
, *arg_fmt
;
18755 if (pnote
->descsz
< (addr_size
* 3))
18756 goto stapdt_note_too_small
;
18758 pc
= byte_get ((unsigned char *) data
, addr_size
);
18761 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18764 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18767 if (data
>= data_end
)
18768 goto stapdt_note_too_small
;
18769 maxlen
= data_end
- data
;
18770 len
= strnlen (data
, maxlen
);
18777 goto stapdt_note_too_small
;
18779 if (data
>= data_end
)
18780 goto stapdt_note_too_small
;
18781 maxlen
= data_end
- data
;
18782 len
= strnlen (data
, maxlen
);
18789 goto stapdt_note_too_small
;
18791 if (data
>= data_end
)
18792 goto stapdt_note_too_small
;
18793 maxlen
= data_end
- data
;
18794 len
= strnlen (data
, maxlen
);
18801 goto stapdt_note_too_small
;
18803 printf (_(" Provider: %s\n"), provider
);
18804 printf (_(" Name: %s\n"), probe
);
18805 printf (_(" Location: "));
18806 print_vma (pc
, FULL_HEX
);
18807 printf (_(", Base: "));
18808 print_vma (base_addr
, FULL_HEX
);
18809 printf (_(", Semaphore: "));
18810 print_vma (semaphore
, FULL_HEX
);
18812 printf (_(" Arguments: %s\n"), arg_fmt
);
18814 return data
== data_end
;
18816 stapdt_note_too_small
:
18817 printf (_(" <corrupt - note is too small>\n"));
18818 error (_("corrupt stapdt note - the data size is too small\n"));
18822 static const char *
18823 get_ia64_vms_note_type (unsigned e_type
)
18825 static char buff
[64];
18830 return _("NT_VMS_MHD (module header)");
18832 return _("NT_VMS_LNM (language name)");
18834 return _("NT_VMS_SRC (source files)");
18836 return "NT_VMS_TITLE";
18838 return _("NT_VMS_EIDC (consistency check)");
18839 case NT_VMS_FPMODE
:
18840 return _("NT_VMS_FPMODE (FP mode)");
18841 case NT_VMS_LINKTIME
:
18842 return "NT_VMS_LINKTIME";
18843 case NT_VMS_IMGNAM
:
18844 return _("NT_VMS_IMGNAM (image name)");
18846 return _("NT_VMS_IMGID (image id)");
18847 case NT_VMS_LINKID
:
18848 return _("NT_VMS_LINKID (link id)");
18849 case NT_VMS_IMGBID
:
18850 return _("NT_VMS_IMGBID (build id)");
18851 case NT_VMS_GSTNAM
:
18852 return _("NT_VMS_GSTNAM (sym table name)");
18853 case NT_VMS_ORIG_DYN
:
18854 return "NT_VMS_ORIG_DYN";
18855 case NT_VMS_PATCHTIME
:
18856 return "NT_VMS_PATCHTIME";
18858 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18864 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18866 int maxlen
= pnote
->descsz
;
18868 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18869 goto desc_size_fail
;
18871 switch (pnote
->type
)
18875 goto desc_size_fail
;
18877 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18879 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18880 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18881 if (l
+ 34 < maxlen
)
18883 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18884 if (l
+ 35 < maxlen
)
18885 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18887 printf (_(" Module version : <missing>\n"));
18891 printf (_(" Module name : <missing>\n"));
18892 printf (_(" Module version : <missing>\n"));
18897 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18901 case NT_VMS_FPMODE
:
18902 printf (_(" Floating Point mode: "));
18904 goto desc_size_fail
;
18905 /* FIXME: Generate an error if descsz > 8 ? */
18907 printf ("0x%016" BFD_VMA_FMT
"x\n",
18908 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18911 case NT_VMS_LINKTIME
:
18912 printf (_(" Link time: "));
18914 goto desc_size_fail
;
18915 /* FIXME: Generate an error if descsz > 8 ? */
18918 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18922 case NT_VMS_PATCHTIME
:
18923 printf (_(" Patch time: "));
18925 goto desc_size_fail
;
18926 /* FIXME: Generate an error if descsz > 8 ? */
18929 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18933 case NT_VMS_ORIG_DYN
:
18935 goto desc_size_fail
;
18937 printf (_(" Major id: %u, minor id: %u\n"),
18938 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18939 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18940 printf (_(" Last modified : "));
18942 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18943 printf (_("\n Link flags : "));
18944 printf ("0x%016" BFD_VMA_FMT
"x\n",
18945 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18946 printf (_(" Header flags: 0x%08x\n"),
18947 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18948 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18952 case NT_VMS_IMGNAM
:
18953 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18956 case NT_VMS_GSTNAM
:
18957 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18961 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18964 case NT_VMS_LINKID
:
18965 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18975 printf (_(" <corrupt - data size is too small>\n"));
18976 error (_("corrupt IA64 note: data size is too small\n"));
18980 struct build_attr_cache
{
18981 Filedata
*filedata
;
18983 unsigned long strtablen
;
18984 Elf_Internal_Sym
*symtab
;
18985 unsigned long nsyms
;
18988 /* Find the symbol associated with a build attribute that is attached
18989 to address OFFSET. If PNAME is non-NULL then store the name of
18990 the symbol (if found) in the provided pointer, Returns NULL if a
18991 symbol could not be found. */
18993 static Elf_Internal_Sym
*
18994 get_symbol_for_build_attribute (Filedata
* filedata
,
18995 unsigned long offset
,
18996 bfd_boolean is_open_attr
,
18997 const char ** pname
)
18999 Elf_Internal_Sym
*saved_sym
= NULL
;
19000 Elf_Internal_Sym
*sym
;
19002 if (filedata
->section_headers
!= NULL
19003 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
19005 Elf_Internal_Shdr
* symsec
;
19007 free (ba_cache
.strtab
);
19008 ba_cache
.strtab
= NULL
;
19009 free (ba_cache
.symtab
);
19010 ba_cache
.symtab
= NULL
;
19012 /* Load the symbol and string sections. */
19013 for (symsec
= filedata
->section_headers
;
19014 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19017 if (symsec
->sh_type
== SHT_SYMTAB
19018 && get_symtab (filedata
, symsec
,
19019 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19020 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19023 ba_cache
.filedata
= filedata
;
19026 if (ba_cache
.symtab
== NULL
)
19029 /* Find a symbol whose value matches offset. */
19030 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19031 if (sym
->st_value
== offset
)
19033 if (sym
->st_name
>= ba_cache
.strtablen
)
19034 /* Huh ? This should not happen. */
19037 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19040 /* The AArch64 and ARM architectures define mapping symbols
19041 (eg $d, $x, $t) which we want to ignore. */
19042 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19043 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19044 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19049 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19050 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19051 FUNC symbols entirely. */
19052 switch (ELF_ST_TYPE (sym
->st_info
))
19059 /* If the symbol has a size associated
19060 with it then we can stop searching. */
19061 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19066 /* Ignore function symbols. */
19073 switch (ELF_ST_BIND (sym
->st_info
))
19076 if (saved_sym
== NULL
19077 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19082 if (saved_sym
== NULL
)
19092 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19100 if (saved_sym
&& pname
)
19101 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19106 /* Returns true iff addr1 and addr2 are in the same section. */
19109 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19111 Elf_Internal_Shdr
* a1
;
19112 Elf_Internal_Shdr
* a2
;
19114 a1
= find_section_by_address (filedata
, addr1
);
19115 a2
= find_section_by_address (filedata
, addr2
);
19117 return a1
== a2
&& a1
!= NULL
;
19121 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19122 Filedata
* filedata
)
19124 static unsigned long global_offset
= 0;
19125 static unsigned long global_end
= 0;
19126 static unsigned long func_offset
= 0;
19127 static unsigned long func_end
= 0;
19129 Elf_Internal_Sym
* sym
;
19131 unsigned long start
;
19133 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19135 switch (pnote
->descsz
)
19138 /* A zero-length description means that the range of
19139 the previous note of the same type should be used. */
19142 if (global_end
> global_offset
)
19143 printf (_(" Applies to region from %#lx to %#lx\n"),
19144 global_offset
, global_end
);
19146 printf (_(" Applies to region from %#lx\n"), global_offset
);
19150 if (func_end
> func_offset
)
19151 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19153 printf (_(" Applies to region from %#lx\n"), func_offset
);
19158 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19165 /* FIXME: We should check that version 3+ notes are being used here... */
19166 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19167 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19171 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19177 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19178 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19182 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19183 printf (_(" <invalid descsz>"));
19188 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19189 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19190 in order to avoid them being confused with the start address of the
19191 first function in the file... */
19192 if (sym
== NULL
&& is_open_attr
)
19193 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19196 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19197 end
= start
+ sym
->st_size
;
19201 /* FIXME: Need to properly allow for section alignment.
19202 16 is just the alignment used on x86_64. */
19204 && start
> BFD_ALIGN (global_end
, 16)
19205 /* Build notes are not guaranteed to be organised in order of
19206 increasing address, but we should find the all of the notes
19207 for one section in the same place. */
19208 && same_section (filedata
, start
, global_end
))
19209 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19210 global_end
+ 1, start
- 1);
19212 printf (_(" Applies to region from %#lx"), start
);
19213 global_offset
= start
;
19217 printf (_(" to %#lx"), end
);
19223 printf (_(" Applies to region from %#lx"), start
);
19224 func_offset
= start
;
19228 printf (_(" to %#lx"), end
);
19234 printf (_(" (%s)"), name
);
19241 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19243 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19244 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19245 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19247 char name_attribute
;
19248 const char * expected_types
;
19249 const char * name
= pnote
->namedata
;
19253 if (name
== NULL
|| pnote
->namesz
< 2)
19255 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19256 print_symbol (-20, _(" <corrupt name>"));
19265 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19266 if (name
[0] == 'G' && name
[1] == 'A')
19268 if (pnote
->namesz
< 4)
19270 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19271 print_symbol (-20, _(" <corrupt name>"));
19280 switch ((name_type
= * name
))
19282 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19283 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19284 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19285 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19286 printf ("%c", * name
);
19290 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19291 print_symbol (-20, _("<unknown name type>"));
19298 switch ((name_attribute
= * name
))
19300 case GNU_BUILD_ATTRIBUTE_VERSION
:
19301 text
= _("<version>");
19302 expected_types
= string_expected
;
19305 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19306 text
= _("<stack prot>");
19307 expected_types
= "!+*";
19310 case GNU_BUILD_ATTRIBUTE_RELRO
:
19311 text
= _("<relro>");
19312 expected_types
= bool_expected
;
19315 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19316 text
= _("<stack size>");
19317 expected_types
= number_expected
;
19320 case GNU_BUILD_ATTRIBUTE_TOOL
:
19321 text
= _("<tool>");
19322 expected_types
= string_expected
;
19325 case GNU_BUILD_ATTRIBUTE_ABI
:
19327 expected_types
= "$*";
19330 case GNU_BUILD_ATTRIBUTE_PIC
:
19332 expected_types
= number_expected
;
19335 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19336 text
= _("<short enum>");
19337 expected_types
= bool_expected
;
19341 if (ISPRINT (* name
))
19343 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19345 if (len
> left
&& ! do_wide
)
19347 printf ("%.*s:", len
, name
);
19353 static char tmpbuf
[128];
19355 error (_("unrecognised byte in name field: %d\n"), * name
);
19356 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19360 expected_types
= "*$!+";
19365 left
-= printf ("%s", text
);
19367 if (strchr (expected_types
, name_type
) == NULL
)
19368 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19370 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19372 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19373 (unsigned long) pnote
->namesz
,
19374 (long) (name
- pnote
->namedata
));
19378 if (left
< 1 && ! do_wide
)
19383 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19385 unsigned int bytes
;
19386 unsigned long long val
= 0;
19387 unsigned int shift
= 0;
19388 char * decoded
= NULL
;
19390 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19392 /* The -1 is because the name field is always 0 terminated, and we
19393 want to be able to ensure that the shift in the while loop below
19394 will not overflow. */
19397 if (bytes
> sizeof (val
))
19399 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19401 bytes
= sizeof (val
);
19403 /* We do not bother to warn if bytes == 0 as this can
19404 happen with some early versions of the gcc plugin. */
19408 unsigned long byte
= (* name
++) & 0xff;
19410 val
|= byte
<< shift
;
19414 switch (name_attribute
)
19416 case GNU_BUILD_ATTRIBUTE_PIC
:
19419 case 0: decoded
= "static"; break;
19420 case 1: decoded
= "pic"; break;
19421 case 2: decoded
= "PIC"; break;
19422 case 3: decoded
= "pie"; break;
19423 case 4: decoded
= "PIE"; break;
19427 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19430 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19431 case 0: decoded
= "off"; break;
19432 case 1: decoded
= "on"; break;
19433 case 2: decoded
= "all"; break;
19434 case 3: decoded
= "strong"; break;
19435 case 4: decoded
= "explicit"; break;
19443 if (decoded
!= NULL
)
19445 print_symbol (-left
, decoded
);
19456 left
-= printf ("0x%llx", val
);
19458 left
-= printf ("0x%-.*llx", left
, val
);
19462 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19463 left
-= print_symbol (- left
, name
);
19465 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19466 left
-= print_symbol (- left
, "true");
19468 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19469 left
-= print_symbol (- left
, "false");
19473 if (do_wide
&& left
> 0)
19474 printf ("%-*s", left
, " ");
19479 /* Note that by the ELF standard, the name field is already null byte
19480 terminated, and namesz includes the terminating null byte.
19481 I.E. the value of namesz for the name "FSF" is 4.
19483 If the value of namesz is zero, there is no name present. */
19486 process_note (Elf_Internal_Note
* pnote
,
19487 Filedata
* filedata
)
19489 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19492 if (pnote
->namesz
== 0)
19493 /* If there is no note name, then use the default set of
19494 note type strings. */
19495 nt
= get_note_type (filedata
, pnote
->type
);
19497 else if (const_strneq (pnote
->namedata
, "GNU"))
19498 /* GNU-specific object file notes. */
19499 nt
= get_gnu_elf_note_type (pnote
->type
);
19501 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19502 /* FreeBSD-specific core file notes. */
19503 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19505 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19506 /* NetBSD-specific core file notes. */
19507 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19509 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19510 /* NetBSD-specific core file notes. */
19511 return process_netbsd_elf_note (pnote
);
19513 else if (const_strneq (pnote
->namedata
, "PaX"))
19514 /* NetBSD-specific core file notes. */
19515 return process_netbsd_elf_note (pnote
);
19517 else if (strneq (pnote
->namedata
, "SPU/", 4))
19519 /* SPU-specific core file notes. */
19520 nt
= pnote
->namedata
+ 4;
19524 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19525 /* VMS/ia64-specific file notes. */
19526 nt
= get_ia64_vms_note_type (pnote
->type
);
19528 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19529 nt
= get_stapsdt_note_type (pnote
->type
);
19532 /* Don't recognize this note name; just use the default set of
19533 note type strings. */
19534 nt
= get_note_type (filedata
, pnote
->type
);
19538 if (((const_strneq (pnote
->namedata
, "GA")
19539 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19540 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19541 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19542 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19543 print_gnu_build_attribute_name (pnote
);
19545 print_symbol (-20, name
);
19548 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19550 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19552 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19553 return print_ia64_vms_note (pnote
);
19554 else if (const_strneq (pnote
->namedata
, "GNU"))
19555 return print_gnu_note (filedata
, pnote
);
19556 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19557 return print_stapsdt_note (pnote
);
19558 else if (const_strneq (pnote
->namedata
, "CORE"))
19559 return print_core_note (pnote
);
19560 else if (((const_strneq (pnote
->namedata
, "GA")
19561 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19562 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19563 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19564 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19565 return print_gnu_build_attribute_description (pnote
, filedata
);
19571 printf (_(" description data: "));
19572 for (i
= 0; i
< pnote
->descsz
; i
++)
19573 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19585 process_notes_at (Filedata
* filedata
,
19586 Elf_Internal_Shdr
* section
,
19591 Elf_External_Note
* pnotes
;
19592 Elf_External_Note
* external
;
19594 bfd_boolean res
= TRUE
;
19601 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19604 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19612 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19615 if (pnotes
== NULL
)
19621 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19623 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19624 (unsigned long) offset
, (unsigned long) length
);
19626 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19627 specifies that notes should be aligned to 4 bytes in 32-bit
19628 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19629 we also support 4 byte alignment in 64-bit objects. If section
19630 alignment is less than 4, we treate alignment as 4 bytes. */
19633 else if (align
!= 4 && align
!= 8)
19635 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19641 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19643 end
= (char *) pnotes
+ length
;
19644 while ((char *) external
< end
)
19646 Elf_Internal_Note inote
;
19649 char * temp
= NULL
;
19650 size_t data_remaining
= end
- (char *) external
;
19652 if (!is_ia64_vms (filedata
))
19654 /* PR binutils/15191
19655 Make sure that there is enough data to read. */
19656 min_notesz
= offsetof (Elf_External_Note
, name
);
19657 if (data_remaining
< min_notesz
)
19659 warn (ngettext ("Corrupt note: only %ld byte remains, "
19660 "not enough for a full note\n",
19661 "Corrupt note: only %ld bytes remain, "
19662 "not enough for a full note\n",
19664 (long) data_remaining
);
19667 data_remaining
-= min_notesz
;
19669 inote
.type
= BYTE_GET (external
->type
);
19670 inote
.namesz
= BYTE_GET (external
->namesz
);
19671 inote
.namedata
= external
->name
;
19672 inote
.descsz
= BYTE_GET (external
->descsz
);
19673 inote
.descdata
= ((char *) external
19674 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19675 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19676 next
= ((char *) external
19677 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19681 Elf64_External_VMS_Note
*vms_external
;
19683 /* PR binutils/15191
19684 Make sure that there is enough data to read. */
19685 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19686 if (data_remaining
< min_notesz
)
19688 warn (ngettext ("Corrupt note: only %ld byte remains, "
19689 "not enough for a full note\n",
19690 "Corrupt note: only %ld bytes remain, "
19691 "not enough for a full note\n",
19693 (long) data_remaining
);
19696 data_remaining
-= min_notesz
;
19698 vms_external
= (Elf64_External_VMS_Note
*) external
;
19699 inote
.type
= BYTE_GET (vms_external
->type
);
19700 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19701 inote
.namedata
= vms_external
->name
;
19702 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19703 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19704 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19705 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19708 /* PR 17531: file: 3443835e. */
19709 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19710 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19711 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19712 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19713 || ((size_t) (next
- inote
.descdata
)
19714 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19716 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19717 (unsigned long) ((char *) external
- (char *) pnotes
));
19718 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19719 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19723 external
= (Elf_External_Note
*) next
;
19725 /* Verify that name is null terminated. It appears that at least
19726 one version of Linux (RedHat 6.0) generates corefiles that don't
19727 comply with the ELF spec by failing to include the null byte in
19729 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19731 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19733 temp
= (char *) malloc (inote
.namesz
+ 1);
19736 error (_("Out of memory allocating space for inote name\n"));
19741 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19742 inote
.namedata
= temp
;
19744 inote
.namedata
[inote
.namesz
] = 0;
19747 if (! process_note (& inote
, filedata
))
19763 process_corefile_note_segments (Filedata
* filedata
)
19765 Elf_Internal_Phdr
* segment
;
19767 bfd_boolean res
= TRUE
;
19769 if (! get_program_headers (filedata
))
19772 for (i
= 0, segment
= filedata
->program_headers
;
19773 i
< filedata
->file_header
.e_phnum
;
19776 if (segment
->p_type
== PT_NOTE
)
19777 if (! process_notes_at (filedata
, NULL
,
19778 (bfd_vma
) segment
->p_offset
,
19779 (bfd_vma
) segment
->p_filesz
,
19780 (bfd_vma
) segment
->p_align
))
19788 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19790 Elf_External_Note
* pnotes
;
19791 Elf_External_Note
* external
;
19793 bfd_boolean res
= TRUE
;
19798 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19800 if (pnotes
== NULL
)
19804 end
= (char*) pnotes
+ length
;
19806 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19807 (unsigned long) offset
, (unsigned long) length
);
19809 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19811 Elf_External_Note
* next
;
19812 Elf_Internal_Note inote
;
19814 inote
.type
= BYTE_GET (external
->type
);
19815 inote
.namesz
= BYTE_GET (external
->namesz
);
19816 inote
.namedata
= external
->name
;
19817 inote
.descsz
= BYTE_GET (external
->descsz
);
19818 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19819 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19821 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19823 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19824 inote
.descdata
= inote
.namedata
;
19828 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19830 if ( ((char *) next
> end
)
19831 || ((char *) next
< (char *) pnotes
))
19833 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19834 (unsigned long) ((char *) external
- (char *) pnotes
));
19835 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19836 inote
.type
, inote
.namesz
, inote
.descsz
);
19842 /* Prevent out-of-bounds indexing. */
19843 if ( inote
.namedata
+ inote
.namesz
> end
19844 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19846 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19847 (unsigned long) ((char *) external
- (char *) pnotes
));
19848 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19849 inote
.type
, inote
.namesz
, inote
.descsz
);
19853 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19855 if (! print_v850_note (& inote
))
19858 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19859 inote
.namesz
, inote
.descsz
);
19869 process_note_sections (Filedata
* filedata
)
19871 Elf_Internal_Shdr
* section
;
19873 unsigned int n
= 0;
19874 bfd_boolean res
= TRUE
;
19876 for (i
= 0, section
= filedata
->section_headers
;
19877 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19880 if (section
->sh_type
== SHT_NOTE
)
19882 if (! process_notes_at (filedata
, section
,
19883 (bfd_vma
) section
->sh_offset
,
19884 (bfd_vma
) section
->sh_size
,
19885 (bfd_vma
) section
->sh_addralign
))
19890 if (( filedata
->file_header
.e_machine
== EM_V800
19891 || filedata
->file_header
.e_machine
== EM_V850
19892 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19893 && section
->sh_type
== SHT_RENESAS_INFO
)
19895 if (! process_v850_notes (filedata
,
19896 (bfd_vma
) section
->sh_offset
,
19897 (bfd_vma
) section
->sh_size
))
19904 /* Try processing NOTE segments instead. */
19905 return process_corefile_note_segments (filedata
);
19911 process_notes (Filedata
* filedata
)
19913 /* If we have not been asked to display the notes then do nothing. */
19917 if (filedata
->file_header
.e_type
!= ET_CORE
)
19918 return process_note_sections (filedata
);
19920 /* No program headers means no NOTE segment. */
19921 if (filedata
->file_header
.e_phnum
> 0)
19922 return process_corefile_note_segments (filedata
);
19924 printf (_("No note segments present in the core file.\n"));
19928 static unsigned char *
19929 display_public_gnu_attributes (unsigned char * start
,
19930 const unsigned char * const end
)
19932 printf (_(" Unknown GNU attribute: %s\n"), start
);
19934 start
+= strnlen ((char *) start
, end
- start
);
19935 display_raw_attribute (start
, end
);
19937 return (unsigned char *) end
;
19940 static unsigned char *
19941 display_generic_attribute (unsigned char * start
,
19943 const unsigned char * const end
)
19946 return (unsigned char *) end
;
19948 return display_tag_value (tag
, start
, end
);
19952 process_arch_specific (Filedata
* filedata
)
19957 switch (filedata
->file_header
.e_machine
)
19960 case EM_ARC_COMPACT
:
19961 case EM_ARC_COMPACT2
:
19962 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19963 display_arc_attribute
,
19964 display_generic_attribute
);
19966 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19967 display_arm_attribute
,
19968 display_generic_attribute
);
19971 case EM_MIPS_RS3_LE
:
19972 return process_mips_specific (filedata
);
19975 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19976 display_msp430x_attribute
,
19977 display_msp430_gnu_attribute
);
19980 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19981 display_riscv_attribute
,
19982 display_generic_attribute
);
19985 return process_nds32_specific (filedata
);
19989 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19990 display_power_gnu_attribute
);
19994 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19995 display_s390_gnu_attribute
);
19998 case EM_SPARC32PLUS
:
20000 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20001 display_sparc_gnu_attribute
);
20004 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
20005 display_tic6x_attribute
,
20006 display_generic_attribute
);
20009 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20010 display_public_gnu_attributes
,
20011 display_generic_attribute
);
20016 get_file_header (Filedata
* filedata
)
20018 /* Read in the identity array. */
20019 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20022 /* Determine how to read the rest of the header. */
20023 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20028 byte_get
= byte_get_little_endian
;
20029 byte_put
= byte_put_little_endian
;
20032 byte_get
= byte_get_big_endian
;
20033 byte_put
= byte_put_big_endian
;
20037 /* For now we only support 32 bit and 64 bit ELF files. */
20038 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20040 /* Read in the rest of the header. */
20043 Elf32_External_Ehdr ehdr32
;
20045 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20048 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20049 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20050 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20051 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20052 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20053 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20054 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20055 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20056 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20057 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20058 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20059 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20060 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20064 Elf64_External_Ehdr ehdr64
;
20066 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20067 we will not be able to cope with the 64bit data found in
20068 64 ELF files. Detect this now and abort before we start
20069 overwriting things. */
20070 if (sizeof (bfd_vma
) < 8)
20072 error (_("This instance of readelf has been built without support for a\n\
20073 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20077 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20080 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20081 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20082 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20083 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20084 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20085 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20086 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20087 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20088 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20089 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20090 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20091 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20092 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20095 if (filedata
->file_header
.e_shoff
)
20097 /* There may be some extensions in the first section header. Don't
20098 bomb if we can't read it. */
20100 get_32bit_section_headers (filedata
, TRUE
);
20102 get_64bit_section_headers (filedata
, TRUE
);
20109 close_file (Filedata
* filedata
)
20113 if (filedata
->handle
)
20114 fclose (filedata
->handle
);
20120 close_debug_file (void * data
)
20122 close_file ((Filedata
*) data
);
20126 open_file (const char * pathname
)
20128 struct stat statbuf
;
20129 Filedata
* filedata
= NULL
;
20131 if (stat (pathname
, & statbuf
) < 0
20132 || ! S_ISREG (statbuf
.st_mode
))
20135 filedata
= calloc (1, sizeof * filedata
);
20136 if (filedata
== NULL
)
20139 filedata
->handle
= fopen (pathname
, "rb");
20140 if (filedata
->handle
== NULL
)
20143 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20144 filedata
->file_name
= pathname
;
20146 if (! get_file_header (filedata
))
20149 if (filedata
->file_header
.e_shoff
)
20153 /* Read the section headers again, this time for real. */
20155 res
= get_32bit_section_headers (filedata
, FALSE
);
20157 res
= get_64bit_section_headers (filedata
, FALSE
);
20168 if (filedata
->handle
)
20169 fclose (filedata
->handle
);
20176 open_debug_file (const char * pathname
)
20178 return open_file (pathname
);
20181 /* Process one ELF object file according to the command line options.
20182 This file may actually be stored in an archive. The file is
20183 positioned at the start of the ELF object. Returns TRUE if no
20184 problems were encountered, FALSE otherwise. */
20187 process_object (Filedata
* filedata
)
20189 bfd_boolean have_separate_files
;
20193 if (! get_file_header (filedata
))
20195 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20199 /* Initialise per file variables. */
20200 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20201 filedata
->version_info
[i
] = 0;
20203 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20204 filedata
->dynamic_info
[i
] = 0;
20205 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20206 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20208 /* Process the file. */
20210 printf (_("\nFile: %s\n"), filedata
->file_name
);
20212 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20213 Note we do this even if cmdline_dump_sects is empty because we
20214 must make sure that the dump_sets array is zeroed out before each
20215 object file is processed. */
20216 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20217 memset (filedata
->dump
.dump_sects
, 0,
20218 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20220 if (cmdline
.num_dump_sects
> 0)
20222 if (filedata
->dump
.num_dump_sects
== 0)
20223 /* A sneaky way of allocating the dump_sects array. */
20224 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20226 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20227 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20228 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20231 if (! process_file_header (filedata
))
20234 if (! process_section_headers (filedata
))
20236 /* Without loaded section headers we cannot process lots of things. */
20237 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20239 if (! do_using_dynamic
)
20240 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20243 if (! process_section_groups (filedata
))
20244 /* Without loaded section groups we cannot process unwind. */
20247 res
= process_program_headers (filedata
);
20249 res
= process_dynamic_section (filedata
);
20251 if (! process_relocs (filedata
))
20254 if (! process_unwind (filedata
))
20257 if (! process_symbol_table (filedata
))
20260 if (! process_syminfo (filedata
))
20263 if (! process_version_sections (filedata
))
20266 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20267 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20269 have_separate_files
= FALSE
;
20271 if (! process_section_contents (filedata
))
20274 if (have_separate_files
)
20278 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20280 if (! process_section_headers (d
->handle
))
20282 else if (! process_section_contents (d
->handle
))
20286 /* The file handles are closed by the call to free_debug_memory() below. */
20289 if (! process_notes (filedata
))
20292 if (! process_gnu_liblist (filedata
))
20295 if (! process_arch_specific (filedata
))
20298 free (filedata
->program_headers
);
20299 filedata
->program_headers
= NULL
;
20301 free (filedata
->section_headers
);
20302 filedata
->section_headers
= NULL
;
20304 free (filedata
->string_table
);
20305 filedata
->string_table
= NULL
;
20306 filedata
->string_table_length
= 0;
20308 if (filedata
->dump
.dump_sects
!= NULL
)
20310 free (filedata
->dump
.dump_sects
);
20311 filedata
->dump
.dump_sects
= NULL
;
20312 filedata
->dump
.num_dump_sects
= 0;
20315 if (filedata
->dynamic_strings
)
20317 free (filedata
->dynamic_strings
);
20318 filedata
->dynamic_strings
= NULL
;
20319 filedata
->dynamic_strings_length
= 0;
20322 if (filedata
->dynamic_symbols
)
20324 free (filedata
->dynamic_symbols
);
20325 filedata
->dynamic_symbols
= NULL
;
20326 filedata
->num_dynamic_syms
= 0;
20329 if (filedata
->dynamic_syminfo
)
20331 free (filedata
->dynamic_syminfo
);
20332 filedata
->dynamic_syminfo
= NULL
;
20335 if (filedata
->dynamic_section
)
20337 free (filedata
->dynamic_section
);
20338 filedata
->dynamic_section
= NULL
;
20341 while (filedata
->symtab_shndx_list
!= NULL
)
20343 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20344 free (filedata
->symtab_shndx_list
);
20345 filedata
->symtab_shndx_list
= next
;
20348 if (filedata
->section_headers_groups
)
20350 free (filedata
->section_headers_groups
);
20351 filedata
->section_headers_groups
= NULL
;
20354 if (filedata
->section_groups
)
20356 struct group_list
* g
;
20357 struct group_list
* next
;
20359 for (i
= 0; i
< filedata
->group_count
; i
++)
20361 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20368 free (filedata
->section_groups
);
20369 filedata
->section_groups
= NULL
;
20372 free_debug_memory ();
20377 /* Process an ELF archive.
20378 On entry the file is positioned just after the ARMAG string.
20379 Returns TRUE upon success, FALSE otherwise. */
20382 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20384 struct archive_info arch
;
20385 struct archive_info nested_arch
;
20387 bfd_boolean ret
= TRUE
;
20391 /* The ARCH structure is used to hold information about this archive. */
20392 arch
.file_name
= NULL
;
20394 arch
.index_array
= NULL
;
20395 arch
.sym_table
= NULL
;
20396 arch
.longnames
= NULL
;
20398 /* The NESTED_ARCH structure is used as a single-item cache of information
20399 about a nested archive (when members of a thin archive reside within
20400 another regular archive file). */
20401 nested_arch
.file_name
= NULL
;
20402 nested_arch
.file
= NULL
;
20403 nested_arch
.index_array
= NULL
;
20404 nested_arch
.sym_table
= NULL
;
20405 nested_arch
.longnames
= NULL
;
20407 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20408 filedata
->file_size
, is_thin_archive
,
20409 do_archive_index
) != 0)
20415 if (do_archive_index
)
20417 if (arch
.sym_table
== NULL
)
20418 error (_("%s: unable to dump the index as none was found\n"),
20419 filedata
->file_name
);
20422 unsigned long i
, l
;
20423 unsigned long current_pos
;
20425 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20426 "in the symbol table)\n"),
20427 filedata
->file_name
, (unsigned long) arch
.index_num
,
20430 current_pos
= ftell (filedata
->handle
);
20432 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20435 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20438 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20441 if (member_name
!= NULL
)
20443 char * qualified_name
20444 = make_qualified_name (&arch
, &nested_arch
,
20447 if (qualified_name
!= NULL
)
20449 printf (_("Contents of binary %s at offset "),
20451 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20453 free (qualified_name
);
20455 free (member_name
);
20459 if (l
>= arch
.sym_size
)
20461 error (_("%s: end of the symbol table reached "
20462 "before the end of the index\n"),
20463 filedata
->file_name
);
20467 /* PR 17531: file: 0b6630b2. */
20468 printf ("\t%.*s\n",
20469 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20470 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20473 if (arch
.uses_64bit_indices
)
20478 if (l
< arch
.sym_size
)
20480 error (ngettext ("%s: %ld byte remains in the symbol table, "
20481 "but without corresponding entries in "
20482 "the index table\n",
20483 "%s: %ld bytes remain in the symbol table, "
20484 "but without corresponding entries in "
20485 "the index table\n",
20486 arch
.sym_size
- l
),
20487 filedata
->file_name
, arch
.sym_size
- l
);
20491 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20493 error (_("%s: failed to seek back to start of object files "
20494 "in the archive\n"),
20495 filedata
->file_name
);
20501 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20502 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20503 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20504 && !do_section_groups
&& !do_dyn_syms
)
20506 ret
= TRUE
; /* Archive index only. */
20515 char * qualified_name
;
20517 /* Read the next archive header. */
20518 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20520 error (_("%s: failed to seek to next archive header\n"),
20525 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20526 if (got
!= sizeof arch
.arhdr
)
20530 /* PR 24049 - we cannot use filedata->file_name as this will
20531 have already been freed. */
20532 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20537 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20539 error (_("%s: did not find a valid archive header\n"),
20545 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20547 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20548 if (filedata
->archive_file_size
& 01)
20549 ++filedata
->archive_file_size
;
20551 name
= get_archive_member_name (&arch
, &nested_arch
);
20554 error (_("%s: bad archive file name\n"), arch
.file_name
);
20558 namelen
= strlen (name
);
20560 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20561 if (qualified_name
== NULL
)
20563 error (_("%s: bad archive file name\n"), arch
.file_name
);
20569 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20571 /* This is a proxy for an external member of a thin archive. */
20572 Filedata
* member_filedata
;
20573 char * member_file_name
= adjust_relative_path
20574 (filedata
->file_name
, name
, namelen
);
20577 if (member_file_name
== NULL
)
20579 free (qualified_name
);
20584 member_filedata
= open_file (member_file_name
);
20585 if (member_filedata
== NULL
)
20587 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20588 free (member_file_name
);
20589 free (qualified_name
);
20594 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20595 member_filedata
->file_name
= qualified_name
;
20597 if (! process_object (member_filedata
))
20600 close_file (member_filedata
);
20601 free (member_file_name
);
20603 else if (is_thin_archive
)
20605 Filedata thin_filedata
;
20607 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20609 /* PR 15140: Allow for corrupt thin archives. */
20610 if (nested_arch
.file
== NULL
)
20612 error (_("%s: contains corrupt thin archive: %s\n"),
20613 qualified_name
, name
);
20614 free (qualified_name
);
20621 /* This is a proxy for a member of a nested archive. */
20622 filedata
->archive_file_offset
20623 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20625 /* The nested archive file will have been opened and setup by
20626 get_archive_member_name. */
20627 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20630 error (_("%s: failed to seek to archive member.\n"),
20631 nested_arch
.file_name
);
20632 free (qualified_name
);
20637 thin_filedata
.handle
= nested_arch
.file
;
20638 thin_filedata
.file_name
= qualified_name
;
20640 if (! process_object (& thin_filedata
))
20646 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20647 filedata
->file_name
= qualified_name
;
20648 if (! process_object (filedata
))
20650 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20651 /* Stop looping with "negative" archive_file_size. */
20652 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20653 arch
.next_arhdr_offset
= -1ul;
20656 free (qualified_name
);
20660 if (nested_arch
.file
!= NULL
)
20661 fclose (nested_arch
.file
);
20662 release_archive (&nested_arch
);
20663 release_archive (&arch
);
20669 process_file (char * file_name
)
20671 Filedata
* filedata
= NULL
;
20672 struct stat statbuf
;
20673 char armag
[SARMAG
];
20674 bfd_boolean ret
= TRUE
;
20676 if (stat (file_name
, &statbuf
) < 0)
20678 if (errno
== ENOENT
)
20679 error (_("'%s': No such file\n"), file_name
);
20681 error (_("Could not locate '%s'. System error message: %s\n"),
20682 file_name
, strerror (errno
));
20686 if (! S_ISREG (statbuf
.st_mode
))
20688 error (_("'%s' is not an ordinary file\n"), file_name
);
20692 filedata
= calloc (1, sizeof * filedata
);
20693 if (filedata
== NULL
)
20695 error (_("Out of memory allocating file data structure\n"));
20699 filedata
->file_name
= file_name
;
20700 filedata
->handle
= fopen (file_name
, "rb");
20701 if (filedata
->handle
== NULL
)
20703 error (_("Input file '%s' is not readable.\n"), file_name
);
20708 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20710 error (_("%s: Failed to read file's magic number\n"), file_name
);
20711 fclose (filedata
->handle
);
20716 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20718 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20720 if (! process_archive (filedata
, FALSE
))
20723 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20725 if ( ! process_archive (filedata
, TRUE
))
20730 if (do_archive_index
&& !check_all
)
20731 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20734 rewind (filedata
->handle
);
20735 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20737 if (! process_object (filedata
))
20741 fclose (filedata
->handle
);
20742 free (filedata
->section_headers
);
20743 free (filedata
->program_headers
);
20744 free (filedata
->string_table
);
20745 free (filedata
->dump
.dump_sects
);
20748 free (ba_cache
.strtab
);
20749 ba_cache
.strtab
= NULL
;
20750 free (ba_cache
.symtab
);
20751 ba_cache
.symtab
= NULL
;
20752 ba_cache
.filedata
= NULL
;
20757 #ifdef SUPPORT_DISASSEMBLY
20758 /* Needed by the i386 disassembler. For extra credit, someone could
20759 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20763 print_address (unsigned int addr
, FILE * outfile
)
20765 fprintf (outfile
,"0x%8.8x", addr
);
20768 /* Needed by the i386 disassembler. */
20771 db_task_printsym (unsigned int addr
)
20773 print_address (addr
, stderr
);
20778 main (int argc
, char ** argv
)
20782 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20783 setlocale (LC_MESSAGES
, "");
20785 #if defined (HAVE_SETLOCALE)
20786 setlocale (LC_CTYPE
, "");
20788 bindtextdomain (PACKAGE
, LOCALEDIR
);
20789 textdomain (PACKAGE
);
20791 expandargv (&argc
, &argv
);
20793 parse_args (& cmdline
, argc
, argv
);
20795 if (optind
< (argc
- 1))
20796 /* When displaying information for more than one file,
20797 prefix the information with the file name. */
20799 else if (optind
>= argc
)
20801 /* Ensure that the warning is always displayed. */
20804 warn (_("Nothing to do.\n"));
20809 while (optind
< argc
)
20810 if (! process_file (argv
[optind
++]))
20813 if (cmdline
.dump_sects
!= NULL
)
20814 free (cmdline
.dump_sects
);
20816 free (dump_ctf_symtab_name
);
20817 free (dump_ctf_strtab_name
);
20818 free (dump_ctf_parent_name
);
20820 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;