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
)
7014 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7019 error (_("Corrupt header in group section `%s'\n"), name
);
7023 if (section
->sh_info
>= num_syms
)
7025 error (_("Bad sh_info in group section `%s'\n"), name
);
7029 sym
= symtab
+ section
->sh_info
;
7031 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7033 if (sym
->st_shndx
== 0
7034 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7036 error (_("Bad sh_info in group section `%s'\n"), name
);
7040 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
7048 /* Get the string table. */
7049 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7057 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7062 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7063 1, strtab_sec
->sh_size
,
7065 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7067 group_name
= sym
->st_name
< strtab_size
7068 ? strtab
+ sym
->st_name
: _("<corrupt>");
7071 /* PR 17531: file: loop. */
7072 if (section
->sh_entsize
> section
->sh_size
)
7074 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7075 printable_section_name (filedata
, section
),
7076 (unsigned long) section
->sh_entsize
,
7077 (unsigned long) section
->sh_size
);
7081 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7082 1, section
->sh_size
,
7088 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7089 entry
= byte_get (indices
, 4);
7092 if (do_section_groups
)
7094 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7095 get_group_flags (entry
), i
, name
, group_name
, size
);
7097 printf (_(" [Index] Name\n"));
7100 group
->group_index
= i
;
7102 for (j
= 0; j
< size
; j
++)
7104 struct group_list
* g
;
7106 entry
= byte_get (indices
, 4);
7109 if (entry
>= filedata
->file_header
.e_shnum
)
7111 static unsigned num_group_errors
= 0;
7113 if (num_group_errors
++ < 10)
7115 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7116 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7117 if (num_group_errors
== 10)
7118 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7123 if (filedata
->section_headers_groups
[entry
] != NULL
)
7127 static unsigned num_errs
= 0;
7129 if (num_errs
++ < 10)
7131 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7133 filedata
->section_headers_groups
[entry
]->group_index
);
7135 warn (_("Further error messages about already contained group sections suppressed\n"));
7141 /* Intel C/C++ compiler may put section 0 in a
7142 section group. We just warn it the first time
7143 and ignore it afterwards. */
7144 static bfd_boolean warned
= FALSE
;
7147 error (_("section 0 in group section [%5u]\n"),
7148 filedata
->section_headers_groups
[entry
]->group_index
);
7154 filedata
->section_headers_groups
[entry
] = group
;
7156 if (do_section_groups
)
7158 sec
= filedata
->section_headers
+ entry
;
7159 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7162 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7163 g
->section_index
= entry
;
7164 g
->next
= group
->root
;
7179 /* Data used to display dynamic fixups. */
7181 struct ia64_vms_dynfixup
7183 bfd_vma needed_ident
; /* Library ident number. */
7184 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7185 bfd_vma fixup_needed
; /* Index of the library. */
7186 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7187 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7190 /* Data used to display dynamic relocations. */
7192 struct ia64_vms_dynimgrela
7194 bfd_vma img_rela_cnt
; /* Number of relocations. */
7195 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7198 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7202 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7203 struct ia64_vms_dynfixup
* fixup
,
7204 const char * strtab
,
7205 unsigned int strtab_sz
)
7207 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7209 const char * lib_name
;
7211 imfs
= get_data (NULL
, filedata
,
7212 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7213 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7214 _("dynamic section image fixups"));
7218 if (fixup
->needed
< strtab_sz
)
7219 lib_name
= strtab
+ fixup
->needed
;
7222 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7223 (unsigned long) fixup
->needed
);
7227 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7228 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7230 (_("Seg Offset Type SymVec DataType\n"));
7232 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7237 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7238 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7239 type
= BYTE_GET (imfs
[i
].type
);
7240 rtype
= elf_ia64_reloc_type (type
);
7242 printf (" 0x%08x ", type
);
7244 printf (" %-32s ", rtype
);
7245 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7246 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7253 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7256 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7258 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7261 imrs
= get_data (NULL
, filedata
,
7262 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7263 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7264 _("dynamic section image relocations"));
7268 printf (_("\nImage relocs\n"));
7270 (_("Seg Offset Type Addend Seg Sym Off\n"));
7272 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7277 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7278 printf ("%08" BFD_VMA_FMT
"x ",
7279 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7280 type
= BYTE_GET (imrs
[i
].type
);
7281 rtype
= elf_ia64_reloc_type (type
);
7283 printf ("0x%08x ", type
);
7285 printf ("%-31s ", rtype
);
7286 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7287 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7288 printf ("%08" BFD_VMA_FMT
"x\n",
7289 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7296 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7299 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7301 struct ia64_vms_dynfixup fixup
;
7302 struct ia64_vms_dynimgrela imgrela
;
7303 Elf_Internal_Dyn
*entry
;
7304 bfd_vma strtab_off
= 0;
7305 bfd_vma strtab_sz
= 0;
7306 char *strtab
= NULL
;
7307 bfd_boolean res
= TRUE
;
7309 memset (&fixup
, 0, sizeof (fixup
));
7310 memset (&imgrela
, 0, sizeof (imgrela
));
7312 /* Note: the order of the entries is specified by the OpenVMS specs. */
7313 for (entry
= filedata
->dynamic_section
;
7314 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7317 switch (entry
->d_tag
)
7319 case DT_IA_64_VMS_STRTAB_OFFSET
:
7320 strtab_off
= entry
->d_un
.d_val
;
7323 strtab_sz
= entry
->d_un
.d_val
;
7325 strtab
= get_data (NULL
, filedata
,
7326 filedata
->dynamic_addr
+ strtab_off
,
7327 1, strtab_sz
, _("dynamic string section"));
7332 case DT_IA_64_VMS_NEEDED_IDENT
:
7333 fixup
.needed_ident
= entry
->d_un
.d_val
;
7336 fixup
.needed
= entry
->d_un
.d_val
;
7338 case DT_IA_64_VMS_FIXUP_NEEDED
:
7339 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7341 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7342 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7344 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7345 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7346 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7349 case DT_IA_64_VMS_IMG_RELA_CNT
:
7350 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7352 case DT_IA_64_VMS_IMG_RELA_OFF
:
7353 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7354 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7375 dynamic_relocations
[] =
7377 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7378 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7379 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7382 /* Process the reloc section. */
7385 process_relocs (Filedata
* filedata
)
7387 unsigned long rel_size
;
7388 unsigned long rel_offset
;
7393 if (do_using_dynamic
)
7397 bfd_boolean has_dynamic_reloc
;
7400 has_dynamic_reloc
= FALSE
;
7402 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7404 is_rela
= dynamic_relocations
[i
].rela
;
7405 name
= dynamic_relocations
[i
].name
;
7406 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7407 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7410 has_dynamic_reloc
= TRUE
;
7412 if (is_rela
== UNKNOWN
)
7414 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7415 switch (filedata
->dynamic_info
[DT_PLTREL
])
7429 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7430 name
, rel_offset
, rel_size
);
7432 dump_relocations (filedata
,
7433 offset_from_vma (filedata
, rel_offset
, rel_size
),
7435 filedata
->dynamic_symbols
,
7436 filedata
->num_dynamic_syms
,
7437 filedata
->dynamic_strings
,
7438 filedata
->dynamic_strings_length
,
7439 is_rela
, TRUE
/* is_dynamic */);
7443 if (is_ia64_vms (filedata
))
7444 if (process_ia64_vms_dynamic_relocs (filedata
))
7445 has_dynamic_reloc
= TRUE
;
7447 if (! has_dynamic_reloc
)
7448 printf (_("\nThere are no dynamic relocations in this file.\n"));
7452 Elf_Internal_Shdr
* section
;
7454 bfd_boolean found
= FALSE
;
7456 for (i
= 0, section
= filedata
->section_headers
;
7457 i
< filedata
->file_header
.e_shnum
;
7460 if ( section
->sh_type
!= SHT_RELA
7461 && section
->sh_type
!= SHT_REL
)
7464 rel_offset
= section
->sh_offset
;
7465 rel_size
= section
->sh_size
;
7470 unsigned long num_rela
;
7472 printf (_("\nRelocation section "));
7474 if (filedata
->string_table
== NULL
)
7475 printf ("%d", section
->sh_name
);
7477 printf ("'%s'", printable_section_name (filedata
, section
));
7479 num_rela
= rel_size
/ section
->sh_entsize
;
7480 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7481 " at offset 0x%lx contains %lu entries:\n",
7483 rel_offset
, num_rela
);
7485 is_rela
= section
->sh_type
== SHT_RELA
;
7487 if (section
->sh_link
!= 0
7488 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7490 Elf_Internal_Shdr
* symsec
;
7491 Elf_Internal_Sym
* symtab
;
7492 unsigned long nsyms
;
7493 unsigned long strtablen
= 0;
7494 char * strtab
= NULL
;
7496 symsec
= filedata
->section_headers
+ section
->sh_link
;
7497 if (symsec
->sh_type
!= SHT_SYMTAB
7498 && symsec
->sh_type
!= SHT_DYNSYM
)
7501 if (!get_symtab (filedata
, symsec
,
7502 &symtab
, &nsyms
, &strtab
, &strtablen
))
7505 dump_relocations (filedata
, rel_offset
, rel_size
,
7506 symtab
, nsyms
, strtab
, strtablen
,
7508 symsec
->sh_type
== SHT_DYNSYM
);
7513 dump_relocations (filedata
, rel_offset
, rel_size
,
7514 NULL
, 0, NULL
, 0, is_rela
,
7515 FALSE
/* is_dynamic */);
7523 /* Users sometimes forget the -D option, so try to be helpful. */
7524 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7526 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7528 printf (_("\nThere are no static relocations in this file."));
7529 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7534 if (i
== ARRAY_SIZE (dynamic_relocations
))
7535 printf (_("\nThere are no relocations in this file.\n"));
7542 /* An absolute address consists of a section and an offset. If the
7543 section is NULL, the offset itself is the address, otherwise, the
7544 address equals to LOAD_ADDRESS(section) + offset. */
7548 unsigned short section
;
7552 /* Find the nearest symbol at or below ADDR. Returns the symbol
7553 name, if found, and the offset from the symbol to ADDR. */
7556 find_symbol_for_address (Filedata
* filedata
,
7557 Elf_Internal_Sym
* symtab
,
7558 unsigned long nsyms
,
7559 const char * strtab
,
7560 unsigned long strtab_size
,
7561 struct absaddr addr
,
7562 const char ** symname
,
7565 bfd_vma dist
= 0x100000;
7566 Elf_Internal_Sym
* sym
;
7567 Elf_Internal_Sym
* beg
;
7568 Elf_Internal_Sym
* end
;
7569 Elf_Internal_Sym
* best
= NULL
;
7571 REMOVE_ARCH_BITS (addr
.offset
);
7573 end
= symtab
+ nsyms
;
7579 sym
= beg
+ (end
- beg
) / 2;
7581 value
= sym
->st_value
;
7582 REMOVE_ARCH_BITS (value
);
7584 if (sym
->st_name
!= 0
7585 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7586 && addr
.offset
>= value
7587 && addr
.offset
- value
< dist
)
7590 dist
= addr
.offset
- value
;
7595 if (addr
.offset
< value
)
7603 *symname
= (best
->st_name
>= strtab_size
7604 ? _("<corrupt>") : strtab
+ best
->st_name
);
7610 *offset
= addr
.offset
;
7613 static /* signed */ int
7614 symcmp (const void *p
, const void *q
)
7616 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7617 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7619 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7622 /* Process the unwind section. */
7624 #include "unwind-ia64.h"
7626 struct ia64_unw_table_entry
7628 struct absaddr start
;
7630 struct absaddr info
;
7633 struct ia64_unw_aux_info
7635 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7636 unsigned long table_len
; /* Length of unwind table. */
7637 unsigned char * info
; /* Unwind info. */
7638 unsigned long info_size
; /* Size of unwind info. */
7639 bfd_vma info_addr
; /* Starting address of unwind info. */
7640 bfd_vma seg_base
; /* Starting address of segment. */
7641 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7642 unsigned long nsyms
; /* Number of symbols. */
7643 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7644 unsigned long nfuns
; /* Number of entries in funtab. */
7645 char * strtab
; /* The string table. */
7646 unsigned long strtab_size
; /* Size of string table. */
7650 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7652 struct ia64_unw_table_entry
* tp
;
7653 unsigned long j
, nfuns
;
7655 bfd_boolean res
= TRUE
;
7657 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7658 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7659 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7660 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7662 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7664 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7668 const unsigned char * dp
;
7669 const unsigned char * head
;
7670 const unsigned char * end
;
7671 const char * procname
;
7673 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7674 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7676 fputs ("\n<", stdout
);
7680 fputs (procname
, stdout
);
7683 printf ("+%lx", (unsigned long) offset
);
7686 fputs (">: [", stdout
);
7687 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7688 fputc ('-', stdout
);
7689 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7690 printf ("], info at +0x%lx\n",
7691 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7693 /* PR 17531: file: 86232b32. */
7694 if (aux
->info
== NULL
)
7697 offset
= tp
->info
.offset
;
7698 if (tp
->info
.section
)
7700 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7702 warn (_("Invalid section %u in table entry %ld\n"),
7703 tp
->info
.section
, (long) (tp
- aux
->table
));
7707 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7709 offset
-= aux
->info_addr
;
7710 /* PR 17531: file: 0997b4d1. */
7711 if (offset
>= aux
->info_size
7712 || aux
->info_size
- offset
< 8)
7714 warn (_("Invalid offset %lx in table entry %ld\n"),
7715 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7720 head
= aux
->info
+ offset
;
7721 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7723 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7724 (unsigned) UNW_VER (stamp
),
7725 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7726 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7727 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7728 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7730 if (UNW_VER (stamp
) != 1)
7732 printf (_("\tUnknown version.\n"));
7737 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7738 /* PR 17531: file: 16ceda89. */
7739 if (end
> aux
->info
+ aux
->info_size
)
7740 end
= aux
->info
+ aux
->info_size
;
7741 for (dp
= head
+ 8; dp
< end
;)
7742 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7751 slurp_ia64_unwind_table (Filedata
* filedata
,
7752 struct ia64_unw_aux_info
* aux
,
7753 Elf_Internal_Shdr
* sec
)
7755 unsigned long size
, nrelas
, i
;
7756 Elf_Internal_Phdr
* seg
;
7757 struct ia64_unw_table_entry
* tep
;
7758 Elf_Internal_Shdr
* relsec
;
7759 Elf_Internal_Rela
* rela
;
7760 Elf_Internal_Rela
* rp
;
7761 unsigned char * table
;
7763 Elf_Internal_Sym
* sym
;
7764 const char * relname
;
7768 /* First, find the starting address of the segment that includes
7771 if (filedata
->file_header
.e_phnum
)
7773 if (! get_program_headers (filedata
))
7776 for (seg
= filedata
->program_headers
;
7777 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7780 if (seg
->p_type
!= PT_LOAD
)
7783 if (sec
->sh_addr
>= seg
->p_vaddr
7784 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7786 aux
->seg_base
= seg
->p_vaddr
;
7792 /* Second, build the unwind table from the contents of the unwind section: */
7793 size
= sec
->sh_size
;
7794 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7799 aux
->table_len
= size
/ (3 * eh_addr_size
);
7800 aux
->table
= (struct ia64_unw_table_entry
*)
7801 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7804 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7806 tep
->start
.section
= SHN_UNDEF
;
7807 tep
->end
.section
= SHN_UNDEF
;
7808 tep
->info
.section
= SHN_UNDEF
;
7809 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7810 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7811 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7812 tep
->start
.offset
+= aux
->seg_base
;
7813 tep
->end
.offset
+= aux
->seg_base
;
7814 tep
->info
.offset
+= aux
->seg_base
;
7818 /* Third, apply any relocations to the unwind table: */
7819 for (relsec
= filedata
->section_headers
;
7820 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7823 if (relsec
->sh_type
!= SHT_RELA
7824 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7825 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7828 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7837 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7839 unsigned int sym_ndx
;
7840 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7841 relname
= elf_ia64_reloc_type (r_type
);
7843 /* PR 17531: file: 9fa67536. */
7844 if (relname
== NULL
)
7846 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7850 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7852 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7856 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7858 /* PR 17531: file: 5bc8d9bf. */
7859 if (i
>= aux
->table_len
)
7861 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7865 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7866 if (sym_ndx
>= aux
->nsyms
)
7868 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7872 sym
= aux
->symtab
+ sym_ndx
;
7874 switch (rp
->r_offset
/ eh_addr_size
% 3)
7877 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7878 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7881 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7882 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7885 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7886 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7900 ia64_process_unwind (Filedata
* filedata
)
7902 Elf_Internal_Shdr
* sec
;
7903 Elf_Internal_Shdr
* unwsec
= NULL
;
7904 unsigned long i
, unwcount
= 0, unwstart
= 0;
7905 struct ia64_unw_aux_info aux
;
7906 bfd_boolean res
= TRUE
;
7908 memset (& aux
, 0, sizeof (aux
));
7910 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7912 if (sec
->sh_type
== SHT_SYMTAB
)
7916 error (_("Multiple symbol tables encountered\n"));
7922 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7923 &aux
.strtab
, &aux
.strtab_size
))
7926 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7931 printf (_("\nThere are no unwind sections in this file.\n"));
7933 while (unwcount
-- > 0)
7938 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7939 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7940 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7945 /* We have already counted the number of SHT_IA64_UNWIND
7946 sections so the loop above should never fail. */
7947 assert (unwsec
!= NULL
);
7950 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7952 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7954 /* We need to find which section group it is in. */
7955 struct group_list
* g
;
7957 if (filedata
->section_headers_groups
== NULL
7958 || filedata
->section_headers_groups
[i
] == NULL
)
7959 i
= filedata
->file_header
.e_shnum
;
7962 g
= filedata
->section_headers_groups
[i
]->root
;
7964 for (; g
!= NULL
; g
= g
->next
)
7966 sec
= filedata
->section_headers
+ g
->section_index
;
7968 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7973 i
= filedata
->file_header
.e_shnum
;
7976 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7978 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7979 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7980 suffix
= SECTION_NAME (unwsec
) + len
;
7981 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7983 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7984 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7989 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7990 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7991 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7992 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7994 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7995 suffix
= SECTION_NAME (unwsec
) + len
;
7996 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7998 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7999 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8003 if (i
== filedata
->file_header
.e_shnum
)
8005 printf (_("\nCould not find unwind info section for "));
8007 if (filedata
->string_table
== NULL
)
8008 printf ("%d", unwsec
->sh_name
);
8010 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8014 aux
.info_addr
= sec
->sh_addr
;
8015 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8018 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8020 printf (_("\nUnwind section "));
8022 if (filedata
->string_table
== NULL
)
8023 printf ("%d", unwsec
->sh_name
);
8025 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8027 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8028 (unsigned long) unwsec
->sh_offset
,
8029 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8031 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8032 && aux
.table_len
> 0)
8033 dump_ia64_unwind (filedata
, & aux
);
8035 free ((char *) aux
.table
);
8036 free ((char *) aux
.info
);
8043 free ((char *) aux
.strtab
);
8048 struct hppa_unw_table_entry
8050 struct absaddr start
;
8052 unsigned int Cannot_unwind
:1; /* 0 */
8053 unsigned int Millicode
:1; /* 1 */
8054 unsigned int Millicode_save_sr0
:1; /* 2 */
8055 unsigned int Region_description
:2; /* 3..4 */
8056 unsigned int reserved1
:1; /* 5 */
8057 unsigned int Entry_SR
:1; /* 6 */
8058 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8059 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8060 unsigned int Args_stored
:1; /* 16 */
8061 unsigned int Variable_Frame
:1; /* 17 */
8062 unsigned int Separate_Package_Body
:1; /* 18 */
8063 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8064 unsigned int Stack_Overflow_Check
:1; /* 20 */
8065 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8066 unsigned int Ada_Region
:1; /* 22 */
8067 unsigned int cxx_info
:1; /* 23 */
8068 unsigned int cxx_try_catch
:1; /* 24 */
8069 unsigned int sched_entry_seq
:1; /* 25 */
8070 unsigned int reserved2
:1; /* 26 */
8071 unsigned int Save_SP
:1; /* 27 */
8072 unsigned int Save_RP
:1; /* 28 */
8073 unsigned int Save_MRP_in_frame
:1; /* 29 */
8074 unsigned int extn_ptr_defined
:1; /* 30 */
8075 unsigned int Cleanup_defined
:1; /* 31 */
8077 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8078 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8079 unsigned int Large_frame
:1; /* 2 */
8080 unsigned int Pseudo_SP_Set
:1; /* 3 */
8081 unsigned int reserved4
:1; /* 4 */
8082 unsigned int Total_frame_size
:27; /* 5..31 */
8085 struct hppa_unw_aux_info
8087 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8088 unsigned long table_len
; /* Length of unwind table. */
8089 bfd_vma seg_base
; /* Starting address of segment. */
8090 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8091 unsigned long nsyms
; /* Number of symbols. */
8092 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8093 unsigned long nfuns
; /* Number of entries in funtab. */
8094 char * strtab
; /* The string table. */
8095 unsigned long strtab_size
; /* Size of string table. */
8099 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8101 struct hppa_unw_table_entry
* tp
;
8102 unsigned long j
, nfuns
;
8103 bfd_boolean res
= TRUE
;
8105 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8106 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8107 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8108 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8110 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8112 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8115 const char * procname
;
8117 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8118 aux
->strtab_size
, tp
->start
, &procname
,
8121 fputs ("\n<", stdout
);
8125 fputs (procname
, stdout
);
8128 printf ("+%lx", (unsigned long) offset
);
8131 fputs (">: [", stdout
);
8132 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8133 fputc ('-', stdout
);
8134 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8137 #define PF(_m) if (tp->_m) printf (#_m " ");
8138 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8141 PF(Millicode_save_sr0
);
8142 /* PV(Region_description); */
8148 PF(Separate_Package_Body
);
8149 PF(Frame_Extension_Millicode
);
8150 PF(Stack_Overflow_Check
);
8151 PF(Two_Instruction_SP_Increment
);
8155 PF(sched_entry_seq
);
8158 PF(Save_MRP_in_frame
);
8159 PF(extn_ptr_defined
);
8160 PF(Cleanup_defined
);
8161 PF(MPE_XL_interrupt_marker
);
8162 PF(HP_UX_interrupt_marker
);
8165 PV(Total_frame_size
);
8178 slurp_hppa_unwind_table (Filedata
* filedata
,
8179 struct hppa_unw_aux_info
* aux
,
8180 Elf_Internal_Shdr
* sec
)
8182 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8183 Elf_Internal_Phdr
* seg
;
8184 struct hppa_unw_table_entry
* tep
;
8185 Elf_Internal_Shdr
* relsec
;
8186 Elf_Internal_Rela
* rela
;
8187 Elf_Internal_Rela
* rp
;
8188 unsigned char * table
;
8190 Elf_Internal_Sym
* sym
;
8191 const char * relname
;
8193 /* First, find the starting address of the segment that includes
8195 if (filedata
->file_header
.e_phnum
)
8197 if (! get_program_headers (filedata
))
8200 for (seg
= filedata
->program_headers
;
8201 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8204 if (seg
->p_type
!= PT_LOAD
)
8207 if (sec
->sh_addr
>= seg
->p_vaddr
8208 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8210 aux
->seg_base
= seg
->p_vaddr
;
8216 /* Second, build the unwind table from the contents of the unwind
8218 size
= sec
->sh_size
;
8219 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8225 nentries
= size
/ unw_ent_size
;
8226 size
= unw_ent_size
* nentries
;
8228 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8229 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8231 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8233 unsigned int tmp1
, tmp2
;
8235 tep
->start
.section
= SHN_UNDEF
;
8236 tep
->end
.section
= SHN_UNDEF
;
8238 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8239 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8240 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8241 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8243 tep
->start
.offset
+= aux
->seg_base
;
8244 tep
->end
.offset
+= aux
->seg_base
;
8246 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8247 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8248 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8249 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8250 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8251 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8252 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8253 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8254 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8255 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8256 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8257 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8258 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8259 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8260 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8261 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8262 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8263 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8264 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8265 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8266 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8267 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8268 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8269 tep
->Cleanup_defined
= tmp1
& 0x1;
8271 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8272 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8273 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8274 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8275 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8276 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8280 /* Third, apply any relocations to the unwind table. */
8281 for (relsec
= filedata
->section_headers
;
8282 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8285 if (relsec
->sh_type
!= SHT_RELA
8286 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8287 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8290 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8294 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8296 unsigned int sym_ndx
;
8297 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8298 relname
= elf_hppa_reloc_type (r_type
);
8300 if (relname
== NULL
)
8302 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8306 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8307 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8309 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8313 i
= rp
->r_offset
/ unw_ent_size
;
8314 if (i
>= aux
->table_len
)
8316 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8320 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8321 if (sym_ndx
>= aux
->nsyms
)
8323 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8327 sym
= aux
->symtab
+ sym_ndx
;
8329 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8332 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8333 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8336 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8337 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8347 aux
->table_len
= nentries
;
8353 hppa_process_unwind (Filedata
* filedata
)
8355 struct hppa_unw_aux_info aux
;
8356 Elf_Internal_Shdr
* unwsec
= NULL
;
8357 Elf_Internal_Shdr
* sec
;
8359 bfd_boolean res
= TRUE
;
8361 if (filedata
->string_table
== NULL
)
8364 memset (& aux
, 0, sizeof (aux
));
8366 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8368 if (sec
->sh_type
== SHT_SYMTAB
)
8372 error (_("Multiple symbol tables encountered\n"));
8378 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8379 &aux
.strtab
, &aux
.strtab_size
))
8382 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8387 printf (_("\nThere are no unwind sections in this file.\n"));
8389 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8391 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8393 unsigned long num_unwind
= sec
->sh_size
/ 16;
8395 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8396 "contains %lu entry:\n",
8397 "\nUnwind section '%s' at offset 0x%lx "
8398 "contains %lu entries:\n",
8400 printable_section_name (filedata
, sec
),
8401 (unsigned long) sec
->sh_offset
,
8404 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8407 if (res
&& aux
.table_len
> 0)
8409 if (! dump_hppa_unwind (filedata
, &aux
))
8413 free ((char *) aux
.table
);
8419 free ((char *) aux
.strtab
);
8426 unsigned char * data
; /* The unwind data. */
8427 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8428 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8429 unsigned long nrelas
; /* The number of relocations. */
8430 unsigned int rel_type
; /* REL or RELA ? */
8431 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8434 struct arm_unw_aux_info
8436 Filedata
* filedata
; /* The file containing the unwind sections. */
8437 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8438 unsigned long nsyms
; /* Number of symbols. */
8439 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8440 unsigned long nfuns
; /* Number of these symbols. */
8441 char * strtab
; /* The file's string table. */
8442 unsigned long strtab_size
; /* Size of string table. */
8446 arm_print_vma_and_name (Filedata
* filedata
,
8447 struct arm_unw_aux_info
* aux
,
8449 struct absaddr addr
)
8451 const char *procname
;
8454 if (addr
.section
== SHN_UNDEF
)
8457 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8458 aux
->strtab_size
, addr
, &procname
,
8461 print_vma (fn
, PREFIX_HEX
);
8465 fputs (" <", stdout
);
8466 fputs (procname
, stdout
);
8469 printf ("+0x%lx", (unsigned long) sym_offset
);
8470 fputc ('>', stdout
);
8477 arm_free_section (struct arm_section
*arm_sec
)
8479 free (arm_sec
->data
);
8480 free (arm_sec
->rela
);
8483 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8484 cached section and install SEC instead.
8485 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8486 and return its valued in * WORDP, relocating if necessary.
8487 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8488 relocation's offset in ADDR.
8489 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8490 into the string table of the symbol associated with the reloc. If no
8491 reloc was applied store -1 there.
8492 5) Return TRUE upon success, FALSE otherwise. */
8495 get_unwind_section_word (Filedata
* filedata
,
8496 struct arm_unw_aux_info
* aux
,
8497 struct arm_section
* arm_sec
,
8498 Elf_Internal_Shdr
* sec
,
8499 bfd_vma word_offset
,
8500 unsigned int * wordp
,
8501 struct absaddr
* addr
,
8504 Elf_Internal_Rela
*rp
;
8505 Elf_Internal_Sym
*sym
;
8506 const char * relname
;
8508 bfd_boolean wrapped
;
8510 if (sec
== NULL
|| arm_sec
== NULL
)
8513 addr
->section
= SHN_UNDEF
;
8516 if (sym_name
!= NULL
)
8517 *sym_name
= (bfd_vma
) -1;
8519 /* If necessary, update the section cache. */
8520 if (sec
!= arm_sec
->sec
)
8522 Elf_Internal_Shdr
*relsec
;
8524 arm_free_section (arm_sec
);
8527 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8528 sec
->sh_size
, _("unwind data"));
8529 arm_sec
->rela
= NULL
;
8530 arm_sec
->nrelas
= 0;
8532 for (relsec
= filedata
->section_headers
;
8533 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8536 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8537 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8538 /* PR 15745: Check the section type as well. */
8539 || (relsec
->sh_type
!= SHT_REL
8540 && relsec
->sh_type
!= SHT_RELA
))
8543 arm_sec
->rel_type
= relsec
->sh_type
;
8544 if (relsec
->sh_type
== SHT_REL
)
8546 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8548 & arm_sec
->rela
, & arm_sec
->nrelas
))
8551 else /* relsec->sh_type == SHT_RELA */
8553 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8555 & arm_sec
->rela
, & arm_sec
->nrelas
))
8561 arm_sec
->next_rela
= arm_sec
->rela
;
8564 /* If there is no unwind data we can do nothing. */
8565 if (arm_sec
->data
== NULL
)
8568 /* If the offset is invalid then fail. */
8569 if (/* PR 21343 *//* PR 18879 */
8571 || word_offset
> (sec
->sh_size
- 4)
8572 || ((bfd_signed_vma
) word_offset
) < 0)
8575 /* Get the word at the required offset. */
8576 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8578 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8579 if (arm_sec
->rela
== NULL
)
8585 /* Look through the relocs to find the one that applies to the provided offset. */
8587 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8589 bfd_vma prelval
, offset
;
8591 if (rp
->r_offset
> word_offset
&& !wrapped
)
8596 if (rp
->r_offset
> word_offset
)
8599 if (rp
->r_offset
& 3)
8601 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8602 (unsigned long) rp
->r_offset
);
8606 if (rp
->r_offset
< word_offset
)
8609 /* PR 17531: file: 027-161405-0.004 */
8610 if (aux
->symtab
== NULL
)
8613 if (arm_sec
->rel_type
== SHT_REL
)
8615 offset
= word
& 0x7fffffff;
8616 if (offset
& 0x40000000)
8617 offset
|= ~ (bfd_vma
) 0x7fffffff;
8619 else if (arm_sec
->rel_type
== SHT_RELA
)
8620 offset
= rp
->r_addend
;
8623 error (_("Unknown section relocation type %d encountered\n"),
8628 /* PR 17531 file: 027-1241568-0.004. */
8629 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8631 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8632 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8636 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8637 offset
+= sym
->st_value
;
8638 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8640 /* Check that we are processing the expected reloc type. */
8641 if (filedata
->file_header
.e_machine
== EM_ARM
)
8643 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8644 if (relname
== NULL
)
8646 warn (_("Skipping unknown ARM relocation type: %d\n"),
8647 (int) ELF32_R_TYPE (rp
->r_info
));
8651 if (streq (relname
, "R_ARM_NONE"))
8654 if (! streq (relname
, "R_ARM_PREL31"))
8656 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8660 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8662 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8663 if (relname
== NULL
)
8665 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8666 (int) ELF32_R_TYPE (rp
->r_info
));
8670 if (streq (relname
, "R_C6000_NONE"))
8673 if (! streq (relname
, "R_C6000_PREL31"))
8675 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8683 /* This function currently only supports ARM and TI unwinders. */
8684 warn (_("Only TI and ARM unwinders are currently supported\n"));
8688 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8689 addr
->section
= sym
->st_shndx
;
8690 addr
->offset
= offset
;
8693 * sym_name
= sym
->st_name
;
8698 arm_sec
->next_rela
= rp
;
8703 static const char *tic6x_unwind_regnames
[16] =
8705 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8706 "A14", "A13", "A12", "A11", "A10",
8707 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8711 decode_tic6x_unwind_regmask (unsigned int mask
)
8715 for (i
= 12; mask
; mask
>>= 1, i
--)
8719 fputs (tic6x_unwind_regnames
[i
], stdout
);
8721 fputs (", ", stdout
);
8727 if (remaining == 0 && more_words) \
8730 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8731 data_offset, & word, & addr, NULL)) \
8737 #define GET_OP(OP) \
8742 (OP) = word >> 24; \
8747 printf (_("[Truncated opcode]\n")); \
8750 printf ("0x%02x ", OP)
8753 decode_arm_unwind_bytecode (Filedata
* filedata
,
8754 struct arm_unw_aux_info
* aux
,
8756 unsigned int remaining
,
8757 unsigned int more_words
,
8758 bfd_vma data_offset
,
8759 Elf_Internal_Shdr
* data_sec
,
8760 struct arm_section
* data_arm_sec
)
8762 struct absaddr addr
;
8763 bfd_boolean res
= TRUE
;
8765 /* Decode the unwinding instructions. */
8768 unsigned int op
, op2
;
8777 printf (" 0x%02x ", op
);
8779 if ((op
& 0xc0) == 0x00)
8781 int offset
= ((op
& 0x3f) << 2) + 4;
8783 printf (" vsp = vsp + %d", offset
);
8785 else if ((op
& 0xc0) == 0x40)
8787 int offset
= ((op
& 0x3f) << 2) + 4;
8789 printf (" vsp = vsp - %d", offset
);
8791 else if ((op
& 0xf0) == 0x80)
8794 if (op
== 0x80 && op2
== 0)
8795 printf (_("Refuse to unwind"));
8798 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8799 bfd_boolean first
= TRUE
;
8803 for (i
= 0; i
< 12; i
++)
8804 if (mask
& (1 << i
))
8810 printf ("r%d", 4 + i
);
8815 else if ((op
& 0xf0) == 0x90)
8817 if (op
== 0x9d || op
== 0x9f)
8818 printf (_(" [Reserved]"));
8820 printf (" vsp = r%d", op
& 0x0f);
8822 else if ((op
& 0xf0) == 0xa0)
8824 int end
= 4 + (op
& 0x07);
8825 bfd_boolean first
= TRUE
;
8829 for (i
= 4; i
<= end
; i
++)
8845 else if (op
== 0xb0)
8846 printf (_(" finish"));
8847 else if (op
== 0xb1)
8850 if (op2
== 0 || (op2
& 0xf0) != 0)
8851 printf (_("[Spare]"));
8854 unsigned int mask
= op2
& 0x0f;
8855 bfd_boolean first
= TRUE
;
8859 for (i
= 0; i
< 12; i
++)
8860 if (mask
& (1 << i
))
8871 else if (op
== 0xb2)
8873 unsigned char buf
[9];
8874 unsigned int i
, len
;
8875 unsigned long offset
;
8877 for (i
= 0; i
< sizeof (buf
); i
++)
8880 if ((buf
[i
] & 0x80) == 0)
8883 if (i
== sizeof (buf
))
8885 error (_("corrupt change to vsp\n"));
8890 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8891 assert (len
== i
+ 1);
8892 offset
= offset
* 4 + 0x204;
8893 printf ("vsp = vsp + %ld", offset
);
8896 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8898 unsigned int first
, last
;
8905 printf ("pop {D%d", first
);
8907 printf ("-D%d", first
+ last
);
8910 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8912 unsigned int count
= op
& 0x07;
8916 printf ("-D%d", 8 + count
);
8919 else if (op
>= 0xc0 && op
<= 0xc5)
8921 unsigned int count
= op
& 0x07;
8923 printf (" pop {wR10");
8925 printf ("-wR%d", 10 + count
);
8928 else if (op
== 0xc6)
8930 unsigned int first
, last
;
8935 printf ("pop {wR%d", first
);
8937 printf ("-wR%d", first
+ last
);
8940 else if (op
== 0xc7)
8943 if (op2
== 0 || (op2
& 0xf0) != 0)
8944 printf (_("[Spare]"));
8947 unsigned int mask
= op2
& 0x0f;
8948 bfd_boolean first
= TRUE
;
8952 for (i
= 0; i
< 4; i
++)
8953 if (mask
& (1 << i
))
8959 printf ("wCGR%d", i
);
8966 printf (_(" [unsupported opcode]"));
8977 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8978 struct arm_unw_aux_info
* aux
,
8980 unsigned int remaining
,
8981 unsigned int more_words
,
8982 bfd_vma data_offset
,
8983 Elf_Internal_Shdr
* data_sec
,
8984 struct arm_section
* data_arm_sec
)
8986 struct absaddr addr
;
8988 /* Decode the unwinding instructions. */
8991 unsigned int op
, op2
;
9000 printf (" 0x%02x ", op
);
9002 if ((op
& 0xc0) == 0x00)
9004 int offset
= ((op
& 0x3f) << 3) + 8;
9005 printf (" sp = sp + %d", offset
);
9007 else if ((op
& 0xc0) == 0x80)
9010 if (op
== 0x80 && op2
== 0)
9011 printf (_("Refuse to unwind"));
9014 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9016 printf ("pop compact {");
9020 decode_tic6x_unwind_regmask (mask
);
9024 else if ((op
& 0xf0) == 0xc0)
9032 unsigned int offset
;
9036 /* Scan entire instruction first so that GET_OP output is not
9037 interleaved with disassembly. */
9039 for (i
= 0; nregs
< (op
& 0xf); i
++)
9045 regpos
[nregs
].offset
= i
* 2;
9046 regpos
[nregs
].reg
= reg
;
9053 regpos
[nregs
].offset
= i
* 2 + 1;
9054 regpos
[nregs
].reg
= reg
;
9059 printf (_("pop frame {"));
9062 printf (_("*corrupt* - no registers specified"));
9067 for (i
= i
* 2; i
> 0; i
--)
9069 if (regpos
[reg
].offset
== i
- 1)
9071 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9078 fputs (name
, stdout
);
9086 else if (op
== 0xd0)
9087 printf (" MOV FP, SP");
9088 else if (op
== 0xd1)
9089 printf (" __c6xabi_pop_rts");
9090 else if (op
== 0xd2)
9092 unsigned char buf
[9];
9093 unsigned int i
, len
;
9094 unsigned long offset
;
9096 for (i
= 0; i
< sizeof (buf
); i
++)
9099 if ((buf
[i
] & 0x80) == 0)
9102 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9103 if (i
== sizeof (buf
))
9105 warn (_("Corrupt stack pointer adjustment detected\n"));
9109 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9110 assert (len
== i
+ 1);
9111 offset
= offset
* 8 + 0x408;
9112 printf (_("sp = sp + %ld"), offset
);
9114 else if ((op
& 0xf0) == 0xe0)
9116 if ((op
& 0x0f) == 7)
9119 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9123 printf (_(" [unsupported opcode]"));
9132 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9136 offset
= word
& 0x7fffffff;
9137 if (offset
& 0x40000000)
9138 offset
|= ~ (bfd_vma
) 0x7fffffff;
9140 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9143 return offset
+ where
;
9147 decode_arm_unwind (Filedata
* filedata
,
9148 struct arm_unw_aux_info
* aux
,
9150 unsigned int remaining
,
9151 bfd_vma data_offset
,
9152 Elf_Internal_Shdr
* data_sec
,
9153 struct arm_section
* data_arm_sec
)
9156 unsigned int more_words
= 0;
9157 struct absaddr addr
;
9158 bfd_vma sym_name
= (bfd_vma
) -1;
9159 bfd_boolean res
= TRUE
;
9163 /* Fetch the first word.
9164 Note - when decoding an object file the address extracted
9165 here will always be 0. So we also pass in the sym_name
9166 parameter so that we can find the symbol associated with
9167 the personality routine. */
9168 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9169 & word
, & addr
, & sym_name
))
9176 addr
.section
= SHN_UNDEF
;
9180 if ((word
& 0x80000000) == 0)
9182 /* Expand prel31 for personality routine. */
9184 const char *procname
;
9186 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9187 printf (_(" Personality routine: "));
9189 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9190 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9192 procname
= aux
->strtab
+ sym_name
;
9193 print_vma (fn
, PREFIX_HEX
);
9196 fputs (" <", stdout
);
9197 fputs (procname
, stdout
);
9198 fputc ('>', stdout
);
9202 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9203 fputc ('\n', stdout
);
9205 /* The GCC personality routines use the standard compact
9206 encoding, starting with one byte giving the number of
9208 if (procname
!= NULL
9209 && (const_strneq (procname
, "__gcc_personality_v0")
9210 || const_strneq (procname
, "__gxx_personality_v0")
9211 || const_strneq (procname
, "__gcj_personality_v0")
9212 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9219 printf (_(" [Truncated data]\n"));
9222 more_words
= word
>> 24;
9232 /* ARM EHABI Section 6.3:
9234 An exception-handling table entry for the compact model looks like:
9238 1 0 index Data for personalityRoutine[index] */
9240 if (filedata
->file_header
.e_machine
== EM_ARM
9241 && (word
& 0x70000000))
9243 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9247 per_index
= (word
>> 24) & 0x7f;
9248 printf (_(" Compact model index: %d\n"), per_index
);
9255 else if (per_index
< 3)
9257 more_words
= (word
>> 16) & 0xff;
9263 switch (filedata
->file_header
.e_machine
)
9268 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9269 data_offset
, data_sec
, data_arm_sec
))
9274 warn (_("Unknown ARM compact model index encountered\n"));
9275 printf (_(" [reserved]\n"));
9283 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9284 data_offset
, data_sec
, data_arm_sec
))
9287 else if (per_index
< 5)
9289 if (((word
>> 17) & 0x7f) == 0x7f)
9290 printf (_(" Restore stack from frame pointer\n"));
9292 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9293 printf (_(" Registers restored: "));
9295 printf (" (compact) ");
9296 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9298 printf (_(" Return register: %s\n"),
9299 tic6x_unwind_regnames
[word
& 0xf]);
9302 printf (_(" [reserved (%d)]\n"), per_index
);
9306 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9307 filedata
->file_header
.e_machine
);
9311 /* Decode the descriptors. Not implemented. */
9317 dump_arm_unwind (Filedata
* filedata
,
9318 struct arm_unw_aux_info
* aux
,
9319 Elf_Internal_Shdr
* exidx_sec
)
9321 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9322 unsigned int i
, exidx_len
;
9323 unsigned long j
, nfuns
;
9324 bfd_boolean res
= TRUE
;
9326 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9327 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9328 exidx_len
= exidx_sec
->sh_size
/ 8;
9330 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9331 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9332 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9333 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9335 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9337 for (i
= 0; i
< exidx_len
; i
++)
9339 unsigned int exidx_fn
, exidx_entry
;
9340 struct absaddr fn_addr
, entry_addr
;
9343 fputc ('\n', stdout
);
9345 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9346 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9347 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9348 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9351 arm_free_section (& exidx_arm_sec
);
9352 arm_free_section (& extab_arm_sec
);
9356 /* ARM EHABI, Section 5:
9357 An index table entry consists of 2 words.
9358 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9359 if (exidx_fn
& 0x80000000)
9361 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9365 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9367 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9368 fputs (": ", stdout
);
9370 if (exidx_entry
== 1)
9372 print_vma (exidx_entry
, PREFIX_HEX
);
9373 fputs (" [cantunwind]\n", stdout
);
9375 else if (exidx_entry
& 0x80000000)
9377 print_vma (exidx_entry
, PREFIX_HEX
);
9378 fputc ('\n', stdout
);
9379 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9383 bfd_vma table
, table_offset
= 0;
9384 Elf_Internal_Shdr
*table_sec
;
9386 fputs ("@", stdout
);
9387 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9388 print_vma (table
, PREFIX_HEX
);
9391 /* Locate the matching .ARM.extab. */
9392 if (entry_addr
.section
!= SHN_UNDEF
9393 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9395 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9396 table_offset
= entry_addr
.offset
;
9398 if (table_offset
> table_sec
->sh_size
9399 || ((bfd_signed_vma
) table_offset
) < 0)
9401 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9402 (unsigned long) table_offset
,
9403 printable_section_name (filedata
, table_sec
));
9410 table_sec
= find_section_by_address (filedata
, table
);
9411 if (table_sec
!= NULL
)
9412 table_offset
= table
- table_sec
->sh_addr
;
9415 if (table_sec
== NULL
)
9417 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9418 (unsigned long) table
);
9423 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9432 arm_free_section (&exidx_arm_sec
);
9433 arm_free_section (&extab_arm_sec
);
9438 /* Used for both ARM and C6X unwinding tables. */
9441 arm_process_unwind (Filedata
* filedata
)
9443 struct arm_unw_aux_info aux
;
9444 Elf_Internal_Shdr
*unwsec
= NULL
;
9445 Elf_Internal_Shdr
*sec
;
9447 unsigned int sec_type
;
9448 bfd_boolean res
= TRUE
;
9450 switch (filedata
->file_header
.e_machine
)
9453 sec_type
= SHT_ARM_EXIDX
;
9457 sec_type
= SHT_C6000_UNWIND
;
9461 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9462 filedata
->file_header
.e_machine
);
9466 if (filedata
->string_table
== NULL
)
9469 memset (& aux
, 0, sizeof (aux
));
9470 aux
.filedata
= filedata
;
9472 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9474 if (sec
->sh_type
== SHT_SYMTAB
)
9478 error (_("Multiple symbol tables encountered\n"));
9484 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9485 &aux
.strtab
, &aux
.strtab_size
))
9488 else if (sec
->sh_type
== sec_type
)
9493 printf (_("\nThere are no unwind sections in this file.\n"));
9495 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9497 if (sec
->sh_type
== sec_type
)
9499 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9500 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9501 "contains %lu entry:\n",
9502 "\nUnwind section '%s' at offset 0x%lx "
9503 "contains %lu entries:\n",
9505 printable_section_name (filedata
, sec
),
9506 (unsigned long) sec
->sh_offset
,
9509 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9515 free ((char *) aux
.strtab
);
9521 process_unwind (Filedata
* filedata
)
9523 struct unwind_handler
9525 unsigned int machtype
;
9526 bfd_boolean (* handler
)(Filedata
*);
9529 { EM_ARM
, arm_process_unwind
},
9530 { EM_IA_64
, ia64_process_unwind
},
9531 { EM_PARISC
, hppa_process_unwind
},
9532 { EM_TI_C6000
, arm_process_unwind
},
9540 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9541 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9542 return handlers
[i
].handler (filedata
);
9544 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9545 get_machine_name (filedata
->file_header
.e_machine
));
9550 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9552 switch (entry
->d_tag
)
9554 case DT_AARCH64_BTI_PLT
:
9555 case DT_AARCH64_PAC_PLT
:
9558 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9565 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9567 switch (entry
->d_tag
)
9570 if (entry
->d_un
.d_val
== 0)
9574 static const char * opts
[] =
9576 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9577 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9578 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9579 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9583 bfd_boolean first
= TRUE
;
9585 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9586 if (entry
->d_un
.d_val
& (1 << cnt
))
9588 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9594 case DT_MIPS_IVERSION
:
9595 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9596 printf (_("Interface Version: %s"),
9597 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9601 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9602 /* Note: coded this way so that there is a single string for translation. */
9603 printf (_("<corrupt: %s>"), buf
);
9607 case DT_MIPS_TIME_STAMP
:
9611 time_t atime
= entry
->d_un
.d_val
;
9613 tmp
= gmtime (&atime
);
9614 /* PR 17531: file: 6accc532. */
9616 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9618 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9619 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9620 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9621 printf (_("Time Stamp: %s"), timebuf
);
9625 case DT_MIPS_RLD_VERSION
:
9626 case DT_MIPS_LOCAL_GOTNO
:
9627 case DT_MIPS_CONFLICTNO
:
9628 case DT_MIPS_LIBLISTNO
:
9629 case DT_MIPS_SYMTABNO
:
9630 case DT_MIPS_UNREFEXTNO
:
9631 case DT_MIPS_HIPAGENO
:
9632 case DT_MIPS_DELTA_CLASS_NO
:
9633 case DT_MIPS_DELTA_INSTANCE_NO
:
9634 case DT_MIPS_DELTA_RELOC_NO
:
9635 case DT_MIPS_DELTA_SYM_NO
:
9636 case DT_MIPS_DELTA_CLASSSYM_NO
:
9637 case DT_MIPS_COMPACT_SIZE
:
9638 print_vma (entry
->d_un
.d_val
, DEC
);
9642 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9643 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9644 /* Falls through. */
9647 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9653 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9655 switch (entry
->d_tag
)
9657 case DT_HP_DLD_FLAGS
:
9666 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9667 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9668 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9669 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9670 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9671 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9672 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9673 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9674 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9675 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9676 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9677 { DT_HP_GST
, "HP_GST" },
9678 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9679 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9680 { DT_HP_NODELETE
, "HP_NODELETE" },
9681 { DT_HP_GROUP
, "HP_GROUP" },
9682 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9684 bfd_boolean first
= TRUE
;
9686 bfd_vma val
= entry
->d_un
.d_val
;
9688 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9689 if (val
& flags
[cnt
].bit
)
9693 fputs (flags
[cnt
].str
, stdout
);
9695 val
^= flags
[cnt
].bit
;
9698 if (val
!= 0 || first
)
9702 print_vma (val
, HEX
);
9708 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9716 /* VMS vs Unix time offset and factor. */
9718 #define VMS_EPOCH_OFFSET 35067168000000000LL
9719 #define VMS_GRANULARITY_FACTOR 10000000
9721 /* Display a VMS time in a human readable format. */
9724 print_vms_time (bfd_int64_t vmstime
)
9729 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9730 tm
= gmtime (&unxtime
);
9731 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9732 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9733 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9738 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9740 switch (entry
->d_tag
)
9742 case DT_IA_64_PLT_RESERVE
:
9743 /* First 3 slots reserved. */
9744 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9746 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9749 case DT_IA_64_VMS_LINKTIME
:
9751 print_vms_time (entry
->d_un
.d_val
);
9755 case DT_IA_64_VMS_LNKFLAGS
:
9756 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9757 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9758 printf (" CALL_DEBUG");
9759 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9760 printf (" NOP0BUFS");
9761 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9762 printf (" P0IMAGE");
9763 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9764 printf (" MKTHREADS");
9765 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9766 printf (" UPCALLS");
9767 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9769 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9770 printf (" INITIALIZE");
9771 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9773 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9774 printf (" EXE_INIT");
9775 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9776 printf (" TBK_IN_IMG");
9777 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9778 printf (" DBG_IN_IMG");
9779 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9780 printf (" TBK_IN_DSF");
9781 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9782 printf (" DBG_IN_DSF");
9783 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9784 printf (" SIGNATURES");
9785 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9786 printf (" REL_SEG_OFF");
9790 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9797 get_32bit_dynamic_section (Filedata
* filedata
)
9799 Elf32_External_Dyn
* edyn
;
9800 Elf32_External_Dyn
* ext
;
9801 Elf_Internal_Dyn
* entry
;
9803 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9804 filedata
->dynamic_addr
, 1,
9805 filedata
->dynamic_size
,
9806 _("dynamic section"));
9810 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9811 might not have the luxury of section headers. Look for the DT_NULL
9812 terminator to determine the number of entries. */
9813 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9814 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9817 filedata
->dynamic_nent
++;
9818 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9822 filedata
->dynamic_section
9823 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9824 if (filedata
->dynamic_section
== NULL
)
9826 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9827 (unsigned long) filedata
->dynamic_nent
);
9832 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9833 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9836 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9837 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9846 get_64bit_dynamic_section (Filedata
* filedata
)
9848 Elf64_External_Dyn
* edyn
;
9849 Elf64_External_Dyn
* ext
;
9850 Elf_Internal_Dyn
* entry
;
9852 /* Read in the data. */
9853 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9854 filedata
->dynamic_addr
, 1,
9855 filedata
->dynamic_size
,
9856 _("dynamic section"));
9860 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9861 might not have the luxury of section headers. Look for the DT_NULL
9862 terminator to determine the number of entries. */
9863 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9864 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9865 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9868 filedata
->dynamic_nent
++;
9869 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9873 filedata
->dynamic_section
9874 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9875 if (filedata
->dynamic_section
== NULL
)
9877 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9878 (unsigned long) filedata
->dynamic_nent
);
9883 /* Convert from external to internal formats. */
9884 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9885 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9888 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9889 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9898 print_dynamic_flags (bfd_vma flags
)
9900 bfd_boolean first
= TRUE
;
9906 flag
= flags
& - flags
;
9916 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9917 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9918 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9919 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9920 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9921 default: fputs (_("unknown"), stdout
); break;
9928 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9930 unsigned char * e_data
;
9933 /* If the size_t type is smaller than the bfd_size_type, eg because
9934 you are building a 32-bit tool on a 64-bit host, then make sure
9935 that when (number) is cast to (size_t) no information is lost. */
9936 if (sizeof (size_t) < sizeof (bfd_size_type
)
9937 && (bfd_size_type
) ((size_t) number
) != number
)
9939 error (_("Size truncation prevents reading %s elements of size %u\n"),
9940 bfd_vmatoa ("u", number
), ent_size
);
9944 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9945 attempting to allocate memory when the read is bound to fail. */
9946 if (ent_size
* number
> filedata
->file_size
)
9948 error (_("Invalid number of dynamic entries: %s\n"),
9949 bfd_vmatoa ("u", number
));
9953 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9956 error (_("Out of memory reading %s dynamic entries\n"),
9957 bfd_vmatoa ("u", number
));
9961 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9963 error (_("Unable to read in %s bytes of dynamic data\n"),
9964 bfd_vmatoa ("u", number
* ent_size
));
9969 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
9972 error (_("Out of memory allocating space for %s dynamic entries\n"),
9973 bfd_vmatoa ("u", number
));
9979 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9986 static unsigned long
9987 get_num_dynamic_syms (Filedata
* filedata
)
9989 unsigned long num_of_syms
= 0;
9991 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
9994 if (filedata
->dynamic_info
[DT_HASH
])
9996 unsigned char nb
[8];
9997 unsigned char nc
[8];
9998 unsigned int hash_ent_size
= 4;
10000 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10001 || filedata
->file_header
.e_machine
== EM_S390
10002 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10003 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10006 if (fseek (filedata
->handle
,
10007 (filedata
->archive_file_offset
10008 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10009 sizeof nb
+ sizeof nc
)),
10012 error (_("Unable to seek to start of dynamic information\n"));
10016 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10018 error (_("Failed to read in number of buckets\n"));
10022 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10024 error (_("Failed to read in number of chains\n"));
10028 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10029 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10031 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10033 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10035 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10038 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10039 num_of_syms
= filedata
->nchains
;
10042 if (num_of_syms
== 0)
10044 free (filedata
->buckets
);
10045 filedata
->buckets
= NULL
;
10046 free (filedata
->chains
);
10047 filedata
->chains
= NULL
;
10048 filedata
->nbuckets
= 0;
10052 if (filedata
->dynamic_info_DT_GNU_HASH
)
10054 unsigned char nb
[16];
10055 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10056 bfd_vma buckets_vma
;
10059 if (fseek (filedata
->handle
,
10060 (filedata
->archive_file_offset
10061 + offset_from_vma (filedata
,
10062 filedata
->dynamic_info_DT_GNU_HASH
,
10066 error (_("Unable to seek to start of dynamic information\n"));
10070 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10072 error (_("Failed to read in number of buckets\n"));
10076 filedata
->ngnubuckets
= byte_get (nb
, 4);
10077 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10078 bitmaskwords
= byte_get (nb
+ 8, 4);
10079 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10081 buckets_vma
+= bitmaskwords
* 4;
10083 buckets_vma
+= bitmaskwords
* 8;
10085 if (fseek (filedata
->handle
,
10086 (filedata
->archive_file_offset
10087 + offset_from_vma (filedata
, buckets_vma
, 4)),
10090 error (_("Unable to seek to start of dynamic information\n"));
10094 filedata
->gnubuckets
10095 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10097 if (filedata
->gnubuckets
== NULL
)
10100 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10101 if (filedata
->gnubuckets
[i
] != 0)
10103 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10106 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10107 maxchain
= filedata
->gnubuckets
[i
];
10110 if (maxchain
== 0xffffffff)
10113 maxchain
-= filedata
->gnusymidx
;
10115 if (fseek (filedata
->handle
,
10116 (filedata
->archive_file_offset
10117 + offset_from_vma (filedata
,
10118 buckets_vma
+ 4 * (filedata
->ngnubuckets
10123 error (_("Unable to seek to start of dynamic information\n"));
10129 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10131 error (_("Failed to determine last chain length\n"));
10135 if (maxchain
+ 1 == 0)
10140 while ((byte_get (nb
, 4) & 1) == 0);
10142 if (fseek (filedata
->handle
,
10143 (filedata
->archive_file_offset
10144 + offset_from_vma (filedata
, (buckets_vma
10145 + 4 * filedata
->ngnubuckets
),
10149 error (_("Unable to seek to start of dynamic information\n"));
10153 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10154 filedata
->ngnuchains
= maxchain
;
10156 if (filedata
->gnuchains
== NULL
)
10159 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10161 if (fseek (filedata
->handle
,
10162 (filedata
->archive_file_offset
10163 + offset_from_vma (filedata
, (buckets_vma
10164 + 4 * (filedata
->ngnubuckets
10168 error (_("Unable to seek to start of dynamic information\n"));
10172 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10173 if (filedata
->mipsxlat
== NULL
)
10177 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10178 if (filedata
->gnubuckets
[hn
] != 0)
10180 bfd_vma si
= filedata
->gnubuckets
[hn
];
10181 bfd_vma off
= si
- filedata
->gnusymidx
;
10185 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10187 if (off
< filedata
->ngnuchains
10188 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10189 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10193 if (si
>= num_of_syms
)
10194 num_of_syms
= si
+ 1;
10198 while (off
< filedata
->ngnuchains
10199 && (filedata
->gnuchains
[off
++] & 1) == 0);
10202 if (num_of_syms
== 0)
10205 free (filedata
->mipsxlat
);
10206 filedata
->mipsxlat
= NULL
;
10207 free (filedata
->gnuchains
);
10208 filedata
->gnuchains
= NULL
;
10209 free (filedata
->gnubuckets
);
10210 filedata
->gnubuckets
= NULL
;
10211 filedata
->ngnubuckets
= 0;
10212 filedata
->ngnuchains
= 0;
10216 return num_of_syms
;
10219 /* Parse and display the contents of the dynamic section. */
10222 process_dynamic_section (Filedata
* filedata
)
10224 Elf_Internal_Dyn
* entry
;
10226 if (filedata
->dynamic_size
== 0)
10229 printf (_("\nThere is no dynamic section in this file.\n"));
10236 if (! get_32bit_dynamic_section (filedata
))
10241 if (! get_64bit_dynamic_section (filedata
))
10245 /* Find the appropriate symbol table. */
10246 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10248 unsigned long num_of_syms
;
10250 for (entry
= filedata
->dynamic_section
;
10251 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10253 if (entry
->d_tag
== DT_SYMTAB
)
10254 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10255 else if (entry
->d_tag
== DT_SYMENT
)
10256 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10257 else if (entry
->d_tag
== DT_HASH
)
10258 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10259 else if (entry
->d_tag
== DT_GNU_HASH
)
10260 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10261 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10262 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10263 && entry
->d_tag
== DT_MIPS_XHASH
)
10265 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10266 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10269 num_of_syms
= get_num_dynamic_syms (filedata
);
10271 if (num_of_syms
!= 0
10272 && filedata
->dynamic_symbols
== NULL
10273 && filedata
->dynamic_info
[DT_SYMTAB
]
10274 && filedata
->dynamic_info
[DT_SYMENT
])
10276 Elf_Internal_Phdr
*seg
;
10277 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10279 if (! get_program_headers (filedata
))
10281 error (_("Cannot interpret virtual addresses "
10282 "without program headers.\n"));
10286 for (seg
= filedata
->program_headers
;
10287 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10290 if (seg
->p_type
!= PT_LOAD
)
10293 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10295 /* See PR 21379 for a reproducer. */
10296 error (_("Invalid PT_LOAD entry\n"));
10300 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10301 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10303 /* Since we do not know how big the symbol table is,
10304 we default to reading in up to the end of PT_LOAD
10305 segment and processing that. This is overkill, I
10306 know, but it should work. */
10307 Elf_Internal_Shdr section
;
10308 section
.sh_offset
= (vma
- seg
->p_vaddr
10310 section
.sh_size
= (num_of_syms
10311 * filedata
->dynamic_info
[DT_SYMENT
]);
10312 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10315 && filedata
->dynamic_symtab_section
!= NULL
10316 && ((filedata
->dynamic_symtab_section
->sh_offset
10317 != section
.sh_offset
)
10318 || (filedata
->dynamic_symtab_section
->sh_size
10319 != section
.sh_size
)
10320 || (filedata
->dynamic_symtab_section
->sh_entsize
10321 != section
.sh_entsize
)))
10323 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10325 section
.sh_name
= filedata
->string_table_length
;
10326 filedata
->dynamic_symbols
10327 = GET_ELF_SYMBOLS (filedata
, §ion
,
10328 &filedata
->num_dynamic_syms
);
10329 if (filedata
->dynamic_symbols
== NULL
10330 || filedata
->num_dynamic_syms
!= num_of_syms
)
10332 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10341 /* Similarly find a string table. */
10342 if (filedata
->dynamic_strings
== NULL
)
10343 for (entry
= filedata
->dynamic_section
;
10344 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10347 if (entry
->d_tag
== DT_STRTAB
)
10348 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10350 if (entry
->d_tag
== DT_STRSZ
)
10351 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10353 if (filedata
->dynamic_info
[DT_STRTAB
]
10354 && filedata
->dynamic_info
[DT_STRSZ
])
10356 unsigned long offset
;
10357 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10359 offset
= offset_from_vma (filedata
,
10360 filedata
->dynamic_info
[DT_STRTAB
],
10363 && filedata
->dynamic_strtab_section
10364 && ((filedata
->dynamic_strtab_section
->sh_offset
10365 != (file_ptr
) offset
)
10366 || (filedata
->dynamic_strtab_section
->sh_size
10369 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10371 filedata
->dynamic_strings
10372 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10373 _("dynamic string table"));
10374 if (filedata
->dynamic_strings
== NULL
)
10376 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10380 filedata
->dynamic_strings_length
= str_tab_len
;
10385 /* And find the syminfo section if available. */
10386 if (filedata
->dynamic_syminfo
== NULL
)
10388 unsigned long syminsz
= 0;
10390 for (entry
= filedata
->dynamic_section
;
10391 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10394 if (entry
->d_tag
== DT_SYMINENT
)
10396 /* Note: these braces are necessary to avoid a syntax
10397 error from the SunOS4 C compiler. */
10398 /* PR binutils/17531: A corrupt file can trigger this test.
10399 So do not use an assert, instead generate an error message. */
10400 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10401 error (_("Bad value (%d) for SYMINENT entry\n"),
10402 (int) entry
->d_un
.d_val
);
10404 else if (entry
->d_tag
== DT_SYMINSZ
)
10405 syminsz
= entry
->d_un
.d_val
;
10406 else if (entry
->d_tag
== DT_SYMINFO
)
10407 filedata
->dynamic_syminfo_offset
10408 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10411 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10413 Elf_External_Syminfo
* extsyminfo
;
10414 Elf_External_Syminfo
* extsym
;
10415 Elf_Internal_Syminfo
* syminfo
;
10417 /* There is a syminfo section. Read the data. */
10418 extsyminfo
= (Elf_External_Syminfo
*)
10419 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10420 1, syminsz
, _("symbol information"));
10424 if (filedata
->dynamic_syminfo
!= NULL
)
10426 error (_("Multiple dynamic symbol information sections found\n"));
10427 free (filedata
->dynamic_syminfo
);
10429 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10430 if (filedata
->dynamic_syminfo
== NULL
)
10432 error (_("Out of memory allocating %lu bytes "
10433 "for dynamic symbol info\n"),
10434 (unsigned long) syminsz
);
10438 filedata
->dynamic_syminfo_nent
10439 = syminsz
/ sizeof (Elf_External_Syminfo
);
10440 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10441 syminfo
< (filedata
->dynamic_syminfo
10442 + filedata
->dynamic_syminfo_nent
);
10443 ++syminfo
, ++extsym
)
10445 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10446 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10453 if (do_dynamic
&& filedata
->dynamic_addr
)
10454 printf (ngettext ("\nDynamic section at offset 0x%lx "
10455 "contains %lu entry:\n",
10456 "\nDynamic section at offset 0x%lx "
10457 "contains %lu entries:\n",
10458 filedata
->dynamic_nent
),
10459 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10461 printf (_(" Tag Type Name/Value\n"));
10463 for (entry
= filedata
->dynamic_section
;
10464 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10469 const char * dtype
;
10472 print_vma (entry
->d_tag
, FULL_HEX
);
10473 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10474 printf (" (%s)%*s", dtype
,
10475 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10478 switch (entry
->d_tag
)
10482 print_dynamic_flags (entry
->d_un
.d_val
);
10492 switch (entry
->d_tag
)
10495 printf (_("Auxiliary library"));
10499 printf (_("Filter library"));
10503 printf (_("Configuration file"));
10507 printf (_("Dependency audit library"));
10511 printf (_("Audit library"));
10515 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10516 printf (": [%s]\n",
10517 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10521 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10530 printf (_("Flags:"));
10532 if (entry
->d_un
.d_val
== 0)
10533 printf (_(" None\n"));
10536 unsigned long int val
= entry
->d_un
.d_val
;
10538 if (val
& DTF_1_PARINIT
)
10540 printf (" PARINIT");
10541 val
^= DTF_1_PARINIT
;
10543 if (val
& DTF_1_CONFEXP
)
10545 printf (" CONFEXP");
10546 val
^= DTF_1_CONFEXP
;
10549 printf (" %lx", val
);
10558 printf (_("Flags:"));
10560 if (entry
->d_un
.d_val
== 0)
10561 printf (_(" None\n"));
10564 unsigned long int val
= entry
->d_un
.d_val
;
10566 if (val
& DF_P1_LAZYLOAD
)
10568 printf (" LAZYLOAD");
10569 val
^= DF_P1_LAZYLOAD
;
10571 if (val
& DF_P1_GROUPPERM
)
10573 printf (" GROUPPERM");
10574 val
^= DF_P1_GROUPPERM
;
10577 printf (" %lx", val
);
10586 printf (_("Flags:"));
10587 if (entry
->d_un
.d_val
== 0)
10588 printf (_(" None\n"));
10591 unsigned long int val
= entry
->d_un
.d_val
;
10593 if (val
& DF_1_NOW
)
10598 if (val
& DF_1_GLOBAL
)
10600 printf (" GLOBAL");
10601 val
^= DF_1_GLOBAL
;
10603 if (val
& DF_1_GROUP
)
10608 if (val
& DF_1_NODELETE
)
10610 printf (" NODELETE");
10611 val
^= DF_1_NODELETE
;
10613 if (val
& DF_1_LOADFLTR
)
10615 printf (" LOADFLTR");
10616 val
^= DF_1_LOADFLTR
;
10618 if (val
& DF_1_INITFIRST
)
10620 printf (" INITFIRST");
10621 val
^= DF_1_INITFIRST
;
10623 if (val
& DF_1_NOOPEN
)
10625 printf (" NOOPEN");
10626 val
^= DF_1_NOOPEN
;
10628 if (val
& DF_1_ORIGIN
)
10630 printf (" ORIGIN");
10631 val
^= DF_1_ORIGIN
;
10633 if (val
& DF_1_DIRECT
)
10635 printf (" DIRECT");
10636 val
^= DF_1_DIRECT
;
10638 if (val
& DF_1_TRANS
)
10643 if (val
& DF_1_INTERPOSE
)
10645 printf (" INTERPOSE");
10646 val
^= DF_1_INTERPOSE
;
10648 if (val
& DF_1_NODEFLIB
)
10650 printf (" NODEFLIB");
10651 val
^= DF_1_NODEFLIB
;
10653 if (val
& DF_1_NODUMP
)
10655 printf (" NODUMP");
10656 val
^= DF_1_NODUMP
;
10658 if (val
& DF_1_CONFALT
)
10660 printf (" CONFALT");
10661 val
^= DF_1_CONFALT
;
10663 if (val
& DF_1_ENDFILTEE
)
10665 printf (" ENDFILTEE");
10666 val
^= DF_1_ENDFILTEE
;
10668 if (val
& DF_1_DISPRELDNE
)
10670 printf (" DISPRELDNE");
10671 val
^= DF_1_DISPRELDNE
;
10673 if (val
& DF_1_DISPRELPND
)
10675 printf (" DISPRELPND");
10676 val
^= DF_1_DISPRELPND
;
10678 if (val
& DF_1_NODIRECT
)
10680 printf (" NODIRECT");
10681 val
^= DF_1_NODIRECT
;
10683 if (val
& DF_1_IGNMULDEF
)
10685 printf (" IGNMULDEF");
10686 val
^= DF_1_IGNMULDEF
;
10688 if (val
& DF_1_NOKSYMS
)
10690 printf (" NOKSYMS");
10691 val
^= DF_1_NOKSYMS
;
10693 if (val
& DF_1_NOHDR
)
10698 if (val
& DF_1_EDITED
)
10700 printf (" EDITED");
10701 val
^= DF_1_EDITED
;
10703 if (val
& DF_1_NORELOC
)
10705 printf (" NORELOC");
10706 val
^= DF_1_NORELOC
;
10708 if (val
& DF_1_SYMINTPOSE
)
10710 printf (" SYMINTPOSE");
10711 val
^= DF_1_SYMINTPOSE
;
10713 if (val
& DF_1_GLOBAUDIT
)
10715 printf (" GLOBAUDIT");
10716 val
^= DF_1_GLOBAUDIT
;
10718 if (val
& DF_1_SINGLETON
)
10720 printf (" SINGLETON");
10721 val
^= DF_1_SINGLETON
;
10723 if (val
& DF_1_STUB
)
10728 if (val
& DF_1_PIE
)
10733 if (val
& DF_1_KMOD
)
10738 if (val
& DF_1_WEAKFILTER
)
10740 printf (" WEAKFILTER");
10741 val
^= DF_1_WEAKFILTER
;
10743 if (val
& DF_1_NOCOMMON
)
10745 printf (" NOCOMMON");
10746 val
^= DF_1_NOCOMMON
;
10749 printf (" %lx", val
);
10756 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10758 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10778 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10784 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10785 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10791 switch (entry
->d_tag
)
10794 printf (_("Shared library: [%s]"), name
);
10796 if (streq (name
, filedata
->program_interpreter
))
10797 printf (_(" program interpreter"));
10801 printf (_("Library soname: [%s]"), name
);
10805 printf (_("Library rpath: [%s]"), name
);
10809 printf (_("Library runpath: [%s]"), name
);
10813 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10818 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10831 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10832 /* Fall through. */
10836 case DT_INIT_ARRAYSZ
:
10837 case DT_FINI_ARRAYSZ
:
10838 case DT_GNU_CONFLICTSZ
:
10839 case DT_GNU_LIBLISTSZ
:
10842 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10843 printf (_(" (bytes)\n"));
10848 case DT_VERNEEDNUM
:
10853 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10862 case DT_INIT_ARRAY
:
10863 case DT_FINI_ARRAY
:
10866 if (entry
->d_tag
== DT_USED
10867 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10869 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10873 printf (_("Not needed object: [%s]\n"), name
);
10878 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10884 /* The value of this entry is ignored. */
10889 case DT_GNU_PRELINKED
:
10893 time_t atime
= entry
->d_un
.d_val
;
10895 tmp
= gmtime (&atime
);
10896 /* PR 17533 file: 041-1244816-0.004. */
10898 printf (_("<corrupt time val: %lx"),
10899 (unsigned long) atime
);
10901 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10902 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10903 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10909 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10912 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10918 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10919 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10920 = entry
->d_un
.d_val
;
10924 switch (filedata
->file_header
.e_machine
)
10927 dynamic_section_aarch64_val (entry
);
10930 case EM_MIPS_RS3_LE
:
10931 dynamic_section_mips_val (filedata
, entry
);
10934 dynamic_section_parisc_val (entry
);
10937 dynamic_section_ia64_val (entry
);
10940 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10952 get_ver_flags (unsigned int flags
)
10954 static char buff
[128];
10961 if (flags
& VER_FLG_BASE
)
10962 strcat (buff
, "BASE");
10964 if (flags
& VER_FLG_WEAK
)
10966 if (flags
& VER_FLG_BASE
)
10967 strcat (buff
, " | ");
10969 strcat (buff
, "WEAK");
10972 if (flags
& VER_FLG_INFO
)
10974 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10975 strcat (buff
, " | ");
10977 strcat (buff
, "INFO");
10980 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10982 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10983 strcat (buff
, " | ");
10985 strcat (buff
, _("<unknown>"));
10991 /* Display the contents of the version sections. */
10994 process_version_sections (Filedata
* filedata
)
10996 Elf_Internal_Shdr
* section
;
10998 bfd_boolean found
= FALSE
;
11003 for (i
= 0, section
= filedata
->section_headers
;
11004 i
< filedata
->file_header
.e_shnum
;
11007 switch (section
->sh_type
)
11009 case SHT_GNU_verdef
:
11011 Elf_External_Verdef
* edefs
;
11018 printf (ngettext ("\nVersion definition section '%s' "
11019 "contains %u entry:\n",
11020 "\nVersion definition section '%s' "
11021 "contains %u entries:\n",
11023 printable_section_name (filedata
, section
),
11026 printf (_(" Addr: 0x"));
11027 printf_vma (section
->sh_addr
);
11028 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11029 (unsigned long) section
->sh_offset
, section
->sh_link
,
11030 printable_section_name_from_index (filedata
, section
->sh_link
));
11032 edefs
= (Elf_External_Verdef
*)
11033 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11034 _("version definition section"));
11037 endbuf
= (char *) edefs
+ section
->sh_size
;
11039 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11042 Elf_External_Verdef
* edef
;
11043 Elf_Internal_Verdef ent
;
11044 Elf_External_Verdaux
* eaux
;
11045 Elf_Internal_Verdaux aux
;
11046 unsigned long isum
;
11049 vstart
= ((char *) edefs
) + idx
;
11050 if (vstart
+ sizeof (*edef
) > endbuf
)
11053 edef
= (Elf_External_Verdef
*) vstart
;
11055 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11056 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11057 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11058 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11059 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11060 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11061 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11063 printf (_(" %#06lx: Rev: %d Flags: %s"),
11064 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11066 printf (_(" Index: %d Cnt: %d "),
11067 ent
.vd_ndx
, ent
.vd_cnt
);
11069 /* Check for overflow. */
11070 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11073 vstart
+= ent
.vd_aux
;
11075 if (vstart
+ sizeof (*eaux
) > endbuf
)
11077 eaux
= (Elf_External_Verdaux
*) vstart
;
11079 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11080 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11082 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11083 printf (_("Name: %s\n"),
11084 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11086 printf (_("Name index: %ld\n"), aux
.vda_name
);
11088 isum
= idx
+ ent
.vd_aux
;
11090 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11092 if (aux
.vda_next
< sizeof (*eaux
)
11093 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11095 warn (_("Invalid vda_next field of %lx\n"),
11100 /* Check for overflow. */
11101 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11104 isum
+= aux
.vda_next
;
11105 vstart
+= aux
.vda_next
;
11107 if (vstart
+ sizeof (*eaux
) > endbuf
)
11109 eaux
= (Elf_External_Verdaux
*) vstart
;
11111 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11112 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11114 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11115 printf (_(" %#06lx: Parent %d: %s\n"),
11117 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11119 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11120 isum
, j
, aux
.vda_name
);
11123 if (j
< ent
.vd_cnt
)
11124 printf (_(" Version def aux past end of section\n"));
11127 file: id:000001,src:000172+005151,op:splice,rep:2. */
11128 if (ent
.vd_next
< sizeof (*edef
)
11129 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11131 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11132 cnt
= section
->sh_info
;
11135 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11138 idx
+= ent
.vd_next
;
11141 if (cnt
< section
->sh_info
)
11142 printf (_(" Version definition past end of section\n"));
11148 case SHT_GNU_verneed
:
11150 Elf_External_Verneed
* eneed
;
11157 printf (ngettext ("\nVersion needs section '%s' "
11158 "contains %u entry:\n",
11159 "\nVersion needs section '%s' "
11160 "contains %u entries:\n",
11162 printable_section_name (filedata
, section
), section
->sh_info
);
11164 printf (_(" Addr: 0x"));
11165 printf_vma (section
->sh_addr
);
11166 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11167 (unsigned long) section
->sh_offset
, section
->sh_link
,
11168 printable_section_name_from_index (filedata
, section
->sh_link
));
11170 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11171 section
->sh_offset
, 1,
11173 _("Version Needs section"));
11176 endbuf
= (char *) eneed
+ section
->sh_size
;
11178 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11180 Elf_External_Verneed
* entry
;
11181 Elf_Internal_Verneed ent
;
11182 unsigned long isum
;
11186 vstart
= ((char *) eneed
) + idx
;
11187 if (vstart
+ sizeof (*entry
) > endbuf
)
11190 entry
= (Elf_External_Verneed
*) vstart
;
11192 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11193 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11194 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11195 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11196 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11198 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11200 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11201 printf (_(" File: %s"),
11202 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11204 printf (_(" File: %lx"), ent
.vn_file
);
11206 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11208 /* Check for overflow. */
11209 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11211 vstart
+= ent
.vn_aux
;
11213 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11215 Elf_External_Vernaux
* eaux
;
11216 Elf_Internal_Vernaux aux
;
11218 if (vstart
+ sizeof (*eaux
) > endbuf
)
11220 eaux
= (Elf_External_Vernaux
*) vstart
;
11222 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11223 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11224 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11225 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11226 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11228 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11229 printf (_(" %#06lx: Name: %s"),
11230 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11232 printf (_(" %#06lx: Name index: %lx"),
11233 isum
, aux
.vna_name
);
11235 printf (_(" Flags: %s Version: %d\n"),
11236 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11238 if (aux
.vna_next
< sizeof (*eaux
)
11239 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11241 warn (_("Invalid vna_next field of %lx\n"),
11246 /* Check for overflow. */
11247 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11249 isum
+= aux
.vna_next
;
11250 vstart
+= aux
.vna_next
;
11253 if (j
< ent
.vn_cnt
)
11254 warn (_("Missing Version Needs auxillary information\n"));
11256 if (ent
.vn_next
< sizeof (*entry
)
11257 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11259 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11260 cnt
= section
->sh_info
;
11263 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11265 idx
+= ent
.vn_next
;
11268 if (cnt
< section
->sh_info
)
11269 warn (_("Missing Version Needs information\n"));
11275 case SHT_GNU_versym
:
11277 Elf_Internal_Shdr
* link_section
;
11280 unsigned char * edata
;
11281 unsigned short * data
;
11283 Elf_Internal_Sym
* symbols
;
11284 Elf_Internal_Shdr
* string_sec
;
11285 unsigned long num_syms
;
11288 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11291 link_section
= filedata
->section_headers
+ section
->sh_link
;
11292 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11294 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11299 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11300 if (symbols
== NULL
)
11303 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11305 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11306 string_sec
->sh_size
,
11307 _("version string table"));
11314 printf (ngettext ("\nVersion symbols section '%s' "
11315 "contains %lu entry:\n",
11316 "\nVersion symbols section '%s' "
11317 "contains %lu entries:\n",
11319 printable_section_name (filedata
, section
), (unsigned long) total
);
11321 printf (_(" Addr: 0x"));
11322 printf_vma (section
->sh_addr
);
11323 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11324 (unsigned long) section
->sh_offset
, section
->sh_link
,
11325 printable_section_name (filedata
, link_section
));
11327 off
= offset_from_vma (filedata
,
11328 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11329 total
* sizeof (short));
11330 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11331 sizeof (short), total
,
11332 _("version symbol data"));
11340 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11342 for (cnt
= total
; cnt
--;)
11343 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11348 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11352 char *invalid
= _("*invalid*");
11354 printf (" %03x:", cnt
);
11356 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11357 switch (data
[cnt
+ j
])
11360 fputs (_(" 0 (*local*) "), stdout
);
11364 fputs (_(" 1 (*global*) "), stdout
);
11368 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11369 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11371 /* If this index value is greater than the size of the symbols
11372 array, break to avoid an out-of-bounds read. */
11373 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11375 warn (_("invalid index into symbol array\n"));
11380 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11382 Elf_Internal_Verneed ivn
;
11383 unsigned long offset
;
11385 offset
= offset_from_vma
11387 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11388 sizeof (Elf_External_Verneed
));
11392 Elf_Internal_Vernaux ivna
;
11393 Elf_External_Verneed evn
;
11394 Elf_External_Vernaux evna
;
11395 unsigned long a_off
;
11397 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11398 _("version need")) == NULL
)
11401 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11402 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11404 a_off
= offset
+ ivn
.vn_aux
;
11408 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11409 1, _("version need aux (2)")) == NULL
)
11412 ivna
.vna_other
= 0;
11416 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11417 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11420 a_off
+= ivna
.vna_next
;
11422 while (ivna
.vna_other
!= data
[cnt
+ j
]
11423 && ivna
.vna_next
!= 0);
11425 if (ivna
.vna_other
== data
[cnt
+ j
])
11427 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11429 if (ivna
.vna_name
>= string_sec
->sh_size
)
11432 name
= strtab
+ ivna
.vna_name
;
11436 offset
+= ivn
.vn_next
;
11438 while (ivn
.vn_next
);
11441 if (data
[cnt
+ j
] != 0x8001
11442 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11444 Elf_Internal_Verdef ivd
;
11445 Elf_External_Verdef evd
;
11446 unsigned long offset
;
11448 offset
= offset_from_vma
11450 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11455 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11456 _("version def")) == NULL
)
11459 /* PR 17531: file: 046-1082287-0.004. */
11460 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11465 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11466 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11469 offset
+= ivd
.vd_next
;
11471 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11472 && ivd
.vd_next
!= 0);
11474 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11476 Elf_External_Verdaux evda
;
11477 Elf_Internal_Verdaux ivda
;
11479 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11481 if (get_data (&evda
, filedata
,
11482 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11484 _("version def aux")) == NULL
)
11487 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11489 if (ivda
.vda_name
>= string_sec
->sh_size
)
11491 else if (name
!= NULL
&& name
!= invalid
)
11492 name
= _("*both*");
11494 name
= strtab
+ ivda
.vda_name
;
11498 nn
+= printf ("(%s%-*s",
11500 12 - (int) strlen (name
),
11504 printf ("%*c", 18 - nn
, ' ');
11522 printf (_("\nNo version information found in this file.\n"));
11527 static const char *
11528 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11530 static char buff
[64];
11534 case STB_LOCAL
: return "LOCAL";
11535 case STB_GLOBAL
: return "GLOBAL";
11536 case STB_WEAK
: return "WEAK";
11538 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11539 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11541 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11543 if (binding
== STB_GNU_UNIQUE
11544 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11546 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11549 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11554 static const char *
11555 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11557 static char buff
[64];
11561 case STT_NOTYPE
: return "NOTYPE";
11562 case STT_OBJECT
: return "OBJECT";
11563 case STT_FUNC
: return "FUNC";
11564 case STT_SECTION
: return "SECTION";
11565 case STT_FILE
: return "FILE";
11566 case STT_COMMON
: return "COMMON";
11567 case STT_TLS
: return "TLS";
11568 case STT_RELC
: return "RELC";
11569 case STT_SRELC
: return "SRELC";
11571 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11573 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11574 return "THUMB_FUNC";
11576 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11579 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11580 return "PARISC_MILLI";
11582 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11584 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11586 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11588 if (type
== STT_HP_OPAQUE
)
11589 return "HP_OPAQUE";
11590 if (type
== STT_HP_STUB
)
11594 if (type
== STT_GNU_IFUNC
11595 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11596 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11599 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11602 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11607 static const char *
11608 get_symbol_visibility (unsigned int visibility
)
11610 switch (visibility
)
11612 case STV_DEFAULT
: return "DEFAULT";
11613 case STV_INTERNAL
: return "INTERNAL";
11614 case STV_HIDDEN
: return "HIDDEN";
11615 case STV_PROTECTED
: return "PROTECTED";
11617 error (_("Unrecognized visibility value: %u\n"), visibility
);
11618 return _("<unknown>");
11622 static const char *
11623 get_alpha_symbol_other (unsigned int other
)
11627 case STO_ALPHA_NOPV
: return "NOPV";
11628 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11630 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11631 return _("<unknown>");
11635 static const char *
11636 get_solaris_symbol_visibility (unsigned int visibility
)
11638 switch (visibility
)
11640 case 4: return "EXPORTED";
11641 case 5: return "SINGLETON";
11642 case 6: return "ELIMINATE";
11643 default: return get_symbol_visibility (visibility
);
11647 static const char *
11648 get_aarch64_symbol_other (unsigned int other
)
11650 static char buf
[32];
11652 if (other
& STO_AARCH64_VARIANT_PCS
)
11654 other
&= ~STO_AARCH64_VARIANT_PCS
;
11656 return "VARIANT_PCS";
11657 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11663 static const char *
11664 get_mips_symbol_other (unsigned int other
)
11668 case STO_OPTIONAL
: return "OPTIONAL";
11669 case STO_MIPS_PLT
: return "MIPS PLT";
11670 case STO_MIPS_PIC
: return "MIPS PIC";
11671 case STO_MICROMIPS
: return "MICROMIPS";
11672 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11673 case STO_MIPS16
: return "MIPS16";
11674 default: return NULL
;
11678 static const char *
11679 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11681 if (is_ia64_vms (filedata
))
11683 static char res
[32];
11687 /* Function types is for images and .STB files only. */
11688 switch (filedata
->file_header
.e_type
)
11692 switch (VMS_ST_FUNC_TYPE (other
))
11694 case VMS_SFT_CODE_ADDR
:
11695 strcat (res
, " CA");
11697 case VMS_SFT_SYMV_IDX
:
11698 strcat (res
, " VEC");
11701 strcat (res
, " FD");
11703 case VMS_SFT_RESERVE
:
11704 strcat (res
, " RSV");
11707 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11708 VMS_ST_FUNC_TYPE (other
));
11709 strcat (res
, " <unknown>");
11716 switch (VMS_ST_LINKAGE (other
))
11718 case VMS_STL_IGNORE
:
11719 strcat (res
, " IGN");
11721 case VMS_STL_RESERVE
:
11722 strcat (res
, " RSV");
11725 strcat (res
, " STD");
11728 strcat (res
, " LNK");
11731 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11732 VMS_ST_LINKAGE (other
));
11733 strcat (res
, " <unknown>");
11745 static const char *
11746 get_ppc64_symbol_other (unsigned int other
)
11748 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11751 other
>>= STO_PPC64_LOCAL_BIT
;
11754 static char buf
[64];
11756 other
= ppc64_decode_local_entry (other
);
11757 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11763 static const char *
11764 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11766 const char * result
= NULL
;
11767 static char buff
[64];
11772 switch (filedata
->file_header
.e_machine
)
11775 result
= get_alpha_symbol_other (other
);
11778 result
= get_aarch64_symbol_other (other
);
11781 result
= get_mips_symbol_other (other
);
11784 result
= get_ia64_symbol_other (filedata
, other
);
11787 result
= get_ppc64_symbol_other (other
);
11797 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11801 static const char *
11802 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11804 static char buff
[32];
11808 case SHN_UNDEF
: return "UND";
11809 case SHN_ABS
: return "ABS";
11810 case SHN_COMMON
: return "COM";
11812 if (type
== SHN_IA_64_ANSI_COMMON
11813 && filedata
->file_header
.e_machine
== EM_IA_64
11814 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11816 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11817 || filedata
->file_header
.e_machine
== EM_L1OM
11818 || filedata
->file_header
.e_machine
== EM_K1OM
)
11819 && type
== SHN_X86_64_LCOMMON
)
11820 return "LARGE_COM";
11821 else if ((type
== SHN_MIPS_SCOMMON
11822 && filedata
->file_header
.e_machine
== EM_MIPS
)
11823 || (type
== SHN_TIC6X_SCOMMON
11824 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11826 else if (type
== SHN_MIPS_SUNDEFINED
11827 && filedata
->file_header
.e_machine
== EM_MIPS
)
11829 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11830 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11831 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11832 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11833 else if (type
>= SHN_LORESERVE
)
11834 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11835 else if (filedata
->file_header
.e_shnum
!= 0
11836 && type
>= filedata
->file_header
.e_shnum
)
11837 sprintf (buff
, _("bad section index[%3d]"), type
);
11839 sprintf (buff
, "%3d", type
);
11846 static const char *
11847 get_symbol_version_string (Filedata
* filedata
,
11848 bfd_boolean is_dynsym
,
11849 const char * strtab
,
11850 unsigned long int strtab_size
,
11852 Elf_Internal_Sym
* psym
,
11853 enum versioned_symbol_info
* sym_info
,
11854 unsigned short * vna_other
)
11856 unsigned char data
[2];
11857 unsigned short vers_data
;
11858 unsigned long offset
;
11859 unsigned short max_vd_ndx
;
11862 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11865 offset
= offset_from_vma (filedata
,
11866 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11867 sizeof data
+ si
* sizeof (vers_data
));
11869 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11870 sizeof (data
), 1, _("version data")) == NULL
)
11873 vers_data
= byte_get (data
, 2);
11875 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11878 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11881 /* Usually we'd only see verdef for defined symbols, and verneed for
11882 undefined symbols. However, symbols defined by the linker in
11883 .dynbss for variables copied from a shared library in order to
11884 avoid text relocations are defined yet have verneed. We could
11885 use a heuristic to detect the special case, for example, check
11886 for verneed first on symbols defined in SHT_NOBITS sections, but
11887 it is simpler and more reliable to just look for both verdef and
11888 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11890 if (psym
->st_shndx
!= SHN_UNDEF
11891 && vers_data
!= 0x8001
11892 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11894 Elf_Internal_Verdef ivd
;
11895 Elf_Internal_Verdaux ivda
;
11896 Elf_External_Verdaux evda
;
11899 off
= offset_from_vma (filedata
,
11900 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11901 sizeof (Elf_External_Verdef
));
11905 Elf_External_Verdef evd
;
11907 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11908 _("version def")) == NULL
)
11917 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11918 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11919 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11920 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11923 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11924 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11926 off
+= ivd
.vd_next
;
11928 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11930 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11932 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11935 off
-= ivd
.vd_next
;
11938 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11939 _("version def aux")) != NULL
)
11941 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11943 if (psym
->st_name
!= ivda
.vda_name
)
11944 return (ivda
.vda_name
< strtab_size
11945 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11950 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11952 Elf_External_Verneed evn
;
11953 Elf_Internal_Verneed ivn
;
11954 Elf_Internal_Vernaux ivna
;
11956 offset
= offset_from_vma (filedata
,
11957 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11961 unsigned long vna_off
;
11963 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11964 _("version need")) == NULL
)
11967 ivna
.vna_other
= 0;
11972 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11973 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11975 vna_off
= offset
+ ivn
.vn_aux
;
11979 Elf_External_Vernaux evna
;
11981 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11982 _("version need aux (3)")) == NULL
)
11985 ivna
.vna_other
= 0;
11990 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11991 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11992 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11995 vna_off
+= ivna
.vna_next
;
11997 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11999 if (ivna
.vna_other
== vers_data
)
12002 offset
+= ivn
.vn_next
;
12004 while (ivn
.vn_next
!= 0);
12006 if (ivna
.vna_other
== vers_data
)
12008 *sym_info
= symbol_undefined
;
12009 *vna_other
= ivna
.vna_other
;
12010 return (ivna
.vna_name
< strtab_size
12011 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12013 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12014 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12015 return _("<corrupt>");
12021 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12022 Elf_Internal_Sym
*symtab
,
12023 Elf_Internal_Shdr
*section
,
12024 char *strtab
, size_t strtab_size
)
12026 const char *version_string
;
12027 enum versioned_symbol_info sym_info
;
12028 unsigned short vna_other
;
12029 Elf_Internal_Sym
*psym
= symtab
+ si
;
12031 printf ("%6ld: ", si
);
12032 print_vma (psym
->st_value
, LONG_HEX
);
12034 print_vma (psym
->st_size
, DEC_5
);
12035 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12036 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12037 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12038 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12041 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12043 printf (" %-7s", get_symbol_visibility (vis
));
12044 /* Check to see if any other bits in the st_other field are set.
12045 Note - displaying this information disrupts the layout of the
12046 table being generated, but for the moment this case is very rare. */
12047 if (psym
->st_other
^ vis
)
12048 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12050 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12051 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
12053 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12056 = get_symbol_version_string (filedata
,
12058 || section
->sh_type
== SHT_DYNSYM
),
12059 strtab
, strtab_size
, si
,
12060 psym
, &sym_info
, &vna_other
);
12061 if (version_string
)
12063 if (sym_info
== symbol_undefined
)
12064 printf ("@%s (%d)", version_string
, vna_other
);
12066 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12072 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12074 && si
>= section
->sh_info
12075 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12076 && filedata
->file_header
.e_machine
!= EM_MIPS
12077 /* Solaris binaries have been found to violate this requirement as
12078 well. Not sure if this is a bug or an ABI requirement. */
12079 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12080 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12081 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12084 /* Dump the symbol table. */
12086 process_symbol_table (Filedata
* filedata
)
12088 Elf_Internal_Shdr
* section
;
12090 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12093 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12095 && do_using_dynamic
12096 && filedata
->dynamic_strings
!= NULL
12097 && filedata
->dynamic_symbols
!= NULL
)
12101 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12102 "\nSymbol table for image contains %lu entries:\n",
12103 filedata
->num_dynamic_syms
),
12104 filedata
->num_dynamic_syms
);
12106 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12108 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12110 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12111 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12112 filedata
->dynamic_strings
,
12113 filedata
->dynamic_strings_length
);
12115 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12116 && filedata
->section_headers
!= NULL
)
12120 for (i
= 0, section
= filedata
->section_headers
;
12121 i
< filedata
->file_header
.e_shnum
;
12124 char * strtab
= NULL
;
12125 unsigned long int strtab_size
= 0;
12126 Elf_Internal_Sym
* symtab
;
12127 unsigned long si
, num_syms
;
12129 if ((section
->sh_type
!= SHT_SYMTAB
12130 && section
->sh_type
!= SHT_DYNSYM
)
12132 && section
->sh_type
== SHT_SYMTAB
))
12135 if (section
->sh_entsize
== 0)
12137 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12138 printable_section_name (filedata
, section
));
12142 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12143 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12144 "\nSymbol table '%s' contains %lu entries:\n",
12146 printable_section_name (filedata
, section
),
12150 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12152 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12154 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12155 if (symtab
== NULL
)
12158 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12160 strtab
= filedata
->string_table
;
12161 strtab_size
= filedata
->string_table_length
;
12163 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12165 Elf_Internal_Shdr
* string_sec
;
12167 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12169 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12170 1, string_sec
->sh_size
,
12171 _("string table"));
12172 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12175 for (si
= 0; si
< num_syms
; si
++)
12176 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12177 strtab
, strtab_size
);
12180 if (strtab
!= filedata
->string_table
)
12186 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12188 if (do_histogram
&& filedata
->buckets
!= NULL
)
12190 unsigned long * lengths
;
12191 unsigned long * counts
;
12194 unsigned long maxlength
= 0;
12195 unsigned long nzero_counts
= 0;
12196 unsigned long nsyms
= 0;
12199 printf (ngettext ("\nHistogram for bucket list length "
12200 "(total of %lu bucket):\n",
12201 "\nHistogram for bucket list length "
12202 "(total of %lu buckets):\n",
12203 (unsigned long) filedata
->nbuckets
),
12204 (unsigned long) filedata
->nbuckets
);
12206 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12207 sizeof (*lengths
));
12208 if (lengths
== NULL
)
12210 error (_("Out of memory allocating space for histogram buckets\n"));
12213 visited
= xcmalloc (filedata
->nchains
, 1);
12214 memset (visited
, 0, filedata
->nchains
);
12216 printf (_(" Length Number %% of total Coverage\n"));
12217 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12219 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12222 if (maxlength
< ++lengths
[hn
])
12224 if (si
>= filedata
->nchains
|| visited
[si
])
12226 error (_("histogram chain is corrupt\n"));
12234 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12235 if (counts
== NULL
)
12238 error (_("Out of memory allocating space for histogram counts\n"));
12242 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12243 ++counts
[lengths
[hn
]];
12245 if (filedata
->nbuckets
> 0)
12248 printf (" 0 %-10lu (%5.1f%%)\n",
12249 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12250 for (i
= 1; i
<= maxlength
; ++i
)
12252 nzero_counts
+= counts
[i
] * i
;
12253 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12254 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12255 (nzero_counts
* 100.0) / nsyms
);
12263 free (filedata
->buckets
);
12264 filedata
->buckets
= NULL
;
12265 filedata
->nbuckets
= 0;
12266 free (filedata
->chains
);
12267 filedata
->chains
= NULL
;
12269 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12271 unsigned long * lengths
;
12272 unsigned long * counts
;
12274 unsigned long maxlength
= 0;
12275 unsigned long nzero_counts
= 0;
12276 unsigned long nsyms
= 0;
12278 printf (ngettext ("\nHistogram for `%s' bucket list length "
12279 "(total of %lu bucket):\n",
12280 "\nHistogram for `%s' bucket list length "
12281 "(total of %lu buckets):\n",
12282 (unsigned long) filedata
->ngnubuckets
),
12283 GNU_HASH_SECTION_NAME (filedata
),
12284 (unsigned long) filedata
->ngnubuckets
);
12286 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12287 sizeof (*lengths
));
12288 if (lengths
== NULL
)
12290 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12294 printf (_(" Length Number %% of total Coverage\n"));
12296 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12297 if (filedata
->gnubuckets
[hn
] != 0)
12299 bfd_vma off
, length
= 1;
12301 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12302 /* PR 17531 file: 010-77222-0.004. */
12303 off
< filedata
->ngnuchains
12304 && (filedata
->gnuchains
[off
] & 1) == 0;
12307 lengths
[hn
] = length
;
12308 if (length
> maxlength
)
12309 maxlength
= length
;
12313 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12314 if (counts
== NULL
)
12317 error (_("Out of memory allocating space for gnu histogram counts\n"));
12321 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12322 ++counts
[lengths
[hn
]];
12324 if (filedata
->ngnubuckets
> 0)
12327 printf (" 0 %-10lu (%5.1f%%)\n",
12328 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12329 for (j
= 1; j
<= maxlength
; ++j
)
12331 nzero_counts
+= counts
[j
] * j
;
12332 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12333 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12334 (nzero_counts
* 100.0) / nsyms
);
12341 free (filedata
->gnubuckets
);
12342 filedata
->gnubuckets
= NULL
;
12343 filedata
->ngnubuckets
= 0;
12344 free (filedata
->gnuchains
);
12345 filedata
->gnuchains
= NULL
;
12346 filedata
->ngnuchains
= 0;
12347 free (filedata
->mipsxlat
);
12348 filedata
->mipsxlat
= NULL
;
12352 free (filedata
->gnubuckets
);
12353 filedata
->gnubuckets
= NULL
;
12354 filedata
->ngnubuckets
= 0;
12355 free (filedata
->gnuchains
);
12356 filedata
->gnuchains
= NULL
;
12357 filedata
->ngnuchains
= 0;
12358 free (filedata
->mipsxlat
);
12359 filedata
->mipsxlat
= NULL
;
12360 free (filedata
->buckets
);
12361 filedata
->buckets
= NULL
;
12362 filedata
->nbuckets
= 0;
12363 free (filedata
->chains
);
12364 filedata
->chains
= NULL
;
12369 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12373 if (filedata
->dynamic_syminfo
== NULL
12375 /* No syminfo, this is ok. */
12378 /* There better should be a dynamic symbol section. */
12379 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12382 if (filedata
->dynamic_addr
)
12383 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12384 "contains %d entry:\n",
12385 "\nDynamic info segment at offset 0x%lx "
12386 "contains %d entries:\n",
12387 filedata
->dynamic_syminfo_nent
),
12388 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12390 printf (_(" Num: Name BoundTo Flags\n"));
12391 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12393 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12395 printf ("%4d: ", i
);
12396 if (i
>= filedata
->num_dynamic_syms
)
12397 printf (_("<corrupt index>"));
12398 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12399 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12400 filedata
->dynamic_symbols
[i
].st_name
));
12402 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12405 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12407 case SYMINFO_BT_SELF
:
12408 fputs ("SELF ", stdout
);
12410 case SYMINFO_BT_PARENT
:
12411 fputs ("PARENT ", stdout
);
12414 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12415 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12416 && VALID_DYNAMIC_NAME (filedata
,
12417 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12419 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12420 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12424 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12428 if (flags
& SYMINFO_FLG_DIRECT
)
12429 printf (" DIRECT");
12430 if (flags
& SYMINFO_FLG_PASSTHRU
)
12431 printf (" PASSTHRU");
12432 if (flags
& SYMINFO_FLG_COPY
)
12434 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12435 printf (" LAZYLOAD");
12443 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12444 is contained by the region START .. END. The types of ADDR, START
12445 and END should all be the same. Note both ADDR + NELEM and END
12446 point to just beyond the end of the regions that are being tested. */
12447 #define IN_RANGE(START,END,ADDR,NELEM) \
12448 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12450 /* Check to see if the given reloc needs to be handled in a target specific
12451 manner. If so then process the reloc and return TRUE otherwise return
12454 If called with reloc == NULL, then this is a signal that reloc processing
12455 for the current section has finished, and any saved state should be
12459 target_specific_reloc_handling (Filedata
* filedata
,
12460 Elf_Internal_Rela
* reloc
,
12461 unsigned char * start
,
12462 unsigned char * end
,
12463 Elf_Internal_Sym
* symtab
,
12464 unsigned long num_syms
)
12466 unsigned int reloc_type
= 0;
12467 unsigned long sym_index
= 0;
12471 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12472 sym_index
= get_reloc_symindex (reloc
->r_info
);
12475 switch (filedata
->file_header
.e_machine
)
12478 case EM_MSP430_OLD
:
12480 static Elf_Internal_Sym
* saved_sym
= NULL
;
12488 switch (reloc_type
)
12490 case 10: /* R_MSP430_SYM_DIFF */
12491 if (uses_msp430x_relocs (filedata
))
12493 /* Fall through. */
12494 case 21: /* R_MSP430X_SYM_DIFF */
12496 if (sym_index
>= num_syms
)
12497 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12500 saved_sym
= symtab
+ sym_index
;
12503 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12504 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12505 goto handle_sym_diff
;
12507 case 5: /* R_MSP430_16_BYTE */
12508 case 9: /* R_MSP430_8 */
12509 if (uses_msp430x_relocs (filedata
))
12511 goto handle_sym_diff
;
12513 case 2: /* R_MSP430_ABS16 */
12514 case 15: /* R_MSP430X_ABS16 */
12515 if (! uses_msp430x_relocs (filedata
))
12517 goto handle_sym_diff
;
12520 if (saved_sym
!= NULL
)
12522 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12525 if (sym_index
>= num_syms
)
12526 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12530 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12531 - saved_sym
->st_value
);
12533 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12534 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12537 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12538 (long) reloc
->r_offset
);
12547 if (saved_sym
!= NULL
)
12548 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12555 case EM_CYGNUS_MN10300
:
12557 static Elf_Internal_Sym
* saved_sym
= NULL
;
12565 switch (reloc_type
)
12567 case 34: /* R_MN10300_ALIGN */
12569 case 33: /* R_MN10300_SYM_DIFF */
12570 if (sym_index
>= num_syms
)
12571 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12574 saved_sym
= symtab
+ sym_index
;
12577 case 1: /* R_MN10300_32 */
12578 case 2: /* R_MN10300_16 */
12579 if (saved_sym
!= NULL
)
12581 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12584 if (sym_index
>= num_syms
)
12585 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12589 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12590 - saved_sym
->st_value
);
12592 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12593 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12595 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12596 (long) reloc
->r_offset
);
12604 if (saved_sym
!= NULL
)
12605 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12613 static bfd_vma saved_sym1
= 0;
12614 static bfd_vma saved_sym2
= 0;
12615 static bfd_vma value
;
12619 saved_sym1
= saved_sym2
= 0;
12623 switch (reloc_type
)
12625 case 0x80: /* R_RL78_SYM. */
12626 saved_sym1
= saved_sym2
;
12627 if (sym_index
>= num_syms
)
12628 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12632 saved_sym2
= symtab
[sym_index
].st_value
;
12633 saved_sym2
+= reloc
->r_addend
;
12637 case 0x83: /* R_RL78_OPsub. */
12638 value
= saved_sym1
- saved_sym2
;
12639 saved_sym2
= saved_sym1
= 0;
12643 case 0x41: /* R_RL78_ABS32. */
12644 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12645 byte_put (start
+ reloc
->r_offset
, value
, 4);
12647 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12648 (long) reloc
->r_offset
);
12652 case 0x43: /* R_RL78_ABS16. */
12653 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12654 byte_put (start
+ reloc
->r_offset
, value
, 2);
12656 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12657 (long) reloc
->r_offset
);
12671 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12672 DWARF debug sections. This is a target specific test. Note - we do not
12673 go through the whole including-target-headers-multiple-times route, (as
12674 we have already done with <elf/h8.h>) because this would become very
12675 messy and even then this function would have to contain target specific
12676 information (the names of the relocs instead of their numeric values).
12677 FIXME: This is not the correct way to solve this problem. The proper way
12678 is to have target specific reloc sizing and typing functions created by
12679 the reloc-macros.h header, in the same way that it already creates the
12680 reloc naming functions. */
12683 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12685 /* Please keep this table alpha-sorted for ease of visual lookup. */
12686 switch (filedata
->file_header
.e_machine
)
12690 return reloc_type
== 1; /* R_386_32. */
12692 return reloc_type
== 1; /* R_68K_32. */
12694 return reloc_type
== 1; /* R_860_32. */
12696 return reloc_type
== 2; /* R_960_32. */
12698 return (reloc_type
== 258
12699 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12701 return reloc_type
== 11; /* R_BPF_DATA_32 */
12702 case EM_ADAPTEVA_EPIPHANY
:
12703 return reloc_type
== 3;
12705 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12707 return reloc_type
== 1; /* R_ARC_32. */
12708 case EM_ARC_COMPACT
:
12709 case EM_ARC_COMPACT2
:
12710 return reloc_type
== 4; /* R_ARC_32. */
12712 return reloc_type
== 2; /* R_ARM_ABS32 */
12715 return reloc_type
== 1;
12717 return reloc_type
== 0x12; /* R_byte4_data. */
12719 return reloc_type
== 3; /* R_CRIS_32. */
12721 return reloc_type
== 3; /* R_CR16_NUM32. */
12723 return reloc_type
== 15; /* R_CRX_NUM32. */
12725 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12726 case EM_CYGNUS_FRV
:
12727 return reloc_type
== 1;
12728 case EM_CYGNUS_D10V
:
12730 return reloc_type
== 6; /* R_D10V_32. */
12731 case EM_CYGNUS_D30V
:
12733 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12735 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12736 case EM_CYGNUS_FR30
:
12738 return reloc_type
== 3; /* R_FR30_32. */
12740 return reloc_type
== 1; /* R_FT32_32. */
12744 return reloc_type
== 1; /* R_H8_DIR32. */
12746 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12747 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12748 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12749 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12752 return reloc_type
== 2; /* R_IP2K_32. */
12754 return reloc_type
== 2; /* R_IQ2000_32. */
12755 case EM_LATTICEMICO32
:
12756 return reloc_type
== 3; /* R_LM32_32. */
12759 return reloc_type
== 3; /* R_M32C_32. */
12761 return reloc_type
== 34; /* R_M32R_32_RELA. */
12764 return reloc_type
== 6; /* R_M68HC11_32. */
12766 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12767 reloc_type
== 6; /* R_S12Z_CW32. */
12769 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12770 case EM_CYGNUS_MEP
:
12771 return reloc_type
== 4; /* R_MEP_32. */
12773 return reloc_type
== 2; /* R_METAG_ADDR32. */
12774 case EM_MICROBLAZE
:
12775 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12777 return reloc_type
== 2; /* R_MIPS_32. */
12779 return reloc_type
== 4; /* R_MMIX_32. */
12780 case EM_CYGNUS_MN10200
:
12782 return reloc_type
== 1; /* R_MN10200_32. */
12783 case EM_CYGNUS_MN10300
:
12785 return reloc_type
== 1; /* R_MN10300_32. */
12787 return reloc_type
== 1; /* R_MOXIE_32. */
12788 case EM_MSP430_OLD
:
12790 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12792 return reloc_type
== 2; /* R_MT_32. */
12794 return reloc_type
== 20; /* R_NDS32_RELA. */
12795 case EM_ALTERA_NIOS2
:
12796 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12798 return reloc_type
== 1; /* R_NIOS_32. */
12800 return reloc_type
== 1; /* R_OR1K_32. */
12802 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12803 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12804 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12807 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12809 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12811 return reloc_type
== 1; /* R_PPC_ADDR32. */
12813 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12815 return reloc_type
== 1; /* R_RISCV_32. */
12817 return reloc_type
== 1; /* R_RL78_DIR32. */
12819 return reloc_type
== 1; /* R_RX_DIR32. */
12821 return reloc_type
== 1; /* R_I370_ADDR31. */
12824 return reloc_type
== 4; /* R_S390_32. */
12826 return reloc_type
== 8; /* R_SCORE_ABS32. */
12828 return reloc_type
== 1; /* R_SH_DIR32. */
12829 case EM_SPARC32PLUS
:
12832 return reloc_type
== 3 /* R_SPARC_32. */
12833 || reloc_type
== 23; /* R_SPARC_UA32. */
12835 return reloc_type
== 6; /* R_SPU_ADDR32 */
12837 return reloc_type
== 1; /* R_C6000_ABS32. */
12839 return reloc_type
== 2; /* R_TILEGX_32. */
12841 return reloc_type
== 1; /* R_TILEPRO_32. */
12842 case EM_CYGNUS_V850
:
12844 return reloc_type
== 6; /* R_V850_ABS32. */
12846 return reloc_type
== 0x33; /* R_V810_WORD. */
12848 return reloc_type
== 1; /* R_VAX_32. */
12850 return reloc_type
== 3; /* R_VISIUM_32. */
12851 case EM_WEBASSEMBLY
:
12852 return reloc_type
== 1; /* R_WASM32_32. */
12856 return reloc_type
== 10; /* R_X86_64_32. */
12859 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12861 return reloc_type
== 4; /* R_XGATE_32. */
12863 return reloc_type
== 1; /* R_XSTROMY16_32. */
12864 case EM_XTENSA_OLD
:
12866 return reloc_type
== 1; /* R_XTENSA_32. */
12868 return reloc_type
== 6; /* R_Z80_32. */
12871 static unsigned int prev_warn
= 0;
12873 /* Avoid repeating the same warning multiple times. */
12874 if (prev_warn
!= filedata
->file_header
.e_machine
)
12875 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12876 filedata
->file_header
.e_machine
);
12877 prev_warn
= filedata
->file_header
.e_machine
;
12883 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12884 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12887 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12889 switch (filedata
->file_header
.e_machine
)
12890 /* Please keep this table alpha-sorted for ease of visual lookup. */
12894 return reloc_type
== 2; /* R_386_PC32. */
12896 return reloc_type
== 4; /* R_68K_PC32. */
12898 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12899 case EM_ADAPTEVA_EPIPHANY
:
12900 return reloc_type
== 6;
12902 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12903 case EM_ARC_COMPACT
:
12904 case EM_ARC_COMPACT2
:
12905 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12907 return reloc_type
== 3; /* R_ARM_REL32 */
12910 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12911 case EM_MICROBLAZE
:
12912 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12914 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12916 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12918 return reloc_type
== 26; /* R_PPC_REL32. */
12920 return reloc_type
== 26; /* R_PPC64_REL32. */
12922 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12925 return reloc_type
== 5; /* R_390_PC32. */
12927 return reloc_type
== 2; /* R_SH_REL32. */
12928 case EM_SPARC32PLUS
:
12931 return reloc_type
== 6; /* R_SPARC_DISP32. */
12933 return reloc_type
== 13; /* R_SPU_REL32. */
12935 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12937 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12939 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12943 return reloc_type
== 2; /* R_X86_64_PC32. */
12945 return reloc_type
== 4; /* R_VAX_PCREL32. */
12946 case EM_XTENSA_OLD
:
12948 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12950 /* Do not abort or issue an error message here. Not all targets use
12951 pc-relative 32-bit relocs in their DWARF debug information and we
12952 have already tested for target coverage in is_32bit_abs_reloc. A
12953 more helpful warning message will be generated by apply_relocations
12954 anyway, so just return. */
12959 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12960 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12963 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12965 switch (filedata
->file_header
.e_machine
)
12968 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12970 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12972 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12973 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12975 return reloc_type
== 80; /* R_PARISC_DIR64. */
12977 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12979 return reloc_type
== 2; /* R_RISCV_64. */
12980 case EM_SPARC32PLUS
:
12983 return reloc_type
== 32 /* R_SPARC_64. */
12984 || reloc_type
== 54; /* R_SPARC_UA64. */
12988 return reloc_type
== 1; /* R_X86_64_64. */
12991 return reloc_type
== 22; /* R_S390_64. */
12993 return reloc_type
== 1; /* R_TILEGX_64. */
12995 return reloc_type
== 18; /* R_MIPS_64. */
13001 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13002 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13005 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13007 switch (filedata
->file_header
.e_machine
)
13010 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13012 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13014 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13015 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13017 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13019 return reloc_type
== 44; /* R_PPC64_REL64. */
13020 case EM_SPARC32PLUS
:
13023 return reloc_type
== 46; /* R_SPARC_DISP64. */
13027 return reloc_type
== 24; /* R_X86_64_PC64. */
13030 return reloc_type
== 23; /* R_S390_PC64. */
13032 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13038 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13039 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13042 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13044 switch (filedata
->file_header
.e_machine
)
13046 case EM_CYGNUS_MN10200
:
13048 return reloc_type
== 4; /* R_MN10200_24. */
13050 return reloc_type
== 5; /* R_FT32_20. */
13052 return reloc_type
== 5; /* R_Z80_24. */
13058 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13059 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13062 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13064 /* Please keep this table alpha-sorted for ease of visual lookup. */
13065 switch (filedata
->file_header
.e_machine
)
13068 case EM_ARC_COMPACT
:
13069 case EM_ARC_COMPACT2
:
13070 return reloc_type
== 2; /* R_ARC_16. */
13071 case EM_ADAPTEVA_EPIPHANY
:
13072 return reloc_type
== 5;
13075 return reloc_type
== 4; /* R_AVR_16. */
13076 case EM_CYGNUS_D10V
:
13078 return reloc_type
== 3; /* R_D10V_16. */
13080 return reloc_type
== 2; /* R_FT32_16. */
13084 return reloc_type
== R_H8_DIR16
;
13087 return reloc_type
== 1; /* R_IP2K_16. */
13090 return reloc_type
== 1; /* R_M32C_16 */
13091 case EM_CYGNUS_MN10200
:
13093 return reloc_type
== 2; /* R_MN10200_16. */
13094 case EM_CYGNUS_MN10300
:
13096 return reloc_type
== 2; /* R_MN10300_16. */
13098 if (uses_msp430x_relocs (filedata
))
13099 return reloc_type
== 2; /* R_MSP430_ABS16. */
13100 /* Fall through. */
13101 case EM_MSP430_OLD
:
13102 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13104 return reloc_type
== 19; /* R_NDS32_RELA. */
13105 case EM_ALTERA_NIOS2
:
13106 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13108 return reloc_type
== 9; /* R_NIOS_16. */
13110 return reloc_type
== 2; /* R_OR1K_16. */
13112 return reloc_type
== 55; /* R_RISCV_SET16. */
13114 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13116 return reloc_type
== 2; /* R_C6000_ABS16. */
13118 return reloc_type
== 2; /* R_VISIUM_16. */
13121 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13123 return reloc_type
== 3; /* R_XGATE_16. */
13125 return reloc_type
== 4; /* R_Z80_16. */
13131 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13132 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13135 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13137 switch (filedata
->file_header
.e_machine
)
13140 return reloc_type
== 54; /* R_RISCV_SET8. */
13142 return reloc_type
== 1; /* R_Z80_8. */
13148 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13149 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13152 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13154 switch (filedata
->file_header
.e_machine
)
13157 return reloc_type
== 53; /* R_RISCV_SET6. */
13163 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13164 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13167 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13169 /* Please keep this table alpha-sorted for ease of visual lookup. */
13170 switch (filedata
->file_header
.e_machine
)
13173 return reloc_type
== 35; /* R_RISCV_ADD32. */
13179 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13180 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13183 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13185 /* Please keep this table alpha-sorted for ease of visual lookup. */
13186 switch (filedata
->file_header
.e_machine
)
13189 return reloc_type
== 39; /* R_RISCV_SUB32. */
13195 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13196 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13199 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13201 /* Please keep this table alpha-sorted for ease of visual lookup. */
13202 switch (filedata
->file_header
.e_machine
)
13205 return reloc_type
== 36; /* R_RISCV_ADD64. */
13211 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13212 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13215 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13217 /* Please keep this table alpha-sorted for ease of visual lookup. */
13218 switch (filedata
->file_header
.e_machine
)
13221 return reloc_type
== 40; /* R_RISCV_SUB64. */
13227 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13228 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13231 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13233 /* Please keep this table alpha-sorted for ease of visual lookup. */
13234 switch (filedata
->file_header
.e_machine
)
13237 return reloc_type
== 34; /* R_RISCV_ADD16. */
13243 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13244 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13247 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13249 /* Please keep this table alpha-sorted for ease of visual lookup. */
13250 switch (filedata
->file_header
.e_machine
)
13253 return reloc_type
== 38; /* R_RISCV_SUB16. */
13259 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13260 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13263 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13265 /* Please keep this table alpha-sorted for ease of visual lookup. */
13266 switch (filedata
->file_header
.e_machine
)
13269 return reloc_type
== 33; /* R_RISCV_ADD8. */
13275 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13276 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13279 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13281 /* Please keep this table alpha-sorted for ease of visual lookup. */
13282 switch (filedata
->file_header
.e_machine
)
13285 return reloc_type
== 37; /* R_RISCV_SUB8. */
13291 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13292 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13295 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13297 switch (filedata
->file_header
.e_machine
)
13300 return reloc_type
== 52; /* R_RISCV_SUB6. */
13306 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13307 relocation entries (possibly formerly used for SHT_GROUP sections). */
13310 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13312 switch (filedata
->file_header
.e_machine
)
13314 case EM_386
: /* R_386_NONE. */
13315 case EM_68K
: /* R_68K_NONE. */
13316 case EM_ADAPTEVA_EPIPHANY
:
13317 case EM_ALPHA
: /* R_ALPHA_NONE. */
13318 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13319 case EM_ARC
: /* R_ARC_NONE. */
13320 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13321 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13322 case EM_ARM
: /* R_ARM_NONE. */
13323 case EM_C166
: /* R_XC16X_NONE. */
13324 case EM_CRIS
: /* R_CRIS_NONE. */
13325 case EM_FT32
: /* R_FT32_NONE. */
13326 case EM_IA_64
: /* R_IA64_NONE. */
13327 case EM_K1OM
: /* R_X86_64_NONE. */
13328 case EM_L1OM
: /* R_X86_64_NONE. */
13329 case EM_M32R
: /* R_M32R_NONE. */
13330 case EM_MIPS
: /* R_MIPS_NONE. */
13331 case EM_MN10300
: /* R_MN10300_NONE. */
13332 case EM_MOXIE
: /* R_MOXIE_NONE. */
13333 case EM_NIOS32
: /* R_NIOS_NONE. */
13334 case EM_OR1K
: /* R_OR1K_NONE. */
13335 case EM_PARISC
: /* R_PARISC_NONE. */
13336 case EM_PPC64
: /* R_PPC64_NONE. */
13337 case EM_PPC
: /* R_PPC_NONE. */
13338 case EM_RISCV
: /* R_RISCV_NONE. */
13339 case EM_S390
: /* R_390_NONE. */
13341 case EM_SH
: /* R_SH_NONE. */
13342 case EM_SPARC32PLUS
:
13343 case EM_SPARC
: /* R_SPARC_NONE. */
13345 case EM_TILEGX
: /* R_TILEGX_NONE. */
13346 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13347 case EM_TI_C6000
:/* R_C6000_NONE. */
13348 case EM_X86_64
: /* R_X86_64_NONE. */
13350 case EM_Z80
: /* R_Z80_NONE. */
13351 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13352 return reloc_type
== 0;
13355 return reloc_type
== 0 || reloc_type
== 256;
13358 return (reloc_type
== 0 /* R_AVR_NONE. */
13359 || reloc_type
== 30 /* R_AVR_DIFF8. */
13360 || reloc_type
== 31 /* R_AVR_DIFF16. */
13361 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13363 return reloc_type
== 3; /* R_METAG_NONE. */
13365 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13366 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13367 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13368 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13369 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13371 return (reloc_type
== 0 /* R_PRU_NONE. */
13372 || reloc_type
== 65 /* R_PRU_DIFF8. */
13373 || reloc_type
== 66 /* R_PRU_DIFF16. */
13374 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13375 case EM_XTENSA_OLD
:
13377 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13378 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13379 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13380 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13381 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13382 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13383 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13384 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13385 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13386 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13391 /* Returns TRUE if there is a relocation against
13392 section NAME at OFFSET bytes. */
13395 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13397 Elf_Internal_Rela
* relocs
;
13398 Elf_Internal_Rela
* rp
;
13400 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13403 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13405 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13406 if (rp
->r_offset
== offset
)
13412 /* Apply relocations to a section.
13413 Returns TRUE upon success, FALSE otherwise.
13414 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13415 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13416 will be set to the number of relocs loaded.
13418 Note: So far support has been added only for those relocations
13419 which can be found in debug sections. FIXME: Add support for
13420 more relocations ? */
13423 apply_relocations (Filedata
* filedata
,
13424 const Elf_Internal_Shdr
* section
,
13425 unsigned char * start
,
13426 bfd_size_type size
,
13427 void ** relocs_return
,
13428 unsigned long * num_relocs_return
)
13430 Elf_Internal_Shdr
* relsec
;
13431 unsigned char * end
= start
+ size
;
13433 if (relocs_return
!= NULL
)
13435 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13436 * num_relocs_return
= 0;
13439 if (filedata
->file_header
.e_type
!= ET_REL
)
13440 /* No relocs to apply. */
13443 /* Find the reloc section associated with the section. */
13444 for (relsec
= filedata
->section_headers
;
13445 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13448 bfd_boolean is_rela
;
13449 unsigned long num_relocs
;
13450 Elf_Internal_Rela
* relocs
;
13451 Elf_Internal_Rela
* rp
;
13452 Elf_Internal_Shdr
* symsec
;
13453 Elf_Internal_Sym
* symtab
;
13454 unsigned long num_syms
;
13455 Elf_Internal_Sym
* sym
;
13457 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13458 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13459 || filedata
->section_headers
+ relsec
->sh_info
!= section
13460 || relsec
->sh_size
== 0
13461 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13464 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13465 if (symsec
->sh_type
!= SHT_SYMTAB
13466 && symsec
->sh_type
!= SHT_DYNSYM
)
13469 is_rela
= relsec
->sh_type
== SHT_RELA
;
13473 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13474 relsec
->sh_size
, & relocs
, & num_relocs
))
13479 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13480 relsec
->sh_size
, & relocs
, & num_relocs
))
13484 /* SH uses RELA but uses in place value instead of the addend field. */
13485 if (filedata
->file_header
.e_machine
== EM_SH
)
13488 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13490 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13493 unsigned int reloc_type
;
13494 unsigned int reloc_size
;
13495 bfd_boolean reloc_inplace
= FALSE
;
13496 bfd_boolean reloc_subtract
= FALSE
;
13497 unsigned char * rloc
;
13498 unsigned long sym_index
;
13500 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13502 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13504 else if (is_none_reloc (filedata
, reloc_type
))
13506 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13507 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13509 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13510 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13512 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13514 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13516 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13517 || is_6bit_abs_reloc (filedata
, reloc_type
))
13519 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13521 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13524 reloc_inplace
= TRUE
;
13526 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13528 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13531 reloc_inplace
= TRUE
;
13533 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13535 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13538 reloc_inplace
= TRUE
;
13540 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13542 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13545 reloc_inplace
= TRUE
;
13547 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13551 reloc_inplace
= TRUE
;
13555 static unsigned int prev_reloc
= 0;
13557 if (reloc_type
!= prev_reloc
)
13558 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13559 reloc_type
, printable_section_name (filedata
, section
));
13560 prev_reloc
= reloc_type
;
13564 rloc
= start
+ rp
->r_offset
;
13565 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13567 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13568 (unsigned long) rp
->r_offset
,
13569 printable_section_name (filedata
, section
));
13573 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13574 if (sym_index
>= num_syms
)
13576 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13577 sym_index
, printable_section_name (filedata
, section
));
13580 sym
= symtab
+ sym_index
;
13582 /* If the reloc has a symbol associated with it,
13583 make sure that it is of an appropriate type.
13585 Relocations against symbols without type can happen.
13586 Gcc -feliminate-dwarf2-dups may generate symbols
13587 without type for debug info.
13589 Icc generates relocations against function symbols
13590 instead of local labels.
13592 Relocations against object symbols can happen, eg when
13593 referencing a global array. For an example of this see
13594 the _clz.o binary in libgcc.a. */
13596 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13597 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13599 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13600 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13601 printable_section_name (filedata
, relsec
),
13602 (long int)(rp
- relocs
));
13608 addend
+= rp
->r_addend
;
13609 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13610 partial_inplace. */
13612 || (filedata
->file_header
.e_machine
== EM_XTENSA
13613 && reloc_type
== 1)
13614 || ((filedata
->file_header
.e_machine
== EM_PJ
13615 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13616 && reloc_type
== 1)
13617 || ((filedata
->file_header
.e_machine
== EM_D30V
13618 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13619 && reloc_type
== 12)
13622 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13623 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13625 addend
+= byte_get (rloc
, reloc_size
);
13628 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13629 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13631 /* On HPPA, all pc-relative relocations are biased by 8. */
13632 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13634 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13637 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13638 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13640 if (reloc_subtract
)
13641 addend
-= sym
->st_value
;
13643 addend
+= sym
->st_value
;
13644 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13645 byte_put (rloc
, addend
, reloc_size
);
13647 else if (reloc_subtract
)
13648 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13650 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13654 /* Let the target specific reloc processing code know that
13655 we have finished with these relocs. */
13656 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13660 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13661 * num_relocs_return
= num_relocs
;
13672 #ifdef SUPPORT_DISASSEMBLY
13674 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13676 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13678 /* FIXME: XXX -- to be done --- XXX */
13684 /* Reads in the contents of SECTION from FILE, returning a pointer
13685 to a malloc'ed buffer or NULL if something went wrong. */
13688 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13690 bfd_size_type num_bytes
= section
->sh_size
;
13692 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13694 printf (_("Section '%s' has no data to dump.\n"),
13695 printable_section_name (filedata
, section
));
13699 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13700 _("section contents"));
13703 /* Uncompresses a section that was compressed using zlib, in place. */
13706 uncompress_section_contents (unsigned char ** buffer
,
13707 dwarf_size_type uncompressed_size
,
13708 dwarf_size_type
* size
)
13710 dwarf_size_type compressed_size
= *size
;
13711 unsigned char * compressed_buffer
= *buffer
;
13712 unsigned char * uncompressed_buffer
;
13716 /* It is possible the section consists of several compressed
13717 buffers concatenated together, so we uncompress in a loop. */
13718 /* PR 18313: The state field in the z_stream structure is supposed
13719 to be invisible to the user (ie us), but some compilers will
13720 still complain about it being used without initialisation. So
13721 we first zero the entire z_stream structure and then set the fields
13723 memset (& strm
, 0, sizeof strm
);
13724 strm
.avail_in
= compressed_size
;
13725 strm
.next_in
= (Bytef
*) compressed_buffer
;
13726 strm
.avail_out
= uncompressed_size
;
13727 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13729 rc
= inflateInit (& strm
);
13730 while (strm
.avail_in
> 0)
13734 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13735 + (uncompressed_size
- strm
.avail_out
));
13736 rc
= inflate (&strm
, Z_FINISH
);
13737 if (rc
!= Z_STREAM_END
)
13739 rc
= inflateReset (& strm
);
13741 rc
= inflateEnd (& strm
);
13743 || strm
.avail_out
!= 0)
13746 *buffer
= uncompressed_buffer
;
13747 *size
= uncompressed_size
;
13751 free (uncompressed_buffer
);
13752 /* Indicate decompression failure. */
13758 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13760 Elf_Internal_Shdr
* relsec
;
13761 bfd_size_type num_bytes
;
13762 unsigned char * data
;
13763 unsigned char * end
;
13764 unsigned char * real_start
;
13765 unsigned char * start
;
13766 bfd_boolean some_strings_shown
;
13768 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13770 /* PR 21820: Do not fail if the section was empty. */
13771 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13773 num_bytes
= section
->sh_size
;
13775 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13777 if (decompress_dumps
)
13779 dwarf_size_type new_size
= num_bytes
;
13780 dwarf_size_type uncompressed_size
= 0;
13782 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13784 Elf_Internal_Chdr chdr
;
13785 unsigned int compression_header_size
13786 = get_compression_header (& chdr
, (unsigned char *) start
,
13788 if (compression_header_size
== 0)
13789 /* An error message will have already been generated
13790 by get_compression_header. */
13793 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13795 warn (_("section '%s' has unsupported compress type: %d\n"),
13796 printable_section_name (filedata
, section
), chdr
.ch_type
);
13799 uncompressed_size
= chdr
.ch_size
;
13800 start
+= compression_header_size
;
13801 new_size
-= compression_header_size
;
13803 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13805 /* Read the zlib header. In this case, it should be "ZLIB"
13806 followed by the uncompressed section size, 8 bytes in
13807 big-endian order. */
13808 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13809 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13810 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13811 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13812 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13813 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13814 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13815 uncompressed_size
+= start
[11];
13820 if (uncompressed_size
)
13822 if (uncompress_section_contents (& start
,
13823 uncompressed_size
, & new_size
))
13824 num_bytes
= new_size
;
13827 error (_("Unable to decompress section %s\n"),
13828 printable_section_name (filedata
, section
));
13833 start
= real_start
;
13836 /* If the section being dumped has relocations against it the user might
13837 be expecting these relocations to have been applied. Check for this
13838 case and issue a warning message in order to avoid confusion.
13839 FIXME: Maybe we ought to have an option that dumps a section with
13840 relocs applied ? */
13841 for (relsec
= filedata
->section_headers
;
13842 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13845 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13846 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13847 || filedata
->section_headers
+ relsec
->sh_info
!= section
13848 || relsec
->sh_size
== 0
13849 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13852 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13857 end
= start
+ num_bytes
;
13858 some_strings_shown
= FALSE
;
13860 #ifdef HAVE_MBSTATE_T
13862 /* Initialise the multibyte conversion state. */
13863 memset (& state
, 0, sizeof (state
));
13866 bfd_boolean continuing
= FALSE
;
13870 while (!ISPRINT (* data
))
13871 if (++ data
>= end
)
13876 size_t maxlen
= end
- data
;
13881 continuing
= FALSE
;
13886 /* PR 11128: Use two separate invocations in order to work
13887 around bugs in the Solaris 8 implementation of printf. */
13888 printf (" [%6tx] ", data
- start
);
13890 printf (" [%6Ix] ", (size_t) (data
- start
));
13905 /* PR 25543: Treat new-lines as string-ending characters. */
13914 /* Do not print control characters directly as they can affect terminal
13915 settings. Such characters usually appear in the names generated
13916 by the assembler for local labels. */
13919 printf ("^%c", c
+ 0x40);
13921 else if (ISPRINT (c
))
13928 #ifdef HAVE_MBSTATE_T
13931 /* Let printf do the hard work of displaying multibyte characters. */
13932 printf ("%.1s", data
- 1);
13933 #ifdef HAVE_MBSTATE_T
13934 /* Try to find out how many bytes made up the character that was
13935 just printed. Advance the symbol pointer past the bytes that
13937 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13941 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13951 printf (_("<corrupt>\n"));
13954 some_strings_shown
= TRUE
;
13958 if (! some_strings_shown
)
13959 printf (_(" No strings found in this section."));
13972 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13973 Filedata
* filedata
,
13974 bfd_boolean relocate
)
13976 Elf_Internal_Shdr
* relsec
;
13977 bfd_size_type bytes
;
13978 bfd_size_type section_size
;
13980 unsigned char * data
;
13981 unsigned char * real_start
;
13982 unsigned char * start
;
13984 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13986 /* PR 21820: Do not fail if the section was empty. */
13987 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13989 section_size
= section
->sh_size
;
13991 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13993 if (decompress_dumps
)
13995 dwarf_size_type new_size
= section_size
;
13996 dwarf_size_type uncompressed_size
= 0;
13998 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14000 Elf_Internal_Chdr chdr
;
14001 unsigned int compression_header_size
14002 = get_compression_header (& chdr
, start
, section_size
);
14004 if (compression_header_size
== 0)
14005 /* An error message will have already been generated
14006 by get_compression_header. */
14009 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14011 warn (_("section '%s' has unsupported compress type: %d\n"),
14012 printable_section_name (filedata
, section
), chdr
.ch_type
);
14015 uncompressed_size
= chdr
.ch_size
;
14016 start
+= compression_header_size
;
14017 new_size
-= compression_header_size
;
14019 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14021 /* Read the zlib header. In this case, it should be "ZLIB"
14022 followed by the uncompressed section size, 8 bytes in
14023 big-endian order. */
14024 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14025 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14026 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14027 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14028 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14029 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14030 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14031 uncompressed_size
+= start
[11];
14036 if (uncompressed_size
)
14038 if (uncompress_section_contents (& start
, uncompressed_size
,
14041 section_size
= new_size
;
14045 error (_("Unable to decompress section %s\n"),
14046 printable_section_name (filedata
, section
));
14047 /* FIXME: Print the section anyway ? */
14052 start
= real_start
;
14057 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14062 /* If the section being dumped has relocations against it the user might
14063 be expecting these relocations to have been applied. Check for this
14064 case and issue a warning message in order to avoid confusion.
14065 FIXME: Maybe we ought to have an option that dumps a section with
14066 relocs applied ? */
14067 for (relsec
= filedata
->section_headers
;
14068 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14071 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14072 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14073 || filedata
->section_headers
+ relsec
->sh_info
!= section
14074 || relsec
->sh_size
== 0
14075 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14078 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14083 addr
= section
->sh_addr
;
14084 bytes
= section_size
;
14093 lbytes
= (bytes
> 16 ? 16 : bytes
);
14095 printf (" 0x%8.8lx ", (unsigned long) addr
);
14097 for (j
= 0; j
< 16; j
++)
14100 printf ("%2.2x", data
[j
]);
14108 for (j
= 0; j
< lbytes
; j
++)
14111 if (k
>= ' ' && k
< 0x7f)
14134 static ctf_sect_t
*
14135 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14137 buf
->cts_name
= SECTION_NAME (shdr
);
14138 buf
->cts_size
= shdr
->sh_size
;
14139 buf
->cts_entsize
= shdr
->sh_entsize
;
14144 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14145 it is passed, or a pointer to newly-allocated storage, in which case
14146 dump_ctf() will free it when it no longer needs it. */
14148 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14149 char *s
, void *arg
)
14151 const char *blanks
= arg
;
14154 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14160 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14162 Elf_Internal_Shdr
* parent_sec
= NULL
;
14163 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14164 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14165 void * data
= NULL
;
14166 void * symdata
= NULL
;
14167 void * strdata
= NULL
;
14168 void * parentdata
= NULL
;
14169 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14170 ctf_sect_t
* symsectp
= NULL
;
14171 ctf_sect_t
* strsectp
= NULL
;
14172 ctf_file_t
* ctf
= NULL
;
14173 ctf_file_t
* parent
= NULL
;
14175 const char *things
[] = {"Header", "Labels", "Data objects",
14176 "Function objects", "Variables", "Types", "Strings",
14178 const char **thing
;
14180 bfd_boolean ret
= FALSE
;
14183 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14184 data
= get_section_contents (section
, filedata
);
14185 ctfsect
.cts_data
= data
;
14187 if (!dump_ctf_symtab_name
)
14188 dump_ctf_symtab_name
= strdup (".symtab");
14190 if (!dump_ctf_strtab_name
)
14191 dump_ctf_strtab_name
= strdup (".strtab");
14193 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14195 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14197 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14200 if ((symdata
= (void *) get_data (NULL
, filedata
,
14201 symtab_sec
->sh_offset
, 1,
14202 symtab_sec
->sh_size
,
14203 _("symbols"))) == NULL
)
14205 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14206 symsect
.cts_data
= symdata
;
14208 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14210 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14212 error (_("No string table section named %s\n"),
14213 dump_ctf_strtab_name
);
14216 if ((strdata
= (void *) get_data (NULL
, filedata
,
14217 strtab_sec
->sh_offset
, 1,
14218 strtab_sec
->sh_size
,
14219 _("strings"))) == NULL
)
14221 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14222 strsect
.cts_data
= strdata
;
14224 if (dump_ctf_parent_name
)
14226 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14228 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14231 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14232 parent_sec
->sh_offset
, 1,
14233 parent_sec
->sh_size
,
14234 _("CTF parent"))) == NULL
)
14236 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14237 parentsect
.cts_data
= parentdata
;
14240 /* Load the CTF file and dump it. */
14242 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14244 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14250 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14252 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14256 ctf_import (ctf
, parent
);
14261 printf (_("\nDump of CTF section '%s':\n"),
14262 printable_section_name (filedata
, section
));
14264 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14266 ctf_dump_state_t
*s
= NULL
;
14269 printf ("\n %s:\n", *thing
);
14270 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14271 (void *) " ")) != NULL
)
14273 printf ("%s\n", item
);
14277 if (ctf_errno (ctf
))
14279 error (_("Iteration failed: %s, %s\n"), *thing
,
14280 ctf_errmsg (ctf_errno (ctf
)));
14286 ctf_file_close (ctf
);
14287 ctf_file_close (parent
);
14296 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14297 const Elf_Internal_Shdr
* sec
,
14300 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14302 Filedata
* filedata
= (Filedata
*) data
;
14304 if (section
->start
!= NULL
)
14306 /* If it is already loaded, do nothing. */
14307 if (streq (section
->filename
, filedata
->file_name
))
14309 free (section
->start
);
14312 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14313 section
->address
= sec
->sh_addr
;
14314 section
->user_data
= NULL
;
14315 section
->filename
= filedata
->file_name
;
14316 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14318 sec
->sh_size
, buf
);
14319 if (section
->start
== NULL
)
14323 unsigned char *start
= section
->start
;
14324 dwarf_size_type size
= sec
->sh_size
;
14325 dwarf_size_type uncompressed_size
= 0;
14327 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14329 Elf_Internal_Chdr chdr
;
14330 unsigned int compression_header_size
;
14332 if (size
< (is_32bit_elf
14333 ? sizeof (Elf32_External_Chdr
)
14334 : sizeof (Elf64_External_Chdr
)))
14336 warn (_("compressed section %s is too small to contain a compression header\n"),
14341 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14342 if (compression_header_size
== 0)
14343 /* An error message will have already been generated
14344 by get_compression_header. */
14347 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14349 warn (_("section '%s' has unsupported compress type: %d\n"),
14350 section
->name
, chdr
.ch_type
);
14353 uncompressed_size
= chdr
.ch_size
;
14354 start
+= compression_header_size
;
14355 size
-= compression_header_size
;
14357 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14359 /* Read the zlib header. In this case, it should be "ZLIB"
14360 followed by the uncompressed section size, 8 bytes in
14361 big-endian order. */
14362 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14363 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14364 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14365 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14366 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14367 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14368 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14369 uncompressed_size
+= start
[11];
14374 if (uncompressed_size
)
14376 if (uncompress_section_contents (&start
, uncompressed_size
,
14379 /* Free the compressed buffer, update the section buffer
14380 and the section size if uncompress is successful. */
14381 free (section
->start
);
14382 section
->start
= start
;
14386 error (_("Unable to decompress section %s\n"),
14387 printable_section_name (filedata
, sec
));
14392 section
->size
= size
;
14395 if (section
->start
== NULL
)
14398 if (debug_displays
[debug
].relocate
)
14400 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14401 & section
->reloc_info
, & section
->num_relocs
))
14406 section
->reloc_info
= NULL
;
14407 section
->num_relocs
= 0;
14413 #if HAVE_LIBDEBUGINFOD
14414 /* Return a hex string representation of the build-id. */
14416 get_build_id (void * data
)
14418 Filedata
* filedata
= (Filedata
*)data
;
14419 Elf_Internal_Shdr
* shdr
;
14422 /* Iterate through notes to find note.gnu.build-id.
14423 FIXME: Only the first note in any note section is examined. */
14424 for (i
= 0, shdr
= filedata
->section_headers
;
14425 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14428 if (shdr
->sh_type
!= SHT_NOTE
)
14433 size_t data_remaining
;
14435 Elf_External_Note
* enote
;
14436 Elf_Internal_Note inote
;
14438 bfd_vma offset
= shdr
->sh_offset
;
14439 bfd_vma align
= shdr
->sh_addralign
;
14440 bfd_vma length
= shdr
->sh_size
;
14442 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14448 else if (align
!= 4 && align
!= 8)
14454 end
= (char *) enote
+ length
;
14455 data_remaining
= end
- (char *) enote
;
14457 if (!is_ia64_vms (filedata
))
14459 min_notesz
= offsetof (Elf_External_Note
, name
);
14460 if (data_remaining
< min_notesz
)
14463 malformed note encountered in section %s whilst scanning for build-id note\n"),
14464 printable_section_name (filedata
, shdr
));
14468 data_remaining
-= min_notesz
;
14470 inote
.type
= BYTE_GET (enote
->type
);
14471 inote
.namesz
= BYTE_GET (enote
->namesz
);
14472 inote
.namedata
= enote
->name
;
14473 inote
.descsz
= BYTE_GET (enote
->descsz
);
14474 inote
.descdata
= ((char *) enote
14475 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14476 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14477 next
= ((char *) enote
14478 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14482 Elf64_External_VMS_Note
*vms_enote
;
14484 /* PR binutils/15191
14485 Make sure that there is enough data to read. */
14486 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14487 if (data_remaining
< min_notesz
)
14490 malformed note encountered in section %s whilst scanning for build-id note\n"),
14491 printable_section_name (filedata
, shdr
));
14495 data_remaining
-= min_notesz
;
14497 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14498 inote
.type
= BYTE_GET (vms_enote
->type
);
14499 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14500 inote
.namedata
= vms_enote
->name
;
14501 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14502 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14503 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14504 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14507 /* Skip malformed notes. */
14508 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14509 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14510 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14511 || ((size_t) (next
- inote
.descdata
)
14512 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14515 malformed note encountered in section %s whilst scanning for build-id note\n"),
14516 printable_section_name (filedata
, shdr
));
14521 /* Check if this is the build-id note. If so then convert the build-id
14522 bytes to a hex string. */
14523 if (inote
.namesz
> 0
14524 && const_strneq (inote
.namedata
, "GNU")
14525 && inote
.type
== NT_GNU_BUILD_ID
)
14530 build_id
= malloc (inote
.descsz
* 2 + 1);
14531 if (build_id
== NULL
)
14537 for (j
= 0; j
< inote
.descsz
; ++j
)
14538 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14539 build_id
[inote
.descsz
* 2] = '\0';
14542 return (unsigned char *) build_id
;
14549 #endif /* HAVE_LIBDEBUGINFOD */
14551 /* If this is not NULL, load_debug_section will only look for sections
14552 within the list of sections given here. */
14553 static unsigned int * section_subset
= NULL
;
14556 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14558 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14559 Elf_Internal_Shdr
* sec
;
14560 Filedata
* filedata
= (Filedata
*) data
;
14562 /* Without section headers we cannot find any sections. */
14563 if (filedata
->section_headers
== NULL
)
14566 if (filedata
->string_table
== NULL
14567 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14568 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14570 Elf_Internal_Shdr
* strs
;
14572 /* Read in the string table, so that we have section names to scan. */
14573 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14575 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14577 filedata
->string_table
14578 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14579 1, strs
->sh_size
, _("string table"));
14581 filedata
->string_table_length
14582 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14586 /* Locate the debug section. */
14587 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14589 section
->name
= section
->uncompressed_name
;
14592 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14594 section
->name
= section
->compressed_name
;
14599 /* If we're loading from a subset of sections, and we've loaded
14600 a section matching this name before, it's likely that it's a
14602 if (section_subset
!= NULL
)
14603 free_debug_section (debug
);
14605 return load_specific_debug_section (debug
, sec
, data
);
14609 free_debug_section (enum dwarf_section_display_enum debug
)
14611 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14613 if (section
->start
== NULL
)
14616 free ((char *) section
->start
);
14617 section
->start
= NULL
;
14618 section
->address
= 0;
14621 free (section
->reloc_info
);
14622 section
->reloc_info
= NULL
;
14623 section
->num_relocs
= 0;
14627 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14629 char * name
= SECTION_NAME (section
);
14630 const char * print_name
= printable_section_name (filedata
, section
);
14631 bfd_size_type length
;
14632 bfd_boolean result
= TRUE
;
14635 length
= section
->sh_size
;
14638 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14641 if (section
->sh_type
== SHT_NOBITS
)
14643 /* There is no point in dumping the contents of a debugging section
14644 which has the NOBITS type - the bits in the file will be random.
14645 This can happen when a file containing a .eh_frame section is
14646 stripped with the --only-keep-debug command line option. */
14647 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14652 if (const_strneq (name
, ".gnu.linkonce.wi."))
14653 name
= ".debug_info";
14655 /* See if we know how to display the contents of this section. */
14656 for (i
= 0; i
< max
; i
++)
14658 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14659 struct dwarf_section_display
* display
= debug_displays
+ i
;
14660 struct dwarf_section
* sec
= & display
->section
;
14662 if (streq (sec
->uncompressed_name
, name
)
14663 || (id
== line
&& const_strneq (name
, ".debug_line."))
14664 || streq (sec
->compressed_name
, name
))
14666 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14669 free_debug_section (id
);
14671 if (i
== line
&& const_strneq (name
, ".debug_line."))
14673 else if (streq (sec
->uncompressed_name
, name
))
14674 sec
->name
= sec
->uncompressed_name
;
14676 sec
->name
= sec
->compressed_name
;
14678 if (load_specific_debug_section (id
, section
, filedata
))
14680 /* If this debug section is part of a CU/TU set in a .dwp file,
14681 restrict load_debug_section to the sections in that set. */
14682 section_subset
= find_cu_tu_set (filedata
, shndx
);
14684 result
&= display
->display (sec
, filedata
);
14686 section_subset
= NULL
;
14688 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14689 free_debug_section (id
);
14697 printf (_("Unrecognized debug section: %s\n"), print_name
);
14704 /* Set DUMP_SECTS for all sections where dumps were requested
14705 based on section name. */
14708 initialise_dumps_byname (Filedata
* filedata
)
14710 struct dump_list_entry
* cur
;
14712 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14715 bfd_boolean any
= FALSE
;
14717 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14718 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14720 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14725 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14731 process_section_contents (Filedata
* filedata
)
14733 Elf_Internal_Shdr
* section
;
14735 bfd_boolean res
= TRUE
;
14740 initialise_dumps_byname (filedata
);
14742 for (i
= 0, section
= filedata
->section_headers
;
14743 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14746 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14748 #ifdef SUPPORT_DISASSEMBLY
14749 if (dump
& DISASS_DUMP
)
14751 if (! disassemble_section (section
, filedata
))
14755 if (dump
& HEX_DUMP
)
14757 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14761 if (dump
& RELOC_DUMP
)
14763 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14767 if (dump
& STRING_DUMP
)
14769 if (! dump_section_as_strings (section
, filedata
))
14773 if (dump
& DEBUG_DUMP
)
14775 if (! display_debug_section (i
, section
, filedata
))
14779 if (dump
& CTF_DUMP
)
14781 if (! dump_section_as_ctf (section
, filedata
))
14786 /* Check to see if the user requested a
14787 dump of a section that does not exist. */
14788 while (i
< filedata
->dump
.num_dump_sects
)
14790 if (filedata
->dump
.dump_sects
[i
])
14792 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14802 process_mips_fpe_exception (int mask
)
14806 bfd_boolean first
= TRUE
;
14808 if (mask
& OEX_FPU_INEX
)
14809 fputs ("INEX", stdout
), first
= FALSE
;
14810 if (mask
& OEX_FPU_UFLO
)
14811 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14812 if (mask
& OEX_FPU_OFLO
)
14813 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14814 if (mask
& OEX_FPU_DIV0
)
14815 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14816 if (mask
& OEX_FPU_INVAL
)
14817 printf ("%sINVAL", first
? "" : "|");
14820 fputs ("0", stdout
);
14823 /* Display's the value of TAG at location P. If TAG is
14824 greater than 0 it is assumed to be an unknown tag, and
14825 a message is printed to this effect. Otherwise it is
14826 assumed that a message has already been printed.
14828 If the bottom bit of TAG is set it assumed to have a
14829 string value, otherwise it is assumed to have an integer
14832 Returns an updated P pointing to the first unread byte
14833 beyond the end of TAG's value.
14835 Reads at or beyond END will not be made. */
14837 static unsigned char *
14838 display_tag_value (signed int tag
,
14840 const unsigned char * const end
)
14845 printf (" Tag_unknown_%d: ", tag
);
14849 warn (_("<corrupt tag>\n"));
14853 /* PR 17531 file: 027-19978-0.004. */
14854 size_t maxlen
= (end
- p
) - 1;
14859 print_symbol ((int) maxlen
, (const char *) p
);
14860 p
+= strnlen ((char *) p
, maxlen
) + 1;
14864 printf (_("<corrupt string tag>"));
14865 p
= (unsigned char *) end
;
14871 READ_ULEB (val
, p
, end
);
14872 printf ("%ld (0x%lx)\n", val
, val
);
14879 /* ARC ABI attributes section. */
14881 static unsigned char *
14882 display_arc_attribute (unsigned char * p
,
14883 const unsigned char * const end
)
14888 READ_ULEB (tag
, p
, end
);
14892 case Tag_ARC_PCS_config
:
14893 READ_ULEB (val
, p
, end
);
14894 printf (" Tag_ARC_PCS_config: ");
14898 printf (_("Absent/Non standard\n"));
14901 printf (_("Bare metal/mwdt\n"));
14904 printf (_("Bare metal/newlib\n"));
14907 printf (_("Linux/uclibc\n"));
14910 printf (_("Linux/glibc\n"));
14913 printf (_("Unknown\n"));
14918 case Tag_ARC_CPU_base
:
14919 READ_ULEB (val
, p
, end
);
14920 printf (" Tag_ARC_CPU_base: ");
14925 printf (_("Absent\n"));
14927 case TAG_CPU_ARC6xx
:
14928 printf ("ARC6xx\n");
14930 case TAG_CPU_ARC7xx
:
14931 printf ("ARC7xx\n");
14933 case TAG_CPU_ARCEM
:
14934 printf ("ARCEM\n");
14936 case TAG_CPU_ARCHS
:
14937 printf ("ARCHS\n");
14942 case Tag_ARC_CPU_variation
:
14943 READ_ULEB (val
, p
, end
);
14944 printf (" Tag_ARC_CPU_variation: ");
14948 if (val
> 0 && val
< 16)
14949 printf ("Core%d\n", val
);
14951 printf ("Unknown\n");
14955 printf (_("Absent\n"));
14960 case Tag_ARC_CPU_name
:
14961 printf (" Tag_ARC_CPU_name: ");
14962 p
= display_tag_value (-1, p
, end
);
14965 case Tag_ARC_ABI_rf16
:
14966 READ_ULEB (val
, p
, end
);
14967 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14970 case Tag_ARC_ABI_osver
:
14971 READ_ULEB (val
, p
, end
);
14972 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14975 case Tag_ARC_ABI_pic
:
14976 case Tag_ARC_ABI_sda
:
14977 READ_ULEB (val
, p
, end
);
14978 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14979 : " Tag_ARC_ABI_pic: ");
14983 printf (_("Absent\n"));
14992 printf (_("Unknown\n"));
14997 case Tag_ARC_ABI_tls
:
14998 READ_ULEB (val
, p
, end
);
14999 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15002 case Tag_ARC_ABI_enumsize
:
15003 READ_ULEB (val
, p
, end
);
15004 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15008 case Tag_ARC_ABI_exceptions
:
15009 READ_ULEB (val
, p
, end
);
15010 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15014 case Tag_ARC_ABI_double_size
:
15015 READ_ULEB (val
, p
, end
);
15016 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15019 case Tag_ARC_ISA_config
:
15020 printf (" Tag_ARC_ISA_config: ");
15021 p
= display_tag_value (-1, p
, end
);
15024 case Tag_ARC_ISA_apex
:
15025 printf (" Tag_ARC_ISA_apex: ");
15026 p
= display_tag_value (-1, p
, end
);
15029 case Tag_ARC_ISA_mpy_option
:
15030 READ_ULEB (val
, p
, end
);
15031 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15034 case Tag_ARC_ATR_version
:
15035 READ_ULEB (val
, p
, end
);
15036 printf (" Tag_ARC_ATR_version: %d\n", val
);
15040 return display_tag_value (tag
& 1, p
, end
);
15046 /* ARM EABI attributes section. */
15051 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15053 const char ** table
;
15054 } arm_attr_public_tag
;
15056 static const char * arm_attr_tag_CPU_arch
[] =
15057 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15058 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15059 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15060 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15061 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15062 {"No", "Thumb-1", "Thumb-2", "Yes"};
15063 static const char * arm_attr_tag_FP_arch
[] =
15064 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15065 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15066 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15067 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15068 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15069 "NEON for ARMv8.1"};
15070 static const char * arm_attr_tag_PCS_config
[] =
15071 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15072 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15073 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15074 {"V6", "SB", "TLS", "Unused"};
15075 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15076 {"Absolute", "PC-relative", "SB-relative", "None"};
15077 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15078 {"Absolute", "PC-relative", "None"};
15079 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15080 {"None", "direct", "GOT-indirect"};
15081 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15082 {"None", "??? 1", "2", "??? 3", "4"};
15083 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15084 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15085 {"Unused", "Needed", "Sign only"};
15086 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15087 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15088 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15089 {"Unused", "Finite", "RTABI", "IEEE 754"};
15090 static const char * arm_attr_tag_ABI_enum_size
[] =
15091 {"Unused", "small", "int", "forced to int"};
15092 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15093 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15094 static const char * arm_attr_tag_ABI_VFP_args
[] =
15095 {"AAPCS", "VFP registers", "custom", "compatible"};
15096 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15097 {"AAPCS", "WMMX registers", "custom"};
15098 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15099 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15100 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15101 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15102 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15103 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15104 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15105 static const char * arm_attr_tag_FP_HP_extension
[] =
15106 {"Not Allowed", "Allowed"};
15107 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15108 {"None", "IEEE 754", "Alternative Format"};
15109 static const char * arm_attr_tag_DSP_extension
[] =
15110 {"Follow architecture", "Allowed"};
15111 static const char * arm_attr_tag_MPextension_use
[] =
15112 {"Not Allowed", "Allowed"};
15113 static const char * arm_attr_tag_DIV_use
[] =
15114 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15115 "Allowed in v7-A with integer division extension"};
15116 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15117 static const char * arm_attr_tag_Virtualization_use
[] =
15118 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15119 "TrustZone and Virtualization Extensions"};
15120 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15121 {"Not Allowed", "Allowed"};
15123 static const char * arm_attr_tag_MVE_arch
[] =
15124 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15126 #define LOOKUP(id, name) \
15127 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15128 static arm_attr_public_tag arm_attr_public_tags
[] =
15130 {4, "CPU_raw_name", 1, NULL
},
15131 {5, "CPU_name", 1, NULL
},
15132 LOOKUP(6, CPU_arch
),
15133 {7, "CPU_arch_profile", 0, NULL
},
15134 LOOKUP(8, ARM_ISA_use
),
15135 LOOKUP(9, THUMB_ISA_use
),
15136 LOOKUP(10, FP_arch
),
15137 LOOKUP(11, WMMX_arch
),
15138 LOOKUP(12, Advanced_SIMD_arch
),
15139 LOOKUP(13, PCS_config
),
15140 LOOKUP(14, ABI_PCS_R9_use
),
15141 LOOKUP(15, ABI_PCS_RW_data
),
15142 LOOKUP(16, ABI_PCS_RO_data
),
15143 LOOKUP(17, ABI_PCS_GOT_use
),
15144 LOOKUP(18, ABI_PCS_wchar_t
),
15145 LOOKUP(19, ABI_FP_rounding
),
15146 LOOKUP(20, ABI_FP_denormal
),
15147 LOOKUP(21, ABI_FP_exceptions
),
15148 LOOKUP(22, ABI_FP_user_exceptions
),
15149 LOOKUP(23, ABI_FP_number_model
),
15150 {24, "ABI_align_needed", 0, NULL
},
15151 {25, "ABI_align_preserved", 0, NULL
},
15152 LOOKUP(26, ABI_enum_size
),
15153 LOOKUP(27, ABI_HardFP_use
),
15154 LOOKUP(28, ABI_VFP_args
),
15155 LOOKUP(29, ABI_WMMX_args
),
15156 LOOKUP(30, ABI_optimization_goals
),
15157 LOOKUP(31, ABI_FP_optimization_goals
),
15158 {32, "compatibility", 0, NULL
},
15159 LOOKUP(34, CPU_unaligned_access
),
15160 LOOKUP(36, FP_HP_extension
),
15161 LOOKUP(38, ABI_FP_16bit_format
),
15162 LOOKUP(42, MPextension_use
),
15163 LOOKUP(44, DIV_use
),
15164 LOOKUP(46, DSP_extension
),
15165 LOOKUP(48, MVE_arch
),
15166 {64, "nodefaults", 0, NULL
},
15167 {65, "also_compatible_with", 0, NULL
},
15168 LOOKUP(66, T2EE_use
),
15169 {67, "conformance", 1, NULL
},
15170 LOOKUP(68, Virtualization_use
),
15171 LOOKUP(70, MPextension_use_legacy
)
15175 static unsigned char *
15176 display_arm_attribute (unsigned char * p
,
15177 const unsigned char * const end
)
15181 arm_attr_public_tag
* attr
;
15185 READ_ULEB (tag
, p
, end
);
15187 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15189 if (arm_attr_public_tags
[i
].tag
== tag
)
15191 attr
= &arm_attr_public_tags
[i
];
15198 printf (" Tag_%s: ", attr
->name
);
15199 switch (attr
->type
)
15204 case 7: /* Tag_CPU_arch_profile. */
15205 READ_ULEB (val
, p
, end
);
15208 case 0: printf (_("None\n")); break;
15209 case 'A': printf (_("Application\n")); break;
15210 case 'R': printf (_("Realtime\n")); break;
15211 case 'M': printf (_("Microcontroller\n")); break;
15212 case 'S': printf (_("Application or Realtime\n")); break;
15213 default: printf ("??? (%d)\n", val
); break;
15217 case 24: /* Tag_align_needed. */
15218 READ_ULEB (val
, p
, end
);
15221 case 0: printf (_("None\n")); break;
15222 case 1: printf (_("8-byte\n")); break;
15223 case 2: printf (_("4-byte\n")); break;
15224 case 3: printf ("??? 3\n"); break;
15227 printf (_("8-byte and up to %d-byte extended\n"),
15230 printf ("??? (%d)\n", val
);
15235 case 25: /* Tag_align_preserved. */
15236 READ_ULEB (val
, p
, end
);
15239 case 0: printf (_("None\n")); break;
15240 case 1: printf (_("8-byte, except leaf SP\n")); break;
15241 case 2: printf (_("8-byte\n")); break;
15242 case 3: printf ("??? 3\n"); break;
15245 printf (_("8-byte and up to %d-byte extended\n"),
15248 printf ("??? (%d)\n", val
);
15253 case 32: /* Tag_compatibility. */
15255 READ_ULEB (val
, p
, end
);
15256 printf (_("flag = %d, vendor = "), val
);
15259 size_t maxlen
= (end
- p
) - 1;
15261 print_symbol ((int) maxlen
, (const char *) p
);
15262 p
+= strnlen ((char *) p
, maxlen
) + 1;
15266 printf (_("<corrupt>"));
15267 p
= (unsigned char *) end
;
15273 case 64: /* Tag_nodefaults. */
15274 /* PR 17531: file: 001-505008-0.01. */
15277 printf (_("True\n"));
15280 case 65: /* Tag_also_compatible_with. */
15281 READ_ULEB (val
, p
, end
);
15282 if (val
== 6 /* Tag_CPU_arch. */)
15284 READ_ULEB (val
, p
, end
);
15285 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15286 printf ("??? (%d)\n", val
);
15288 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15292 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15297 printf (_("<unknown: %d>\n"), tag
);
15303 return display_tag_value (-1, p
, end
);
15305 return display_tag_value (0, p
, end
);
15308 assert (attr
->type
& 0x80);
15309 READ_ULEB (val
, p
, end
);
15310 type
= attr
->type
& 0x7f;
15312 printf ("??? (%d)\n", val
);
15314 printf ("%s\n", attr
->table
[val
]);
15319 return display_tag_value (tag
, p
, end
);
15322 static unsigned char *
15323 display_gnu_attribute (unsigned char * p
,
15324 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15325 const unsigned char * const end
)
15330 READ_ULEB (tag
, p
, end
);
15332 /* Tag_compatibility is the only generic GNU attribute defined at
15336 READ_ULEB (val
, p
, end
);
15338 printf (_("flag = %d, vendor = "), val
);
15341 printf (_("<corrupt>\n"));
15342 warn (_("corrupt vendor attribute\n"));
15348 size_t maxlen
= (end
- p
) - 1;
15350 print_symbol ((int) maxlen
, (const char *) p
);
15351 p
+= strnlen ((char *) p
, maxlen
) + 1;
15355 printf (_("<corrupt>"));
15356 p
= (unsigned char *) end
;
15363 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15364 return display_proc_gnu_attribute (p
, tag
, end
);
15366 return display_tag_value (tag
, p
, end
);
15369 static unsigned char *
15370 display_power_gnu_attribute (unsigned char * p
,
15372 const unsigned char * const end
)
15376 if (tag
== Tag_GNU_Power_ABI_FP
)
15378 printf (" Tag_GNU_Power_ABI_FP: ");
15381 printf (_("<corrupt>\n"));
15384 READ_ULEB (val
, p
, end
);
15387 printf ("(%#x), ", val
);
15392 printf (_("unspecified hard/soft float, "));
15395 printf (_("hard float, "));
15398 printf (_("soft float, "));
15401 printf (_("single-precision hard float, "));
15408 printf (_("unspecified long double\n"));
15411 printf (_("128-bit IBM long double\n"));
15414 printf (_("64-bit long double\n"));
15417 printf (_("128-bit IEEE long double\n"));
15423 if (tag
== Tag_GNU_Power_ABI_Vector
)
15425 printf (" Tag_GNU_Power_ABI_Vector: ");
15428 printf (_("<corrupt>\n"));
15431 READ_ULEB (val
, p
, end
);
15434 printf ("(%#x), ", val
);
15439 printf (_("unspecified\n"));
15442 printf (_("generic\n"));
15445 printf ("AltiVec\n");
15454 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15456 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15459 printf (_("<corrupt>\n"));
15462 READ_ULEB (val
, p
, end
);
15465 printf ("(%#x), ", val
);
15470 printf (_("unspecified\n"));
15473 printf ("r3/r4\n");
15476 printf (_("memory\n"));
15485 return display_tag_value (tag
& 1, p
, end
);
15488 static unsigned char *
15489 display_s390_gnu_attribute (unsigned char * p
,
15491 const unsigned char * const end
)
15495 if (tag
== Tag_GNU_S390_ABI_Vector
)
15497 printf (" Tag_GNU_S390_ABI_Vector: ");
15498 READ_ULEB (val
, p
, end
);
15503 printf (_("any\n"));
15506 printf (_("software\n"));
15509 printf (_("hardware\n"));
15512 printf ("??? (%d)\n", val
);
15518 return display_tag_value (tag
& 1, p
, end
);
15522 display_sparc_hwcaps (unsigned int mask
)
15526 bfd_boolean first
= TRUE
;
15528 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15529 fputs ("mul32", stdout
), first
= FALSE
;
15530 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15531 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15532 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15533 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15534 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15535 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15536 if (mask
& ELF_SPARC_HWCAP_POPC
)
15537 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15538 if (mask
& ELF_SPARC_HWCAP_VIS
)
15539 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15540 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15541 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15542 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15543 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15544 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15545 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15546 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15547 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15548 if (mask
& ELF_SPARC_HWCAP_HPC
)
15549 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15550 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15551 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15552 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15553 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15554 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15555 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15556 if (mask
& ELF_SPARC_HWCAP_IMA
)
15557 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15558 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15559 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15562 fputc ('0', stdout
);
15563 fputc ('\n', stdout
);
15567 display_sparc_hwcaps2 (unsigned int mask
)
15571 bfd_boolean first
= TRUE
;
15573 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15574 fputs ("fjathplus", stdout
), first
= FALSE
;
15575 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15576 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15577 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15578 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15579 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15580 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15581 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15582 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15583 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15584 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15585 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15586 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15587 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15588 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15589 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15590 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15591 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15592 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15593 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15594 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15597 fputc ('0', stdout
);
15598 fputc ('\n', stdout
);
15601 static unsigned char *
15602 display_sparc_gnu_attribute (unsigned char * p
,
15604 const unsigned char * const end
)
15608 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15610 READ_ULEB (val
, p
, end
);
15611 printf (" Tag_GNU_Sparc_HWCAPS: ");
15612 display_sparc_hwcaps (val
);
15615 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15617 READ_ULEB (val
, p
, end
);
15618 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15619 display_sparc_hwcaps2 (val
);
15623 return display_tag_value (tag
, p
, end
);
15627 print_mips_fp_abi_value (unsigned int val
)
15631 case Val_GNU_MIPS_ABI_FP_ANY
:
15632 printf (_("Hard or soft float\n"));
15634 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15635 printf (_("Hard float (double precision)\n"));
15637 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15638 printf (_("Hard float (single precision)\n"));
15640 case Val_GNU_MIPS_ABI_FP_SOFT
:
15641 printf (_("Soft float\n"));
15643 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15644 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15646 case Val_GNU_MIPS_ABI_FP_XX
:
15647 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15649 case Val_GNU_MIPS_ABI_FP_64
:
15650 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15652 case Val_GNU_MIPS_ABI_FP_64A
:
15653 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15655 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15656 printf (_("NaN 2008 compatibility\n"));
15659 printf ("??? (%d)\n", val
);
15664 static unsigned char *
15665 display_mips_gnu_attribute (unsigned char * p
,
15667 const unsigned char * const end
)
15669 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15673 printf (" Tag_GNU_MIPS_ABI_FP: ");
15674 READ_ULEB (val
, p
, end
);
15675 print_mips_fp_abi_value (val
);
15679 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15683 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15684 READ_ULEB (val
, p
, end
);
15688 case Val_GNU_MIPS_ABI_MSA_ANY
:
15689 printf (_("Any MSA or not\n"));
15691 case Val_GNU_MIPS_ABI_MSA_128
:
15692 printf (_("128-bit MSA\n"));
15695 printf ("??? (%d)\n", val
);
15701 return display_tag_value (tag
& 1, p
, end
);
15704 static unsigned char *
15705 display_tic6x_attribute (unsigned char * p
,
15706 const unsigned char * const end
)
15711 READ_ULEB (tag
, p
, end
);
15716 printf (" Tag_ISA: ");
15717 READ_ULEB (val
, p
, end
);
15721 case C6XABI_Tag_ISA_none
:
15722 printf (_("None\n"));
15724 case C6XABI_Tag_ISA_C62X
:
15727 case C6XABI_Tag_ISA_C67X
:
15730 case C6XABI_Tag_ISA_C67XP
:
15731 printf ("C67x+\n");
15733 case C6XABI_Tag_ISA_C64X
:
15736 case C6XABI_Tag_ISA_C64XP
:
15737 printf ("C64x+\n");
15739 case C6XABI_Tag_ISA_C674X
:
15740 printf ("C674x\n");
15743 printf ("??? (%d)\n", val
);
15748 case Tag_ABI_wchar_t
:
15749 printf (" Tag_ABI_wchar_t: ");
15750 READ_ULEB (val
, p
, end
);
15754 printf (_("Not used\n"));
15757 printf (_("2 bytes\n"));
15760 printf (_("4 bytes\n"));
15763 printf ("??? (%d)\n", val
);
15768 case Tag_ABI_stack_align_needed
:
15769 printf (" Tag_ABI_stack_align_needed: ");
15770 READ_ULEB (val
, p
, end
);
15774 printf (_("8-byte\n"));
15777 printf (_("16-byte\n"));
15780 printf ("??? (%d)\n", val
);
15785 case Tag_ABI_stack_align_preserved
:
15786 READ_ULEB (val
, p
, end
);
15787 printf (" Tag_ABI_stack_align_preserved: ");
15791 printf (_("8-byte\n"));
15794 printf (_("16-byte\n"));
15797 printf ("??? (%d)\n", val
);
15803 READ_ULEB (val
, p
, end
);
15804 printf (" Tag_ABI_DSBT: ");
15808 printf (_("DSBT addressing not used\n"));
15811 printf (_("DSBT addressing used\n"));
15814 printf ("??? (%d)\n", val
);
15820 READ_ULEB (val
, p
, end
);
15821 printf (" Tag_ABI_PID: ");
15825 printf (_("Data addressing position-dependent\n"));
15828 printf (_("Data addressing position-independent, GOT near DP\n"));
15831 printf (_("Data addressing position-independent, GOT far from DP\n"));
15834 printf ("??? (%d)\n", val
);
15840 READ_ULEB (val
, p
, end
);
15841 printf (" Tag_ABI_PIC: ");
15845 printf (_("Code addressing position-dependent\n"));
15848 printf (_("Code addressing position-independent\n"));
15851 printf ("??? (%d)\n", val
);
15856 case Tag_ABI_array_object_alignment
:
15857 READ_ULEB (val
, p
, end
);
15858 printf (" Tag_ABI_array_object_alignment: ");
15862 printf (_("8-byte\n"));
15865 printf (_("4-byte\n"));
15868 printf (_("16-byte\n"));
15871 printf ("??? (%d)\n", val
);
15876 case Tag_ABI_array_object_align_expected
:
15877 READ_ULEB (val
, p
, end
);
15878 printf (" Tag_ABI_array_object_align_expected: ");
15882 printf (_("8-byte\n"));
15885 printf (_("4-byte\n"));
15888 printf (_("16-byte\n"));
15891 printf ("??? (%d)\n", val
);
15896 case Tag_ABI_compatibility
:
15898 READ_ULEB (val
, p
, end
);
15899 printf (" Tag_ABI_compatibility: ");
15900 printf (_("flag = %d, vendor = "), val
);
15903 size_t maxlen
= (end
- p
) - 1;
15905 print_symbol ((int) maxlen
, (const char *) p
);
15906 p
+= strnlen ((char *) p
, maxlen
) + 1;
15910 printf (_("<corrupt>"));
15911 p
= (unsigned char *) end
;
15917 case Tag_ABI_conformance
:
15919 printf (" Tag_ABI_conformance: \"");
15922 size_t maxlen
= (end
- p
) - 1;
15924 print_symbol ((int) maxlen
, (const char *) p
);
15925 p
+= strnlen ((char *) p
, maxlen
) + 1;
15929 printf (_("<corrupt>"));
15930 p
= (unsigned char *) end
;
15937 return display_tag_value (tag
, p
, end
);
15941 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15943 unsigned long addr
= 0;
15944 size_t bytes
= end
- p
;
15951 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15953 printf (" 0x%8.8lx ", addr
);
15955 for (j
= 0; j
< 16; j
++)
15958 printf ("%2.2x", p
[j
]);
15966 for (j
= 0; j
< lbytes
; j
++)
15969 if (k
>= ' ' && k
< 0x7f)
15985 static unsigned char *
15986 display_msp430x_attribute (unsigned char * p
,
15987 const unsigned char * const end
)
15992 READ_ULEB (tag
, p
, end
);
15996 case OFBA_MSPABI_Tag_ISA
:
15997 printf (" Tag_ISA: ");
15998 READ_ULEB (val
, p
, end
);
16001 case 0: printf (_("None\n")); break;
16002 case 1: printf (_("MSP430\n")); break;
16003 case 2: printf (_("MSP430X\n")); break;
16004 default: printf ("??? (%d)\n", val
); break;
16008 case OFBA_MSPABI_Tag_Code_Model
:
16009 printf (" Tag_Code_Model: ");
16010 READ_ULEB (val
, p
, end
);
16013 case 0: printf (_("None\n")); break;
16014 case 1: printf (_("Small\n")); break;
16015 case 2: printf (_("Large\n")); break;
16016 default: printf ("??? (%d)\n", val
); break;
16020 case OFBA_MSPABI_Tag_Data_Model
:
16021 printf (" Tag_Data_Model: ");
16022 READ_ULEB (val
, p
, end
);
16025 case 0: printf (_("None\n")); break;
16026 case 1: printf (_("Small\n")); break;
16027 case 2: printf (_("Large\n")); break;
16028 case 3: printf (_("Restricted Large\n")); break;
16029 default: printf ("??? (%d)\n", val
); break;
16034 printf (_(" <unknown tag %d>: "), tag
);
16041 size_t maxlen
= (end
- p
) - 1;
16043 print_symbol ((int) maxlen
, (const char *) p
);
16044 p
+= strnlen ((char *) p
, maxlen
) + 1;
16048 printf (_("<corrupt>"));
16049 p
= (unsigned char *) end
;
16055 READ_ULEB (val
, p
, end
);
16056 printf ("%d (0x%x)\n", val
, val
);
16065 static unsigned char *
16066 display_msp430_gnu_attribute (unsigned char * p
,
16068 const unsigned char * const end
)
16070 if (tag
== Tag_GNU_MSP430_Data_Region
)
16074 printf (" Tag_GNU_MSP430_Data_Region: ");
16075 READ_ULEB (val
, p
, end
);
16079 case Val_GNU_MSP430_Data_Region_Any
:
16080 printf (_("Any Region\n"));
16082 case Val_GNU_MSP430_Data_Region_Lower
:
16083 printf (_("Lower Region Only\n"));
16086 printf ("??? (%u)\n", val
);
16090 return display_tag_value (tag
& 1, p
, end
);
16093 struct riscv_attr_tag_t
{
16098 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16100 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16103 T(priv_spec_minor
),
16104 T(priv_spec_revision
),
16105 T(unaligned_access
),
16110 static unsigned char *
16111 display_riscv_attribute (unsigned char *p
,
16112 const unsigned char * const end
)
16116 struct riscv_attr_tag_t
*attr
= NULL
;
16119 READ_ULEB (tag
, p
, end
);
16121 /* Find the name of attribute. */
16122 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16124 if (riscv_attr_tag
[i
].tag
== tag
)
16126 attr
= &riscv_attr_tag
[i
];
16132 printf (" %s: ", attr
->name
);
16134 return display_tag_value (tag
, p
, end
);
16138 case Tag_RISCV_priv_spec
:
16139 case Tag_RISCV_priv_spec_minor
:
16140 case Tag_RISCV_priv_spec_revision
:
16141 READ_ULEB (val
, p
, end
);
16142 printf (_("%u\n"), val
);
16144 case Tag_RISCV_unaligned_access
:
16145 READ_ULEB (val
, p
, end
);
16149 printf (_("No unaligned access\n"));
16152 printf (_("Unaligned access\n"));
16156 case Tag_RISCV_stack_align
:
16157 READ_ULEB (val
, p
, end
);
16158 printf (_("%u-bytes\n"), val
);
16160 case Tag_RISCV_arch
:
16161 p
= display_tag_value (-1, p
, end
);
16164 return display_tag_value (tag
, p
, end
);
16171 process_attributes (Filedata
* filedata
,
16172 const char * public_name
,
16173 unsigned int proc_type
,
16174 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16175 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16177 Elf_Internal_Shdr
* sect
;
16179 bfd_boolean res
= TRUE
;
16181 /* Find the section header so that we get the size. */
16182 for (i
= 0, sect
= filedata
->section_headers
;
16183 i
< filedata
->file_header
.e_shnum
;
16186 unsigned char * contents
;
16189 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16192 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16193 sect
->sh_size
, _("attributes"));
16194 if (contents
== NULL
)
16201 /* The first character is the version of the attributes.
16202 Currently only version 1, (aka 'A') is recognised here. */
16205 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16210 bfd_vma section_len
;
16212 section_len
= sect
->sh_size
- 1;
16215 while (section_len
> 0)
16218 unsigned int namelen
;
16219 bfd_boolean public_section
;
16220 bfd_boolean gnu_section
;
16222 if (section_len
<= 4)
16224 error (_("Tag section ends prematurely\n"));
16228 attr_len
= byte_get (p
, 4);
16231 if (attr_len
> section_len
)
16233 error (_("Bad attribute length (%u > %u)\n"),
16234 (unsigned) attr_len
, (unsigned) section_len
);
16235 attr_len
= section_len
;
16238 /* PR 17531: file: 001-101425-0.004 */
16239 else if (attr_len
< 5)
16241 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16246 section_len
-= attr_len
;
16249 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16250 if (namelen
== 0 || namelen
>= attr_len
)
16252 error (_("Corrupt attribute section name\n"));
16257 printf (_("Attribute Section: "));
16258 print_symbol (INT_MAX
, (const char *) p
);
16261 if (public_name
&& streq ((char *) p
, public_name
))
16262 public_section
= TRUE
;
16264 public_section
= FALSE
;
16266 if (streq ((char *) p
, "gnu"))
16267 gnu_section
= TRUE
;
16269 gnu_section
= FALSE
;
16272 attr_len
-= namelen
;
16274 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16279 unsigned char * end
;
16281 /* PR binutils/17531: Safe handling of corrupt files. */
16284 error (_("Unused bytes at end of section\n"));
16291 size
= byte_get (p
, 4);
16292 if (size
> attr_len
)
16294 error (_("Bad subsection length (%u > %u)\n"),
16295 (unsigned) size
, (unsigned) attr_len
);
16299 /* PR binutils/17531: Safe handling of corrupt files. */
16302 error (_("Bad subsection length (%u < 6)\n"),
16310 end
= p
+ size
- 1;
16311 assert (end
<= contents
+ sect
->sh_size
);
16317 printf (_("File Attributes\n"));
16320 printf (_("Section Attributes:"));
16323 printf (_("Symbol Attributes:"));
16324 /* Fall through. */
16328 READ_ULEB (val
, p
, end
);
16331 printf (" %d", val
);
16336 printf (_("Unknown tag: %d\n"), tag
);
16337 public_section
= FALSE
;
16341 if (public_section
&& display_pub_attribute
!= NULL
)
16344 p
= display_pub_attribute (p
, end
);
16347 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16350 p
= display_gnu_attribute (p
,
16351 display_proc_gnu_attribute
,
16357 printf (_(" Unknown attribute:\n"));
16358 display_raw_attribute (p
, end
);
16373 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16374 Print the Address, Access and Initial fields of an entry at VMA ADDR
16375 and return the VMA of the next entry, or -1 if there was a problem.
16376 Does not read from DATA_END or beyond. */
16379 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16380 unsigned char * data_end
)
16383 print_vma (addr
, LONG_HEX
);
16385 if (addr
< pltgot
+ 0xfff0)
16386 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16388 printf ("%10s", "");
16391 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16395 unsigned char * from
= data
+ addr
- pltgot
;
16397 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16399 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16400 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16401 return (bfd_vma
) -1;
16405 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16406 print_vma (entry
, LONG_HEX
);
16409 return addr
+ (is_32bit_elf
? 4 : 8);
16412 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16413 PLTGOT. Print the Address and Initial fields of an entry at VMA
16414 ADDR and return the VMA of the next entry. */
16417 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16420 print_vma (addr
, LONG_HEX
);
16423 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16428 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16429 print_vma (entry
, LONG_HEX
);
16431 return addr
+ (is_32bit_elf
? 4 : 8);
16435 print_mips_ases (unsigned int mask
)
16437 if (mask
& AFL_ASE_DSP
)
16438 fputs ("\n\tDSP ASE", stdout
);
16439 if (mask
& AFL_ASE_DSPR2
)
16440 fputs ("\n\tDSP R2 ASE", stdout
);
16441 if (mask
& AFL_ASE_DSPR3
)
16442 fputs ("\n\tDSP R3 ASE", stdout
);
16443 if (mask
& AFL_ASE_EVA
)
16444 fputs ("\n\tEnhanced VA Scheme", stdout
);
16445 if (mask
& AFL_ASE_MCU
)
16446 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16447 if (mask
& AFL_ASE_MDMX
)
16448 fputs ("\n\tMDMX ASE", stdout
);
16449 if (mask
& AFL_ASE_MIPS3D
)
16450 fputs ("\n\tMIPS-3D ASE", stdout
);
16451 if (mask
& AFL_ASE_MT
)
16452 fputs ("\n\tMT ASE", stdout
);
16453 if (mask
& AFL_ASE_SMARTMIPS
)
16454 fputs ("\n\tSmartMIPS ASE", stdout
);
16455 if (mask
& AFL_ASE_VIRT
)
16456 fputs ("\n\tVZ ASE", stdout
);
16457 if (mask
& AFL_ASE_MSA
)
16458 fputs ("\n\tMSA ASE", stdout
);
16459 if (mask
& AFL_ASE_MIPS16
)
16460 fputs ("\n\tMIPS16 ASE", stdout
);
16461 if (mask
& AFL_ASE_MICROMIPS
)
16462 fputs ("\n\tMICROMIPS ASE", stdout
);
16463 if (mask
& AFL_ASE_XPA
)
16464 fputs ("\n\tXPA ASE", stdout
);
16465 if (mask
& AFL_ASE_MIPS16E2
)
16466 fputs ("\n\tMIPS16e2 ASE", stdout
);
16467 if (mask
& AFL_ASE_CRC
)
16468 fputs ("\n\tCRC ASE", stdout
);
16469 if (mask
& AFL_ASE_GINV
)
16470 fputs ("\n\tGINV ASE", stdout
);
16471 if (mask
& AFL_ASE_LOONGSON_MMI
)
16472 fputs ("\n\tLoongson MMI ASE", stdout
);
16473 if (mask
& AFL_ASE_LOONGSON_CAM
)
16474 fputs ("\n\tLoongson CAM ASE", stdout
);
16475 if (mask
& AFL_ASE_LOONGSON_EXT
)
16476 fputs ("\n\tLoongson EXT ASE", stdout
);
16477 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16478 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16480 fprintf (stdout
, "\n\t%s", _("None"));
16481 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16482 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16486 print_mips_isa_ext (unsigned int isa_ext
)
16491 fputs (_("None"), stdout
);
16494 fputs ("RMI XLR", stdout
);
16496 case AFL_EXT_OCTEON3
:
16497 fputs ("Cavium Networks Octeon3", stdout
);
16499 case AFL_EXT_OCTEON2
:
16500 fputs ("Cavium Networks Octeon2", stdout
);
16502 case AFL_EXT_OCTEONP
:
16503 fputs ("Cavium Networks OcteonP", stdout
);
16505 case AFL_EXT_OCTEON
:
16506 fputs ("Cavium Networks Octeon", stdout
);
16509 fputs ("Toshiba R5900", stdout
);
16512 fputs ("MIPS R4650", stdout
);
16515 fputs ("LSI R4010", stdout
);
16518 fputs ("NEC VR4100", stdout
);
16521 fputs ("Toshiba R3900", stdout
);
16523 case AFL_EXT_10000
:
16524 fputs ("MIPS R10000", stdout
);
16527 fputs ("Broadcom SB-1", stdout
);
16530 fputs ("NEC VR4111/VR4181", stdout
);
16533 fputs ("NEC VR4120", stdout
);
16536 fputs ("NEC VR5400", stdout
);
16539 fputs ("NEC VR5500", stdout
);
16541 case AFL_EXT_LOONGSON_2E
:
16542 fputs ("ST Microelectronics Loongson 2E", stdout
);
16544 case AFL_EXT_LOONGSON_2F
:
16545 fputs ("ST Microelectronics Loongson 2F", stdout
);
16547 case AFL_EXT_INTERAPTIV_MR2
:
16548 fputs ("Imagination interAptiv MR2", stdout
);
16551 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16556 get_mips_reg_size (int reg_size
)
16558 return (reg_size
== AFL_REG_NONE
) ? 0
16559 : (reg_size
== AFL_REG_32
) ? 32
16560 : (reg_size
== AFL_REG_64
) ? 64
16561 : (reg_size
== AFL_REG_128
) ? 128
16566 process_mips_specific (Filedata
* filedata
)
16568 Elf_Internal_Dyn
* entry
;
16569 Elf_Internal_Shdr
*sect
= NULL
;
16570 size_t liblist_offset
= 0;
16571 size_t liblistno
= 0;
16572 size_t conflictsno
= 0;
16573 size_t options_offset
= 0;
16574 size_t conflicts_offset
= 0;
16575 size_t pltrelsz
= 0;
16577 bfd_vma pltgot
= 0;
16578 bfd_vma mips_pltgot
= 0;
16579 bfd_vma jmprel
= 0;
16580 bfd_vma local_gotno
= 0;
16581 bfd_vma gotsym
= 0;
16582 bfd_vma symtabno
= 0;
16583 bfd_boolean res
= TRUE
;
16585 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16586 display_mips_gnu_attribute
))
16589 sect
= find_section (filedata
, ".MIPS.abiflags");
16593 Elf_External_ABIFlags_v0
*abiflags_ext
;
16594 Elf_Internal_ABIFlags_v0 abiflags_in
;
16596 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16598 error (_("Corrupt MIPS ABI Flags section.\n"));
16603 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16604 sect
->sh_size
, _("MIPS ABI Flags section"));
16607 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16608 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16609 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16610 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16611 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16612 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16613 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16614 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16615 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16616 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16617 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16619 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16620 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16621 if (abiflags_in
.isa_rev
> 1)
16622 printf ("r%d", abiflags_in
.isa_rev
);
16623 printf ("\nGPR size: %d",
16624 get_mips_reg_size (abiflags_in
.gpr_size
));
16625 printf ("\nCPR1 size: %d",
16626 get_mips_reg_size (abiflags_in
.cpr1_size
));
16627 printf ("\nCPR2 size: %d",
16628 get_mips_reg_size (abiflags_in
.cpr2_size
));
16629 fputs ("\nFP ABI: ", stdout
);
16630 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16631 fputs ("ISA Extension: ", stdout
);
16632 print_mips_isa_ext (abiflags_in
.isa_ext
);
16633 fputs ("\nASEs:", stdout
);
16634 print_mips_ases (abiflags_in
.ases
);
16635 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16636 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16637 fputc ('\n', stdout
);
16638 free (abiflags_ext
);
16643 /* We have a lot of special sections. Thanks SGI! */
16644 if (filedata
->dynamic_section
== NULL
)
16646 /* No dynamic information available. See if there is static GOT. */
16647 sect
= find_section (filedata
, ".got");
16650 unsigned char *data_end
;
16651 unsigned char *data
;
16655 pltgot
= sect
->sh_addr
;
16658 addr_size
= (is_32bit_elf
? 4 : 8);
16659 end
= pltgot
+ sect
->sh_size
;
16661 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16663 _("Global Offset Table data"));
16664 /* PR 12855: Null data is handled gracefully throughout. */
16665 data_end
= data
+ (end
- pltgot
);
16667 printf (_("\nStatic GOT:\n"));
16668 printf (_(" Canonical gp value: "));
16669 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16672 /* In a dynamic binary GOT[0] is reserved for the dynamic
16673 loader to store the lazy resolver pointer, however in
16674 a static binary it may well have been omitted and GOT
16675 reduced to a table of addresses.
16676 PR 21344: Check for the entry being fully available
16677 before fetching it. */
16679 && data
+ ent
- pltgot
+ addr_size
<= data_end
16680 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16682 printf (_(" Reserved entries:\n"));
16683 printf (_(" %*s %10s %*s\n"),
16684 addr_size
* 2, _("Address"), _("Access"),
16685 addr_size
* 2, _("Value"));
16686 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16688 if (ent
== (bfd_vma
) -1)
16689 goto sgot_print_fail
;
16691 /* Check for the MSB of GOT[1] being set, identifying a
16692 GNU object. This entry will be used by some runtime
16693 loaders, to store the module pointer. Otherwise this
16694 is an ordinary local entry.
16695 PR 21344: Check for the entry being fully available
16696 before fetching it. */
16698 && data
+ ent
- pltgot
+ addr_size
<= data_end
16699 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16700 >> (addr_size
* 8 - 1)) != 0)
16702 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16704 if (ent
== (bfd_vma
) -1)
16705 goto sgot_print_fail
;
16710 if (data
!= NULL
&& ent
< end
)
16712 printf (_(" Local entries:\n"));
16713 printf (" %*s %10s %*s\n",
16714 addr_size
* 2, _("Address"), _("Access"),
16715 addr_size
* 2, _("Value"));
16718 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16720 if (ent
== (bfd_vma
) -1)
16721 goto sgot_print_fail
;
16732 for (entry
= filedata
->dynamic_section
;
16733 /* PR 17531 file: 012-50589-0.004. */
16734 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16735 && entry
->d_tag
!= DT_NULL
);
16737 switch (entry
->d_tag
)
16739 case DT_MIPS_LIBLIST
:
16741 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16742 liblistno
* sizeof (Elf32_External_Lib
));
16744 case DT_MIPS_LIBLISTNO
:
16745 liblistno
= entry
->d_un
.d_val
;
16747 case DT_MIPS_OPTIONS
:
16748 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16750 case DT_MIPS_CONFLICT
:
16752 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16753 conflictsno
* sizeof (Elf32_External_Conflict
));
16755 case DT_MIPS_CONFLICTNO
:
16756 conflictsno
= entry
->d_un
.d_val
;
16759 pltgot
= entry
->d_un
.d_ptr
;
16761 case DT_MIPS_LOCAL_GOTNO
:
16762 local_gotno
= entry
->d_un
.d_val
;
16764 case DT_MIPS_GOTSYM
:
16765 gotsym
= entry
->d_un
.d_val
;
16767 case DT_MIPS_SYMTABNO
:
16768 symtabno
= entry
->d_un
.d_val
;
16770 case DT_MIPS_PLTGOT
:
16771 mips_pltgot
= entry
->d_un
.d_ptr
;
16774 pltrel
= entry
->d_un
.d_val
;
16777 pltrelsz
= entry
->d_un
.d_val
;
16780 jmprel
= entry
->d_un
.d_ptr
;
16786 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16788 Elf32_External_Lib
* elib
;
16791 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16792 sizeof (Elf32_External_Lib
),
16794 _("liblist section data"));
16797 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16798 "\nSection '.liblist' contains %lu entries:\n",
16799 (unsigned long) liblistno
),
16800 (unsigned long) liblistno
);
16801 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16804 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16811 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16812 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16813 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16814 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16815 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16817 tmp
= gmtime (&atime
);
16818 snprintf (timebuf
, sizeof (timebuf
),
16819 "%04u-%02u-%02uT%02u:%02u:%02u",
16820 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16821 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16823 printf ("%3lu: ", (unsigned long) cnt
);
16824 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
16825 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
16827 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16828 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16829 liblist
.l_version
);
16831 if (liblist
.l_flags
== 0)
16835 static const struct
16842 { " EXACT_MATCH", LL_EXACT_MATCH
},
16843 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16844 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16845 { " EXPORTS", LL_EXPORTS
},
16846 { " DELAY_LOAD", LL_DELAY_LOAD
},
16847 { " DELTA", LL_DELTA
}
16849 int flags
= liblist
.l_flags
;
16852 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16853 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16855 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16856 flags
^= l_flags_vals
[fcnt
].bit
;
16859 printf (" %#x", (unsigned int) flags
);
16871 if (options_offset
!= 0)
16873 Elf_External_Options
* eopt
;
16876 sect
= filedata
->section_headers
;
16878 /* Find the section header so that we get the size. */
16879 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16880 /* PR 17533 file: 012-277276-0.004. */
16883 error (_("No MIPS_OPTIONS header found\n"));
16887 if (sect
->sh_size
< sizeof (* eopt
))
16889 error (_("The MIPS options section is too small.\n"));
16893 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16894 sect
->sh_size
, _("options"));
16897 Elf_Internal_Options
* iopt
;
16898 Elf_Internal_Options
* option
;
16899 Elf_Internal_Options
* iopt_end
;
16901 iopt
= (Elf_Internal_Options
*)
16902 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16905 error (_("Out of memory allocating space for MIPS options\n"));
16912 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16914 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16916 Elf_External_Options
* eoption
;
16918 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16920 option
->kind
= BYTE_GET (eoption
->kind
);
16921 option
->size
= BYTE_GET (eoption
->size
);
16922 option
->section
= BYTE_GET (eoption
->section
);
16923 option
->info
= BYTE_GET (eoption
->info
);
16925 /* PR 17531: file: ffa0fa3b. */
16926 if (option
->size
< sizeof (* eopt
)
16927 || offset
+ option
->size
> sect
->sh_size
)
16929 error (_("Invalid size (%u) for MIPS option\n"),
16935 offset
+= option
->size
;
16941 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16942 "\nSection '%s' contains %d entries:\n",
16944 printable_section_name (filedata
, sect
), cnt
);
16953 switch (option
->kind
)
16956 /* This shouldn't happen. */
16957 printf (" NULL %d %lx", option
->section
, option
->info
);
16961 printf (" REGINFO ");
16962 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16964 Elf32_External_RegInfo
* ereg
;
16965 Elf32_RegInfo reginfo
;
16968 if (option
+ 2 > iopt_end
)
16970 printf (_("<corrupt>\n"));
16971 error (_("Truncated MIPS REGINFO option\n"));
16976 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16978 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16979 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16980 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16981 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16982 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16983 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16985 printf ("GPR %08lx GP 0x%lx\n",
16986 reginfo
.ri_gprmask
,
16987 (unsigned long) reginfo
.ri_gp_value
);
16988 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16989 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16990 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16995 Elf64_External_RegInfo
* ereg
;
16996 Elf64_Internal_RegInfo reginfo
;
16998 if (option
+ 2 > iopt_end
)
17000 printf (_("<corrupt>\n"));
17001 error (_("Truncated MIPS REGINFO option\n"));
17006 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
17007 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17008 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17009 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17010 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17011 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17012 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17014 printf ("GPR %08lx GP 0x",
17015 reginfo
.ri_gprmask
);
17016 printf_vma (reginfo
.ri_gp_value
);
17019 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
17020 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17021 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17026 case ODK_EXCEPTIONS
:
17027 fputs (" EXCEPTIONS fpe_min(", stdout
);
17028 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
17029 fputs (") fpe_max(", stdout
);
17030 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
17031 fputs (")", stdout
);
17033 if (option
->info
& OEX_PAGE0
)
17034 fputs (" PAGE0", stdout
);
17035 if (option
->info
& OEX_SMM
)
17036 fputs (" SMM", stdout
);
17037 if (option
->info
& OEX_FPDBUG
)
17038 fputs (" FPDBUG", stdout
);
17039 if (option
->info
& OEX_DISMISS
)
17040 fputs (" DISMISS", stdout
);
17044 fputs (" PAD ", stdout
);
17045 if (option
->info
& OPAD_PREFIX
)
17046 fputs (" PREFIX", stdout
);
17047 if (option
->info
& OPAD_POSTFIX
)
17048 fputs (" POSTFIX", stdout
);
17049 if (option
->info
& OPAD_SYMBOL
)
17050 fputs (" SYMBOL", stdout
);
17054 fputs (" HWPATCH ", stdout
);
17055 if (option
->info
& OHW_R4KEOP
)
17056 fputs (" R4KEOP", stdout
);
17057 if (option
->info
& OHW_R8KPFETCH
)
17058 fputs (" R8KPFETCH", stdout
);
17059 if (option
->info
& OHW_R5KEOP
)
17060 fputs (" R5KEOP", stdout
);
17061 if (option
->info
& OHW_R5KCVTL
)
17062 fputs (" R5KCVTL", stdout
);
17066 fputs (" FILL ", stdout
);
17067 /* XXX Print content of info word? */
17071 fputs (" TAGS ", stdout
);
17072 /* XXX Print content of info word? */
17076 fputs (" HWAND ", stdout
);
17077 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17078 fputs (" R4KEOP_CHECKED", stdout
);
17079 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17080 fputs (" R4KEOP_CLEAN", stdout
);
17084 fputs (" HWOR ", stdout
);
17085 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17086 fputs (" R4KEOP_CHECKED", stdout
);
17087 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17088 fputs (" R4KEOP_CLEAN", stdout
);
17092 printf (" GP_GROUP %#06lx self-contained %#06lx",
17093 option
->info
& OGP_GROUP
,
17094 (option
->info
& OGP_SELF
) >> 16);
17098 printf (" IDENT %#06lx self-contained %#06lx",
17099 option
->info
& OGP_GROUP
,
17100 (option
->info
& OGP_SELF
) >> 16);
17104 /* This shouldn't happen. */
17105 printf (" %3d ??? %d %lx",
17106 option
->kind
, option
->section
, option
->info
);
17110 len
= sizeof (* eopt
);
17111 while (len
< option
->size
)
17113 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17115 if (ISPRINT (datum
))
17116 printf ("%c", datum
);
17118 printf ("\\%03o", datum
);
17121 fputs ("\n", stdout
);
17123 offset
+= option
->size
;
17133 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17135 Elf32_Conflict
* iconf
;
17138 if (filedata
->dynamic_symbols
== NULL
)
17140 error (_("conflict list found without a dynamic symbol table\n"));
17144 /* PR 21345 - print a slightly more helpful error message
17145 if we are sure that the cmalloc will fail. */
17146 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17148 error (_("Overlarge number of conflicts detected: %lx\n"),
17149 (long) conflictsno
);
17153 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17156 error (_("Out of memory allocating space for dynamic conflicts\n"));
17162 Elf32_External_Conflict
* econf32
;
17164 econf32
= (Elf32_External_Conflict
*)
17165 get_data (NULL
, filedata
, conflicts_offset
,
17166 sizeof (*econf32
), conflictsno
, _("conflict"));
17173 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17174 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17180 Elf64_External_Conflict
* econf64
;
17182 econf64
= (Elf64_External_Conflict
*)
17183 get_data (NULL
, filedata
, conflicts_offset
,
17184 sizeof (*econf64
), conflictsno
, _("conflict"));
17191 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17192 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17197 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17198 "\nSection '.conflict' contains %lu entries:\n",
17199 (unsigned long) conflictsno
),
17200 (unsigned long) conflictsno
);
17201 puts (_(" Num: Index Value Name"));
17203 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17205 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17207 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17208 printf (_("<corrupt symbol index>"));
17211 Elf_Internal_Sym
* psym
;
17213 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17214 print_vma (psym
->st_value
, FULL_HEX
);
17216 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17217 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17219 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17227 if (pltgot
!= 0 && local_gotno
!= 0)
17229 bfd_vma ent
, local_end
, global_end
;
17231 unsigned char * data
;
17232 unsigned char * data_end
;
17236 addr_size
= (is_32bit_elf
? 4 : 8);
17237 local_end
= pltgot
+ local_gotno
* addr_size
;
17239 /* PR binutils/17533 file: 012-111227-0.004 */
17240 if (symtabno
< gotsym
)
17242 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17243 (unsigned long) gotsym
, (unsigned long) symtabno
);
17247 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17248 /* PR 17531: file: 54c91a34. */
17249 if (global_end
< local_end
)
17251 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17255 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17256 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17257 global_end
- pltgot
, 1,
17258 _("Global Offset Table data"));
17259 /* PR 12855: Null data is handled gracefully throughout. */
17260 data_end
= data
+ (global_end
- pltgot
);
17262 printf (_("\nPrimary GOT:\n"));
17263 printf (_(" Canonical gp value: "));
17264 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17267 printf (_(" Reserved entries:\n"));
17268 printf (_(" %*s %10s %*s Purpose\n"),
17269 addr_size
* 2, _("Address"), _("Access"),
17270 addr_size
* 2, _("Initial"));
17271 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17272 printf (_(" Lazy resolver\n"));
17273 if (ent
== (bfd_vma
) -1)
17274 goto got_print_fail
;
17276 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17277 This entry will be used by some runtime loaders, to store the
17278 module pointer. Otherwise this is an ordinary local entry.
17279 PR 21344: Check for the entry being fully available before
17282 && data
+ ent
- pltgot
+ addr_size
<= data_end
17283 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17284 >> (addr_size
* 8 - 1)) != 0)
17286 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17287 printf (_(" Module pointer (GNU extension)\n"));
17288 if (ent
== (bfd_vma
) -1)
17289 goto got_print_fail
;
17293 if (data
!= NULL
&& ent
< local_end
)
17295 printf (_(" Local entries:\n"));
17296 printf (" %*s %10s %*s\n",
17297 addr_size
* 2, _("Address"), _("Access"),
17298 addr_size
* 2, _("Initial"));
17299 while (ent
< local_end
)
17301 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17303 if (ent
== (bfd_vma
) -1)
17304 goto got_print_fail
;
17309 if (data
!= NULL
&& gotsym
< symtabno
)
17313 printf (_(" Global entries:\n"));
17314 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17315 addr_size
* 2, _("Address"),
17317 addr_size
* 2, _("Initial"),
17318 addr_size
* 2, _("Sym.Val."),
17320 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17321 _("Ndx"), _("Name"));
17323 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17325 for (i
= gotsym
; i
< symtabno
; i
++)
17327 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17330 if (filedata
->dynamic_symbols
== NULL
)
17331 printf (_("<no dynamic symbols>"));
17332 else if (i
< filedata
->num_dynamic_syms
)
17334 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17336 print_vma (psym
->st_value
, LONG_HEX
);
17337 printf (" %-7s %3s ",
17338 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17339 get_symbol_index_type (filedata
, psym
->st_shndx
));
17341 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17342 print_symbol (sym_width
,
17343 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17345 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17348 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17349 (unsigned long) i
);
17352 if (ent
== (bfd_vma
) -1)
17362 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17365 size_t offset
, rel_offset
;
17366 unsigned long count
, i
;
17367 unsigned char * data
;
17368 int addr_size
, sym_width
;
17369 Elf_Internal_Rela
* rels
;
17371 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17372 if (pltrel
== DT_RELA
)
17374 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17379 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17384 addr_size
= (is_32bit_elf
? 4 : 8);
17385 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17387 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17388 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17389 1, _("Procedure Linkage Table data"));
17393 printf ("\nPLT GOT:\n\n");
17394 printf (_(" Reserved entries:\n"));
17395 printf (_(" %*s %*s Purpose\n"),
17396 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17397 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17398 printf (_(" PLT lazy resolver\n"));
17399 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17400 printf (_(" Module pointer\n"));
17403 printf (_(" Entries:\n"));
17404 printf (" %*s %*s %*s %-7s %3s %s\n",
17405 addr_size
* 2, _("Address"),
17406 addr_size
* 2, _("Initial"),
17407 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17408 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17409 for (i
= 0; i
< count
; i
++)
17411 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17413 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17416 if (idx
>= filedata
->num_dynamic_syms
)
17417 printf (_("<corrupt symbol index: %lu>"), idx
);
17420 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17422 print_vma (psym
->st_value
, LONG_HEX
);
17423 printf (" %-7s %3s ",
17424 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17425 get_symbol_index_type (filedata
, psym
->st_shndx
));
17426 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17427 print_symbol (sym_width
,
17428 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17430 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17444 process_nds32_specific (Filedata
* filedata
)
17446 Elf_Internal_Shdr
*sect
= NULL
;
17448 sect
= find_section (filedata
, ".nds32_e_flags");
17449 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17451 unsigned char *buf
;
17454 printf ("\nNDS32 elf flags section:\n");
17455 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17456 _("NDS32 elf flags section"));
17461 flag
= byte_get (buf
, 4);
17463 switch (flag
& 0x3)
17466 printf ("(VEC_SIZE):\tNo entry.\n");
17469 printf ("(VEC_SIZE):\t4 bytes\n");
17472 printf ("(VEC_SIZE):\t16 bytes\n");
17475 printf ("(VEC_SIZE):\treserved\n");
17484 process_gnu_liblist (Filedata
* filedata
)
17486 Elf_Internal_Shdr
* section
;
17487 Elf_Internal_Shdr
* string_sec
;
17488 Elf32_External_Lib
* elib
;
17490 size_t strtab_size
;
17492 unsigned long num_liblist
;
17494 bfd_boolean res
= TRUE
;
17499 for (i
= 0, section
= filedata
->section_headers
;
17500 i
< filedata
->file_header
.e_shnum
;
17503 switch (section
->sh_type
)
17505 case SHT_GNU_LIBLIST
:
17506 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17509 elib
= (Elf32_External_Lib
*)
17510 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17511 _("liblist section data"));
17519 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17520 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17521 string_sec
->sh_size
,
17522 _("liblist string table"));
17524 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17531 strtab_size
= string_sec
->sh_size
;
17533 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17534 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17535 "\nLibrary list section '%s' contains %lu entries:\n",
17537 printable_section_name (filedata
, section
),
17540 puts (_(" Library Time Stamp Checksum Version Flags"));
17542 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17550 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17551 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17552 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17553 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17554 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17556 tmp
= gmtime (&atime
);
17557 snprintf (timebuf
, sizeof (timebuf
),
17558 "%04u-%02u-%02uT%02u:%02u:%02u",
17559 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17560 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17562 printf ("%3lu: ", (unsigned long) cnt
);
17564 printf ("%-20s", liblist
.l_name
< strtab_size
17565 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17567 printf ("%-20.20s", liblist
.l_name
< strtab_size
17568 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17569 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17570 liblist
.l_version
, liblist
.l_flags
);
17581 static const char *
17582 get_note_type (Filedata
* filedata
, unsigned e_type
)
17584 static char buff
[64];
17586 if (filedata
->file_header
.e_type
== ET_CORE
)
17590 return _("NT_AUXV (auxiliary vector)");
17592 return _("NT_PRSTATUS (prstatus structure)");
17594 return _("NT_FPREGSET (floating point registers)");
17596 return _("NT_PRPSINFO (prpsinfo structure)");
17597 case NT_TASKSTRUCT
:
17598 return _("NT_TASKSTRUCT (task structure)");
17600 return _("NT_PRXFPREG (user_xfpregs structure)");
17602 return _("NT_PPC_VMX (ppc Altivec registers)");
17604 return _("NT_PPC_VSX (ppc VSX registers)");
17606 return _("NT_PPC_TAR (ppc TAR register)");
17608 return _("NT_PPC_PPR (ppc PPR register)");
17610 return _("NT_PPC_DSCR (ppc DSCR register)");
17612 return _("NT_PPC_EBB (ppc EBB registers)");
17614 return _("NT_PPC_PMU (ppc PMU registers)");
17615 case NT_PPC_TM_CGPR
:
17616 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17617 case NT_PPC_TM_CFPR
:
17618 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17619 case NT_PPC_TM_CVMX
:
17620 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17621 case NT_PPC_TM_CVSX
:
17622 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17623 case NT_PPC_TM_SPR
:
17624 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17625 case NT_PPC_TM_CTAR
:
17626 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17627 case NT_PPC_TM_CPPR
:
17628 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17629 case NT_PPC_TM_CDSCR
:
17630 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17632 return _("NT_386_TLS (x86 TLS information)");
17633 case NT_386_IOPERM
:
17634 return _("NT_386_IOPERM (x86 I/O permissions)");
17635 case NT_X86_XSTATE
:
17636 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17637 case NT_S390_HIGH_GPRS
:
17638 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17639 case NT_S390_TIMER
:
17640 return _("NT_S390_TIMER (s390 timer register)");
17641 case NT_S390_TODCMP
:
17642 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17643 case NT_S390_TODPREG
:
17644 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17646 return _("NT_S390_CTRS (s390 control registers)");
17647 case NT_S390_PREFIX
:
17648 return _("NT_S390_PREFIX (s390 prefix register)");
17649 case NT_S390_LAST_BREAK
:
17650 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17651 case NT_S390_SYSTEM_CALL
:
17652 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17654 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17655 case NT_S390_VXRS_LOW
:
17656 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17657 case NT_S390_VXRS_HIGH
:
17658 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17659 case NT_S390_GS_CB
:
17660 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17661 case NT_S390_GS_BC
:
17662 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17664 return _("NT_ARM_VFP (arm VFP registers)");
17666 return _("NT_ARM_TLS (AArch TLS registers)");
17667 case NT_ARM_HW_BREAK
:
17668 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17669 case NT_ARM_HW_WATCH
:
17670 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17672 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17674 return _("NT_PSTATUS (pstatus structure)");
17676 return _("NT_FPREGS (floating point registers)");
17678 return _("NT_PSINFO (psinfo structure)");
17680 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17682 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17683 case NT_WIN32PSTATUS
:
17684 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17686 return _("NT_SIGINFO (siginfo_t data)");
17688 return _("NT_FILE (mapped files)");
17696 return _("NT_VERSION (version)");
17698 return _("NT_ARCH (architecture)");
17699 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17701 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17707 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17712 print_core_note (Elf_Internal_Note
*pnote
)
17714 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17715 bfd_vma count
, page_size
;
17716 unsigned char *descdata
, *filenames
, *descend
;
17718 if (pnote
->type
!= NT_FILE
)
17728 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17729 /* Still "successful". */
17734 if (pnote
->descsz
< 2 * addr_size
)
17736 error (_(" Malformed note - too short for header\n"));
17740 descdata
= (unsigned char *) pnote
->descdata
;
17741 descend
= descdata
+ pnote
->descsz
;
17743 if (descdata
[pnote
->descsz
- 1] != '\0')
17745 error (_(" Malformed note - does not end with \\0\n"));
17749 count
= byte_get (descdata
, addr_size
);
17750 descdata
+= addr_size
;
17752 page_size
= byte_get (descdata
, addr_size
);
17753 descdata
+= addr_size
;
17755 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17756 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17758 error (_(" Malformed note - too short for supplied file count\n"));
17762 printf (_(" Page size: "));
17763 print_vma (page_size
, DEC
);
17766 printf (_(" %*s%*s%*s\n"),
17767 (int) (2 + 2 * addr_size
), _("Start"),
17768 (int) (4 + 2 * addr_size
), _("End"),
17769 (int) (4 + 2 * addr_size
), _("Page Offset"));
17770 filenames
= descdata
+ count
* 3 * addr_size
;
17771 while (count
-- > 0)
17773 bfd_vma start
, end
, file_ofs
;
17775 if (filenames
== descend
)
17777 error (_(" Malformed note - filenames end too early\n"));
17781 start
= byte_get (descdata
, addr_size
);
17782 descdata
+= addr_size
;
17783 end
= byte_get (descdata
, addr_size
);
17784 descdata
+= addr_size
;
17785 file_ofs
= byte_get (descdata
, addr_size
);
17786 descdata
+= addr_size
;
17789 print_vma (start
, FULL_HEX
);
17791 print_vma (end
, FULL_HEX
);
17793 print_vma (file_ofs
, FULL_HEX
);
17794 printf ("\n %s\n", filenames
);
17796 filenames
+= 1 + strlen ((char *) filenames
);
17802 static const char *
17803 get_gnu_elf_note_type (unsigned e_type
)
17805 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17808 case NT_GNU_ABI_TAG
:
17809 return _("NT_GNU_ABI_TAG (ABI version tag)");
17811 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17812 case NT_GNU_BUILD_ID
:
17813 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17814 case NT_GNU_GOLD_VERSION
:
17815 return _("NT_GNU_GOLD_VERSION (gold version)");
17816 case NT_GNU_PROPERTY_TYPE_0
:
17817 return _("NT_GNU_PROPERTY_TYPE_0");
17818 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17819 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17820 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17821 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17824 static char buff
[64];
17826 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17833 decode_x86_compat_isa (unsigned int bitmask
)
17837 unsigned int bit
= bitmask
& (- bitmask
);
17842 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17845 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17848 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17851 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17854 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17857 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17860 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17863 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17866 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17869 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17872 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17875 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17876 printf ("AVX512F");
17878 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17879 printf ("AVX512CD");
17881 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17882 printf ("AVX512ER");
17884 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17885 printf ("AVX512PF");
17887 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17888 printf ("AVX512VL");
17890 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17891 printf ("AVX512DQ");
17893 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17894 printf ("AVX512BW");
17897 printf (_("<unknown: %x>"), bit
);
17906 decode_x86_isa (unsigned int bitmask
)
17910 printf (_("<None>"));
17916 unsigned int bit
= bitmask
& (- bitmask
);
17921 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17924 case GNU_PROPERTY_X86_ISA_1_SSE
:
17927 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17930 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17933 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17936 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17939 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17942 case GNU_PROPERTY_X86_ISA_1_AVX
:
17945 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17948 case GNU_PROPERTY_X86_ISA_1_FMA
:
17951 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17952 printf ("AVX512F");
17954 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17955 printf ("AVX512CD");
17957 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17958 printf ("AVX512ER");
17960 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17961 printf ("AVX512PF");
17963 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17964 printf ("AVX512VL");
17966 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17967 printf ("AVX512DQ");
17969 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17970 printf ("AVX512BW");
17972 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17973 printf ("AVX512_4FMAPS");
17975 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17976 printf ("AVX512_4VNNIW");
17978 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17979 printf ("AVX512_BITALG");
17981 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17982 printf ("AVX512_IFMA");
17984 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17985 printf ("AVX512_VBMI");
17987 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17988 printf ("AVX512_VBMI2");
17990 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17991 printf ("AVX512_VNNI");
17993 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17994 printf ("AVX512_BF16");
17997 printf (_("<unknown: %x>"), bit
);
18006 decode_x86_feature_1 (unsigned int bitmask
)
18010 printf (_("<None>"));
18016 unsigned int bit
= bitmask
& (- bitmask
);
18021 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18024 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18028 printf (_("<unknown: %x>"), bit
);
18037 decode_x86_feature_2 (unsigned int bitmask
)
18041 printf (_("<None>"));
18047 unsigned int bit
= bitmask
& (- bitmask
);
18052 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18055 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18058 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18061 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18064 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18067 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18070 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18073 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18076 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18077 printf ("XSAVEOPT");
18079 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18083 printf (_("<unknown: %x>"), bit
);
18092 decode_aarch64_feature_1_and (unsigned int bitmask
)
18096 unsigned int bit
= bitmask
& (- bitmask
);
18101 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18105 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18110 printf (_("<unknown: %x>"), bit
);
18119 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18121 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18122 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18123 unsigned int size
= is_32bit_elf
? 4 : 8;
18125 printf (_(" Properties: "));
18127 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18129 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18133 while (ptr
< ptr_end
)
18137 unsigned int datasz
;
18139 if ((size_t) (ptr_end
- ptr
) < 8)
18141 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18145 type
= byte_get (ptr
, 4);
18146 datasz
= byte_get (ptr
+ 4, 4);
18150 if (datasz
> (size_t) (ptr_end
- ptr
))
18152 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18157 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18159 if (filedata
->file_header
.e_machine
== EM_X86_64
18160 || filedata
->file_header
.e_machine
== EM_IAMCU
18161 || filedata
->file_header
.e_machine
== EM_386
)
18163 unsigned int bitmask
;
18166 bitmask
= byte_get (ptr
, 4);
18172 case GNU_PROPERTY_X86_ISA_1_USED
:
18174 printf (_("x86 ISA used: <corrupt length: %#x> "),
18178 printf ("x86 ISA used: ");
18179 decode_x86_isa (bitmask
);
18183 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18185 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18189 printf ("x86 ISA needed: ");
18190 decode_x86_isa (bitmask
);
18194 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18196 printf (_("x86 feature: <corrupt length: %#x> "),
18200 printf ("x86 feature: ");
18201 decode_x86_feature_1 (bitmask
);
18205 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18207 printf (_("x86 feature used: <corrupt length: %#x> "),
18211 printf ("x86 feature used: ");
18212 decode_x86_feature_2 (bitmask
);
18216 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18218 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18221 printf ("x86 feature needed: ");
18222 decode_x86_feature_2 (bitmask
);
18226 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18228 printf (_("x86 ISA used: <corrupt length: %#x> "),
18232 printf ("x86 ISA used: ");
18233 decode_x86_compat_isa (bitmask
);
18237 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18239 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18243 printf ("x86 ISA needed: ");
18244 decode_x86_compat_isa (bitmask
);
18252 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18254 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18256 printf ("AArch64 feature: ");
18258 printf (_("<corrupt length: %#x> "), datasz
);
18260 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18269 case GNU_PROPERTY_STACK_SIZE
:
18270 printf (_("stack size: "));
18271 if (datasz
!= size
)
18272 printf (_("<corrupt length: %#x> "), datasz
);
18274 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18277 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18278 printf ("no copy on protected ");
18280 printf (_("<corrupt length: %#x> "), datasz
);
18288 if (type
< GNU_PROPERTY_LOPROC
)
18289 printf (_("<unknown type %#x data: "), type
);
18290 else if (type
< GNU_PROPERTY_LOUSER
)
18291 printf (_("<procesor-specific type %#x data: "), type
);
18293 printf (_("<application-specific type %#x data: "), type
);
18294 for (j
= 0; j
< datasz
; ++j
)
18295 printf ("%02x ", ptr
[j
] & 0xff);
18299 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18300 if (ptr
== ptr_end
)
18313 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18315 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18316 switch (pnote
->type
)
18318 case NT_GNU_BUILD_ID
:
18322 printf (_(" Build ID: "));
18323 for (i
= 0; i
< pnote
->descsz
; ++i
)
18324 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18329 case NT_GNU_ABI_TAG
:
18331 unsigned long os
, major
, minor
, subminor
;
18332 const char *osname
;
18334 /* PR 17531: file: 030-599401-0.004. */
18335 if (pnote
->descsz
< 16)
18337 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18341 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18342 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18343 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18344 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18348 case GNU_ABI_TAG_LINUX
:
18351 case GNU_ABI_TAG_HURD
:
18354 case GNU_ABI_TAG_SOLARIS
:
18355 osname
= "Solaris";
18357 case GNU_ABI_TAG_FREEBSD
:
18358 osname
= "FreeBSD";
18360 case GNU_ABI_TAG_NETBSD
:
18363 case GNU_ABI_TAG_SYLLABLE
:
18364 osname
= "Syllable";
18366 case GNU_ABI_TAG_NACL
:
18370 osname
= "Unknown";
18374 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18375 major
, minor
, subminor
);
18379 case NT_GNU_GOLD_VERSION
:
18383 printf (_(" Version: "));
18384 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18385 printf ("%c", pnote
->descdata
[i
]);
18392 unsigned long num_entries
, mask
;
18394 /* Hardware capabilities information. Word 0 is the number of entries.
18395 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18396 is a series of entries, where each entry is a single byte followed
18397 by a nul terminated string. The byte gives the bit number to test
18398 if enabled in the bitmask. */
18399 printf (_(" Hardware Capabilities: "));
18400 if (pnote
->descsz
< 8)
18402 error (_("<corrupt GNU_HWCAP>\n"));
18405 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18406 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18407 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18408 /* FIXME: Add code to display the entries... */
18412 case NT_GNU_PROPERTY_TYPE_0
:
18413 print_gnu_property_note (filedata
, pnote
);
18417 /* Handle unrecognised types. An error message should have already been
18418 created by get_gnu_elf_note_type(), so all that we need to do is to
18419 display the data. */
18423 printf (_(" Description data: "));
18424 for (i
= 0; i
< pnote
->descsz
; ++i
)
18425 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18434 static const char *
18435 get_v850_elf_note_type (enum v850_notes n_type
)
18437 static char buff
[64];
18441 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18442 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18443 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18444 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18445 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18446 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18448 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18454 print_v850_note (Elf_Internal_Note
* pnote
)
18458 if (pnote
->descsz
!= 4)
18461 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18465 printf (_("not set\n"));
18469 switch (pnote
->type
)
18471 case V850_NOTE_ALIGNMENT
:
18474 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18475 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18479 case V850_NOTE_DATA_SIZE
:
18482 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18483 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18487 case V850_NOTE_FPU_INFO
:
18490 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18491 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18495 case V850_NOTE_MMU_INFO
:
18496 case V850_NOTE_CACHE_INFO
:
18497 case V850_NOTE_SIMD_INFO
:
18498 if (val
== EF_RH850_SIMD
)
18500 printf (_("yes\n"));
18506 /* An 'unknown note type' message will already have been displayed. */
18510 printf (_("unknown value: %x\n"), val
);
18515 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18517 unsigned int version
;
18519 switch (pnote
->type
)
18521 case NT_NETBSD_IDENT
:
18522 if (pnote
->descsz
< 1)
18524 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18525 if ((version
/ 10000) % 100)
18526 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18527 version
, version
/ 100000000, (version
/ 1000000) % 100,
18528 (version
/ 10000) % 100 > 26 ? "Z" : "",
18529 'A' + (version
/ 10000) % 26);
18531 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18532 version
, version
/ 100000000, (version
/ 1000000) % 100,
18533 (version
/ 100) % 100);
18536 case NT_NETBSD_MARCH
:
18537 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18541 #ifdef NT_NETBSD_PAX
18542 case NT_NETBSD_PAX
:
18543 if (pnote
->descsz
< 1)
18545 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18546 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18547 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18548 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18549 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18550 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18551 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18552 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18557 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18558 pnote
->descsz
, pnote
->type
);
18562 static const char *
18563 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18567 case NT_FREEBSD_THRMISC
:
18568 return _("NT_THRMISC (thrmisc structure)");
18569 case NT_FREEBSD_PROCSTAT_PROC
:
18570 return _("NT_PROCSTAT_PROC (proc data)");
18571 case NT_FREEBSD_PROCSTAT_FILES
:
18572 return _("NT_PROCSTAT_FILES (files data)");
18573 case NT_FREEBSD_PROCSTAT_VMMAP
:
18574 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18575 case NT_FREEBSD_PROCSTAT_GROUPS
:
18576 return _("NT_PROCSTAT_GROUPS (groups data)");
18577 case NT_FREEBSD_PROCSTAT_UMASK
:
18578 return _("NT_PROCSTAT_UMASK (umask data)");
18579 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18580 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18581 case NT_FREEBSD_PROCSTAT_OSREL
:
18582 return _("NT_PROCSTAT_OSREL (osreldate data)");
18583 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18584 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18585 case NT_FREEBSD_PROCSTAT_AUXV
:
18586 return _("NT_PROCSTAT_AUXV (auxv data)");
18587 case NT_FREEBSD_PTLWPINFO
:
18588 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18590 return get_note_type (filedata
, e_type
);
18593 static const char *
18594 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18596 static char buff
[64];
18600 case NT_NETBSDCORE_PROCINFO
:
18601 /* NetBSD core "procinfo" structure. */
18602 return _("NetBSD procinfo structure");
18604 #ifdef NT_NETBSDCORE_AUXV
18605 case NT_NETBSDCORE_AUXV
:
18606 return _("NetBSD ELF auxiliary vector data");
18609 #ifdef NT_NETBSDCORE_LWPSTATUS
18610 case NT_NETBSDCORE_LWPSTATUS
:
18611 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18615 /* As of Jan 2020 there are no other machine-independent notes
18616 defined for NetBSD core files. If the note type is less
18617 than the start of the machine-dependent note types, we don't
18620 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18622 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18628 switch (filedata
->file_header
.e_machine
)
18630 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18631 and PT_GETFPREGS == mach+2. */
18636 case EM_SPARC32PLUS
:
18640 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18641 return _("PT_GETREGS (reg structure)");
18642 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18643 return _("PT_GETFPREGS (fpreg structure)");
18649 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18650 There's also old PT___GETREGS40 == mach + 1 for old reg
18651 structure which lacks GBR. */
18655 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18656 return _("PT___GETREGS40 (old reg structure)");
18657 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18658 return _("PT_GETREGS (reg structure)");
18659 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18660 return _("PT_GETFPREGS (fpreg structure)");
18666 /* On all other arch's, PT_GETREGS == mach+1 and
18667 PT_GETFPREGS == mach+3. */
18671 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18672 return _("PT_GETREGS (reg structure)");
18673 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18674 return _("PT_GETFPREGS (fpreg structure)");
18680 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18681 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18685 static const char *
18686 get_stapsdt_note_type (unsigned e_type
)
18688 static char buff
[64];
18693 return _("NT_STAPSDT (SystemTap probe descriptors)");
18699 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18704 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18706 size_t len
, maxlen
;
18707 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18708 char *data
= pnote
->descdata
;
18709 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18710 bfd_vma pc
, base_addr
, semaphore
;
18711 char *provider
, *probe
, *arg_fmt
;
18713 if (pnote
->descsz
< (addr_size
* 3))
18714 goto stapdt_note_too_small
;
18716 pc
= byte_get ((unsigned char *) data
, addr_size
);
18719 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18722 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18725 if (data
>= data_end
)
18726 goto stapdt_note_too_small
;
18727 maxlen
= data_end
- data
;
18728 len
= strnlen (data
, maxlen
);
18735 goto stapdt_note_too_small
;
18737 if (data
>= data_end
)
18738 goto stapdt_note_too_small
;
18739 maxlen
= data_end
- data
;
18740 len
= strnlen (data
, maxlen
);
18747 goto stapdt_note_too_small
;
18749 if (data
>= data_end
)
18750 goto stapdt_note_too_small
;
18751 maxlen
= data_end
- data
;
18752 len
= strnlen (data
, maxlen
);
18759 goto stapdt_note_too_small
;
18761 printf (_(" Provider: %s\n"), provider
);
18762 printf (_(" Name: %s\n"), probe
);
18763 printf (_(" Location: "));
18764 print_vma (pc
, FULL_HEX
);
18765 printf (_(", Base: "));
18766 print_vma (base_addr
, FULL_HEX
);
18767 printf (_(", Semaphore: "));
18768 print_vma (semaphore
, FULL_HEX
);
18770 printf (_(" Arguments: %s\n"), arg_fmt
);
18772 return data
== data_end
;
18774 stapdt_note_too_small
:
18775 printf (_(" <corrupt - note is too small>\n"));
18776 error (_("corrupt stapdt note - the data size is too small\n"));
18780 static const char *
18781 get_ia64_vms_note_type (unsigned e_type
)
18783 static char buff
[64];
18788 return _("NT_VMS_MHD (module header)");
18790 return _("NT_VMS_LNM (language name)");
18792 return _("NT_VMS_SRC (source files)");
18794 return "NT_VMS_TITLE";
18796 return _("NT_VMS_EIDC (consistency check)");
18797 case NT_VMS_FPMODE
:
18798 return _("NT_VMS_FPMODE (FP mode)");
18799 case NT_VMS_LINKTIME
:
18800 return "NT_VMS_LINKTIME";
18801 case NT_VMS_IMGNAM
:
18802 return _("NT_VMS_IMGNAM (image name)");
18804 return _("NT_VMS_IMGID (image id)");
18805 case NT_VMS_LINKID
:
18806 return _("NT_VMS_LINKID (link id)");
18807 case NT_VMS_IMGBID
:
18808 return _("NT_VMS_IMGBID (build id)");
18809 case NT_VMS_GSTNAM
:
18810 return _("NT_VMS_GSTNAM (sym table name)");
18811 case NT_VMS_ORIG_DYN
:
18812 return "NT_VMS_ORIG_DYN";
18813 case NT_VMS_PATCHTIME
:
18814 return "NT_VMS_PATCHTIME";
18816 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18822 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18824 int maxlen
= pnote
->descsz
;
18826 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18827 goto desc_size_fail
;
18829 switch (pnote
->type
)
18833 goto desc_size_fail
;
18835 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18837 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18838 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18839 if (l
+ 34 < maxlen
)
18841 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18842 if (l
+ 35 < maxlen
)
18843 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18845 printf (_(" Module version : <missing>\n"));
18849 printf (_(" Module name : <missing>\n"));
18850 printf (_(" Module version : <missing>\n"));
18855 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18859 case NT_VMS_FPMODE
:
18860 printf (_(" Floating Point mode: "));
18862 goto desc_size_fail
;
18863 /* FIXME: Generate an error if descsz > 8 ? */
18865 printf ("0x%016" BFD_VMA_FMT
"x\n",
18866 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18869 case NT_VMS_LINKTIME
:
18870 printf (_(" Link time: "));
18872 goto desc_size_fail
;
18873 /* FIXME: Generate an error if descsz > 8 ? */
18876 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18880 case NT_VMS_PATCHTIME
:
18881 printf (_(" Patch time: "));
18883 goto desc_size_fail
;
18884 /* FIXME: Generate an error if descsz > 8 ? */
18887 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18891 case NT_VMS_ORIG_DYN
:
18893 goto desc_size_fail
;
18895 printf (_(" Major id: %u, minor id: %u\n"),
18896 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18897 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18898 printf (_(" Last modified : "));
18900 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18901 printf (_("\n Link flags : "));
18902 printf ("0x%016" BFD_VMA_FMT
"x\n",
18903 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18904 printf (_(" Header flags: 0x%08x\n"),
18905 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18906 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18910 case NT_VMS_IMGNAM
:
18911 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18914 case NT_VMS_GSTNAM
:
18915 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18919 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18922 case NT_VMS_LINKID
:
18923 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18933 printf (_(" <corrupt - data size is too small>\n"));
18934 error (_("corrupt IA64 note: data size is too small\n"));
18938 struct build_attr_cache
{
18939 Filedata
*filedata
;
18941 unsigned long strtablen
;
18942 Elf_Internal_Sym
*symtab
;
18943 unsigned long nsyms
;
18946 /* Find the symbol associated with a build attribute that is attached
18947 to address OFFSET. If PNAME is non-NULL then store the name of
18948 the symbol (if found) in the provided pointer, Returns NULL if a
18949 symbol could not be found. */
18951 static Elf_Internal_Sym
*
18952 get_symbol_for_build_attribute (Filedata
* filedata
,
18953 unsigned long offset
,
18954 bfd_boolean is_open_attr
,
18955 const char ** pname
)
18957 Elf_Internal_Sym
*saved_sym
= NULL
;
18958 Elf_Internal_Sym
*sym
;
18960 if (filedata
->section_headers
!= NULL
18961 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18963 Elf_Internal_Shdr
* symsec
;
18965 free (ba_cache
.strtab
);
18966 ba_cache
.strtab
= NULL
;
18967 free (ba_cache
.symtab
);
18968 ba_cache
.symtab
= NULL
;
18970 /* Load the symbol and string sections. */
18971 for (symsec
= filedata
->section_headers
;
18972 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18975 if (symsec
->sh_type
== SHT_SYMTAB
18976 && get_symtab (filedata
, symsec
,
18977 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18978 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18981 ba_cache
.filedata
= filedata
;
18984 if (ba_cache
.symtab
== NULL
)
18987 /* Find a symbol whose value matches offset. */
18988 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18989 if (sym
->st_value
== offset
)
18991 if (sym
->st_name
>= ba_cache
.strtablen
)
18992 /* Huh ? This should not happen. */
18995 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18998 /* The AArch64 and ARM architectures define mapping symbols
18999 (eg $d, $x, $t) which we want to ignore. */
19000 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19001 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19002 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19007 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19008 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19009 FUNC symbols entirely. */
19010 switch (ELF_ST_TYPE (sym
->st_info
))
19017 /* If the symbol has a size associated
19018 with it then we can stop searching. */
19019 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19024 /* Ignore function symbols. */
19031 switch (ELF_ST_BIND (sym
->st_info
))
19034 if (saved_sym
== NULL
19035 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19040 if (saved_sym
== NULL
)
19050 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19058 if (saved_sym
&& pname
)
19059 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19064 /* Returns true iff addr1 and addr2 are in the same section. */
19067 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19069 Elf_Internal_Shdr
* a1
;
19070 Elf_Internal_Shdr
* a2
;
19072 a1
= find_section_by_address (filedata
, addr1
);
19073 a2
= find_section_by_address (filedata
, addr2
);
19075 return a1
== a2
&& a1
!= NULL
;
19079 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19080 Filedata
* filedata
)
19082 static unsigned long global_offset
= 0;
19083 static unsigned long global_end
= 0;
19084 static unsigned long func_offset
= 0;
19085 static unsigned long func_end
= 0;
19087 Elf_Internal_Sym
* sym
;
19089 unsigned long start
;
19091 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19093 switch (pnote
->descsz
)
19096 /* A zero-length description means that the range of
19097 the previous note of the same type should be used. */
19100 if (global_end
> global_offset
)
19101 printf (_(" Applies to region from %#lx to %#lx\n"),
19102 global_offset
, global_end
);
19104 printf (_(" Applies to region from %#lx\n"), global_offset
);
19108 if (func_end
> func_offset
)
19109 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19111 printf (_(" Applies to region from %#lx\n"), func_offset
);
19116 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19123 /* FIXME: We should check that version 3+ notes are being used here... */
19124 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19125 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19129 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19135 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19136 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19140 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19141 printf (_(" <invalid descsz>"));
19146 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19147 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19148 in order to avoid them being confused with the start address of the
19149 first function in the file... */
19150 if (sym
== NULL
&& is_open_attr
)
19151 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19154 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19155 end
= start
+ sym
->st_size
;
19159 /* FIXME: Need to properly allow for section alignment.
19160 16 is just the alignment used on x86_64. */
19162 && start
> BFD_ALIGN (global_end
, 16)
19163 /* Build notes are not guaranteed to be organised in order of
19164 increasing address, but we should find the all of the notes
19165 for one section in the same place. */
19166 && same_section (filedata
, start
, global_end
))
19167 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19168 global_end
+ 1, start
- 1);
19170 printf (_(" Applies to region from %#lx"), start
);
19171 global_offset
= start
;
19175 printf (_(" to %#lx"), end
);
19181 printf (_(" Applies to region from %#lx"), start
);
19182 func_offset
= start
;
19186 printf (_(" to %#lx"), end
);
19192 printf (_(" (%s)"), name
);
19199 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19201 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19202 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19203 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19205 char name_attribute
;
19206 const char * expected_types
;
19207 const char * name
= pnote
->namedata
;
19211 if (name
== NULL
|| pnote
->namesz
< 2)
19213 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19214 print_symbol (-20, _(" <corrupt name>"));
19223 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19224 if (name
[0] == 'G' && name
[1] == 'A')
19226 if (pnote
->namesz
< 4)
19228 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19229 print_symbol (-20, _(" <corrupt name>"));
19238 switch ((name_type
= * name
))
19240 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19241 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19242 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19243 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19244 printf ("%c", * name
);
19248 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19249 print_symbol (-20, _("<unknown name type>"));
19256 switch ((name_attribute
= * name
))
19258 case GNU_BUILD_ATTRIBUTE_VERSION
:
19259 text
= _("<version>");
19260 expected_types
= string_expected
;
19263 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19264 text
= _("<stack prot>");
19265 expected_types
= "!+*";
19268 case GNU_BUILD_ATTRIBUTE_RELRO
:
19269 text
= _("<relro>");
19270 expected_types
= bool_expected
;
19273 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19274 text
= _("<stack size>");
19275 expected_types
= number_expected
;
19278 case GNU_BUILD_ATTRIBUTE_TOOL
:
19279 text
= _("<tool>");
19280 expected_types
= string_expected
;
19283 case GNU_BUILD_ATTRIBUTE_ABI
:
19285 expected_types
= "$*";
19288 case GNU_BUILD_ATTRIBUTE_PIC
:
19290 expected_types
= number_expected
;
19293 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19294 text
= _("<short enum>");
19295 expected_types
= bool_expected
;
19299 if (ISPRINT (* name
))
19301 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19303 if (len
> left
&& ! do_wide
)
19305 printf ("%.*s:", len
, name
);
19311 static char tmpbuf
[128];
19313 error (_("unrecognised byte in name field: %d\n"), * name
);
19314 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19318 expected_types
= "*$!+";
19323 left
-= printf ("%s", text
);
19325 if (strchr (expected_types
, name_type
) == NULL
)
19326 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19328 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19330 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19331 (unsigned long) pnote
->namesz
,
19332 (long) (name
- pnote
->namedata
));
19336 if (left
< 1 && ! do_wide
)
19341 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19343 unsigned int bytes
;
19344 unsigned long long val
= 0;
19345 unsigned int shift
= 0;
19346 char * decoded
= NULL
;
19348 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19350 /* The -1 is because the name field is always 0 terminated, and we
19351 want to be able to ensure that the shift in the while loop below
19352 will not overflow. */
19355 if (bytes
> sizeof (val
))
19357 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19359 bytes
= sizeof (val
);
19361 /* We do not bother to warn if bytes == 0 as this can
19362 happen with some early versions of the gcc plugin. */
19366 unsigned long byte
= (* name
++) & 0xff;
19368 val
|= byte
<< shift
;
19372 switch (name_attribute
)
19374 case GNU_BUILD_ATTRIBUTE_PIC
:
19377 case 0: decoded
= "static"; break;
19378 case 1: decoded
= "pic"; break;
19379 case 2: decoded
= "PIC"; break;
19380 case 3: decoded
= "pie"; break;
19381 case 4: decoded
= "PIE"; break;
19385 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19388 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19389 case 0: decoded
= "off"; break;
19390 case 1: decoded
= "on"; break;
19391 case 2: decoded
= "all"; break;
19392 case 3: decoded
= "strong"; break;
19393 case 4: decoded
= "explicit"; break;
19401 if (decoded
!= NULL
)
19403 print_symbol (-left
, decoded
);
19414 left
-= printf ("0x%llx", val
);
19416 left
-= printf ("0x%-.*llx", left
, val
);
19420 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19421 left
-= print_symbol (- left
, name
);
19423 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19424 left
-= print_symbol (- left
, "true");
19426 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19427 left
-= print_symbol (- left
, "false");
19431 if (do_wide
&& left
> 0)
19432 printf ("%-*s", left
, " ");
19437 /* Note that by the ELF standard, the name field is already null byte
19438 terminated, and namesz includes the terminating null byte.
19439 I.E. the value of namesz for the name "FSF" is 4.
19441 If the value of namesz is zero, there is no name present. */
19444 process_note (Elf_Internal_Note
* pnote
,
19445 Filedata
* filedata
)
19447 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19450 if (pnote
->namesz
== 0)
19451 /* If there is no note name, then use the default set of
19452 note type strings. */
19453 nt
= get_note_type (filedata
, pnote
->type
);
19455 else if (const_strneq (pnote
->namedata
, "GNU"))
19456 /* GNU-specific object file notes. */
19457 nt
= get_gnu_elf_note_type (pnote
->type
);
19459 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19460 /* FreeBSD-specific core file notes. */
19461 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19463 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19464 /* NetBSD-specific core file notes. */
19465 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19467 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19468 /* NetBSD-specific core file notes. */
19469 return process_netbsd_elf_note (pnote
);
19471 else if (const_strneq (pnote
->namedata
, "PaX"))
19472 /* NetBSD-specific core file notes. */
19473 return process_netbsd_elf_note (pnote
);
19475 else if (strneq (pnote
->namedata
, "SPU/", 4))
19477 /* SPU-specific core file notes. */
19478 nt
= pnote
->namedata
+ 4;
19482 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19483 /* VMS/ia64-specific file notes. */
19484 nt
= get_ia64_vms_note_type (pnote
->type
);
19486 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19487 nt
= get_stapsdt_note_type (pnote
->type
);
19490 /* Don't recognize this note name; just use the default set of
19491 note type strings. */
19492 nt
= get_note_type (filedata
, pnote
->type
);
19496 if (((const_strneq (pnote
->namedata
, "GA")
19497 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19498 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19499 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19500 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19501 print_gnu_build_attribute_name (pnote
);
19503 print_symbol (-20, name
);
19506 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19508 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19510 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19511 return print_ia64_vms_note (pnote
);
19512 else if (const_strneq (pnote
->namedata
, "GNU"))
19513 return print_gnu_note (filedata
, pnote
);
19514 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19515 return print_stapsdt_note (pnote
);
19516 else if (const_strneq (pnote
->namedata
, "CORE"))
19517 return print_core_note (pnote
);
19518 else if (((const_strneq (pnote
->namedata
, "GA")
19519 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19520 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19521 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19522 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19523 return print_gnu_build_attribute_description (pnote
, filedata
);
19529 printf (_(" description data: "));
19530 for (i
= 0; i
< pnote
->descsz
; i
++)
19531 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19543 process_notes_at (Filedata
* filedata
,
19544 Elf_Internal_Shdr
* section
,
19549 Elf_External_Note
* pnotes
;
19550 Elf_External_Note
* external
;
19552 bfd_boolean res
= TRUE
;
19559 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19562 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19570 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19573 if (pnotes
== NULL
)
19579 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19581 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19582 (unsigned long) offset
, (unsigned long) length
);
19584 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19585 specifies that notes should be aligned to 4 bytes in 32-bit
19586 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19587 we also support 4 byte alignment in 64-bit objects. If section
19588 alignment is less than 4, we treate alignment as 4 bytes. */
19591 else if (align
!= 4 && align
!= 8)
19593 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19599 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19601 end
= (char *) pnotes
+ length
;
19602 while ((char *) external
< end
)
19604 Elf_Internal_Note inote
;
19607 char * temp
= NULL
;
19608 size_t data_remaining
= end
- (char *) external
;
19610 if (!is_ia64_vms (filedata
))
19612 /* PR binutils/15191
19613 Make sure that there is enough data to read. */
19614 min_notesz
= offsetof (Elf_External_Note
, name
);
19615 if (data_remaining
< min_notesz
)
19617 warn (ngettext ("Corrupt note: only %ld byte remains, "
19618 "not enough for a full note\n",
19619 "Corrupt note: only %ld bytes remain, "
19620 "not enough for a full note\n",
19622 (long) data_remaining
);
19625 data_remaining
-= min_notesz
;
19627 inote
.type
= BYTE_GET (external
->type
);
19628 inote
.namesz
= BYTE_GET (external
->namesz
);
19629 inote
.namedata
= external
->name
;
19630 inote
.descsz
= BYTE_GET (external
->descsz
);
19631 inote
.descdata
= ((char *) external
19632 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19633 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19634 next
= ((char *) external
19635 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19639 Elf64_External_VMS_Note
*vms_external
;
19641 /* PR binutils/15191
19642 Make sure that there is enough data to read. */
19643 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19644 if (data_remaining
< min_notesz
)
19646 warn (ngettext ("Corrupt note: only %ld byte remains, "
19647 "not enough for a full note\n",
19648 "Corrupt note: only %ld bytes remain, "
19649 "not enough for a full note\n",
19651 (long) data_remaining
);
19654 data_remaining
-= min_notesz
;
19656 vms_external
= (Elf64_External_VMS_Note
*) external
;
19657 inote
.type
= BYTE_GET (vms_external
->type
);
19658 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19659 inote
.namedata
= vms_external
->name
;
19660 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19661 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19662 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19663 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19666 /* PR 17531: file: 3443835e. */
19667 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19668 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19669 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19670 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19671 || ((size_t) (next
- inote
.descdata
)
19672 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19674 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19675 (unsigned long) ((char *) external
- (char *) pnotes
));
19676 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19677 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19681 external
= (Elf_External_Note
*) next
;
19683 /* Verify that name is null terminated. It appears that at least
19684 one version of Linux (RedHat 6.0) generates corefiles that don't
19685 comply with the ELF spec by failing to include the null byte in
19687 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19689 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19691 temp
= (char *) malloc (inote
.namesz
+ 1);
19694 error (_("Out of memory allocating space for inote name\n"));
19699 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19700 inote
.namedata
= temp
;
19702 inote
.namedata
[inote
.namesz
] = 0;
19705 if (! process_note (& inote
, filedata
))
19718 process_corefile_note_segments (Filedata
* filedata
)
19720 Elf_Internal_Phdr
* segment
;
19722 bfd_boolean res
= TRUE
;
19724 if (! get_program_headers (filedata
))
19727 for (i
= 0, segment
= filedata
->program_headers
;
19728 i
< filedata
->file_header
.e_phnum
;
19731 if (segment
->p_type
== PT_NOTE
)
19732 if (! process_notes_at (filedata
, NULL
,
19733 (bfd_vma
) segment
->p_offset
,
19734 (bfd_vma
) segment
->p_filesz
,
19735 (bfd_vma
) segment
->p_align
))
19743 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19745 Elf_External_Note
* pnotes
;
19746 Elf_External_Note
* external
;
19748 bfd_boolean res
= TRUE
;
19753 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19755 if (pnotes
== NULL
)
19759 end
= (char*) pnotes
+ length
;
19761 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19762 (unsigned long) offset
, (unsigned long) length
);
19764 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19766 Elf_External_Note
* next
;
19767 Elf_Internal_Note inote
;
19769 inote
.type
= BYTE_GET (external
->type
);
19770 inote
.namesz
= BYTE_GET (external
->namesz
);
19771 inote
.namedata
= external
->name
;
19772 inote
.descsz
= BYTE_GET (external
->descsz
);
19773 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19774 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19776 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19778 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19779 inote
.descdata
= inote
.namedata
;
19783 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19785 if ( ((char *) next
> end
)
19786 || ((char *) next
< (char *) pnotes
))
19788 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19789 (unsigned long) ((char *) external
- (char *) pnotes
));
19790 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19791 inote
.type
, inote
.namesz
, inote
.descsz
);
19797 /* Prevent out-of-bounds indexing. */
19798 if ( inote
.namedata
+ inote
.namesz
> end
19799 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19801 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19802 (unsigned long) ((char *) external
- (char *) pnotes
));
19803 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19804 inote
.type
, inote
.namesz
, inote
.descsz
);
19808 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19810 if (! print_v850_note (& inote
))
19813 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19814 inote
.namesz
, inote
.descsz
);
19824 process_note_sections (Filedata
* filedata
)
19826 Elf_Internal_Shdr
* section
;
19828 unsigned int n
= 0;
19829 bfd_boolean res
= TRUE
;
19831 for (i
= 0, section
= filedata
->section_headers
;
19832 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19835 if (section
->sh_type
== SHT_NOTE
)
19837 if (! process_notes_at (filedata
, section
,
19838 (bfd_vma
) section
->sh_offset
,
19839 (bfd_vma
) section
->sh_size
,
19840 (bfd_vma
) section
->sh_addralign
))
19845 if (( filedata
->file_header
.e_machine
== EM_V800
19846 || filedata
->file_header
.e_machine
== EM_V850
19847 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19848 && section
->sh_type
== SHT_RENESAS_INFO
)
19850 if (! process_v850_notes (filedata
,
19851 (bfd_vma
) section
->sh_offset
,
19852 (bfd_vma
) section
->sh_size
))
19859 /* Try processing NOTE segments instead. */
19860 return process_corefile_note_segments (filedata
);
19866 process_notes (Filedata
* filedata
)
19868 /* If we have not been asked to display the notes then do nothing. */
19872 if (filedata
->file_header
.e_type
!= ET_CORE
)
19873 return process_note_sections (filedata
);
19875 /* No program headers means no NOTE segment. */
19876 if (filedata
->file_header
.e_phnum
> 0)
19877 return process_corefile_note_segments (filedata
);
19879 printf (_("No note segments present in the core file.\n"));
19883 static unsigned char *
19884 display_public_gnu_attributes (unsigned char * start
,
19885 const unsigned char * const end
)
19887 printf (_(" Unknown GNU attribute: %s\n"), start
);
19889 start
+= strnlen ((char *) start
, end
- start
);
19890 display_raw_attribute (start
, end
);
19892 return (unsigned char *) end
;
19895 static unsigned char *
19896 display_generic_attribute (unsigned char * start
,
19898 const unsigned char * const end
)
19901 return (unsigned char *) end
;
19903 return display_tag_value (tag
, start
, end
);
19907 process_arch_specific (Filedata
* filedata
)
19912 switch (filedata
->file_header
.e_machine
)
19915 case EM_ARC_COMPACT
:
19916 case EM_ARC_COMPACT2
:
19917 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19918 display_arc_attribute
,
19919 display_generic_attribute
);
19921 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19922 display_arm_attribute
,
19923 display_generic_attribute
);
19926 case EM_MIPS_RS3_LE
:
19927 return process_mips_specific (filedata
);
19930 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19931 display_msp430x_attribute
,
19932 display_msp430_gnu_attribute
);
19935 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19936 display_riscv_attribute
,
19937 display_generic_attribute
);
19940 return process_nds32_specific (filedata
);
19944 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19945 display_power_gnu_attribute
);
19949 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19950 display_s390_gnu_attribute
);
19953 case EM_SPARC32PLUS
:
19955 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19956 display_sparc_gnu_attribute
);
19959 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19960 display_tic6x_attribute
,
19961 display_generic_attribute
);
19964 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19965 display_public_gnu_attributes
,
19966 display_generic_attribute
);
19971 get_file_header (Filedata
* filedata
)
19973 /* Read in the identity array. */
19974 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19977 /* Determine how to read the rest of the header. */
19978 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19983 byte_get
= byte_get_little_endian
;
19984 byte_put
= byte_put_little_endian
;
19987 byte_get
= byte_get_big_endian
;
19988 byte_put
= byte_put_big_endian
;
19992 /* For now we only support 32 bit and 64 bit ELF files. */
19993 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19995 /* Read in the rest of the header. */
19998 Elf32_External_Ehdr ehdr32
;
20000 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20003 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20004 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20005 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20006 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20007 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20008 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20009 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20010 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20011 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20012 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20013 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20014 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20015 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20019 Elf64_External_Ehdr ehdr64
;
20021 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20022 we will not be able to cope with the 64bit data found in
20023 64 ELF files. Detect this now and abort before we start
20024 overwriting things. */
20025 if (sizeof (bfd_vma
) < 8)
20027 error (_("This instance of readelf has been built without support for a\n\
20028 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20032 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20035 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20036 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20037 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20038 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20039 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20040 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20041 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20042 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20043 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20044 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20045 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20046 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20047 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20050 if (filedata
->file_header
.e_shoff
)
20052 /* There may be some extensions in the first section header. Don't
20053 bomb if we can't read it. */
20055 get_32bit_section_headers (filedata
, TRUE
);
20057 get_64bit_section_headers (filedata
, TRUE
);
20064 close_file (Filedata
* filedata
)
20068 if (filedata
->handle
)
20069 fclose (filedata
->handle
);
20075 close_debug_file (void * data
)
20077 close_file ((Filedata
*) data
);
20081 open_file (const char * pathname
)
20083 struct stat statbuf
;
20084 Filedata
* filedata
= NULL
;
20086 if (stat (pathname
, & statbuf
) < 0
20087 || ! S_ISREG (statbuf
.st_mode
))
20090 filedata
= calloc (1, sizeof * filedata
);
20091 if (filedata
== NULL
)
20094 filedata
->handle
= fopen (pathname
, "rb");
20095 if (filedata
->handle
== NULL
)
20098 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20099 filedata
->file_name
= pathname
;
20101 if (! get_file_header (filedata
))
20104 if (filedata
->file_header
.e_shoff
)
20108 /* Read the section headers again, this time for real. */
20110 res
= get_32bit_section_headers (filedata
, FALSE
);
20112 res
= get_64bit_section_headers (filedata
, FALSE
);
20123 if (filedata
->handle
)
20124 fclose (filedata
->handle
);
20131 open_debug_file (const char * pathname
)
20133 return open_file (pathname
);
20136 /* Process one ELF object file according to the command line options.
20137 This file may actually be stored in an archive. The file is
20138 positioned at the start of the ELF object. Returns TRUE if no
20139 problems were encountered, FALSE otherwise. */
20142 process_object (Filedata
* filedata
)
20144 bfd_boolean have_separate_files
;
20148 if (! get_file_header (filedata
))
20150 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20154 /* Initialise per file variables. */
20155 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20156 filedata
->version_info
[i
] = 0;
20158 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20159 filedata
->dynamic_info
[i
] = 0;
20160 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20161 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20163 /* Process the file. */
20165 printf (_("\nFile: %s\n"), filedata
->file_name
);
20167 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20168 Note we do this even if cmdline_dump_sects is empty because we
20169 must make sure that the dump_sets array is zeroed out before each
20170 object file is processed. */
20171 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20172 memset (filedata
->dump
.dump_sects
, 0,
20173 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20175 if (cmdline
.num_dump_sects
> 0)
20177 if (filedata
->dump
.num_dump_sects
== 0)
20178 /* A sneaky way of allocating the dump_sects array. */
20179 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20181 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20182 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20183 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20186 if (! process_file_header (filedata
))
20189 if (! process_section_headers (filedata
))
20191 /* Without loaded section headers we cannot process lots of things. */
20192 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20194 if (! do_using_dynamic
)
20195 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20198 if (! process_section_groups (filedata
))
20199 /* Without loaded section groups we cannot process unwind. */
20202 res
= process_program_headers (filedata
);
20204 res
= process_dynamic_section (filedata
);
20206 if (! process_relocs (filedata
))
20209 if (! process_unwind (filedata
))
20212 if (! process_symbol_table (filedata
))
20215 if (! process_syminfo (filedata
))
20218 if (! process_version_sections (filedata
))
20221 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20222 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20224 have_separate_files
= FALSE
;
20226 if (! process_section_contents (filedata
))
20229 if (have_separate_files
)
20233 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20235 if (! process_section_headers (d
->handle
))
20237 else if (! process_section_contents (d
->handle
))
20241 /* The file handles are closed by the call to free_debug_memory() below. */
20244 if (! process_notes (filedata
))
20247 if (! process_gnu_liblist (filedata
))
20250 if (! process_arch_specific (filedata
))
20253 free (filedata
->program_headers
);
20254 filedata
->program_headers
= NULL
;
20256 free (filedata
->section_headers
);
20257 filedata
->section_headers
= NULL
;
20259 free (filedata
->string_table
);
20260 filedata
->string_table
= NULL
;
20261 filedata
->string_table_length
= 0;
20263 free (filedata
->dump
.dump_sects
);
20264 filedata
->dump
.dump_sects
= NULL
;
20265 filedata
->dump
.num_dump_sects
= 0;
20267 free (filedata
->dynamic_strings
);
20268 filedata
->dynamic_strings
= NULL
;
20269 filedata
->dynamic_strings_length
= 0;
20271 free (filedata
->dynamic_symbols
);
20272 filedata
->dynamic_symbols
= NULL
;
20273 filedata
->num_dynamic_syms
= 0;
20275 free (filedata
->dynamic_syminfo
);
20276 filedata
->dynamic_syminfo
= NULL
;
20278 free (filedata
->dynamic_section
);
20279 filedata
->dynamic_section
= NULL
;
20281 while (filedata
->symtab_shndx_list
!= NULL
)
20283 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20284 free (filedata
->symtab_shndx_list
);
20285 filedata
->symtab_shndx_list
= next
;
20288 free (filedata
->section_headers_groups
);
20289 filedata
->section_headers_groups
= NULL
;
20291 if (filedata
->section_groups
)
20293 struct group_list
* g
;
20294 struct group_list
* next
;
20296 for (i
= 0; i
< filedata
->group_count
; i
++)
20298 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20305 free (filedata
->section_groups
);
20306 filedata
->section_groups
= NULL
;
20309 free_debug_memory ();
20314 /* Process an ELF archive.
20315 On entry the file is positioned just after the ARMAG string.
20316 Returns TRUE upon success, FALSE otherwise. */
20319 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20321 struct archive_info arch
;
20322 struct archive_info nested_arch
;
20324 bfd_boolean ret
= TRUE
;
20328 /* The ARCH structure is used to hold information about this archive. */
20329 arch
.file_name
= NULL
;
20331 arch
.index_array
= NULL
;
20332 arch
.sym_table
= NULL
;
20333 arch
.longnames
= NULL
;
20335 /* The NESTED_ARCH structure is used as a single-item cache of information
20336 about a nested archive (when members of a thin archive reside within
20337 another regular archive file). */
20338 nested_arch
.file_name
= NULL
;
20339 nested_arch
.file
= NULL
;
20340 nested_arch
.index_array
= NULL
;
20341 nested_arch
.sym_table
= NULL
;
20342 nested_arch
.longnames
= NULL
;
20344 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20345 filedata
->file_size
, is_thin_archive
,
20346 do_archive_index
) != 0)
20352 if (do_archive_index
)
20354 if (arch
.sym_table
== NULL
)
20355 error (_("%s: unable to dump the index as none was found\n"),
20356 filedata
->file_name
);
20359 unsigned long i
, l
;
20360 unsigned long current_pos
;
20362 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20363 "in the symbol table)\n"),
20364 filedata
->file_name
, (unsigned long) arch
.index_num
,
20367 current_pos
= ftell (filedata
->handle
);
20369 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20372 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20375 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20378 if (member_name
!= NULL
)
20380 char * qualified_name
20381 = make_qualified_name (&arch
, &nested_arch
,
20384 if (qualified_name
!= NULL
)
20386 printf (_("Contents of binary %s at offset "),
20388 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20390 free (qualified_name
);
20392 free (member_name
);
20396 if (l
>= arch
.sym_size
)
20398 error (_("%s: end of the symbol table reached "
20399 "before the end of the index\n"),
20400 filedata
->file_name
);
20404 /* PR 17531: file: 0b6630b2. */
20405 printf ("\t%.*s\n",
20406 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20407 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20410 if (arch
.uses_64bit_indices
)
20415 if (l
< arch
.sym_size
)
20417 error (ngettext ("%s: %ld byte remains in the symbol table, "
20418 "but without corresponding entries in "
20419 "the index table\n",
20420 "%s: %ld bytes remain in the symbol table, "
20421 "but without corresponding entries in "
20422 "the index table\n",
20423 arch
.sym_size
- l
),
20424 filedata
->file_name
, arch
.sym_size
- l
);
20428 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20430 error (_("%s: failed to seek back to start of object files "
20431 "in the archive\n"),
20432 filedata
->file_name
);
20438 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20439 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20440 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20441 && !do_section_groups
&& !do_dyn_syms
)
20443 ret
= TRUE
; /* Archive index only. */
20452 char * qualified_name
;
20454 /* Read the next archive header. */
20455 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20457 error (_("%s: failed to seek to next archive header\n"),
20462 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20463 if (got
!= sizeof arch
.arhdr
)
20467 /* PR 24049 - we cannot use filedata->file_name as this will
20468 have already been freed. */
20469 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20474 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20476 error (_("%s: did not find a valid archive header\n"),
20482 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20484 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20485 if (filedata
->archive_file_size
& 01)
20486 ++filedata
->archive_file_size
;
20488 name
= get_archive_member_name (&arch
, &nested_arch
);
20491 error (_("%s: bad archive file name\n"), arch
.file_name
);
20495 namelen
= strlen (name
);
20497 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20498 if (qualified_name
== NULL
)
20500 error (_("%s: bad archive file name\n"), arch
.file_name
);
20506 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20508 /* This is a proxy for an external member of a thin archive. */
20509 Filedata
* member_filedata
;
20510 char * member_file_name
= adjust_relative_path
20511 (filedata
->file_name
, name
, namelen
);
20514 if (member_file_name
== NULL
)
20516 free (qualified_name
);
20521 member_filedata
= open_file (member_file_name
);
20522 if (member_filedata
== NULL
)
20524 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20525 free (member_file_name
);
20526 free (qualified_name
);
20531 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20532 member_filedata
->file_name
= qualified_name
;
20534 if (! process_object (member_filedata
))
20537 close_file (member_filedata
);
20538 free (member_file_name
);
20540 else if (is_thin_archive
)
20542 Filedata thin_filedata
;
20544 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20546 /* PR 15140: Allow for corrupt thin archives. */
20547 if (nested_arch
.file
== NULL
)
20549 error (_("%s: contains corrupt thin archive: %s\n"),
20550 qualified_name
, name
);
20551 free (qualified_name
);
20558 /* This is a proxy for a member of a nested archive. */
20559 filedata
->archive_file_offset
20560 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20562 /* The nested archive file will have been opened and setup by
20563 get_archive_member_name. */
20564 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20567 error (_("%s: failed to seek to archive member.\n"),
20568 nested_arch
.file_name
);
20569 free (qualified_name
);
20574 thin_filedata
.handle
= nested_arch
.file
;
20575 thin_filedata
.file_name
= qualified_name
;
20577 if (! process_object (& thin_filedata
))
20583 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20584 filedata
->file_name
= qualified_name
;
20585 if (! process_object (filedata
))
20587 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20588 /* Stop looping with "negative" archive_file_size. */
20589 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20590 arch
.next_arhdr_offset
= -1ul;
20593 free (qualified_name
);
20597 if (nested_arch
.file
!= NULL
)
20598 fclose (nested_arch
.file
);
20599 release_archive (&nested_arch
);
20600 release_archive (&arch
);
20606 process_file (char * file_name
)
20608 Filedata
* filedata
= NULL
;
20609 struct stat statbuf
;
20610 char armag
[SARMAG
];
20611 bfd_boolean ret
= TRUE
;
20613 if (stat (file_name
, &statbuf
) < 0)
20615 if (errno
== ENOENT
)
20616 error (_("'%s': No such file\n"), file_name
);
20618 error (_("Could not locate '%s'. System error message: %s\n"),
20619 file_name
, strerror (errno
));
20623 if (! S_ISREG (statbuf
.st_mode
))
20625 error (_("'%s' is not an ordinary file\n"), file_name
);
20629 filedata
= calloc (1, sizeof * filedata
);
20630 if (filedata
== NULL
)
20632 error (_("Out of memory allocating file data structure\n"));
20636 filedata
->file_name
= file_name
;
20637 filedata
->handle
= fopen (file_name
, "rb");
20638 if (filedata
->handle
== NULL
)
20640 error (_("Input file '%s' is not readable.\n"), file_name
);
20645 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20647 error (_("%s: Failed to read file's magic number\n"), file_name
);
20648 fclose (filedata
->handle
);
20653 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20655 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20657 if (! process_archive (filedata
, FALSE
))
20660 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20662 if ( ! process_archive (filedata
, TRUE
))
20667 if (do_archive_index
&& !check_all
)
20668 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20671 rewind (filedata
->handle
);
20672 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20674 if (! process_object (filedata
))
20678 fclose (filedata
->handle
);
20679 free (filedata
->section_headers
);
20680 free (filedata
->program_headers
);
20681 free (filedata
->string_table
);
20682 free (filedata
->dump
.dump_sects
);
20685 free (ba_cache
.strtab
);
20686 ba_cache
.strtab
= NULL
;
20687 free (ba_cache
.symtab
);
20688 ba_cache
.symtab
= NULL
;
20689 ba_cache
.filedata
= NULL
;
20694 #ifdef SUPPORT_DISASSEMBLY
20695 /* Needed by the i386 disassembler. For extra credit, someone could
20696 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20700 print_address (unsigned int addr
, FILE * outfile
)
20702 fprintf (outfile
,"0x%8.8x", addr
);
20705 /* Needed by the i386 disassembler. */
20708 db_task_printsym (unsigned int addr
)
20710 print_address (addr
, stderr
);
20715 main (int argc
, char ** argv
)
20719 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20720 setlocale (LC_MESSAGES
, "");
20722 #if defined (HAVE_SETLOCALE)
20723 setlocale (LC_CTYPE
, "");
20725 bindtextdomain (PACKAGE
, LOCALEDIR
);
20726 textdomain (PACKAGE
);
20728 expandargv (&argc
, &argv
);
20730 parse_args (& cmdline
, argc
, argv
);
20732 if (optind
< (argc
- 1))
20733 /* When displaying information for more than one file,
20734 prefix the information with the file name. */
20736 else if (optind
>= argc
)
20738 /* Ensure that the warning is always displayed. */
20741 warn (_("Nothing to do.\n"));
20746 while (optind
< argc
)
20747 if (! process_file (argv
[optind
++]))
20750 free (cmdline
.dump_sects
);
20752 free (dump_ctf_symtab_name
);
20753 free (dump_ctf_strtab_name
);
20754 free (dump_ctf_parent_name
);
20756 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;