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 #ifdef ENABLE_LIBCTF
4506 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4508 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4509 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4510 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4513 {"version", no_argument
, 0, 'v'},
4514 {"wide", no_argument
, 0, 'W'},
4515 {"help", no_argument
, 0, 'H'},
4516 {0, no_argument
, 0, 0}
4520 usage (FILE * stream
)
4522 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4523 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4524 fprintf (stream
, _(" Options are:\n\
4525 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4526 -h --file-header Display the ELF file header\n\
4527 -l --program-headers Display the program headers\n\
4528 --segments An alias for --program-headers\n\
4529 -S --section-headers Display the sections' header\n\
4530 --sections An alias for --section-headers\n\
4531 -g --section-groups Display the section groups\n\
4532 -t --section-details Display the section details\n\
4533 -e --headers Equivalent to: -h -l -S\n\
4534 -s --syms Display the symbol table\n\
4535 --symbols An alias for --syms\n\
4536 --dyn-syms Display the dynamic symbol table\n\
4537 -n --notes Display the core notes (if present)\n\
4538 -r --relocs Display the relocations (if present)\n\
4539 -u --unwind Display the unwind info (if present)\n\
4540 -d --dynamic Display the dynamic section (if present)\n\
4541 -V --version-info Display the version sections (if present)\n\
4542 -A --arch-specific Display architecture specific information (if any)\n\
4543 -c --archive-index Display the symbol/file index in an archive\n\
4544 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4545 -L --lint|--enable-checks Display warning messages for possible problems\n\
4546 -x --hex-dump=<number|name>\n\
4547 Dump the contents of section <number|name> as bytes\n\
4548 -p --string-dump=<number|name>\n\
4549 Dump the contents of section <number|name> as strings\n\
4550 -R --relocated-dump=<number|name>\n\
4551 Dump the contents of section <number|name> as relocated bytes\n\
4552 -z --decompress Decompress section before dumping it\n\
4553 -w[lLiaprmfFsoORtUuTgAckK] or\n\
4554 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4555 =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
4556 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4557 =addr,=cu_index,=links,=follow-links]\n\
4558 Display the contents of DWARF debug sections\n"));
4559 fprintf (stream
, _("\
4560 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4561 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4563 #ifdef ENABLE_LIBCTF
4564 fprintf (stream
, _("\
4565 --ctf=<number|name> Display CTF info from section <number|name>\n\
4566 --ctf-parent=<number|name>\n\
4567 Use section <number|name> as the CTF parent\n\n\
4568 --ctf-symbols=<number|name>\n\
4569 Use section <number|name> as the CTF external symtab\n\n\
4570 --ctf-strings=<number|name>\n\
4571 Use section <number|name> as the CTF external strtab\n\n"));
4574 #ifdef SUPPORT_DISASSEMBLY
4575 fprintf (stream
, _("\
4576 -i --instruction-dump=<number|name>\n\
4577 Disassemble the contents of section <number|name>\n"));
4579 fprintf (stream
, _("\
4580 -I --histogram Display histogram of bucket list lengths\n\
4581 -W --wide Allow output width to exceed 80 characters\n\
4582 @<file> Read options from <file>\n\
4583 -H --help Display this information\n\
4584 -v --version Display the version number of readelf\n"));
4586 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4587 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4589 exit (stream
== stdout
? 0 : 1);
4592 /* Record the fact that the user wants the contents of section number
4593 SECTION to be displayed using the method(s) encoded as flags bits
4594 in TYPE. Note, TYPE can be zero if we are creating the array for
4598 request_dump_bynumber (struct dump_data
*dumpdata
,
4599 unsigned int section
, dump_type type
)
4601 if (section
>= dumpdata
->num_dump_sects
)
4603 dump_type
* new_dump_sects
;
4605 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4606 sizeof (* new_dump_sects
));
4608 if (new_dump_sects
== NULL
)
4609 error (_("Out of memory allocating dump request table.\n"));
4612 if (dumpdata
->dump_sects
)
4614 /* Copy current flag settings. */
4615 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4616 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4618 free (dumpdata
->dump_sects
);
4621 dumpdata
->dump_sects
= new_dump_sects
;
4622 dumpdata
->num_dump_sects
= section
+ 1;
4626 if (dumpdata
->dump_sects
)
4627 dumpdata
->dump_sects
[section
] |= type
;
4630 /* Request a dump by section name. */
4633 request_dump_byname (const char * section
, dump_type type
)
4635 struct dump_list_entry
* new_request
;
4637 new_request
= (struct dump_list_entry
*)
4638 malloc (sizeof (struct dump_list_entry
));
4640 error (_("Out of memory allocating dump request table.\n"));
4642 new_request
->name
= strdup (section
);
4643 if (!new_request
->name
)
4644 error (_("Out of memory allocating dump request table.\n"));
4646 new_request
->type
= type
;
4648 new_request
->next
= dump_sects_byname
;
4649 dump_sects_byname
= new_request
;
4653 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4659 section
= strtoul (optarg
, & cp
, 0);
4661 if (! *cp
&& section
>= 0)
4662 request_dump_bynumber (dumpdata
, section
, type
);
4664 request_dump_byname (optarg
, type
);
4668 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4675 while ((c
= getopt_long
4676 (argc
, argv
, "ADHILNR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4694 do_section_groups
= TRUE
;
4697 do_histogram
= TRUE
;
4702 do_section_groups
= TRUE
;
4707 do_section_details
= TRUE
;
4718 do_using_dynamic
= TRUE
;
4742 do_histogram
= TRUE
;
4748 do_archive_index
= TRUE
;
4754 request_dump (dumpdata
, HEX_DUMP
);
4757 request_dump (dumpdata
, STRING_DUMP
);
4760 request_dump (dumpdata
, RELOC_DUMP
);
4763 decompress_dumps
= TRUE
;
4769 do_debugging
= TRUE
;
4770 dwarf_select_sections_all ();
4774 do_debugging
= FALSE
;
4775 dwarf_select_sections_by_letters (optarg
);
4778 case OPTION_DEBUG_DUMP
:
4781 do_debugging
= TRUE
;
4784 do_debugging
= FALSE
;
4785 dwarf_select_sections_by_names (optarg
);
4788 case OPTION_DWARF_DEPTH
:
4792 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4795 case OPTION_DWARF_START
:
4799 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4802 case OPTION_DWARF_CHECK
:
4805 case OPTION_CTF_DUMP
:
4807 request_dump (dumpdata
, CTF_DUMP
);
4809 case OPTION_CTF_SYMBOLS
:
4810 dump_ctf_symtab_name
= strdup (optarg
);
4812 case OPTION_CTF_STRINGS
:
4813 dump_ctf_strtab_name
= strdup (optarg
);
4815 case OPTION_CTF_PARENT
:
4816 dump_ctf_parent_name
= strdup (optarg
);
4818 case OPTION_DYN_SYMS
:
4821 #ifdef SUPPORT_DISASSEMBLY
4823 request_dump (dumpdata
, DISASS_DUMP
);
4827 print_version (program_name
);
4836 /* xgettext:c-format */
4837 error (_("Invalid option '-%c'\n"), c
);
4844 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4845 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4846 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4847 && !do_section_groups
&& !do_archive_index
4853 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= TRUE
;
4854 do_segments
= do_header
= do_dump
= do_version
= TRUE
;
4855 do_histogram
= do_debugging
= do_arch
= do_notes
= TRUE
;
4856 do_section_groups
= do_archive_index
= do_dyn_syms
= TRUE
;
4864 get_elf_class (unsigned int elf_class
)
4866 static char buff
[32];
4870 case ELFCLASSNONE
: return _("none");
4871 case ELFCLASS32
: return "ELF32";
4872 case ELFCLASS64
: return "ELF64";
4874 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4880 get_data_encoding (unsigned int encoding
)
4882 static char buff
[32];
4886 case ELFDATANONE
: return _("none");
4887 case ELFDATA2LSB
: return _("2's complement, little endian");
4888 case ELFDATA2MSB
: return _("2's complement, big endian");
4890 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4895 /* Decode the data held in 'filedata->file_header'. */
4898 process_file_header (Filedata
* filedata
)
4900 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4902 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4903 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4904 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4905 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4908 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4912 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4918 printf (_("ELF Header:\n"));
4919 printf (_(" Magic: "));
4920 for (i
= 0; i
< EI_NIDENT
; i
++)
4921 printf ("%2.2x ", header
->e_ident
[i
]);
4923 printf (_(" Class: %s\n"),
4924 get_elf_class (header
->e_ident
[EI_CLASS
]));
4925 printf (_(" Data: %s\n"),
4926 get_data_encoding (header
->e_ident
[EI_DATA
]));
4927 printf (_(" Version: %d%s\n"),
4928 header
->e_ident
[EI_VERSION
],
4929 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4931 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4934 printf (_(" OS/ABI: %s\n"),
4935 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4936 printf (_(" ABI Version: %d\n"),
4937 header
->e_ident
[EI_ABIVERSION
]);
4938 printf (_(" Type: %s\n"),
4939 get_file_type (header
->e_type
));
4940 printf (_(" Machine: %s\n"),
4941 get_machine_name (header
->e_machine
));
4942 printf (_(" Version: 0x%lx\n"),
4945 printf (_(" Entry point address: "));
4946 print_vma (header
->e_entry
, PREFIX_HEX
);
4947 printf (_("\n Start of program headers: "));
4948 print_vma (header
->e_phoff
, DEC
);
4949 printf (_(" (bytes into file)\n Start of section headers: "));
4950 print_vma (header
->e_shoff
, DEC
);
4951 printf (_(" (bytes into file)\n"));
4953 printf (_(" Flags: 0x%lx%s\n"),
4955 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4956 printf (_(" Size of this header: %u (bytes)\n"),
4958 printf (_(" Size of program headers: %u (bytes)\n"),
4959 header
->e_phentsize
);
4960 printf (_(" Number of program headers: %u"),
4962 if (filedata
->section_headers
!= NULL
4963 && header
->e_phnum
== PN_XNUM
4964 && filedata
->section_headers
[0].sh_info
!= 0)
4966 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4967 printf (" (%u)", header
->e_phnum
);
4969 putc ('\n', stdout
);
4970 printf (_(" Size of section headers: %u (bytes)\n"),
4971 header
->e_shentsize
);
4972 printf (_(" Number of section headers: %u"),
4974 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4976 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4977 printf (" (%u)", header
->e_shnum
);
4979 putc ('\n', stdout
);
4980 printf (_(" Section header string table index: %u"),
4981 header
->e_shstrndx
);
4982 if (filedata
->section_headers
!= NULL
4983 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4985 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4986 printf (" (%u)", header
->e_shstrndx
);
4988 if (header
->e_shstrndx
!= SHN_UNDEF
4989 && header
->e_shstrndx
>= header
->e_shnum
)
4991 header
->e_shstrndx
= SHN_UNDEF
;
4992 printf (_(" <corrupt: out of range>"));
4994 putc ('\n', stdout
);
4997 if (filedata
->section_headers
!= NULL
)
4999 if (header
->e_phnum
== PN_XNUM
5000 && filedata
->section_headers
[0].sh_info
!= 0)
5001 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5002 if (header
->e_shnum
== SHN_UNDEF
)
5003 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5004 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5005 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5006 if (header
->e_shstrndx
>= header
->e_shnum
)
5007 header
->e_shstrndx
= SHN_UNDEF
;
5008 free (filedata
->section_headers
);
5009 filedata
->section_headers
= NULL
;
5015 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5016 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5019 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5021 Elf32_External_Phdr
* phdrs
;
5022 Elf32_External_Phdr
* external
;
5023 Elf_Internal_Phdr
* internal
;
5025 unsigned int size
= filedata
->file_header
.e_phentsize
;
5026 unsigned int num
= filedata
->file_header
.e_phnum
;
5028 /* PR binutils/17531: Cope with unexpected section header sizes. */
5029 if (size
== 0 || num
== 0)
5031 if (size
< sizeof * phdrs
)
5033 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5036 if (size
> sizeof * phdrs
)
5037 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5039 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5040 size
, num
, _("program headers"));
5044 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5045 i
< filedata
->file_header
.e_phnum
;
5046 i
++, internal
++, external
++)
5048 internal
->p_type
= BYTE_GET (external
->p_type
);
5049 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5050 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5051 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5052 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5053 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5054 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5055 internal
->p_align
= BYTE_GET (external
->p_align
);
5062 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5063 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5066 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5068 Elf64_External_Phdr
* phdrs
;
5069 Elf64_External_Phdr
* external
;
5070 Elf_Internal_Phdr
* internal
;
5072 unsigned int size
= filedata
->file_header
.e_phentsize
;
5073 unsigned int num
= filedata
->file_header
.e_phnum
;
5075 /* PR binutils/17531: Cope with unexpected section header sizes. */
5076 if (size
== 0 || num
== 0)
5078 if (size
< sizeof * phdrs
)
5080 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5083 if (size
> sizeof * phdrs
)
5084 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5086 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5087 size
, num
, _("program headers"));
5091 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5092 i
< filedata
->file_header
.e_phnum
;
5093 i
++, internal
++, external
++)
5095 internal
->p_type
= BYTE_GET (external
->p_type
);
5096 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5097 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5098 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5099 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5100 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5101 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5102 internal
->p_align
= BYTE_GET (external
->p_align
);
5109 /* Returns TRUE if the program headers were read into `program_headers'. */
5112 get_program_headers (Filedata
* filedata
)
5114 Elf_Internal_Phdr
* phdrs
;
5116 /* Check cache of prior read. */
5117 if (filedata
->program_headers
!= NULL
)
5120 /* Be kind to memory checkers by looking for
5121 e_phnum values which we know must be invalid. */
5122 if (filedata
->file_header
.e_phnum
5123 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5124 >= filedata
->file_size
)
5126 error (_("Too many program headers - %#x - the file is not that big\n"),
5127 filedata
->file_header
.e_phnum
);
5131 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5132 sizeof (Elf_Internal_Phdr
));
5135 error (_("Out of memory reading %u program headers\n"),
5136 filedata
->file_header
.e_phnum
);
5141 ? get_32bit_program_headers (filedata
, phdrs
)
5142 : get_64bit_program_headers (filedata
, phdrs
))
5144 filedata
->program_headers
= phdrs
;
5152 /* Returns TRUE if the program headers were loaded. */
5155 process_program_headers (Filedata
* filedata
)
5157 Elf_Internal_Phdr
* segment
;
5159 Elf_Internal_Phdr
* previous_load
= NULL
;
5161 filedata
->dynamic_addr
= 0;
5162 filedata
->dynamic_size
= 0;
5164 if (filedata
->file_header
.e_phnum
== 0)
5166 /* PR binutils/12467. */
5167 if (filedata
->file_header
.e_phoff
!= 0)
5169 warn (_("possibly corrupt ELF header - it has a non-zero program"
5170 " header offset, but no program headers\n"));
5173 else if (do_segments
)
5174 printf (_("\nThere are no program headers in this file.\n"));
5178 if (do_segments
&& !do_header
)
5180 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5181 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5182 printf (ngettext ("There is %d program header, starting at offset %s\n",
5183 "There are %d program headers, starting at offset %s\n",
5184 filedata
->file_header
.e_phnum
),
5185 filedata
->file_header
.e_phnum
,
5186 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5189 if (! get_program_headers (filedata
))
5194 if (filedata
->file_header
.e_phnum
> 1)
5195 printf (_("\nProgram Headers:\n"));
5197 printf (_("\nProgram Headers:\n"));
5201 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5204 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5208 (_(" Type Offset VirtAddr PhysAddr\n"));
5210 (_(" FileSiz MemSiz Flags Align\n"));
5214 for (i
= 0, segment
= filedata
->program_headers
;
5215 i
< filedata
->file_header
.e_phnum
;
5220 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5224 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5225 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5226 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5227 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5228 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5230 (segment
->p_flags
& PF_R
? 'R' : ' '),
5231 (segment
->p_flags
& PF_W
? 'W' : ' '),
5232 (segment
->p_flags
& PF_X
? 'E' : ' '));
5233 printf ("%#lx", (unsigned long) segment
->p_align
);
5237 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5238 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5241 print_vma (segment
->p_offset
, FULL_HEX
);
5245 print_vma (segment
->p_vaddr
, FULL_HEX
);
5247 print_vma (segment
->p_paddr
, FULL_HEX
);
5250 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5251 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5254 print_vma (segment
->p_filesz
, FULL_HEX
);
5258 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5259 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5262 print_vma (segment
->p_memsz
, FULL_HEX
);
5266 (segment
->p_flags
& PF_R
? 'R' : ' '),
5267 (segment
->p_flags
& PF_W
? 'W' : ' '),
5268 (segment
->p_flags
& PF_X
? 'E' : ' '));
5270 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5271 printf ("%#lx", (unsigned long) segment
->p_align
);
5274 print_vma (segment
->p_align
, PREFIX_HEX
);
5279 print_vma (segment
->p_offset
, FULL_HEX
);
5281 print_vma (segment
->p_vaddr
, FULL_HEX
);
5283 print_vma (segment
->p_paddr
, FULL_HEX
);
5285 print_vma (segment
->p_filesz
, FULL_HEX
);
5287 print_vma (segment
->p_memsz
, FULL_HEX
);
5289 (segment
->p_flags
& PF_R
? 'R' : ' '),
5290 (segment
->p_flags
& PF_W
? 'W' : ' '),
5291 (segment
->p_flags
& PF_X
? 'E' : ' '));
5292 print_vma (segment
->p_align
, PREFIX_HEX
);
5295 putc ('\n', stdout
);
5298 switch (segment
->p_type
)
5301 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5302 required by the ELF standard, several programs, including the Linux
5303 kernel, make use of non-ordered segments. */
5305 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5306 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5308 if (segment
->p_memsz
< segment
->p_filesz
)
5309 error (_("the segment's file size is larger than its memory size\n"));
5310 previous_load
= segment
;
5314 /* PR 20815 - Verify that the program header is loaded into memory. */
5315 if (i
> 0 && previous_load
!= NULL
)
5316 error (_("the PHDR segment must occur before any LOAD segment\n"));
5317 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5321 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5323 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5324 if (load
->p_type
== PT_LOAD
5325 && load
->p_offset
<= segment
->p_offset
5326 && (load
->p_offset
+ load
->p_filesz
5327 >= segment
->p_offset
+ segment
->p_filesz
)
5328 && load
->p_vaddr
<= segment
->p_vaddr
5329 && (load
->p_vaddr
+ load
->p_filesz
5330 >= segment
->p_vaddr
+ segment
->p_filesz
))
5333 if (j
== filedata
->file_header
.e_phnum
)
5334 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5339 if (filedata
->dynamic_addr
)
5340 error (_("more than one dynamic segment\n"));
5342 /* By default, assume that the .dynamic section is the first
5343 section in the DYNAMIC segment. */
5344 filedata
->dynamic_addr
= segment
->p_offset
;
5345 filedata
->dynamic_size
= segment
->p_filesz
;
5347 /* Try to locate the .dynamic section. If there is
5348 a section header table, we can easily locate it. */
5349 if (filedata
->section_headers
!= NULL
)
5351 Elf_Internal_Shdr
* sec
;
5353 sec
= find_section (filedata
, ".dynamic");
5354 if (sec
== NULL
|| sec
->sh_size
== 0)
5356 /* A corresponding .dynamic section is expected, but on
5357 IA-64/OpenVMS it is OK for it to be missing. */
5358 if (!is_ia64_vms (filedata
))
5359 error (_("no .dynamic section in the dynamic segment\n"));
5363 if (sec
->sh_type
== SHT_NOBITS
)
5365 filedata
->dynamic_size
= 0;
5369 filedata
->dynamic_addr
= sec
->sh_offset
;
5370 filedata
->dynamic_size
= sec
->sh_size
;
5372 /* The PT_DYNAMIC segment, which is used by the run-time
5373 loader, should exactly match the .dynamic section. */
5375 && (filedata
->dynamic_addr
!= segment
->p_offset
5376 || filedata
->dynamic_size
!= segment
->p_filesz
))
5378 the .dynamic section is not the same as the dynamic segment\n"));
5381 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5382 segment. Check this after matching against the section headers
5383 so we don't warn on debuginfo file (which have NOBITS .dynamic
5385 if (filedata
->dynamic_addr
> filedata
->file_size
5386 || (filedata
->dynamic_size
5387 > filedata
->file_size
- filedata
->dynamic_addr
))
5389 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5390 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5395 if (fseek (filedata
->handle
,
5396 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5398 error (_("Unable to find program interpreter name\n"));
5402 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5404 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5405 error (_("Internal error: failed to create format string to display program interpreter\n"));
5407 filedata
->program_interpreter
[0] = 0;
5408 if (fscanf (filedata
->handle
, fmt
,
5409 filedata
->program_interpreter
) <= 0)
5410 error (_("Unable to read program interpreter name\n"));
5413 printf (_(" [Requesting program interpreter: %s]\n"),
5414 filedata
->program_interpreter
);
5421 && filedata
->section_headers
!= NULL
5422 && filedata
->string_table
!= NULL
)
5424 printf (_("\n Section to Segment mapping:\n"));
5425 printf (_(" Segment Sections...\n"));
5427 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5430 Elf_Internal_Shdr
* section
;
5432 segment
= filedata
->program_headers
+ i
;
5433 section
= filedata
->section_headers
+ 1;
5435 printf (" %2.2d ", i
);
5437 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5439 if (!ELF_TBSS_SPECIAL (section
, segment
)
5440 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5441 printf ("%s ", printable_section_name (filedata
, section
));
5452 /* Find the file offset corresponding to VMA by using the program headers. */
5455 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5457 Elf_Internal_Phdr
* seg
;
5459 if (! get_program_headers (filedata
))
5461 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5465 for (seg
= filedata
->program_headers
;
5466 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5469 if (seg
->p_type
!= PT_LOAD
)
5472 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5473 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5474 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5477 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5478 (unsigned long) vma
);
5483 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5484 If PROBE is true, this is just a probe and we do not generate any error
5485 messages if the load fails. */
5488 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5490 Elf32_External_Shdr
* shdrs
;
5491 Elf_Internal_Shdr
* internal
;
5493 unsigned int size
= filedata
->file_header
.e_shentsize
;
5494 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5496 /* PR binutils/17531: Cope with unexpected section header sizes. */
5497 if (size
== 0 || num
== 0)
5499 if (size
< sizeof * shdrs
)
5502 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5505 if (!probe
&& size
> sizeof * shdrs
)
5506 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5508 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5510 probe
? NULL
: _("section headers"));
5514 free (filedata
->section_headers
);
5515 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5516 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5517 if (filedata
->section_headers
== NULL
)
5520 error (_("Out of memory reading %u section headers\n"), num
);
5525 for (i
= 0, internal
= filedata
->section_headers
;
5529 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5530 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5531 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5532 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5533 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5534 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5535 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5536 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5537 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5538 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5539 if (!probe
&& internal
->sh_link
> num
)
5540 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5541 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5542 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5549 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5552 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5554 Elf64_External_Shdr
* shdrs
;
5555 Elf_Internal_Shdr
* internal
;
5557 unsigned int size
= filedata
->file_header
.e_shentsize
;
5558 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5560 /* PR binutils/17531: Cope with unexpected section header sizes. */
5561 if (size
== 0 || num
== 0)
5564 if (size
< sizeof * shdrs
)
5567 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5571 if (! probe
&& size
> sizeof * shdrs
)
5572 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5574 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5575 filedata
->file_header
.e_shoff
,
5577 probe
? NULL
: _("section headers"));
5581 free (filedata
->section_headers
);
5582 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5583 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5584 if (filedata
->section_headers
== NULL
)
5587 error (_("Out of memory reading %u section headers\n"), num
);
5592 for (i
= 0, internal
= filedata
->section_headers
;
5596 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5597 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5598 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5599 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5600 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5601 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5602 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5603 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5604 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5605 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5606 if (!probe
&& internal
->sh_link
> num
)
5607 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5608 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5609 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5616 static Elf_Internal_Sym
*
5617 get_32bit_elf_symbols (Filedata
* filedata
,
5618 Elf_Internal_Shdr
* section
,
5619 unsigned long * num_syms_return
)
5621 unsigned long number
= 0;
5622 Elf32_External_Sym
* esyms
= NULL
;
5623 Elf_External_Sym_Shndx
* shndx
= NULL
;
5624 Elf_Internal_Sym
* isyms
= NULL
;
5625 Elf_Internal_Sym
* psym
;
5627 elf_section_list
* entry
;
5629 if (section
->sh_size
== 0)
5631 if (num_syms_return
!= NULL
)
5632 * num_syms_return
= 0;
5636 /* Run some sanity checks first. */
5637 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5639 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5640 printable_section_name (filedata
, section
),
5641 (unsigned long) section
->sh_entsize
);
5645 if (section
->sh_size
> filedata
->file_size
)
5647 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5648 printable_section_name (filedata
, section
),
5649 (unsigned long) section
->sh_size
);
5653 number
= section
->sh_size
/ section
->sh_entsize
;
5655 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5657 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5658 (unsigned long) section
->sh_size
,
5659 printable_section_name (filedata
, section
),
5660 (unsigned long) section
->sh_entsize
);
5664 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5665 section
->sh_size
, _("symbols"));
5670 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5672 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5677 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5681 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5682 entry
->hdr
->sh_offset
,
5683 1, entry
->hdr
->sh_size
,
5684 _("symbol table section indices"));
5688 /* PR17531: file: heap-buffer-overflow */
5689 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5691 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5692 printable_section_name (filedata
, entry
->hdr
),
5693 (unsigned long) entry
->hdr
->sh_size
,
5694 (unsigned long) section
->sh_size
);
5699 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5703 error (_("Out of memory reading %lu symbols\n"),
5704 (unsigned long) number
);
5708 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5710 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5711 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5712 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5713 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5714 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5716 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5717 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5718 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5719 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5720 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5727 if (num_syms_return
!= NULL
)
5728 * num_syms_return
= isyms
== NULL
? 0 : number
;
5733 static Elf_Internal_Sym
*
5734 get_64bit_elf_symbols (Filedata
* filedata
,
5735 Elf_Internal_Shdr
* section
,
5736 unsigned long * num_syms_return
)
5738 unsigned long number
= 0;
5739 Elf64_External_Sym
* esyms
= NULL
;
5740 Elf_External_Sym_Shndx
* shndx
= NULL
;
5741 Elf_Internal_Sym
* isyms
= NULL
;
5742 Elf_Internal_Sym
* psym
;
5744 elf_section_list
* entry
;
5746 if (section
->sh_size
== 0)
5748 if (num_syms_return
!= NULL
)
5749 * num_syms_return
= 0;
5753 /* Run some sanity checks first. */
5754 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5756 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5757 printable_section_name (filedata
, section
),
5758 (unsigned long) section
->sh_entsize
);
5762 if (section
->sh_size
> filedata
->file_size
)
5764 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5765 printable_section_name (filedata
, section
),
5766 (unsigned long) section
->sh_size
);
5770 number
= section
->sh_size
/ section
->sh_entsize
;
5772 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5774 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5775 (unsigned long) section
->sh_size
,
5776 printable_section_name (filedata
, section
),
5777 (unsigned long) section
->sh_entsize
);
5781 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5782 section
->sh_size
, _("symbols"));
5787 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5789 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5794 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5798 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5799 entry
->hdr
->sh_offset
,
5800 1, entry
->hdr
->sh_size
,
5801 _("symbol table section indices"));
5805 /* PR17531: file: heap-buffer-overflow */
5806 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5808 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5809 printable_section_name (filedata
, entry
->hdr
),
5810 (unsigned long) entry
->hdr
->sh_size
,
5811 (unsigned long) section
->sh_size
);
5816 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5820 error (_("Out of memory reading %lu symbols\n"),
5821 (unsigned long) number
);
5825 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5827 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5828 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5829 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5830 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5832 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5834 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5835 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5836 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5838 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5839 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5846 if (num_syms_return
!= NULL
)
5847 * num_syms_return
= isyms
== NULL
? 0 : number
;
5853 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5855 static char buff
[1024];
5857 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5859 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5860 bfd_vma os_flags
= 0;
5861 bfd_vma proc_flags
= 0;
5862 bfd_vma unknown_flags
= 0;
5870 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5871 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5872 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5873 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5874 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5875 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5876 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5877 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5878 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5879 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5880 /* IA-64 specific. */
5881 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5882 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5883 /* IA-64 OpenVMS specific. */
5884 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5885 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5886 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5887 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5888 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5889 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5891 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5892 /* SPARC specific. */
5893 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5894 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5896 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5897 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5898 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5900 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5902 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5905 if (do_section_details
)
5907 sprintf (buff
, "[%*.*lx]: ",
5908 field_size
, field_size
, (unsigned long) sh_flags
);
5909 p
+= field_size
+ 4;
5916 flag
= sh_flags
& - sh_flags
;
5919 if (do_section_details
)
5923 case SHF_WRITE
: sindex
= 0; break;
5924 case SHF_ALLOC
: sindex
= 1; break;
5925 case SHF_EXECINSTR
: sindex
= 2; break;
5926 case SHF_MERGE
: sindex
= 3; break;
5927 case SHF_STRINGS
: sindex
= 4; break;
5928 case SHF_INFO_LINK
: sindex
= 5; break;
5929 case SHF_LINK_ORDER
: sindex
= 6; break;
5930 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5931 case SHF_GROUP
: sindex
= 8; break;
5932 case SHF_TLS
: sindex
= 9; break;
5933 case SHF_EXCLUDE
: sindex
= 18; break;
5934 case SHF_COMPRESSED
: sindex
= 20; break;
5935 case SHF_GNU_MBIND
: sindex
= 24; break;
5939 switch (filedata
->file_header
.e_machine
)
5942 if (flag
== SHF_IA_64_SHORT
)
5944 else if (flag
== SHF_IA_64_NORECOV
)
5947 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5950 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5951 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5952 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5953 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5954 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5955 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5966 case EM_OLD_SPARCV9
:
5967 case EM_SPARC32PLUS
:
5970 if (flag
== SHF_ORDERED
)
5977 case SHF_ENTRYSECT
: sindex
= 21; break;
5978 case SHF_ARM_PURECODE
: sindex
= 22; break;
5979 case SHF_COMDEF
: sindex
= 23; break;
5984 if (flag
== SHF_PPC_VLE
)
5995 if (p
!= buff
+ field_size
+ 4)
5997 if (size
< (10 + 2))
5999 warn (_("Internal error: not enough buffer room for section flag info"));
6000 return _("<unknown>");
6007 size
-= flags
[sindex
].len
;
6008 p
= stpcpy (p
, flags
[sindex
].str
);
6010 else if (flag
& SHF_MASKOS
)
6012 else if (flag
& SHF_MASKPROC
)
6015 unknown_flags
|= flag
;
6021 case SHF_WRITE
: *p
= 'W'; break;
6022 case SHF_ALLOC
: *p
= 'A'; break;
6023 case SHF_EXECINSTR
: *p
= 'X'; break;
6024 case SHF_MERGE
: *p
= 'M'; break;
6025 case SHF_STRINGS
: *p
= 'S'; break;
6026 case SHF_INFO_LINK
: *p
= 'I'; break;
6027 case SHF_LINK_ORDER
: *p
= 'L'; break;
6028 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6029 case SHF_GROUP
: *p
= 'G'; break;
6030 case SHF_TLS
: *p
= 'T'; break;
6031 case SHF_EXCLUDE
: *p
= 'E'; break;
6032 case SHF_COMPRESSED
: *p
= 'C'; break;
6033 case SHF_GNU_MBIND
: *p
= 'D'; break;
6036 if ((filedata
->file_header
.e_machine
== EM_X86_64
6037 || filedata
->file_header
.e_machine
== EM_L1OM
6038 || filedata
->file_header
.e_machine
== EM_K1OM
)
6039 && flag
== SHF_X86_64_LARGE
)
6041 else if (filedata
->file_header
.e_machine
== EM_ARM
6042 && flag
== SHF_ARM_PURECODE
)
6044 else if (filedata
->file_header
.e_machine
== EM_PPC
6045 && flag
== SHF_PPC_VLE
)
6047 else if (flag
& SHF_MASKOS
)
6050 sh_flags
&= ~ SHF_MASKOS
;
6052 else if (flag
& SHF_MASKPROC
)
6055 sh_flags
&= ~ SHF_MASKPROC
;
6065 if (do_section_details
)
6069 size
-= 5 + field_size
;
6070 if (p
!= buff
+ field_size
+ 4)
6074 warn (_("Internal error: not enough buffer room for section flag info"));
6075 return _("<unknown>");
6081 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6082 (unsigned long) os_flags
);
6083 p
+= 5 + field_size
;
6087 size
-= 7 + field_size
;
6088 if (p
!= buff
+ field_size
+ 4)
6092 warn (_("Internal error: not enough buffer room for section flag info"));
6093 return _("<unknown>");
6099 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6100 (unsigned long) proc_flags
);
6101 p
+= 7 + field_size
;
6105 size
-= 10 + field_size
;
6106 if (p
!= buff
+ field_size
+ 4)
6110 warn (_("Internal error: not enough buffer room for section flag info"));
6111 return _("<unknown>");
6117 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6118 (unsigned long) unknown_flags
);
6119 p
+= 10 + field_size
;
6127 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6128 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6132 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6134 if (size
< sizeof (* echdr
))
6136 error (_("Compressed section is too small even for a compression header\n"));
6140 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6141 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6142 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6143 return sizeof (*echdr
);
6147 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6149 if (size
< sizeof (* echdr
))
6151 error (_("Compressed section is too small even for a compression header\n"));
6155 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6156 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6157 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6158 return sizeof (*echdr
);
6163 process_section_headers (Filedata
* filedata
)
6165 Elf_Internal_Shdr
* section
;
6168 free (filedata
->section_headers
);
6169 filedata
->section_headers
= NULL
;
6170 free (filedata
->dynamic_symbols
);
6171 filedata
->dynamic_symbols
= NULL
;
6172 filedata
->num_dynamic_syms
= 0;
6173 free (filedata
->dynamic_strings
);
6174 filedata
->dynamic_strings
= NULL
;
6175 filedata
->dynamic_strings_length
= 0;
6176 free (filedata
->dynamic_syminfo
);
6177 filedata
->dynamic_syminfo
= NULL
;
6178 while (filedata
->symtab_shndx_list
!= NULL
)
6180 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6181 free (filedata
->symtab_shndx_list
);
6182 filedata
->symtab_shndx_list
= next
;
6185 if (filedata
->file_header
.e_shnum
== 0)
6187 /* PR binutils/12467. */
6188 if (filedata
->file_header
.e_shoff
!= 0)
6190 warn (_("possibly corrupt ELF file header - it has a non-zero"
6191 " section header offset, but no section headers\n"));
6194 else if (do_sections
)
6195 printf (_("\nThere are no sections in this file.\n"));
6200 if (do_sections
&& !do_header
)
6201 printf (ngettext ("There is %d section header, "
6202 "starting at offset 0x%lx:\n",
6203 "There are %d section headers, "
6204 "starting at offset 0x%lx:\n",
6205 filedata
->file_header
.e_shnum
),
6206 filedata
->file_header
.e_shnum
,
6207 (unsigned long) filedata
->file_header
.e_shoff
);
6211 if (! get_32bit_section_headers (filedata
, FALSE
))
6216 if (! get_64bit_section_headers (filedata
, FALSE
))
6220 /* Read in the string table, so that we have names to display. */
6221 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6222 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6224 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6226 if (section
->sh_size
!= 0)
6228 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6229 1, section
->sh_size
,
6232 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6236 /* Scan the sections for the dynamic symbol table
6237 and dynamic string table and debug sections. */
6238 eh_addr_size
= is_32bit_elf
? 4 : 8;
6239 switch (filedata
->file_header
.e_machine
)
6242 case EM_MIPS_RS3_LE
:
6243 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6244 FDE addresses. However, the ABI also has a semi-official ILP32
6245 variant for which the normal FDE address size rules apply.
6247 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6248 section, where XX is the size of longs in bits. Unfortunately,
6249 earlier compilers provided no way of distinguishing ILP32 objects
6250 from LP64 objects, so if there's any doubt, we should assume that
6251 the official LP64 form is being used. */
6252 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6253 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6259 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6261 case E_H8_MACH_H8300
:
6262 case E_H8_MACH_H8300HN
:
6263 case E_H8_MACH_H8300SN
:
6264 case E_H8_MACH_H8300SXN
:
6267 case E_H8_MACH_H8300H
:
6268 case E_H8_MACH_H8300S
:
6269 case E_H8_MACH_H8300SX
:
6277 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6279 case EF_M32C_CPU_M16C
:
6286 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6289 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6290 if (section->sh_entsize != expected_entsize) \
6293 sprintf_vma (buf, section->sh_entsize); \
6294 /* Note: coded this way so that there is a single string for \
6296 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6297 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6298 (unsigned) expected_entsize); \
6299 section->sh_entsize = expected_entsize; \
6304 #define CHECK_ENTSIZE(section, i, type) \
6305 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6306 sizeof (Elf64_External_##type))
6308 for (i
= 0, section
= filedata
->section_headers
;
6309 i
< filedata
->file_header
.e_shnum
;
6312 char * name
= SECTION_NAME (section
);
6314 /* Run some sanity checks on the headers and
6315 possibly fill in some file data as well. */
6316 switch (section
->sh_type
)
6319 if (filedata
->dynamic_symbols
!= NULL
)
6321 error (_("File contains multiple dynamic symbol tables\n"));
6325 CHECK_ENTSIZE (section
, i
, Sym
);
6326 filedata
->dynamic_symbols
6327 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6328 filedata
->dynamic_symtab_section
= section
;
6332 if (streq (name
, ".dynstr"))
6334 if (filedata
->dynamic_strings
!= NULL
)
6336 error (_("File contains multiple dynamic string tables\n"));
6340 filedata
->dynamic_strings
6341 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6342 1, section
->sh_size
, _("dynamic strings"));
6343 filedata
->dynamic_strings_length
6344 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6345 filedata
->dynamic_strtab_section
= section
;
6349 case SHT_SYMTAB_SHNDX
:
6351 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6353 entry
->hdr
= section
;
6354 entry
->next
= filedata
->symtab_shndx_list
;
6355 filedata
->symtab_shndx_list
= entry
;
6360 CHECK_ENTSIZE (section
, i
, Sym
);
6364 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6368 CHECK_ENTSIZE (section
, i
, Rel
);
6369 if (do_checks
&& section
->sh_size
== 0)
6370 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6374 CHECK_ENTSIZE (section
, i
, Rela
);
6375 if (do_checks
&& section
->sh_size
== 0)
6376 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6381 /* Having a zero sized section is not illegal according to the
6382 ELF standard, but it might be an indication that something
6383 is wrong. So issue a warning if we are running in lint mode. */
6384 if (do_checks
&& section
->sh_size
== 0)
6385 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6392 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6393 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6394 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6395 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
|| do_debug_ranges
6396 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6397 && (const_strneq (name
, ".debug_")
6398 || const_strneq (name
, ".zdebug_")))
6401 name
+= sizeof (".zdebug_") - 1;
6403 name
+= sizeof (".debug_") - 1;
6406 || (do_debug_info
&& const_strneq (name
, "info"))
6407 || (do_debug_info
&& const_strneq (name
, "types"))
6408 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6409 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6410 || (do_debug_lines
&& const_strneq (name
, "line."))
6411 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6412 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6413 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6414 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6415 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6416 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6417 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6418 || (do_debug_frames
&& const_strneq (name
, "frame"))
6419 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6420 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6421 || (do_debug_str
&& const_strneq (name
, "str"))
6422 || (do_debug_str_offsets
&& const_strneq (name
, "str_offsets"))
6423 || (do_debug_loc
&& const_strneq (name
, "loc"))
6424 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6425 || (do_debug_addr
&& const_strneq (name
, "addr"))
6426 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6427 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6429 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6431 /* Linkonce section to be combined with .debug_info at link time. */
6432 else if ((do_debugging
|| do_debug_info
)
6433 && const_strneq (name
, ".gnu.linkonce.wi."))
6434 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6435 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6436 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6437 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6438 || streq (name
, ".debug_names")))
6439 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6440 /* Trace sections for Itanium VMS. */
6441 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6442 || do_trace_aranges
)
6443 && const_strneq (name
, ".trace_"))
6445 name
+= sizeof (".trace_") - 1;
6448 || (do_trace_info
&& streq (name
, "info"))
6449 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6450 || (do_trace_aranges
&& streq (name
, "aranges"))
6452 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6454 else if ((do_debugging
|| do_debug_links
)
6455 && (const_strneq (name
, ".gnu_debuglink")
6456 || const_strneq (name
, ".gnu_debugaltlink")))
6457 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6463 if (filedata
->file_header
.e_shnum
> 1)
6464 printf (_("\nSection Headers:\n"));
6466 printf (_("\nSection Header:\n"));
6470 if (do_section_details
)
6472 printf (_(" [Nr] Name\n"));
6473 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6477 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6481 if (do_section_details
)
6483 printf (_(" [Nr] Name\n"));
6484 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6488 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6492 if (do_section_details
)
6494 printf (_(" [Nr] Name\n"));
6495 printf (_(" Type Address Offset Link\n"));
6496 printf (_(" Size EntSize Info Align\n"));
6500 printf (_(" [Nr] Name Type Address Offset\n"));
6501 printf (_(" Size EntSize Flags Link Info Align\n"));
6505 if (do_section_details
)
6506 printf (_(" Flags\n"));
6508 for (i
= 0, section
= filedata
->section_headers
;
6509 i
< filedata
->file_header
.e_shnum
;
6512 /* Run some sanity checks on the section header. */
6514 /* Check the sh_link field. */
6515 switch (section
->sh_type
)
6519 if (section
->sh_link
== 0
6520 && (filedata
->file_header
.e_type
== ET_EXEC
6521 || filedata
->file_header
.e_type
== ET_DYN
))
6522 /* A dynamic relocation section where all entries use a
6523 zero symbol index need not specify a symtab section. */
6526 case SHT_SYMTAB_SHNDX
:
6530 case SHT_GNU_versym
:
6531 if (section
->sh_link
== 0
6532 || section
->sh_link
>= filedata
->file_header
.e_shnum
6533 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6534 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6535 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6536 i
, section
->sh_link
);
6542 case SHT_GNU_verneed
:
6543 case SHT_GNU_verdef
:
6544 case SHT_GNU_LIBLIST
:
6545 if (section
->sh_link
== 0
6546 || section
->sh_link
>= filedata
->file_header
.e_shnum
6547 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6548 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6549 i
, section
->sh_link
);
6552 case SHT_INIT_ARRAY
:
6553 case SHT_FINI_ARRAY
:
6554 case SHT_PREINIT_ARRAY
:
6555 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6556 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6557 i
, section
->sh_link
);
6561 /* FIXME: Add support for target specific section types. */
6562 #if 0 /* Currently we do not check other section types as there are too
6563 many special cases. Stab sections for example have a type
6564 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6566 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6567 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6568 i
, section
->sh_link
);
6573 /* Check the sh_info field. */
6574 switch (section
->sh_type
)
6578 if (section
->sh_info
== 0
6579 && (filedata
->file_header
.e_type
== ET_EXEC
6580 || filedata
->file_header
.e_type
== ET_DYN
))
6581 /* Dynamic relocations apply to segments, so they do not
6582 need to specify the section they relocate. */
6584 if (section
->sh_info
== 0
6585 || section
->sh_info
>= filedata
->file_header
.e_shnum
6586 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6587 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6588 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6589 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6590 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6591 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6592 /* FIXME: Are other section types valid ? */
6593 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6594 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6595 i
, section
->sh_info
);
6600 case SHT_SYMTAB_SHNDX
:
6601 case SHT_INIT_ARRAY
:
6602 case SHT_FINI_ARRAY
:
6603 case SHT_PREINIT_ARRAY
:
6604 if (section
->sh_info
!= 0)
6605 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6606 i
, section
->sh_info
);
6612 /* A symbol index - we assume that it is valid. */
6616 /* FIXME: Add support for target specific section types. */
6617 if (section
->sh_type
== SHT_NOBITS
)
6618 /* NOBITS section headers with non-zero sh_info fields can be
6619 created when a binary is stripped of everything but its debug
6620 information. The stripped sections have their headers
6621 preserved but their types set to SHT_NOBITS. So do not check
6622 this type of section. */
6624 else if (section
->sh_flags
& SHF_INFO_LINK
)
6626 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6627 warn (_("[%2u]: Expected link to another section in info field"), i
);
6629 else if (section
->sh_type
< SHT_LOOS
6630 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6631 && section
->sh_info
!= 0)
6632 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6633 i
, section
->sh_info
);
6637 /* Check the sh_size field. */
6638 if (section
->sh_size
> filedata
->file_size
6639 && section
->sh_type
!= SHT_NOBITS
6640 && section
->sh_type
!= SHT_NULL
6641 && section
->sh_type
< SHT_LOOS
)
6642 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6644 printf (" [%2u] ", i
);
6645 if (do_section_details
)
6646 printf ("%s\n ", printable_section_name (filedata
, section
));
6648 print_symbol (-17, SECTION_NAME (section
));
6650 printf (do_wide
? " %-15s " : " %-15.15s ",
6651 get_section_type_name (filedata
, section
->sh_type
));
6655 const char * link_too_big
= NULL
;
6657 print_vma (section
->sh_addr
, LONG_HEX
);
6659 printf ( " %6.6lx %6.6lx %2.2lx",
6660 (unsigned long) section
->sh_offset
,
6661 (unsigned long) section
->sh_size
,
6662 (unsigned long) section
->sh_entsize
);
6664 if (do_section_details
)
6665 fputs (" ", stdout
);
6667 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6669 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6672 /* The sh_link value is out of range. Normally this indicates
6673 an error but it can have special values in Solaris binaries. */
6674 switch (filedata
->file_header
.e_machine
)
6681 case EM_OLD_SPARCV9
:
6682 case EM_SPARC32PLUS
:
6685 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6686 link_too_big
= "BEFORE";
6687 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6688 link_too_big
= "AFTER";
6695 if (do_section_details
)
6697 if (link_too_big
!= NULL
&& * link_too_big
)
6698 printf ("<%s> ", link_too_big
);
6700 printf ("%2u ", section
->sh_link
);
6701 printf ("%3u %2lu\n", section
->sh_info
,
6702 (unsigned long) section
->sh_addralign
);
6705 printf ("%2u %3u %2lu\n",
6708 (unsigned long) section
->sh_addralign
);
6710 if (link_too_big
&& ! * link_too_big
)
6711 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6712 i
, section
->sh_link
);
6716 print_vma (section
->sh_addr
, LONG_HEX
);
6718 if ((long) section
->sh_offset
== section
->sh_offset
)
6719 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6723 print_vma (section
->sh_offset
, LONG_HEX
);
6726 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6727 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6731 print_vma (section
->sh_size
, LONG_HEX
);
6734 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6735 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6739 print_vma (section
->sh_entsize
, LONG_HEX
);
6742 if (do_section_details
)
6743 fputs (" ", stdout
);
6745 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6747 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6749 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6750 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6753 print_vma (section
->sh_addralign
, DEC
);
6757 else if (do_section_details
)
6760 print_vma (section
->sh_addr
, LONG_HEX
);
6761 if ((long) section
->sh_offset
== section
->sh_offset
)
6762 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6766 print_vma (section
->sh_offset
, LONG_HEX
);
6768 printf (" %u\n ", section
->sh_link
);
6769 print_vma (section
->sh_size
, LONG_HEX
);
6771 print_vma (section
->sh_entsize
, LONG_HEX
);
6773 printf (" %-16u %lu\n",
6775 (unsigned long) section
->sh_addralign
);
6780 print_vma (section
->sh_addr
, LONG_HEX
);
6781 if ((long) section
->sh_offset
== section
->sh_offset
)
6782 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6786 print_vma (section
->sh_offset
, LONG_HEX
);
6789 print_vma (section
->sh_size
, LONG_HEX
);
6791 print_vma (section
->sh_entsize
, LONG_HEX
);
6793 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6795 printf (" %2u %3u %lu\n",
6798 (unsigned long) section
->sh_addralign
);
6801 if (do_section_details
)
6803 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6804 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6806 /* Minimum section size is 12 bytes for 32-bit compression
6807 header + 12 bytes for compressed data header. */
6808 unsigned char buf
[24];
6810 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6811 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6812 sizeof (buf
), _("compression header")))
6814 Elf_Internal_Chdr chdr
;
6816 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6817 printf (_(" [<corrupt>]\n"));
6820 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6823 printf (_(" [<unknown>: 0x%x], "),
6825 print_vma (chdr
.ch_size
, LONG_HEX
);
6826 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6833 if (!do_section_details
)
6835 /* The ordering of the letters shown here matches the ordering of the
6836 corresponding SHF_xxx values, and hence the order in which these
6837 letters will be displayed to the user. */
6838 printf (_("Key to Flags:\n\
6839 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6840 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6841 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6842 if (filedata
->file_header
.e_machine
== EM_X86_64
6843 || filedata
->file_header
.e_machine
== EM_L1OM
6844 || filedata
->file_header
.e_machine
== EM_K1OM
)
6845 printf (_("l (large), "));
6846 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6847 printf (_("y (purecode), "));
6848 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6849 printf (_("v (VLE), "));
6850 printf ("p (processor specific)\n");
6857 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6858 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6859 char **strtab
, unsigned long *strtablen
)
6863 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6865 if (*symtab
== NULL
)
6868 if (symsec
->sh_link
!= 0)
6870 Elf_Internal_Shdr
*strsec
;
6872 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6874 error (_("Bad sh_link in symbol table section\n"));
6881 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6883 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6884 1, strsec
->sh_size
, _("string table"));
6885 if (*strtab
== NULL
)
6892 *strtablen
= strsec
->sh_size
;
6898 get_group_flags (unsigned int flags
)
6900 static char buff
[128];
6904 else if (flags
== GRP_COMDAT
)
6907 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6909 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6910 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6911 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6912 ? _("<unknown>") : ""));
6918 process_section_groups (Filedata
* filedata
)
6920 Elf_Internal_Shdr
* section
;
6922 struct group
* group
;
6923 Elf_Internal_Shdr
* symtab_sec
;
6924 Elf_Internal_Shdr
* strtab_sec
;
6925 Elf_Internal_Sym
* symtab
;
6926 unsigned long num_syms
;
6930 /* Don't process section groups unless needed. */
6931 if (!do_unwind
&& !do_section_groups
)
6934 if (filedata
->file_header
.e_shnum
== 0)
6936 if (do_section_groups
)
6937 printf (_("\nThere are no sections to group in this file.\n"));
6942 if (filedata
->section_headers
== NULL
)
6944 error (_("Section headers are not available!\n"));
6945 /* PR 13622: This can happen with a corrupt ELF header. */
6949 filedata
->section_headers_groups
6950 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6951 sizeof (struct group
*));
6953 if (filedata
->section_headers_groups
== NULL
)
6955 error (_("Out of memory reading %u section group headers\n"),
6956 filedata
->file_header
.e_shnum
);
6960 /* Scan the sections for the group section. */
6961 filedata
->group_count
= 0;
6962 for (i
= 0, section
= filedata
->section_headers
;
6963 i
< filedata
->file_header
.e_shnum
;
6965 if (section
->sh_type
== SHT_GROUP
)
6966 filedata
->group_count
++;
6968 if (filedata
->group_count
== 0)
6970 if (do_section_groups
)
6971 printf (_("\nThere are no section groups in this file.\n"));
6976 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
6977 sizeof (struct group
));
6979 if (filedata
->section_groups
== NULL
)
6981 error (_("Out of memory reading %lu groups\n"),
6982 (unsigned long) filedata
->group_count
);
6992 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
6993 i
< filedata
->file_header
.e_shnum
;
6996 if (section
->sh_type
== SHT_GROUP
)
6998 const char * name
= printable_section_name (filedata
, section
);
6999 const char * group_name
;
7000 unsigned char * start
;
7001 unsigned char * indices
;
7002 unsigned int entry
, j
, size
;
7003 Elf_Internal_Shdr
* sec
;
7004 Elf_Internal_Sym
* sym
;
7006 /* Get the symbol table. */
7007 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7008 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7011 error (_("Bad sh_link in group section `%s'\n"), name
);
7015 if (symtab_sec
!= sec
)
7019 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7024 error (_("Corrupt header in group section `%s'\n"), name
);
7028 if (section
->sh_info
>= num_syms
)
7030 error (_("Bad sh_info in group section `%s'\n"), name
);
7034 sym
= symtab
+ section
->sh_info
;
7036 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7038 if (sym
->st_shndx
== 0
7039 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7041 error (_("Bad sh_info in group section `%s'\n"), name
);
7045 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
7053 /* Get the string table. */
7054 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7062 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7067 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7068 1, strtab_sec
->sh_size
,
7070 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7072 group_name
= sym
->st_name
< strtab_size
7073 ? strtab
+ sym
->st_name
: _("<corrupt>");
7076 /* PR 17531: file: loop. */
7077 if (section
->sh_entsize
> section
->sh_size
)
7079 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7080 printable_section_name (filedata
, section
),
7081 (unsigned long) section
->sh_entsize
,
7082 (unsigned long) section
->sh_size
);
7086 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7087 1, section
->sh_size
,
7093 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7094 entry
= byte_get (indices
, 4);
7097 if (do_section_groups
)
7099 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7100 get_group_flags (entry
), i
, name
, group_name
, size
);
7102 printf (_(" [Index] Name\n"));
7105 group
->group_index
= i
;
7107 for (j
= 0; j
< size
; j
++)
7109 struct group_list
* g
;
7111 entry
= byte_get (indices
, 4);
7114 if (entry
>= filedata
->file_header
.e_shnum
)
7116 static unsigned num_group_errors
= 0;
7118 if (num_group_errors
++ < 10)
7120 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7121 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7122 if (num_group_errors
== 10)
7123 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7128 if (filedata
->section_headers_groups
[entry
] != NULL
)
7132 static unsigned num_errs
= 0;
7134 if (num_errs
++ < 10)
7136 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7138 filedata
->section_headers_groups
[entry
]->group_index
);
7140 warn (_("Further error messages about already contained group sections suppressed\n"));
7146 /* Intel C/C++ compiler may put section 0 in a
7147 section group. We just warn it the first time
7148 and ignore it afterwards. */
7149 static bfd_boolean warned
= FALSE
;
7152 error (_("section 0 in group section [%5u]\n"),
7153 filedata
->section_headers_groups
[entry
]->group_index
);
7159 filedata
->section_headers_groups
[entry
] = group
;
7161 if (do_section_groups
)
7163 sec
= filedata
->section_headers
+ entry
;
7164 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7167 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7168 g
->section_index
= entry
;
7169 g
->next
= group
->root
;
7184 /* Data used to display dynamic fixups. */
7186 struct ia64_vms_dynfixup
7188 bfd_vma needed_ident
; /* Library ident number. */
7189 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7190 bfd_vma fixup_needed
; /* Index of the library. */
7191 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7192 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7195 /* Data used to display dynamic relocations. */
7197 struct ia64_vms_dynimgrela
7199 bfd_vma img_rela_cnt
; /* Number of relocations. */
7200 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7203 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7207 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7208 struct ia64_vms_dynfixup
* fixup
,
7209 const char * strtab
,
7210 unsigned int strtab_sz
)
7212 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7214 const char * lib_name
;
7216 imfs
= get_data (NULL
, filedata
,
7217 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7218 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7219 _("dynamic section image fixups"));
7223 if (fixup
->needed
< strtab_sz
)
7224 lib_name
= strtab
+ fixup
->needed
;
7227 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7228 (unsigned long) fixup
->needed
);
7232 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7233 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7235 (_("Seg Offset Type SymVec DataType\n"));
7237 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7242 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7243 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7244 type
= BYTE_GET (imfs
[i
].type
);
7245 rtype
= elf_ia64_reloc_type (type
);
7247 printf (" 0x%08x ", type
);
7249 printf (" %-32s ", rtype
);
7250 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7251 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7258 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7261 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7263 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7266 imrs
= get_data (NULL
, filedata
,
7267 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7268 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7269 _("dynamic section image relocations"));
7273 printf (_("\nImage relocs\n"));
7275 (_("Seg Offset Type Addend Seg Sym Off\n"));
7277 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7282 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7283 printf ("%08" BFD_VMA_FMT
"x ",
7284 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7285 type
= BYTE_GET (imrs
[i
].type
);
7286 rtype
= elf_ia64_reloc_type (type
);
7288 printf ("0x%08x ", type
);
7290 printf ("%-31s ", rtype
);
7291 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7292 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7293 printf ("%08" BFD_VMA_FMT
"x\n",
7294 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7301 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7304 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7306 struct ia64_vms_dynfixup fixup
;
7307 struct ia64_vms_dynimgrela imgrela
;
7308 Elf_Internal_Dyn
*entry
;
7309 bfd_vma strtab_off
= 0;
7310 bfd_vma strtab_sz
= 0;
7311 char *strtab
= NULL
;
7312 bfd_boolean res
= TRUE
;
7314 memset (&fixup
, 0, sizeof (fixup
));
7315 memset (&imgrela
, 0, sizeof (imgrela
));
7317 /* Note: the order of the entries is specified by the OpenVMS specs. */
7318 for (entry
= filedata
->dynamic_section
;
7319 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7322 switch (entry
->d_tag
)
7324 case DT_IA_64_VMS_STRTAB_OFFSET
:
7325 strtab_off
= entry
->d_un
.d_val
;
7328 strtab_sz
= entry
->d_un
.d_val
;
7330 strtab
= get_data (NULL
, filedata
,
7331 filedata
->dynamic_addr
+ strtab_off
,
7332 1, strtab_sz
, _("dynamic string section"));
7337 case DT_IA_64_VMS_NEEDED_IDENT
:
7338 fixup
.needed_ident
= entry
->d_un
.d_val
;
7341 fixup
.needed
= entry
->d_un
.d_val
;
7343 case DT_IA_64_VMS_FIXUP_NEEDED
:
7344 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7346 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7347 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7349 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7350 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7351 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7354 case DT_IA_64_VMS_IMG_RELA_CNT
:
7355 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7357 case DT_IA_64_VMS_IMG_RELA_OFF
:
7358 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7359 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7380 dynamic_relocations
[] =
7382 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7383 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7384 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7387 /* Process the reloc section. */
7390 process_relocs (Filedata
* filedata
)
7392 unsigned long rel_size
;
7393 unsigned long rel_offset
;
7398 if (do_using_dynamic
)
7402 bfd_boolean has_dynamic_reloc
;
7405 has_dynamic_reloc
= FALSE
;
7407 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7409 is_rela
= dynamic_relocations
[i
].rela
;
7410 name
= dynamic_relocations
[i
].name
;
7411 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7412 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7415 has_dynamic_reloc
= TRUE
;
7417 if (is_rela
== UNKNOWN
)
7419 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7420 switch (filedata
->dynamic_info
[DT_PLTREL
])
7434 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7435 name
, rel_offset
, rel_size
);
7437 dump_relocations (filedata
,
7438 offset_from_vma (filedata
, rel_offset
, rel_size
),
7440 filedata
->dynamic_symbols
,
7441 filedata
->num_dynamic_syms
,
7442 filedata
->dynamic_strings
,
7443 filedata
->dynamic_strings_length
,
7444 is_rela
, TRUE
/* is_dynamic */);
7448 if (is_ia64_vms (filedata
))
7449 if (process_ia64_vms_dynamic_relocs (filedata
))
7450 has_dynamic_reloc
= TRUE
;
7452 if (! has_dynamic_reloc
)
7453 printf (_("\nThere are no dynamic relocations in this file.\n"));
7457 Elf_Internal_Shdr
* section
;
7459 bfd_boolean found
= FALSE
;
7461 for (i
= 0, section
= filedata
->section_headers
;
7462 i
< filedata
->file_header
.e_shnum
;
7465 if ( section
->sh_type
!= SHT_RELA
7466 && section
->sh_type
!= SHT_REL
)
7469 rel_offset
= section
->sh_offset
;
7470 rel_size
= section
->sh_size
;
7475 unsigned long num_rela
;
7477 printf (_("\nRelocation section "));
7479 if (filedata
->string_table
== NULL
)
7480 printf ("%d", section
->sh_name
);
7482 printf ("'%s'", printable_section_name (filedata
, section
));
7484 num_rela
= rel_size
/ section
->sh_entsize
;
7485 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7486 " at offset 0x%lx contains %lu entries:\n",
7488 rel_offset
, num_rela
);
7490 is_rela
= section
->sh_type
== SHT_RELA
;
7492 if (section
->sh_link
!= 0
7493 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7495 Elf_Internal_Shdr
* symsec
;
7496 Elf_Internal_Sym
* symtab
;
7497 unsigned long nsyms
;
7498 unsigned long strtablen
= 0;
7499 char * strtab
= NULL
;
7501 symsec
= filedata
->section_headers
+ section
->sh_link
;
7502 if (symsec
->sh_type
!= SHT_SYMTAB
7503 && symsec
->sh_type
!= SHT_DYNSYM
)
7506 if (!get_symtab (filedata
, symsec
,
7507 &symtab
, &nsyms
, &strtab
, &strtablen
))
7510 dump_relocations (filedata
, rel_offset
, rel_size
,
7511 symtab
, nsyms
, strtab
, strtablen
,
7513 symsec
->sh_type
== SHT_DYNSYM
);
7518 dump_relocations (filedata
, rel_offset
, rel_size
,
7519 NULL
, 0, NULL
, 0, is_rela
,
7520 FALSE
/* is_dynamic */);
7528 /* Users sometimes forget the -D option, so try to be helpful. */
7529 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7531 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7533 printf (_("\nThere are no static relocations in this file."));
7534 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7539 if (i
== ARRAY_SIZE (dynamic_relocations
))
7540 printf (_("\nThere are no relocations in this file.\n"));
7547 /* An absolute address consists of a section and an offset. If the
7548 section is NULL, the offset itself is the address, otherwise, the
7549 address equals to LOAD_ADDRESS(section) + offset. */
7553 unsigned short section
;
7557 /* Find the nearest symbol at or below ADDR. Returns the symbol
7558 name, if found, and the offset from the symbol to ADDR. */
7561 find_symbol_for_address (Filedata
* filedata
,
7562 Elf_Internal_Sym
* symtab
,
7563 unsigned long nsyms
,
7564 const char * strtab
,
7565 unsigned long strtab_size
,
7566 struct absaddr addr
,
7567 const char ** symname
,
7570 bfd_vma dist
= 0x100000;
7571 Elf_Internal_Sym
* sym
;
7572 Elf_Internal_Sym
* beg
;
7573 Elf_Internal_Sym
* end
;
7574 Elf_Internal_Sym
* best
= NULL
;
7576 REMOVE_ARCH_BITS (addr
.offset
);
7578 end
= symtab
+ nsyms
;
7584 sym
= beg
+ (end
- beg
) / 2;
7586 value
= sym
->st_value
;
7587 REMOVE_ARCH_BITS (value
);
7589 if (sym
->st_name
!= 0
7590 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7591 && addr
.offset
>= value
7592 && addr
.offset
- value
< dist
)
7595 dist
= addr
.offset
- value
;
7600 if (addr
.offset
< value
)
7608 *symname
= (best
->st_name
>= strtab_size
7609 ? _("<corrupt>") : strtab
+ best
->st_name
);
7615 *offset
= addr
.offset
;
7618 static /* signed */ int
7619 symcmp (const void *p
, const void *q
)
7621 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7622 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7624 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7627 /* Process the unwind section. */
7629 #include "unwind-ia64.h"
7631 struct ia64_unw_table_entry
7633 struct absaddr start
;
7635 struct absaddr info
;
7638 struct ia64_unw_aux_info
7640 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7641 unsigned long table_len
; /* Length of unwind table. */
7642 unsigned char * info
; /* Unwind info. */
7643 unsigned long info_size
; /* Size of unwind info. */
7644 bfd_vma info_addr
; /* Starting address of unwind info. */
7645 bfd_vma seg_base
; /* Starting address of segment. */
7646 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7647 unsigned long nsyms
; /* Number of symbols. */
7648 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7649 unsigned long nfuns
; /* Number of entries in funtab. */
7650 char * strtab
; /* The string table. */
7651 unsigned long strtab_size
; /* Size of string table. */
7655 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7657 struct ia64_unw_table_entry
* tp
;
7658 unsigned long j
, nfuns
;
7660 bfd_boolean res
= TRUE
;
7662 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7663 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7664 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7665 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7667 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7669 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7673 const unsigned char * dp
;
7674 const unsigned char * head
;
7675 const unsigned char * end
;
7676 const char * procname
;
7678 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7679 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7681 fputs ("\n<", stdout
);
7685 fputs (procname
, stdout
);
7688 printf ("+%lx", (unsigned long) offset
);
7691 fputs (">: [", stdout
);
7692 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7693 fputc ('-', stdout
);
7694 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7695 printf ("], info at +0x%lx\n",
7696 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7698 /* PR 17531: file: 86232b32. */
7699 if (aux
->info
== NULL
)
7702 offset
= tp
->info
.offset
;
7703 if (tp
->info
.section
)
7705 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7707 warn (_("Invalid section %u in table entry %ld\n"),
7708 tp
->info
.section
, (long) (tp
- aux
->table
));
7712 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7714 offset
-= aux
->info_addr
;
7715 /* PR 17531: file: 0997b4d1. */
7716 if (offset
>= aux
->info_size
7717 || aux
->info_size
- offset
< 8)
7719 warn (_("Invalid offset %lx in table entry %ld\n"),
7720 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7725 head
= aux
->info
+ offset
;
7726 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7728 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7729 (unsigned) UNW_VER (stamp
),
7730 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7731 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7732 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7733 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7735 if (UNW_VER (stamp
) != 1)
7737 printf (_("\tUnknown version.\n"));
7742 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7743 /* PR 17531: file: 16ceda89. */
7744 if (end
> aux
->info
+ aux
->info_size
)
7745 end
= aux
->info
+ aux
->info_size
;
7746 for (dp
= head
+ 8; dp
< end
;)
7747 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7756 slurp_ia64_unwind_table (Filedata
* filedata
,
7757 struct ia64_unw_aux_info
* aux
,
7758 Elf_Internal_Shdr
* sec
)
7760 unsigned long size
, nrelas
, i
;
7761 Elf_Internal_Phdr
* seg
;
7762 struct ia64_unw_table_entry
* tep
;
7763 Elf_Internal_Shdr
* relsec
;
7764 Elf_Internal_Rela
* rela
;
7765 Elf_Internal_Rela
* rp
;
7766 unsigned char * table
;
7768 Elf_Internal_Sym
* sym
;
7769 const char * relname
;
7773 /* First, find the starting address of the segment that includes
7776 if (filedata
->file_header
.e_phnum
)
7778 if (! get_program_headers (filedata
))
7781 for (seg
= filedata
->program_headers
;
7782 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7785 if (seg
->p_type
!= PT_LOAD
)
7788 if (sec
->sh_addr
>= seg
->p_vaddr
7789 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7791 aux
->seg_base
= seg
->p_vaddr
;
7797 /* Second, build the unwind table from the contents of the unwind section: */
7798 size
= sec
->sh_size
;
7799 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7804 aux
->table_len
= size
/ (3 * eh_addr_size
);
7805 aux
->table
= (struct ia64_unw_table_entry
*)
7806 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7809 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7811 tep
->start
.section
= SHN_UNDEF
;
7812 tep
->end
.section
= SHN_UNDEF
;
7813 tep
->info
.section
= SHN_UNDEF
;
7814 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7815 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7816 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7817 tep
->start
.offset
+= aux
->seg_base
;
7818 tep
->end
.offset
+= aux
->seg_base
;
7819 tep
->info
.offset
+= aux
->seg_base
;
7823 /* Third, apply any relocations to the unwind table: */
7824 for (relsec
= filedata
->section_headers
;
7825 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7828 if (relsec
->sh_type
!= SHT_RELA
7829 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7830 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7833 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7842 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7844 unsigned int sym_ndx
;
7845 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7846 relname
= elf_ia64_reloc_type (r_type
);
7848 /* PR 17531: file: 9fa67536. */
7849 if (relname
== NULL
)
7851 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7855 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7857 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7861 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7863 /* PR 17531: file: 5bc8d9bf. */
7864 if (i
>= aux
->table_len
)
7866 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7870 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7871 if (sym_ndx
>= aux
->nsyms
)
7873 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7877 sym
= aux
->symtab
+ sym_ndx
;
7879 switch (rp
->r_offset
/ eh_addr_size
% 3)
7882 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7883 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7886 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7887 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7890 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7891 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7905 ia64_process_unwind (Filedata
* filedata
)
7907 Elf_Internal_Shdr
* sec
;
7908 Elf_Internal_Shdr
* unwsec
= NULL
;
7909 unsigned long i
, unwcount
= 0, unwstart
= 0;
7910 struct ia64_unw_aux_info aux
;
7911 bfd_boolean res
= TRUE
;
7913 memset (& aux
, 0, sizeof (aux
));
7915 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7917 if (sec
->sh_type
== SHT_SYMTAB
)
7921 error (_("Multiple symbol tables encountered\n"));
7927 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7928 &aux
.strtab
, &aux
.strtab_size
))
7931 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7936 printf (_("\nThere are no unwind sections in this file.\n"));
7938 while (unwcount
-- > 0)
7943 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7944 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7945 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7950 /* We have already counted the number of SHT_IA64_UNWIND
7951 sections so the loop above should never fail. */
7952 assert (unwsec
!= NULL
);
7955 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7957 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7959 /* We need to find which section group it is in. */
7960 struct group_list
* g
;
7962 if (filedata
->section_headers_groups
== NULL
7963 || filedata
->section_headers_groups
[i
] == NULL
)
7964 i
= filedata
->file_header
.e_shnum
;
7967 g
= filedata
->section_headers_groups
[i
]->root
;
7969 for (; g
!= NULL
; g
= g
->next
)
7971 sec
= filedata
->section_headers
+ g
->section_index
;
7973 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7978 i
= filedata
->file_header
.e_shnum
;
7981 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7983 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7984 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7985 suffix
= SECTION_NAME (unwsec
) + len
;
7986 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7988 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7989 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7994 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7995 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7996 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7997 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7999 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
8000 suffix
= SECTION_NAME (unwsec
) + len
;
8001 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8003 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
8004 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8008 if (i
== filedata
->file_header
.e_shnum
)
8010 printf (_("\nCould not find unwind info section for "));
8012 if (filedata
->string_table
== NULL
)
8013 printf ("%d", unwsec
->sh_name
);
8015 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8019 aux
.info_addr
= sec
->sh_addr
;
8020 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8023 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8025 printf (_("\nUnwind section "));
8027 if (filedata
->string_table
== NULL
)
8028 printf ("%d", unwsec
->sh_name
);
8030 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8032 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8033 (unsigned long) unwsec
->sh_offset
,
8034 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8036 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8037 && aux
.table_len
> 0)
8038 dump_ia64_unwind (filedata
, & aux
);
8040 free ((char *) aux
.table
);
8041 free ((char *) aux
.info
);
8048 free ((char *) aux
.strtab
);
8053 struct hppa_unw_table_entry
8055 struct absaddr start
;
8057 unsigned int Cannot_unwind
:1; /* 0 */
8058 unsigned int Millicode
:1; /* 1 */
8059 unsigned int Millicode_save_sr0
:1; /* 2 */
8060 unsigned int Region_description
:2; /* 3..4 */
8061 unsigned int reserved1
:1; /* 5 */
8062 unsigned int Entry_SR
:1; /* 6 */
8063 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8064 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8065 unsigned int Args_stored
:1; /* 16 */
8066 unsigned int Variable_Frame
:1; /* 17 */
8067 unsigned int Separate_Package_Body
:1; /* 18 */
8068 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8069 unsigned int Stack_Overflow_Check
:1; /* 20 */
8070 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8071 unsigned int Ada_Region
:1; /* 22 */
8072 unsigned int cxx_info
:1; /* 23 */
8073 unsigned int cxx_try_catch
:1; /* 24 */
8074 unsigned int sched_entry_seq
:1; /* 25 */
8075 unsigned int reserved2
:1; /* 26 */
8076 unsigned int Save_SP
:1; /* 27 */
8077 unsigned int Save_RP
:1; /* 28 */
8078 unsigned int Save_MRP_in_frame
:1; /* 29 */
8079 unsigned int extn_ptr_defined
:1; /* 30 */
8080 unsigned int Cleanup_defined
:1; /* 31 */
8082 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8083 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8084 unsigned int Large_frame
:1; /* 2 */
8085 unsigned int Pseudo_SP_Set
:1; /* 3 */
8086 unsigned int reserved4
:1; /* 4 */
8087 unsigned int Total_frame_size
:27; /* 5..31 */
8090 struct hppa_unw_aux_info
8092 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8093 unsigned long table_len
; /* Length of unwind table. */
8094 bfd_vma seg_base
; /* Starting address of segment. */
8095 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8096 unsigned long nsyms
; /* Number of symbols. */
8097 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8098 unsigned long nfuns
; /* Number of entries in funtab. */
8099 char * strtab
; /* The string table. */
8100 unsigned long strtab_size
; /* Size of string table. */
8104 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8106 struct hppa_unw_table_entry
* tp
;
8107 unsigned long j
, nfuns
;
8108 bfd_boolean res
= TRUE
;
8110 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8111 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8112 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8113 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8115 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8117 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8120 const char * procname
;
8122 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8123 aux
->strtab_size
, tp
->start
, &procname
,
8126 fputs ("\n<", stdout
);
8130 fputs (procname
, stdout
);
8133 printf ("+%lx", (unsigned long) offset
);
8136 fputs (">: [", stdout
);
8137 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8138 fputc ('-', stdout
);
8139 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8142 #define PF(_m) if (tp->_m) printf (#_m " ");
8143 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8146 PF(Millicode_save_sr0
);
8147 /* PV(Region_description); */
8153 PF(Separate_Package_Body
);
8154 PF(Frame_Extension_Millicode
);
8155 PF(Stack_Overflow_Check
);
8156 PF(Two_Instruction_SP_Increment
);
8160 PF(sched_entry_seq
);
8163 PF(Save_MRP_in_frame
);
8164 PF(extn_ptr_defined
);
8165 PF(Cleanup_defined
);
8166 PF(MPE_XL_interrupt_marker
);
8167 PF(HP_UX_interrupt_marker
);
8170 PV(Total_frame_size
);
8183 slurp_hppa_unwind_table (Filedata
* filedata
,
8184 struct hppa_unw_aux_info
* aux
,
8185 Elf_Internal_Shdr
* sec
)
8187 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8188 Elf_Internal_Phdr
* seg
;
8189 struct hppa_unw_table_entry
* tep
;
8190 Elf_Internal_Shdr
* relsec
;
8191 Elf_Internal_Rela
* rela
;
8192 Elf_Internal_Rela
* rp
;
8193 unsigned char * table
;
8195 Elf_Internal_Sym
* sym
;
8196 const char * relname
;
8198 /* First, find the starting address of the segment that includes
8200 if (filedata
->file_header
.e_phnum
)
8202 if (! get_program_headers (filedata
))
8205 for (seg
= filedata
->program_headers
;
8206 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8209 if (seg
->p_type
!= PT_LOAD
)
8212 if (sec
->sh_addr
>= seg
->p_vaddr
8213 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8215 aux
->seg_base
= seg
->p_vaddr
;
8221 /* Second, build the unwind table from the contents of the unwind
8223 size
= sec
->sh_size
;
8224 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8230 nentries
= size
/ unw_ent_size
;
8231 size
= unw_ent_size
* nentries
;
8233 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8234 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8236 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8238 unsigned int tmp1
, tmp2
;
8240 tep
->start
.section
= SHN_UNDEF
;
8241 tep
->end
.section
= SHN_UNDEF
;
8243 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8244 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8245 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8246 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8248 tep
->start
.offset
+= aux
->seg_base
;
8249 tep
->end
.offset
+= aux
->seg_base
;
8251 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8252 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8253 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8254 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8255 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8256 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8257 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8258 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8259 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8260 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8261 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8262 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8263 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8264 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8265 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8266 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8267 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8268 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8269 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8270 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8271 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8272 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8273 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8274 tep
->Cleanup_defined
= tmp1
& 0x1;
8276 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8277 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8278 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8279 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8280 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8281 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8285 /* Third, apply any relocations to the unwind table. */
8286 for (relsec
= filedata
->section_headers
;
8287 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8290 if (relsec
->sh_type
!= SHT_RELA
8291 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8292 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8295 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8299 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8301 unsigned int sym_ndx
;
8302 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8303 relname
= elf_hppa_reloc_type (r_type
);
8305 if (relname
== NULL
)
8307 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8311 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8312 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8314 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8318 i
= rp
->r_offset
/ unw_ent_size
;
8319 if (i
>= aux
->table_len
)
8321 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8325 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8326 if (sym_ndx
>= aux
->nsyms
)
8328 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8332 sym
= aux
->symtab
+ sym_ndx
;
8334 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8337 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8338 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8341 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8342 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8352 aux
->table_len
= nentries
;
8358 hppa_process_unwind (Filedata
* filedata
)
8360 struct hppa_unw_aux_info aux
;
8361 Elf_Internal_Shdr
* unwsec
= NULL
;
8362 Elf_Internal_Shdr
* sec
;
8364 bfd_boolean res
= TRUE
;
8366 if (filedata
->string_table
== NULL
)
8369 memset (& aux
, 0, sizeof (aux
));
8371 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8373 if (sec
->sh_type
== SHT_SYMTAB
)
8377 error (_("Multiple symbol tables encountered\n"));
8383 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8384 &aux
.strtab
, &aux
.strtab_size
))
8387 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8392 printf (_("\nThere are no unwind sections in this file.\n"));
8394 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8396 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8398 unsigned long num_unwind
= sec
->sh_size
/ 16;
8400 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8401 "contains %lu entry:\n",
8402 "\nUnwind section '%s' at offset 0x%lx "
8403 "contains %lu entries:\n",
8405 printable_section_name (filedata
, sec
),
8406 (unsigned long) sec
->sh_offset
,
8409 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8412 if (res
&& aux
.table_len
> 0)
8414 if (! dump_hppa_unwind (filedata
, &aux
))
8418 free ((char *) aux
.table
);
8424 free ((char *) aux
.strtab
);
8431 unsigned char * data
; /* The unwind data. */
8432 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8433 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8434 unsigned long nrelas
; /* The number of relocations. */
8435 unsigned int rel_type
; /* REL or RELA ? */
8436 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8439 struct arm_unw_aux_info
8441 Filedata
* filedata
; /* The file containing the unwind sections. */
8442 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8443 unsigned long nsyms
; /* Number of symbols. */
8444 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8445 unsigned long nfuns
; /* Number of these symbols. */
8446 char * strtab
; /* The file's string table. */
8447 unsigned long strtab_size
; /* Size of string table. */
8451 arm_print_vma_and_name (Filedata
* filedata
,
8452 struct arm_unw_aux_info
* aux
,
8454 struct absaddr addr
)
8456 const char *procname
;
8459 if (addr
.section
== SHN_UNDEF
)
8462 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8463 aux
->strtab_size
, addr
, &procname
,
8466 print_vma (fn
, PREFIX_HEX
);
8470 fputs (" <", stdout
);
8471 fputs (procname
, stdout
);
8474 printf ("+0x%lx", (unsigned long) sym_offset
);
8475 fputc ('>', stdout
);
8482 arm_free_section (struct arm_section
*arm_sec
)
8484 free (arm_sec
->data
);
8485 free (arm_sec
->rela
);
8488 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8489 cached section and install SEC instead.
8490 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8491 and return its valued in * WORDP, relocating if necessary.
8492 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8493 relocation's offset in ADDR.
8494 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8495 into the string table of the symbol associated with the reloc. If no
8496 reloc was applied store -1 there.
8497 5) Return TRUE upon success, FALSE otherwise. */
8500 get_unwind_section_word (Filedata
* filedata
,
8501 struct arm_unw_aux_info
* aux
,
8502 struct arm_section
* arm_sec
,
8503 Elf_Internal_Shdr
* sec
,
8504 bfd_vma word_offset
,
8505 unsigned int * wordp
,
8506 struct absaddr
* addr
,
8509 Elf_Internal_Rela
*rp
;
8510 Elf_Internal_Sym
*sym
;
8511 const char * relname
;
8513 bfd_boolean wrapped
;
8515 if (sec
== NULL
|| arm_sec
== NULL
)
8518 addr
->section
= SHN_UNDEF
;
8521 if (sym_name
!= NULL
)
8522 *sym_name
= (bfd_vma
) -1;
8524 /* If necessary, update the section cache. */
8525 if (sec
!= arm_sec
->sec
)
8527 Elf_Internal_Shdr
*relsec
;
8529 arm_free_section (arm_sec
);
8532 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8533 sec
->sh_size
, _("unwind data"));
8534 arm_sec
->rela
= NULL
;
8535 arm_sec
->nrelas
= 0;
8537 for (relsec
= filedata
->section_headers
;
8538 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8541 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8542 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8543 /* PR 15745: Check the section type as well. */
8544 || (relsec
->sh_type
!= SHT_REL
8545 && relsec
->sh_type
!= SHT_RELA
))
8548 arm_sec
->rel_type
= relsec
->sh_type
;
8549 if (relsec
->sh_type
== SHT_REL
)
8551 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8553 & arm_sec
->rela
, & arm_sec
->nrelas
))
8556 else /* relsec->sh_type == SHT_RELA */
8558 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8560 & arm_sec
->rela
, & arm_sec
->nrelas
))
8566 arm_sec
->next_rela
= arm_sec
->rela
;
8569 /* If there is no unwind data we can do nothing. */
8570 if (arm_sec
->data
== NULL
)
8573 /* If the offset is invalid then fail. */
8574 if (/* PR 21343 *//* PR 18879 */
8576 || word_offset
> (sec
->sh_size
- 4)
8577 || ((bfd_signed_vma
) word_offset
) < 0)
8580 /* Get the word at the required offset. */
8581 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8583 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8584 if (arm_sec
->rela
== NULL
)
8590 /* Look through the relocs to find the one that applies to the provided offset. */
8592 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8594 bfd_vma prelval
, offset
;
8596 if (rp
->r_offset
> word_offset
&& !wrapped
)
8601 if (rp
->r_offset
> word_offset
)
8604 if (rp
->r_offset
& 3)
8606 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8607 (unsigned long) rp
->r_offset
);
8611 if (rp
->r_offset
< word_offset
)
8614 /* PR 17531: file: 027-161405-0.004 */
8615 if (aux
->symtab
== NULL
)
8618 if (arm_sec
->rel_type
== SHT_REL
)
8620 offset
= word
& 0x7fffffff;
8621 if (offset
& 0x40000000)
8622 offset
|= ~ (bfd_vma
) 0x7fffffff;
8624 else if (arm_sec
->rel_type
== SHT_RELA
)
8625 offset
= rp
->r_addend
;
8628 error (_("Unknown section relocation type %d encountered\n"),
8633 /* PR 17531 file: 027-1241568-0.004. */
8634 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8636 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8637 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8641 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8642 offset
+= sym
->st_value
;
8643 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8645 /* Check that we are processing the expected reloc type. */
8646 if (filedata
->file_header
.e_machine
== EM_ARM
)
8648 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8649 if (relname
== NULL
)
8651 warn (_("Skipping unknown ARM relocation type: %d\n"),
8652 (int) ELF32_R_TYPE (rp
->r_info
));
8656 if (streq (relname
, "R_ARM_NONE"))
8659 if (! streq (relname
, "R_ARM_PREL31"))
8661 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8665 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8667 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8668 if (relname
== NULL
)
8670 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8671 (int) ELF32_R_TYPE (rp
->r_info
));
8675 if (streq (relname
, "R_C6000_NONE"))
8678 if (! streq (relname
, "R_C6000_PREL31"))
8680 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8688 /* This function currently only supports ARM and TI unwinders. */
8689 warn (_("Only TI and ARM unwinders are currently supported\n"));
8693 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8694 addr
->section
= sym
->st_shndx
;
8695 addr
->offset
= offset
;
8698 * sym_name
= sym
->st_name
;
8703 arm_sec
->next_rela
= rp
;
8708 static const char *tic6x_unwind_regnames
[16] =
8710 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8711 "A14", "A13", "A12", "A11", "A10",
8712 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8716 decode_tic6x_unwind_regmask (unsigned int mask
)
8720 for (i
= 12; mask
; mask
>>= 1, i
--)
8724 fputs (tic6x_unwind_regnames
[i
], stdout
);
8726 fputs (", ", stdout
);
8732 if (remaining == 0 && more_words) \
8735 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8736 data_offset, & word, & addr, NULL)) \
8742 #define GET_OP(OP) \
8747 (OP) = word >> 24; \
8752 printf (_("[Truncated opcode]\n")); \
8755 printf ("0x%02x ", OP)
8758 decode_arm_unwind_bytecode (Filedata
* filedata
,
8759 struct arm_unw_aux_info
* aux
,
8761 unsigned int remaining
,
8762 unsigned int more_words
,
8763 bfd_vma data_offset
,
8764 Elf_Internal_Shdr
* data_sec
,
8765 struct arm_section
* data_arm_sec
)
8767 struct absaddr addr
;
8768 bfd_boolean res
= TRUE
;
8770 /* Decode the unwinding instructions. */
8773 unsigned int op
, op2
;
8782 printf (" 0x%02x ", op
);
8784 if ((op
& 0xc0) == 0x00)
8786 int offset
= ((op
& 0x3f) << 2) + 4;
8788 printf (" vsp = vsp + %d", offset
);
8790 else if ((op
& 0xc0) == 0x40)
8792 int offset
= ((op
& 0x3f) << 2) + 4;
8794 printf (" vsp = vsp - %d", offset
);
8796 else if ((op
& 0xf0) == 0x80)
8799 if (op
== 0x80 && op2
== 0)
8800 printf (_("Refuse to unwind"));
8803 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8804 bfd_boolean first
= TRUE
;
8808 for (i
= 0; i
< 12; i
++)
8809 if (mask
& (1 << i
))
8815 printf ("r%d", 4 + i
);
8820 else if ((op
& 0xf0) == 0x90)
8822 if (op
== 0x9d || op
== 0x9f)
8823 printf (_(" [Reserved]"));
8825 printf (" vsp = r%d", op
& 0x0f);
8827 else if ((op
& 0xf0) == 0xa0)
8829 int end
= 4 + (op
& 0x07);
8830 bfd_boolean first
= TRUE
;
8834 for (i
= 4; i
<= end
; i
++)
8850 else if (op
== 0xb0)
8851 printf (_(" finish"));
8852 else if (op
== 0xb1)
8855 if (op2
== 0 || (op2
& 0xf0) != 0)
8856 printf (_("[Spare]"));
8859 unsigned int mask
= op2
& 0x0f;
8860 bfd_boolean first
= TRUE
;
8864 for (i
= 0; i
< 12; i
++)
8865 if (mask
& (1 << i
))
8876 else if (op
== 0xb2)
8878 unsigned char buf
[9];
8879 unsigned int i
, len
;
8880 unsigned long offset
;
8882 for (i
= 0; i
< sizeof (buf
); i
++)
8885 if ((buf
[i
] & 0x80) == 0)
8888 if (i
== sizeof (buf
))
8890 error (_("corrupt change to vsp\n"));
8895 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8896 assert (len
== i
+ 1);
8897 offset
= offset
* 4 + 0x204;
8898 printf ("vsp = vsp + %ld", offset
);
8901 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8903 unsigned int first
, last
;
8910 printf ("pop {D%d", first
);
8912 printf ("-D%d", first
+ last
);
8915 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8917 unsigned int count
= op
& 0x07;
8921 printf ("-D%d", 8 + count
);
8924 else if (op
>= 0xc0 && op
<= 0xc5)
8926 unsigned int count
= op
& 0x07;
8928 printf (" pop {wR10");
8930 printf ("-wR%d", 10 + count
);
8933 else if (op
== 0xc6)
8935 unsigned int first
, last
;
8940 printf ("pop {wR%d", first
);
8942 printf ("-wR%d", first
+ last
);
8945 else if (op
== 0xc7)
8948 if (op2
== 0 || (op2
& 0xf0) != 0)
8949 printf (_("[Spare]"));
8952 unsigned int mask
= op2
& 0x0f;
8953 bfd_boolean first
= TRUE
;
8957 for (i
= 0; i
< 4; i
++)
8958 if (mask
& (1 << i
))
8964 printf ("wCGR%d", i
);
8971 printf (_(" [unsupported opcode]"));
8982 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8983 struct arm_unw_aux_info
* aux
,
8985 unsigned int remaining
,
8986 unsigned int more_words
,
8987 bfd_vma data_offset
,
8988 Elf_Internal_Shdr
* data_sec
,
8989 struct arm_section
* data_arm_sec
)
8991 struct absaddr addr
;
8993 /* Decode the unwinding instructions. */
8996 unsigned int op
, op2
;
9005 printf (" 0x%02x ", op
);
9007 if ((op
& 0xc0) == 0x00)
9009 int offset
= ((op
& 0x3f) << 3) + 8;
9010 printf (" sp = sp + %d", offset
);
9012 else if ((op
& 0xc0) == 0x80)
9015 if (op
== 0x80 && op2
== 0)
9016 printf (_("Refuse to unwind"));
9019 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9021 printf ("pop compact {");
9025 decode_tic6x_unwind_regmask (mask
);
9029 else if ((op
& 0xf0) == 0xc0)
9037 unsigned int offset
;
9041 /* Scan entire instruction first so that GET_OP output is not
9042 interleaved with disassembly. */
9044 for (i
= 0; nregs
< (op
& 0xf); i
++)
9050 regpos
[nregs
].offset
= i
* 2;
9051 regpos
[nregs
].reg
= reg
;
9058 regpos
[nregs
].offset
= i
* 2 + 1;
9059 regpos
[nregs
].reg
= reg
;
9064 printf (_("pop frame {"));
9067 printf (_("*corrupt* - no registers specified"));
9072 for (i
= i
* 2; i
> 0; i
--)
9074 if (regpos
[reg
].offset
== i
- 1)
9076 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9083 fputs (name
, stdout
);
9091 else if (op
== 0xd0)
9092 printf (" MOV FP, SP");
9093 else if (op
== 0xd1)
9094 printf (" __c6xabi_pop_rts");
9095 else if (op
== 0xd2)
9097 unsigned char buf
[9];
9098 unsigned int i
, len
;
9099 unsigned long offset
;
9101 for (i
= 0; i
< sizeof (buf
); i
++)
9104 if ((buf
[i
] & 0x80) == 0)
9107 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9108 if (i
== sizeof (buf
))
9110 warn (_("Corrupt stack pointer adjustment detected\n"));
9114 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9115 assert (len
== i
+ 1);
9116 offset
= offset
* 8 + 0x408;
9117 printf (_("sp = sp + %ld"), offset
);
9119 else if ((op
& 0xf0) == 0xe0)
9121 if ((op
& 0x0f) == 7)
9124 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9128 printf (_(" [unsupported opcode]"));
9137 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9141 offset
= word
& 0x7fffffff;
9142 if (offset
& 0x40000000)
9143 offset
|= ~ (bfd_vma
) 0x7fffffff;
9145 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9148 return offset
+ where
;
9152 decode_arm_unwind (Filedata
* filedata
,
9153 struct arm_unw_aux_info
* aux
,
9155 unsigned int remaining
,
9156 bfd_vma data_offset
,
9157 Elf_Internal_Shdr
* data_sec
,
9158 struct arm_section
* data_arm_sec
)
9161 unsigned int more_words
= 0;
9162 struct absaddr addr
;
9163 bfd_vma sym_name
= (bfd_vma
) -1;
9164 bfd_boolean res
= TRUE
;
9168 /* Fetch the first word.
9169 Note - when decoding an object file the address extracted
9170 here will always be 0. So we also pass in the sym_name
9171 parameter so that we can find the symbol associated with
9172 the personality routine. */
9173 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9174 & word
, & addr
, & sym_name
))
9181 addr
.section
= SHN_UNDEF
;
9185 if ((word
& 0x80000000) == 0)
9187 /* Expand prel31 for personality routine. */
9189 const char *procname
;
9191 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9192 printf (_(" Personality routine: "));
9194 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9195 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9197 procname
= aux
->strtab
+ sym_name
;
9198 print_vma (fn
, PREFIX_HEX
);
9201 fputs (" <", stdout
);
9202 fputs (procname
, stdout
);
9203 fputc ('>', stdout
);
9207 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9208 fputc ('\n', stdout
);
9210 /* The GCC personality routines use the standard compact
9211 encoding, starting with one byte giving the number of
9213 if (procname
!= NULL
9214 && (const_strneq (procname
, "__gcc_personality_v0")
9215 || const_strneq (procname
, "__gxx_personality_v0")
9216 || const_strneq (procname
, "__gcj_personality_v0")
9217 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9224 printf (_(" [Truncated data]\n"));
9227 more_words
= word
>> 24;
9237 /* ARM EHABI Section 6.3:
9239 An exception-handling table entry for the compact model looks like:
9243 1 0 index Data for personalityRoutine[index] */
9245 if (filedata
->file_header
.e_machine
== EM_ARM
9246 && (word
& 0x70000000))
9248 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9252 per_index
= (word
>> 24) & 0x7f;
9253 printf (_(" Compact model index: %d\n"), per_index
);
9260 else if (per_index
< 3)
9262 more_words
= (word
>> 16) & 0xff;
9268 switch (filedata
->file_header
.e_machine
)
9273 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9274 data_offset
, data_sec
, data_arm_sec
))
9279 warn (_("Unknown ARM compact model index encountered\n"));
9280 printf (_(" [reserved]\n"));
9288 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9289 data_offset
, data_sec
, data_arm_sec
))
9292 else if (per_index
< 5)
9294 if (((word
>> 17) & 0x7f) == 0x7f)
9295 printf (_(" Restore stack from frame pointer\n"));
9297 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9298 printf (_(" Registers restored: "));
9300 printf (" (compact) ");
9301 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9303 printf (_(" Return register: %s\n"),
9304 tic6x_unwind_regnames
[word
& 0xf]);
9307 printf (_(" [reserved (%d)]\n"), per_index
);
9311 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9312 filedata
->file_header
.e_machine
);
9316 /* Decode the descriptors. Not implemented. */
9322 dump_arm_unwind (Filedata
* filedata
,
9323 struct arm_unw_aux_info
* aux
,
9324 Elf_Internal_Shdr
* exidx_sec
)
9326 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9327 unsigned int i
, exidx_len
;
9328 unsigned long j
, nfuns
;
9329 bfd_boolean res
= TRUE
;
9331 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9332 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9333 exidx_len
= exidx_sec
->sh_size
/ 8;
9335 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9336 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9337 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9338 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9340 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9342 for (i
= 0; i
< exidx_len
; i
++)
9344 unsigned int exidx_fn
, exidx_entry
;
9345 struct absaddr fn_addr
, entry_addr
;
9348 fputc ('\n', stdout
);
9350 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9351 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9352 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9353 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9356 arm_free_section (& exidx_arm_sec
);
9357 arm_free_section (& extab_arm_sec
);
9361 /* ARM EHABI, Section 5:
9362 An index table entry consists of 2 words.
9363 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9364 if (exidx_fn
& 0x80000000)
9366 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9370 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9372 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9373 fputs (": ", stdout
);
9375 if (exidx_entry
== 1)
9377 print_vma (exidx_entry
, PREFIX_HEX
);
9378 fputs (" [cantunwind]\n", stdout
);
9380 else if (exidx_entry
& 0x80000000)
9382 print_vma (exidx_entry
, PREFIX_HEX
);
9383 fputc ('\n', stdout
);
9384 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9388 bfd_vma table
, table_offset
= 0;
9389 Elf_Internal_Shdr
*table_sec
;
9391 fputs ("@", stdout
);
9392 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9393 print_vma (table
, PREFIX_HEX
);
9396 /* Locate the matching .ARM.extab. */
9397 if (entry_addr
.section
!= SHN_UNDEF
9398 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9400 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9401 table_offset
= entry_addr
.offset
;
9403 if (table_offset
> table_sec
->sh_size
9404 || ((bfd_signed_vma
) table_offset
) < 0)
9406 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9407 (unsigned long) table_offset
,
9408 printable_section_name (filedata
, table_sec
));
9415 table_sec
= find_section_by_address (filedata
, table
);
9416 if (table_sec
!= NULL
)
9417 table_offset
= table
- table_sec
->sh_addr
;
9420 if (table_sec
== NULL
)
9422 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9423 (unsigned long) table
);
9428 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9437 arm_free_section (&exidx_arm_sec
);
9438 arm_free_section (&extab_arm_sec
);
9443 /* Used for both ARM and C6X unwinding tables. */
9446 arm_process_unwind (Filedata
* filedata
)
9448 struct arm_unw_aux_info aux
;
9449 Elf_Internal_Shdr
*unwsec
= NULL
;
9450 Elf_Internal_Shdr
*sec
;
9452 unsigned int sec_type
;
9453 bfd_boolean res
= TRUE
;
9455 switch (filedata
->file_header
.e_machine
)
9458 sec_type
= SHT_ARM_EXIDX
;
9462 sec_type
= SHT_C6000_UNWIND
;
9466 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9467 filedata
->file_header
.e_machine
);
9471 if (filedata
->string_table
== NULL
)
9474 memset (& aux
, 0, sizeof (aux
));
9475 aux
.filedata
= filedata
;
9477 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9479 if (sec
->sh_type
== SHT_SYMTAB
)
9483 error (_("Multiple symbol tables encountered\n"));
9489 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9490 &aux
.strtab
, &aux
.strtab_size
))
9493 else if (sec
->sh_type
== sec_type
)
9498 printf (_("\nThere are no unwind sections in this file.\n"));
9500 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9502 if (sec
->sh_type
== sec_type
)
9504 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9505 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9506 "contains %lu entry:\n",
9507 "\nUnwind section '%s' at offset 0x%lx "
9508 "contains %lu entries:\n",
9510 printable_section_name (filedata
, sec
),
9511 (unsigned long) sec
->sh_offset
,
9514 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9520 free ((char *) aux
.strtab
);
9526 process_unwind (Filedata
* filedata
)
9528 struct unwind_handler
9530 unsigned int machtype
;
9531 bfd_boolean (* handler
)(Filedata
*);
9534 { EM_ARM
, arm_process_unwind
},
9535 { EM_IA_64
, ia64_process_unwind
},
9536 { EM_PARISC
, hppa_process_unwind
},
9537 { EM_TI_C6000
, arm_process_unwind
},
9545 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9546 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9547 return handlers
[i
].handler (filedata
);
9549 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9550 get_machine_name (filedata
->file_header
.e_machine
));
9555 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9557 switch (entry
->d_tag
)
9559 case DT_AARCH64_BTI_PLT
:
9560 case DT_AARCH64_PAC_PLT
:
9563 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9570 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9572 switch (entry
->d_tag
)
9575 if (entry
->d_un
.d_val
== 0)
9579 static const char * opts
[] =
9581 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9582 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9583 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9584 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9588 bfd_boolean first
= TRUE
;
9590 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9591 if (entry
->d_un
.d_val
& (1 << cnt
))
9593 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9599 case DT_MIPS_IVERSION
:
9600 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9601 printf (_("Interface Version: %s"),
9602 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9606 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9607 /* Note: coded this way so that there is a single string for translation. */
9608 printf (_("<corrupt: %s>"), buf
);
9612 case DT_MIPS_TIME_STAMP
:
9616 time_t atime
= entry
->d_un
.d_val
;
9618 tmp
= gmtime (&atime
);
9619 /* PR 17531: file: 6accc532. */
9621 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9623 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9624 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9625 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9626 printf (_("Time Stamp: %s"), timebuf
);
9630 case DT_MIPS_RLD_VERSION
:
9631 case DT_MIPS_LOCAL_GOTNO
:
9632 case DT_MIPS_CONFLICTNO
:
9633 case DT_MIPS_LIBLISTNO
:
9634 case DT_MIPS_SYMTABNO
:
9635 case DT_MIPS_UNREFEXTNO
:
9636 case DT_MIPS_HIPAGENO
:
9637 case DT_MIPS_DELTA_CLASS_NO
:
9638 case DT_MIPS_DELTA_INSTANCE_NO
:
9639 case DT_MIPS_DELTA_RELOC_NO
:
9640 case DT_MIPS_DELTA_SYM_NO
:
9641 case DT_MIPS_DELTA_CLASSSYM_NO
:
9642 case DT_MIPS_COMPACT_SIZE
:
9643 print_vma (entry
->d_un
.d_val
, DEC
);
9647 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9648 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9649 /* Falls through. */
9652 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9658 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9660 switch (entry
->d_tag
)
9662 case DT_HP_DLD_FLAGS
:
9671 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9672 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9673 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9674 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9675 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9676 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9677 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9678 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9679 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9680 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9681 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9682 { DT_HP_GST
, "HP_GST" },
9683 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9684 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9685 { DT_HP_NODELETE
, "HP_NODELETE" },
9686 { DT_HP_GROUP
, "HP_GROUP" },
9687 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9689 bfd_boolean first
= TRUE
;
9691 bfd_vma val
= entry
->d_un
.d_val
;
9693 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9694 if (val
& flags
[cnt
].bit
)
9698 fputs (flags
[cnt
].str
, stdout
);
9700 val
^= flags
[cnt
].bit
;
9703 if (val
!= 0 || first
)
9707 print_vma (val
, HEX
);
9713 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9721 /* VMS vs Unix time offset and factor. */
9723 #define VMS_EPOCH_OFFSET 35067168000000000LL
9724 #define VMS_GRANULARITY_FACTOR 10000000
9726 /* Display a VMS time in a human readable format. */
9729 print_vms_time (bfd_int64_t vmstime
)
9734 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9735 tm
= gmtime (&unxtime
);
9736 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9737 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9738 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9743 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9745 switch (entry
->d_tag
)
9747 case DT_IA_64_PLT_RESERVE
:
9748 /* First 3 slots reserved. */
9749 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9751 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9754 case DT_IA_64_VMS_LINKTIME
:
9756 print_vms_time (entry
->d_un
.d_val
);
9760 case DT_IA_64_VMS_LNKFLAGS
:
9761 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9762 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9763 printf (" CALL_DEBUG");
9764 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9765 printf (" NOP0BUFS");
9766 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9767 printf (" P0IMAGE");
9768 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9769 printf (" MKTHREADS");
9770 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9771 printf (" UPCALLS");
9772 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9774 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9775 printf (" INITIALIZE");
9776 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9778 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9779 printf (" EXE_INIT");
9780 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9781 printf (" TBK_IN_IMG");
9782 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9783 printf (" DBG_IN_IMG");
9784 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9785 printf (" TBK_IN_DSF");
9786 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9787 printf (" DBG_IN_DSF");
9788 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9789 printf (" SIGNATURES");
9790 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9791 printf (" REL_SEG_OFF");
9795 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9802 get_32bit_dynamic_section (Filedata
* filedata
)
9804 Elf32_External_Dyn
* edyn
;
9805 Elf32_External_Dyn
* ext
;
9806 Elf_Internal_Dyn
* entry
;
9808 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9809 filedata
->dynamic_addr
, 1,
9810 filedata
->dynamic_size
,
9811 _("dynamic section"));
9815 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9816 might not have the luxury of section headers. Look for the DT_NULL
9817 terminator to determine the number of entries. */
9818 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9819 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9822 filedata
->dynamic_nent
++;
9823 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9827 filedata
->dynamic_section
9828 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9829 if (filedata
->dynamic_section
== NULL
)
9831 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9832 (unsigned long) filedata
->dynamic_nent
);
9837 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9838 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9841 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9842 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9851 get_64bit_dynamic_section (Filedata
* filedata
)
9853 Elf64_External_Dyn
* edyn
;
9854 Elf64_External_Dyn
* ext
;
9855 Elf_Internal_Dyn
* entry
;
9857 /* Read in the data. */
9858 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9859 filedata
->dynamic_addr
, 1,
9860 filedata
->dynamic_size
,
9861 _("dynamic section"));
9865 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9866 might not have the luxury of section headers. Look for the DT_NULL
9867 terminator to determine the number of entries. */
9868 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9869 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9870 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9873 filedata
->dynamic_nent
++;
9874 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9878 filedata
->dynamic_section
9879 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9880 if (filedata
->dynamic_section
== NULL
)
9882 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9883 (unsigned long) filedata
->dynamic_nent
);
9888 /* Convert from external to internal formats. */
9889 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9890 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9893 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9894 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9903 print_dynamic_flags (bfd_vma flags
)
9905 bfd_boolean first
= TRUE
;
9911 flag
= flags
& - flags
;
9921 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9922 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9923 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9924 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9925 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9926 default: fputs (_("unknown"), stdout
); break;
9933 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9935 unsigned char * e_data
;
9938 /* If the size_t type is smaller than the bfd_size_type, eg because
9939 you are building a 32-bit tool on a 64-bit host, then make sure
9940 that when (number) is cast to (size_t) no information is lost. */
9941 if (sizeof (size_t) < sizeof (bfd_size_type
)
9942 && (bfd_size_type
) ((size_t) number
) != number
)
9944 error (_("Size truncation prevents reading %s elements of size %u\n"),
9945 bfd_vmatoa ("u", number
), ent_size
);
9949 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9950 attempting to allocate memory when the read is bound to fail. */
9951 if (ent_size
* number
> filedata
->file_size
)
9953 error (_("Invalid number of dynamic entries: %s\n"),
9954 bfd_vmatoa ("u", number
));
9958 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9961 error (_("Out of memory reading %s dynamic entries\n"),
9962 bfd_vmatoa ("u", number
));
9966 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9968 error (_("Unable to read in %s bytes of dynamic data\n"),
9969 bfd_vmatoa ("u", number
* ent_size
));
9974 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
9977 error (_("Out of memory allocating space for %s dynamic entries\n"),
9978 bfd_vmatoa ("u", number
));
9984 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9991 static unsigned long
9992 get_num_dynamic_syms (Filedata
* filedata
)
9994 unsigned long num_of_syms
= 0;
9996 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
9999 if (filedata
->dynamic_info
[DT_HASH
])
10001 unsigned char nb
[8];
10002 unsigned char nc
[8];
10003 unsigned int hash_ent_size
= 4;
10005 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10006 || filedata
->file_header
.e_machine
== EM_S390
10007 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10008 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10011 if (fseek (filedata
->handle
,
10012 (filedata
->archive_file_offset
10013 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10014 sizeof nb
+ sizeof nc
)),
10017 error (_("Unable to seek to start of dynamic information\n"));
10021 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10023 error (_("Failed to read in number of buckets\n"));
10027 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10029 error (_("Failed to read in number of chains\n"));
10033 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10034 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10036 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10038 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10040 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10043 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10044 num_of_syms
= filedata
->nchains
;
10047 if (num_of_syms
== 0)
10049 free (filedata
->buckets
);
10050 filedata
->buckets
= NULL
;
10051 free (filedata
->chains
);
10052 filedata
->chains
= NULL
;
10053 filedata
->nbuckets
= 0;
10057 if (filedata
->dynamic_info_DT_GNU_HASH
)
10059 unsigned char nb
[16];
10060 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10061 bfd_vma buckets_vma
;
10064 if (fseek (filedata
->handle
,
10065 (filedata
->archive_file_offset
10066 + offset_from_vma (filedata
,
10067 filedata
->dynamic_info_DT_GNU_HASH
,
10071 error (_("Unable to seek to start of dynamic information\n"));
10075 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10077 error (_("Failed to read in number of buckets\n"));
10081 filedata
->ngnubuckets
= byte_get (nb
, 4);
10082 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10083 bitmaskwords
= byte_get (nb
+ 8, 4);
10084 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10086 buckets_vma
+= bitmaskwords
* 4;
10088 buckets_vma
+= bitmaskwords
* 8;
10090 if (fseek (filedata
->handle
,
10091 (filedata
->archive_file_offset
10092 + offset_from_vma (filedata
, buckets_vma
, 4)),
10095 error (_("Unable to seek to start of dynamic information\n"));
10099 filedata
->gnubuckets
10100 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10102 if (filedata
->gnubuckets
== NULL
)
10105 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10106 if (filedata
->gnubuckets
[i
] != 0)
10108 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10111 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10112 maxchain
= filedata
->gnubuckets
[i
];
10115 if (maxchain
== 0xffffffff)
10118 maxchain
-= filedata
->gnusymidx
;
10120 if (fseek (filedata
->handle
,
10121 (filedata
->archive_file_offset
10122 + offset_from_vma (filedata
,
10123 buckets_vma
+ 4 * (filedata
->ngnubuckets
10128 error (_("Unable to seek to start of dynamic information\n"));
10134 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10136 error (_("Failed to determine last chain length\n"));
10140 if (maxchain
+ 1 == 0)
10145 while ((byte_get (nb
, 4) & 1) == 0);
10147 if (fseek (filedata
->handle
,
10148 (filedata
->archive_file_offset
10149 + offset_from_vma (filedata
, (buckets_vma
10150 + 4 * filedata
->ngnubuckets
),
10154 error (_("Unable to seek to start of dynamic information\n"));
10158 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10159 filedata
->ngnuchains
= maxchain
;
10161 if (filedata
->gnuchains
== NULL
)
10164 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10166 if (fseek (filedata
->handle
,
10167 (filedata
->archive_file_offset
10168 + offset_from_vma (filedata
, (buckets_vma
10169 + 4 * (filedata
->ngnubuckets
10173 error (_("Unable to seek to start of dynamic information\n"));
10177 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10178 if (filedata
->mipsxlat
== NULL
)
10182 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10183 if (filedata
->gnubuckets
[hn
] != 0)
10185 bfd_vma si
= filedata
->gnubuckets
[hn
];
10186 bfd_vma off
= si
- filedata
->gnusymidx
;
10190 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10192 if (off
< filedata
->ngnuchains
10193 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10194 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10198 if (si
>= num_of_syms
)
10199 num_of_syms
= si
+ 1;
10203 while (off
< filedata
->ngnuchains
10204 && (filedata
->gnuchains
[off
++] & 1) == 0);
10207 if (num_of_syms
== 0)
10210 free (filedata
->mipsxlat
);
10211 filedata
->mipsxlat
= NULL
;
10212 free (filedata
->gnuchains
);
10213 filedata
->gnuchains
= NULL
;
10214 free (filedata
->gnubuckets
);
10215 filedata
->gnubuckets
= NULL
;
10216 filedata
->ngnubuckets
= 0;
10217 filedata
->ngnuchains
= 0;
10221 return num_of_syms
;
10224 /* Parse and display the contents of the dynamic section. */
10227 process_dynamic_section (Filedata
* filedata
)
10229 Elf_Internal_Dyn
* entry
;
10231 if (filedata
->dynamic_size
== 0)
10234 printf (_("\nThere is no dynamic section in this file.\n"));
10241 if (! get_32bit_dynamic_section (filedata
))
10246 if (! get_64bit_dynamic_section (filedata
))
10250 /* Find the appropriate symbol table. */
10251 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10253 unsigned long num_of_syms
;
10255 for (entry
= filedata
->dynamic_section
;
10256 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10258 if (entry
->d_tag
== DT_SYMTAB
)
10259 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10260 else if (entry
->d_tag
== DT_SYMENT
)
10261 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10262 else if (entry
->d_tag
== DT_HASH
)
10263 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10264 else if (entry
->d_tag
== DT_GNU_HASH
)
10265 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10266 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10267 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10268 && entry
->d_tag
== DT_MIPS_XHASH
)
10270 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10271 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10274 num_of_syms
= get_num_dynamic_syms (filedata
);
10276 if (num_of_syms
!= 0
10277 && filedata
->dynamic_symbols
== NULL
10278 && filedata
->dynamic_info
[DT_SYMTAB
]
10279 && filedata
->dynamic_info
[DT_SYMENT
])
10281 Elf_Internal_Phdr
*seg
;
10282 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10284 if (! get_program_headers (filedata
))
10286 error (_("Cannot interpret virtual addresses "
10287 "without program headers.\n"));
10291 for (seg
= filedata
->program_headers
;
10292 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10295 if (seg
->p_type
!= PT_LOAD
)
10298 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10300 /* See PR 21379 for a reproducer. */
10301 error (_("Invalid PT_LOAD entry\n"));
10305 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10306 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10308 /* Since we do not know how big the symbol table is,
10309 we default to reading in up to the end of PT_LOAD
10310 segment and processing that. This is overkill, I
10311 know, but it should work. */
10312 Elf_Internal_Shdr section
;
10313 section
.sh_offset
= (vma
- seg
->p_vaddr
10315 section
.sh_size
= (num_of_syms
10316 * filedata
->dynamic_info
[DT_SYMENT
]);
10317 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10320 && filedata
->dynamic_symtab_section
!= NULL
10321 && ((filedata
->dynamic_symtab_section
->sh_offset
10322 != section
.sh_offset
)
10323 || (filedata
->dynamic_symtab_section
->sh_size
10324 != section
.sh_size
)
10325 || (filedata
->dynamic_symtab_section
->sh_entsize
10326 != section
.sh_entsize
)))
10328 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10330 section
.sh_name
= filedata
->string_table_length
;
10331 filedata
->dynamic_symbols
10332 = GET_ELF_SYMBOLS (filedata
, §ion
,
10333 &filedata
->num_dynamic_syms
);
10334 if (filedata
->dynamic_symbols
== NULL
10335 || filedata
->num_dynamic_syms
!= num_of_syms
)
10337 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10346 /* Similarly find a string table. */
10347 if (filedata
->dynamic_strings
== NULL
)
10348 for (entry
= filedata
->dynamic_section
;
10349 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10352 if (entry
->d_tag
== DT_STRTAB
)
10353 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10355 if (entry
->d_tag
== DT_STRSZ
)
10356 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10358 if (filedata
->dynamic_info
[DT_STRTAB
]
10359 && filedata
->dynamic_info
[DT_STRSZ
])
10361 unsigned long offset
;
10362 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10364 offset
= offset_from_vma (filedata
,
10365 filedata
->dynamic_info
[DT_STRTAB
],
10368 && filedata
->dynamic_strtab_section
10369 && ((filedata
->dynamic_strtab_section
->sh_offset
10370 != (file_ptr
) offset
)
10371 || (filedata
->dynamic_strtab_section
->sh_size
10374 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10376 filedata
->dynamic_strings
10377 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10378 _("dynamic string table"));
10379 if (filedata
->dynamic_strings
== NULL
)
10381 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10385 filedata
->dynamic_strings_length
= str_tab_len
;
10390 /* And find the syminfo section if available. */
10391 if (filedata
->dynamic_syminfo
== NULL
)
10393 unsigned long syminsz
= 0;
10395 for (entry
= filedata
->dynamic_section
;
10396 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10399 if (entry
->d_tag
== DT_SYMINENT
)
10401 /* Note: these braces are necessary to avoid a syntax
10402 error from the SunOS4 C compiler. */
10403 /* PR binutils/17531: A corrupt file can trigger this test.
10404 So do not use an assert, instead generate an error message. */
10405 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10406 error (_("Bad value (%d) for SYMINENT entry\n"),
10407 (int) entry
->d_un
.d_val
);
10409 else if (entry
->d_tag
== DT_SYMINSZ
)
10410 syminsz
= entry
->d_un
.d_val
;
10411 else if (entry
->d_tag
== DT_SYMINFO
)
10412 filedata
->dynamic_syminfo_offset
10413 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10416 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10418 Elf_External_Syminfo
* extsyminfo
;
10419 Elf_External_Syminfo
* extsym
;
10420 Elf_Internal_Syminfo
* syminfo
;
10422 /* There is a syminfo section. Read the data. */
10423 extsyminfo
= (Elf_External_Syminfo
*)
10424 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10425 1, syminsz
, _("symbol information"));
10429 if (filedata
->dynamic_syminfo
!= NULL
)
10431 error (_("Multiple dynamic symbol information sections found\n"));
10432 free (filedata
->dynamic_syminfo
);
10434 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10435 if (filedata
->dynamic_syminfo
== NULL
)
10437 error (_("Out of memory allocating %lu bytes "
10438 "for dynamic symbol info\n"),
10439 (unsigned long) syminsz
);
10443 filedata
->dynamic_syminfo_nent
10444 = syminsz
/ sizeof (Elf_External_Syminfo
);
10445 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10446 syminfo
< (filedata
->dynamic_syminfo
10447 + filedata
->dynamic_syminfo_nent
);
10448 ++syminfo
, ++extsym
)
10450 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10451 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10458 if (do_dynamic
&& filedata
->dynamic_addr
)
10459 printf (ngettext ("\nDynamic section at offset 0x%lx "
10460 "contains %lu entry:\n",
10461 "\nDynamic section at offset 0x%lx "
10462 "contains %lu entries:\n",
10463 filedata
->dynamic_nent
),
10464 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10466 printf (_(" Tag Type Name/Value\n"));
10468 for (entry
= filedata
->dynamic_section
;
10469 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10474 const char * dtype
;
10477 print_vma (entry
->d_tag
, FULL_HEX
);
10478 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10479 printf (" (%s)%*s", dtype
,
10480 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10483 switch (entry
->d_tag
)
10487 print_dynamic_flags (entry
->d_un
.d_val
);
10497 switch (entry
->d_tag
)
10500 printf (_("Auxiliary library"));
10504 printf (_("Filter library"));
10508 printf (_("Configuration file"));
10512 printf (_("Dependency audit library"));
10516 printf (_("Audit library"));
10520 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10521 printf (": [%s]\n",
10522 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10526 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10535 printf (_("Flags:"));
10537 if (entry
->d_un
.d_val
== 0)
10538 printf (_(" None\n"));
10541 unsigned long int val
= entry
->d_un
.d_val
;
10543 if (val
& DTF_1_PARINIT
)
10545 printf (" PARINIT");
10546 val
^= DTF_1_PARINIT
;
10548 if (val
& DTF_1_CONFEXP
)
10550 printf (" CONFEXP");
10551 val
^= DTF_1_CONFEXP
;
10554 printf (" %lx", val
);
10563 printf (_("Flags:"));
10565 if (entry
->d_un
.d_val
== 0)
10566 printf (_(" None\n"));
10569 unsigned long int val
= entry
->d_un
.d_val
;
10571 if (val
& DF_P1_LAZYLOAD
)
10573 printf (" LAZYLOAD");
10574 val
^= DF_P1_LAZYLOAD
;
10576 if (val
& DF_P1_GROUPPERM
)
10578 printf (" GROUPPERM");
10579 val
^= DF_P1_GROUPPERM
;
10582 printf (" %lx", val
);
10591 printf (_("Flags:"));
10592 if (entry
->d_un
.d_val
== 0)
10593 printf (_(" None\n"));
10596 unsigned long int val
= entry
->d_un
.d_val
;
10598 if (val
& DF_1_NOW
)
10603 if (val
& DF_1_GLOBAL
)
10605 printf (" GLOBAL");
10606 val
^= DF_1_GLOBAL
;
10608 if (val
& DF_1_GROUP
)
10613 if (val
& DF_1_NODELETE
)
10615 printf (" NODELETE");
10616 val
^= DF_1_NODELETE
;
10618 if (val
& DF_1_LOADFLTR
)
10620 printf (" LOADFLTR");
10621 val
^= DF_1_LOADFLTR
;
10623 if (val
& DF_1_INITFIRST
)
10625 printf (" INITFIRST");
10626 val
^= DF_1_INITFIRST
;
10628 if (val
& DF_1_NOOPEN
)
10630 printf (" NOOPEN");
10631 val
^= DF_1_NOOPEN
;
10633 if (val
& DF_1_ORIGIN
)
10635 printf (" ORIGIN");
10636 val
^= DF_1_ORIGIN
;
10638 if (val
& DF_1_DIRECT
)
10640 printf (" DIRECT");
10641 val
^= DF_1_DIRECT
;
10643 if (val
& DF_1_TRANS
)
10648 if (val
& DF_1_INTERPOSE
)
10650 printf (" INTERPOSE");
10651 val
^= DF_1_INTERPOSE
;
10653 if (val
& DF_1_NODEFLIB
)
10655 printf (" NODEFLIB");
10656 val
^= DF_1_NODEFLIB
;
10658 if (val
& DF_1_NODUMP
)
10660 printf (" NODUMP");
10661 val
^= DF_1_NODUMP
;
10663 if (val
& DF_1_CONFALT
)
10665 printf (" CONFALT");
10666 val
^= DF_1_CONFALT
;
10668 if (val
& DF_1_ENDFILTEE
)
10670 printf (" ENDFILTEE");
10671 val
^= DF_1_ENDFILTEE
;
10673 if (val
& DF_1_DISPRELDNE
)
10675 printf (" DISPRELDNE");
10676 val
^= DF_1_DISPRELDNE
;
10678 if (val
& DF_1_DISPRELPND
)
10680 printf (" DISPRELPND");
10681 val
^= DF_1_DISPRELPND
;
10683 if (val
& DF_1_NODIRECT
)
10685 printf (" NODIRECT");
10686 val
^= DF_1_NODIRECT
;
10688 if (val
& DF_1_IGNMULDEF
)
10690 printf (" IGNMULDEF");
10691 val
^= DF_1_IGNMULDEF
;
10693 if (val
& DF_1_NOKSYMS
)
10695 printf (" NOKSYMS");
10696 val
^= DF_1_NOKSYMS
;
10698 if (val
& DF_1_NOHDR
)
10703 if (val
& DF_1_EDITED
)
10705 printf (" EDITED");
10706 val
^= DF_1_EDITED
;
10708 if (val
& DF_1_NORELOC
)
10710 printf (" NORELOC");
10711 val
^= DF_1_NORELOC
;
10713 if (val
& DF_1_SYMINTPOSE
)
10715 printf (" SYMINTPOSE");
10716 val
^= DF_1_SYMINTPOSE
;
10718 if (val
& DF_1_GLOBAUDIT
)
10720 printf (" GLOBAUDIT");
10721 val
^= DF_1_GLOBAUDIT
;
10723 if (val
& DF_1_SINGLETON
)
10725 printf (" SINGLETON");
10726 val
^= DF_1_SINGLETON
;
10728 if (val
& DF_1_STUB
)
10733 if (val
& DF_1_PIE
)
10738 if (val
& DF_1_KMOD
)
10743 if (val
& DF_1_WEAKFILTER
)
10745 printf (" WEAKFILTER");
10746 val
^= DF_1_WEAKFILTER
;
10748 if (val
& DF_1_NOCOMMON
)
10750 printf (" NOCOMMON");
10751 val
^= DF_1_NOCOMMON
;
10754 printf (" %lx", val
);
10761 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10763 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10783 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10789 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10790 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10796 switch (entry
->d_tag
)
10799 printf (_("Shared library: [%s]"), name
);
10801 if (streq (name
, filedata
->program_interpreter
))
10802 printf (_(" program interpreter"));
10806 printf (_("Library soname: [%s]"), name
);
10810 printf (_("Library rpath: [%s]"), name
);
10814 printf (_("Library runpath: [%s]"), name
);
10818 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10823 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10836 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10837 /* Fall through. */
10841 case DT_INIT_ARRAYSZ
:
10842 case DT_FINI_ARRAYSZ
:
10843 case DT_GNU_CONFLICTSZ
:
10844 case DT_GNU_LIBLISTSZ
:
10847 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10848 printf (_(" (bytes)\n"));
10853 case DT_VERNEEDNUM
:
10858 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10867 case DT_INIT_ARRAY
:
10868 case DT_FINI_ARRAY
:
10871 if (entry
->d_tag
== DT_USED
10872 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10874 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10878 printf (_("Not needed object: [%s]\n"), name
);
10883 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10889 /* The value of this entry is ignored. */
10894 case DT_GNU_PRELINKED
:
10898 time_t atime
= entry
->d_un
.d_val
;
10900 tmp
= gmtime (&atime
);
10901 /* PR 17533 file: 041-1244816-0.004. */
10903 printf (_("<corrupt time val: %lx"),
10904 (unsigned long) atime
);
10906 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10907 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10908 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10914 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10917 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10923 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10924 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10925 = entry
->d_un
.d_val
;
10929 switch (filedata
->file_header
.e_machine
)
10932 dynamic_section_aarch64_val (entry
);
10935 case EM_MIPS_RS3_LE
:
10936 dynamic_section_mips_val (filedata
, entry
);
10939 dynamic_section_parisc_val (entry
);
10942 dynamic_section_ia64_val (entry
);
10945 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10957 get_ver_flags (unsigned int flags
)
10959 static char buff
[128];
10966 if (flags
& VER_FLG_BASE
)
10967 strcat (buff
, "BASE");
10969 if (flags
& VER_FLG_WEAK
)
10971 if (flags
& VER_FLG_BASE
)
10972 strcat (buff
, " | ");
10974 strcat (buff
, "WEAK");
10977 if (flags
& VER_FLG_INFO
)
10979 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10980 strcat (buff
, " | ");
10982 strcat (buff
, "INFO");
10985 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10987 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10988 strcat (buff
, " | ");
10990 strcat (buff
, _("<unknown>"));
10996 /* Display the contents of the version sections. */
10999 process_version_sections (Filedata
* filedata
)
11001 Elf_Internal_Shdr
* section
;
11003 bfd_boolean found
= FALSE
;
11008 for (i
= 0, section
= filedata
->section_headers
;
11009 i
< filedata
->file_header
.e_shnum
;
11012 switch (section
->sh_type
)
11014 case SHT_GNU_verdef
:
11016 Elf_External_Verdef
* edefs
;
11023 printf (ngettext ("\nVersion definition section '%s' "
11024 "contains %u entry:\n",
11025 "\nVersion definition section '%s' "
11026 "contains %u entries:\n",
11028 printable_section_name (filedata
, section
),
11031 printf (_(" Addr: 0x"));
11032 printf_vma (section
->sh_addr
);
11033 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11034 (unsigned long) section
->sh_offset
, section
->sh_link
,
11035 printable_section_name_from_index (filedata
, section
->sh_link
));
11037 edefs
= (Elf_External_Verdef
*)
11038 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11039 _("version definition section"));
11042 endbuf
= (char *) edefs
+ section
->sh_size
;
11044 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11047 Elf_External_Verdef
* edef
;
11048 Elf_Internal_Verdef ent
;
11049 Elf_External_Verdaux
* eaux
;
11050 Elf_Internal_Verdaux aux
;
11051 unsigned long isum
;
11054 vstart
= ((char *) edefs
) + idx
;
11055 if (vstart
+ sizeof (*edef
) > endbuf
)
11058 edef
= (Elf_External_Verdef
*) vstart
;
11060 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11061 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11062 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11063 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11064 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11065 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11066 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11068 printf (_(" %#06lx: Rev: %d Flags: %s"),
11069 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11071 printf (_(" Index: %d Cnt: %d "),
11072 ent
.vd_ndx
, ent
.vd_cnt
);
11074 /* Check for overflow. */
11075 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11078 vstart
+= ent
.vd_aux
;
11080 if (vstart
+ sizeof (*eaux
) > endbuf
)
11082 eaux
= (Elf_External_Verdaux
*) vstart
;
11084 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11085 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11087 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11088 printf (_("Name: %s\n"),
11089 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11091 printf (_("Name index: %ld\n"), aux
.vda_name
);
11093 isum
= idx
+ ent
.vd_aux
;
11095 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11097 if (aux
.vda_next
< sizeof (*eaux
)
11098 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11100 warn (_("Invalid vda_next field of %lx\n"),
11105 /* Check for overflow. */
11106 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11109 isum
+= aux
.vda_next
;
11110 vstart
+= aux
.vda_next
;
11112 if (vstart
+ sizeof (*eaux
) > endbuf
)
11114 eaux
= (Elf_External_Verdaux
*) vstart
;
11116 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11117 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11119 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11120 printf (_(" %#06lx: Parent %d: %s\n"),
11122 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11124 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11125 isum
, j
, aux
.vda_name
);
11128 if (j
< ent
.vd_cnt
)
11129 printf (_(" Version def aux past end of section\n"));
11132 file: id:000001,src:000172+005151,op:splice,rep:2. */
11133 if (ent
.vd_next
< sizeof (*edef
)
11134 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11136 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11137 cnt
= section
->sh_info
;
11140 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11143 idx
+= ent
.vd_next
;
11146 if (cnt
< section
->sh_info
)
11147 printf (_(" Version definition past end of section\n"));
11153 case SHT_GNU_verneed
:
11155 Elf_External_Verneed
* eneed
;
11162 printf (ngettext ("\nVersion needs section '%s' "
11163 "contains %u entry:\n",
11164 "\nVersion needs section '%s' "
11165 "contains %u entries:\n",
11167 printable_section_name (filedata
, section
), section
->sh_info
);
11169 printf (_(" Addr: 0x"));
11170 printf_vma (section
->sh_addr
);
11171 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11172 (unsigned long) section
->sh_offset
, section
->sh_link
,
11173 printable_section_name_from_index (filedata
, section
->sh_link
));
11175 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11176 section
->sh_offset
, 1,
11178 _("Version Needs section"));
11181 endbuf
= (char *) eneed
+ section
->sh_size
;
11183 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11185 Elf_External_Verneed
* entry
;
11186 Elf_Internal_Verneed ent
;
11187 unsigned long isum
;
11191 vstart
= ((char *) eneed
) + idx
;
11192 if (vstart
+ sizeof (*entry
) > endbuf
)
11195 entry
= (Elf_External_Verneed
*) vstart
;
11197 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11198 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11199 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11200 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11201 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11203 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11205 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11206 printf (_(" File: %s"),
11207 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11209 printf (_(" File: %lx"), ent
.vn_file
);
11211 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11213 /* Check for overflow. */
11214 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11216 vstart
+= ent
.vn_aux
;
11218 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11220 Elf_External_Vernaux
* eaux
;
11221 Elf_Internal_Vernaux aux
;
11223 if (vstart
+ sizeof (*eaux
) > endbuf
)
11225 eaux
= (Elf_External_Vernaux
*) vstart
;
11227 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11228 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11229 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11230 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11231 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11233 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11234 printf (_(" %#06lx: Name: %s"),
11235 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11237 printf (_(" %#06lx: Name index: %lx"),
11238 isum
, aux
.vna_name
);
11240 printf (_(" Flags: %s Version: %d\n"),
11241 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11243 if (aux
.vna_next
< sizeof (*eaux
)
11244 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11246 warn (_("Invalid vna_next field of %lx\n"),
11251 /* Check for overflow. */
11252 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11254 isum
+= aux
.vna_next
;
11255 vstart
+= aux
.vna_next
;
11258 if (j
< ent
.vn_cnt
)
11259 warn (_("Missing Version Needs auxillary information\n"));
11261 if (ent
.vn_next
< sizeof (*entry
)
11262 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11264 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11265 cnt
= section
->sh_info
;
11268 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11270 idx
+= ent
.vn_next
;
11273 if (cnt
< section
->sh_info
)
11274 warn (_("Missing Version Needs information\n"));
11280 case SHT_GNU_versym
:
11282 Elf_Internal_Shdr
* link_section
;
11285 unsigned char * edata
;
11286 unsigned short * data
;
11288 Elf_Internal_Sym
* symbols
;
11289 Elf_Internal_Shdr
* string_sec
;
11290 unsigned long num_syms
;
11293 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11296 link_section
= filedata
->section_headers
+ section
->sh_link
;
11297 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11299 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11304 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11305 if (symbols
== NULL
)
11308 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11310 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11311 string_sec
->sh_size
,
11312 _("version string table"));
11319 printf (ngettext ("\nVersion symbols section '%s' "
11320 "contains %lu entry:\n",
11321 "\nVersion symbols section '%s' "
11322 "contains %lu entries:\n",
11324 printable_section_name (filedata
, section
), (unsigned long) total
);
11326 printf (_(" Addr: 0x"));
11327 printf_vma (section
->sh_addr
);
11328 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11329 (unsigned long) section
->sh_offset
, section
->sh_link
,
11330 printable_section_name (filedata
, link_section
));
11332 off
= offset_from_vma (filedata
,
11333 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11334 total
* sizeof (short));
11335 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11336 sizeof (short), total
,
11337 _("version symbol data"));
11345 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11347 for (cnt
= total
; cnt
--;)
11348 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11353 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11357 char *invalid
= _("*invalid*");
11359 printf (" %03x:", cnt
);
11361 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11362 switch (data
[cnt
+ j
])
11365 fputs (_(" 0 (*local*) "), stdout
);
11369 fputs (_(" 1 (*global*) "), stdout
);
11373 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11374 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11376 /* If this index value is greater than the size of the symbols
11377 array, break to avoid an out-of-bounds read. */
11378 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11380 warn (_("invalid index into symbol array\n"));
11385 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11387 Elf_Internal_Verneed ivn
;
11388 unsigned long offset
;
11390 offset
= offset_from_vma
11392 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11393 sizeof (Elf_External_Verneed
));
11397 Elf_Internal_Vernaux ivna
;
11398 Elf_External_Verneed evn
;
11399 Elf_External_Vernaux evna
;
11400 unsigned long a_off
;
11402 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11403 _("version need")) == NULL
)
11406 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11407 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11409 a_off
= offset
+ ivn
.vn_aux
;
11413 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11414 1, _("version need aux (2)")) == NULL
)
11417 ivna
.vna_other
= 0;
11421 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11422 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11425 a_off
+= ivna
.vna_next
;
11427 while (ivna
.vna_other
!= data
[cnt
+ j
]
11428 && ivna
.vna_next
!= 0);
11430 if (ivna
.vna_other
== data
[cnt
+ j
])
11432 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11434 if (ivna
.vna_name
>= string_sec
->sh_size
)
11437 name
= strtab
+ ivna
.vna_name
;
11441 offset
+= ivn
.vn_next
;
11443 while (ivn
.vn_next
);
11446 if (data
[cnt
+ j
] != 0x8001
11447 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11449 Elf_Internal_Verdef ivd
;
11450 Elf_External_Verdef evd
;
11451 unsigned long offset
;
11453 offset
= offset_from_vma
11455 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11460 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11461 _("version def")) == NULL
)
11464 /* PR 17531: file: 046-1082287-0.004. */
11465 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11470 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11471 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11474 offset
+= ivd
.vd_next
;
11476 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11477 && ivd
.vd_next
!= 0);
11479 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11481 Elf_External_Verdaux evda
;
11482 Elf_Internal_Verdaux ivda
;
11484 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11486 if (get_data (&evda
, filedata
,
11487 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11489 _("version def aux")) == NULL
)
11492 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11494 if (ivda
.vda_name
>= string_sec
->sh_size
)
11496 else if (name
!= NULL
&& name
!= invalid
)
11497 name
= _("*both*");
11499 name
= strtab
+ ivda
.vda_name
;
11503 nn
+= printf ("(%s%-*s",
11505 12 - (int) strlen (name
),
11509 printf ("%*c", 18 - nn
, ' ');
11527 printf (_("\nNo version information found in this file.\n"));
11532 static const char *
11533 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11535 static char buff
[64];
11539 case STB_LOCAL
: return "LOCAL";
11540 case STB_GLOBAL
: return "GLOBAL";
11541 case STB_WEAK
: return "WEAK";
11543 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11544 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11546 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11548 if (binding
== STB_GNU_UNIQUE
11549 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11551 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11554 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11559 static const char *
11560 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11562 static char buff
[64];
11566 case STT_NOTYPE
: return "NOTYPE";
11567 case STT_OBJECT
: return "OBJECT";
11568 case STT_FUNC
: return "FUNC";
11569 case STT_SECTION
: return "SECTION";
11570 case STT_FILE
: return "FILE";
11571 case STT_COMMON
: return "COMMON";
11572 case STT_TLS
: return "TLS";
11573 case STT_RELC
: return "RELC";
11574 case STT_SRELC
: return "SRELC";
11576 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11578 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11579 return "THUMB_FUNC";
11581 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11584 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11585 return "PARISC_MILLI";
11587 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11589 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11591 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11593 if (type
== STT_HP_OPAQUE
)
11594 return "HP_OPAQUE";
11595 if (type
== STT_HP_STUB
)
11599 if (type
== STT_GNU_IFUNC
11600 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11601 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11604 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11607 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11612 static const char *
11613 get_symbol_visibility (unsigned int visibility
)
11615 switch (visibility
)
11617 case STV_DEFAULT
: return "DEFAULT";
11618 case STV_INTERNAL
: return "INTERNAL";
11619 case STV_HIDDEN
: return "HIDDEN";
11620 case STV_PROTECTED
: return "PROTECTED";
11622 error (_("Unrecognized visibility value: %u\n"), visibility
);
11623 return _("<unknown>");
11627 static const char *
11628 get_alpha_symbol_other (unsigned int other
)
11632 case STO_ALPHA_NOPV
: return "NOPV";
11633 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11635 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11636 return _("<unknown>");
11640 static const char *
11641 get_solaris_symbol_visibility (unsigned int visibility
)
11643 switch (visibility
)
11645 case 4: return "EXPORTED";
11646 case 5: return "SINGLETON";
11647 case 6: return "ELIMINATE";
11648 default: return get_symbol_visibility (visibility
);
11652 static const char *
11653 get_aarch64_symbol_other (unsigned int other
)
11655 static char buf
[32];
11657 if (other
& STO_AARCH64_VARIANT_PCS
)
11659 other
&= ~STO_AARCH64_VARIANT_PCS
;
11661 return "VARIANT_PCS";
11662 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11668 static const char *
11669 get_mips_symbol_other (unsigned int other
)
11673 case STO_OPTIONAL
: return "OPTIONAL";
11674 case STO_MIPS_PLT
: return "MIPS PLT";
11675 case STO_MIPS_PIC
: return "MIPS PIC";
11676 case STO_MICROMIPS
: return "MICROMIPS";
11677 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11678 case STO_MIPS16
: return "MIPS16";
11679 default: return NULL
;
11683 static const char *
11684 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11686 if (is_ia64_vms (filedata
))
11688 static char res
[32];
11692 /* Function types is for images and .STB files only. */
11693 switch (filedata
->file_header
.e_type
)
11697 switch (VMS_ST_FUNC_TYPE (other
))
11699 case VMS_SFT_CODE_ADDR
:
11700 strcat (res
, " CA");
11702 case VMS_SFT_SYMV_IDX
:
11703 strcat (res
, " VEC");
11706 strcat (res
, " FD");
11708 case VMS_SFT_RESERVE
:
11709 strcat (res
, " RSV");
11712 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11713 VMS_ST_FUNC_TYPE (other
));
11714 strcat (res
, " <unknown>");
11721 switch (VMS_ST_LINKAGE (other
))
11723 case VMS_STL_IGNORE
:
11724 strcat (res
, " IGN");
11726 case VMS_STL_RESERVE
:
11727 strcat (res
, " RSV");
11730 strcat (res
, " STD");
11733 strcat (res
, " LNK");
11736 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11737 VMS_ST_LINKAGE (other
));
11738 strcat (res
, " <unknown>");
11750 static const char *
11751 get_ppc64_symbol_other (unsigned int other
)
11753 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11756 other
>>= STO_PPC64_LOCAL_BIT
;
11759 static char buf
[64];
11761 other
= ppc64_decode_local_entry (other
);
11762 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11768 static const char *
11769 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11771 const char * result
= NULL
;
11772 static char buff
[64];
11777 switch (filedata
->file_header
.e_machine
)
11780 result
= get_alpha_symbol_other (other
);
11783 result
= get_aarch64_symbol_other (other
);
11786 result
= get_mips_symbol_other (other
);
11789 result
= get_ia64_symbol_other (filedata
, other
);
11792 result
= get_ppc64_symbol_other (other
);
11802 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11806 static const char *
11807 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11809 static char buff
[32];
11813 case SHN_UNDEF
: return "UND";
11814 case SHN_ABS
: return "ABS";
11815 case SHN_COMMON
: return "COM";
11817 if (type
== SHN_IA_64_ANSI_COMMON
11818 && filedata
->file_header
.e_machine
== EM_IA_64
11819 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11821 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11822 || filedata
->file_header
.e_machine
== EM_L1OM
11823 || filedata
->file_header
.e_machine
== EM_K1OM
)
11824 && type
== SHN_X86_64_LCOMMON
)
11825 return "LARGE_COM";
11826 else if ((type
== SHN_MIPS_SCOMMON
11827 && filedata
->file_header
.e_machine
== EM_MIPS
)
11828 || (type
== SHN_TIC6X_SCOMMON
11829 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11831 else if (type
== SHN_MIPS_SUNDEFINED
11832 && filedata
->file_header
.e_machine
== EM_MIPS
)
11834 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11835 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11836 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11837 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11838 else if (type
>= SHN_LORESERVE
)
11839 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11840 else if (filedata
->file_header
.e_shnum
!= 0
11841 && type
>= filedata
->file_header
.e_shnum
)
11842 sprintf (buff
, _("bad section index[%3d]"), type
);
11844 sprintf (buff
, "%3d", type
);
11851 static const char *
11852 get_symbol_version_string (Filedata
* filedata
,
11853 bfd_boolean is_dynsym
,
11854 const char * strtab
,
11855 unsigned long int strtab_size
,
11857 Elf_Internal_Sym
* psym
,
11858 enum versioned_symbol_info
* sym_info
,
11859 unsigned short * vna_other
)
11861 unsigned char data
[2];
11862 unsigned short vers_data
;
11863 unsigned long offset
;
11864 unsigned short max_vd_ndx
;
11867 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11870 offset
= offset_from_vma (filedata
,
11871 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11872 sizeof data
+ si
* sizeof (vers_data
));
11874 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11875 sizeof (data
), 1, _("version data")) == NULL
)
11878 vers_data
= byte_get (data
, 2);
11880 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11883 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11886 /* Usually we'd only see verdef for defined symbols, and verneed for
11887 undefined symbols. However, symbols defined by the linker in
11888 .dynbss for variables copied from a shared library in order to
11889 avoid text relocations are defined yet have verneed. We could
11890 use a heuristic to detect the special case, for example, check
11891 for verneed first on symbols defined in SHT_NOBITS sections, but
11892 it is simpler and more reliable to just look for both verdef and
11893 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11895 if (psym
->st_shndx
!= SHN_UNDEF
11896 && vers_data
!= 0x8001
11897 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11899 Elf_Internal_Verdef ivd
;
11900 Elf_Internal_Verdaux ivda
;
11901 Elf_External_Verdaux evda
;
11904 off
= offset_from_vma (filedata
,
11905 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11906 sizeof (Elf_External_Verdef
));
11910 Elf_External_Verdef evd
;
11912 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11913 _("version def")) == NULL
)
11922 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11923 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11924 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11925 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11928 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11929 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11931 off
+= ivd
.vd_next
;
11933 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11935 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11937 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11940 off
-= ivd
.vd_next
;
11943 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11944 _("version def aux")) != NULL
)
11946 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11948 if (psym
->st_name
!= ivda
.vda_name
)
11949 return (ivda
.vda_name
< strtab_size
11950 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11955 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11957 Elf_External_Verneed evn
;
11958 Elf_Internal_Verneed ivn
;
11959 Elf_Internal_Vernaux ivna
;
11961 offset
= offset_from_vma (filedata
,
11962 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11966 unsigned long vna_off
;
11968 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11969 _("version need")) == NULL
)
11972 ivna
.vna_other
= 0;
11977 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11978 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11980 vna_off
= offset
+ ivn
.vn_aux
;
11984 Elf_External_Vernaux evna
;
11986 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11987 _("version need aux (3)")) == NULL
)
11990 ivna
.vna_other
= 0;
11995 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11996 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11997 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12000 vna_off
+= ivna
.vna_next
;
12002 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12004 if (ivna
.vna_other
== vers_data
)
12007 offset
+= ivn
.vn_next
;
12009 while (ivn
.vn_next
!= 0);
12011 if (ivna
.vna_other
== vers_data
)
12013 *sym_info
= symbol_undefined
;
12014 *vna_other
= ivna
.vna_other
;
12015 return (ivna
.vna_name
< strtab_size
12016 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12018 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12019 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12020 return _("<corrupt>");
12026 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12027 Elf_Internal_Sym
*symtab
,
12028 Elf_Internal_Shdr
*section
,
12029 char *strtab
, size_t strtab_size
)
12031 const char *version_string
;
12032 enum versioned_symbol_info sym_info
;
12033 unsigned short vna_other
;
12034 Elf_Internal_Sym
*psym
= symtab
+ si
;
12036 printf ("%6ld: ", si
);
12037 print_vma (psym
->st_value
, LONG_HEX
);
12039 print_vma (psym
->st_size
, DEC_5
);
12040 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12041 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12042 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12043 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12046 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12048 printf (" %-7s", get_symbol_visibility (vis
));
12049 /* Check to see if any other bits in the st_other field are set.
12050 Note - displaying this information disrupts the layout of the
12051 table being generated, but for the moment this case is very rare. */
12052 if (psym
->st_other
^ vis
)
12053 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12055 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12056 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
12058 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12061 = get_symbol_version_string (filedata
,
12063 || section
->sh_type
== SHT_DYNSYM
),
12064 strtab
, strtab_size
, si
,
12065 psym
, &sym_info
, &vna_other
);
12066 if (version_string
)
12068 if (sym_info
== symbol_undefined
)
12069 printf ("@%s (%d)", version_string
, vna_other
);
12071 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12077 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12079 && si
>= section
->sh_info
12080 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12081 && filedata
->file_header
.e_machine
!= EM_MIPS
12082 /* Solaris binaries have been found to violate this requirement as
12083 well. Not sure if this is a bug or an ABI requirement. */
12084 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12085 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12086 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12089 /* Dump the symbol table. */
12091 process_symbol_table (Filedata
* filedata
)
12093 Elf_Internal_Shdr
* section
;
12095 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12098 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12100 && do_using_dynamic
12101 && filedata
->dynamic_strings
!= NULL
12102 && filedata
->dynamic_symbols
!= NULL
)
12106 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12107 "\nSymbol table for image contains %lu entries:\n",
12108 filedata
->num_dynamic_syms
),
12109 filedata
->num_dynamic_syms
);
12111 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12113 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12115 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12116 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12117 filedata
->dynamic_strings
,
12118 filedata
->dynamic_strings_length
);
12120 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12121 && filedata
->section_headers
!= NULL
)
12125 for (i
= 0, section
= filedata
->section_headers
;
12126 i
< filedata
->file_header
.e_shnum
;
12129 char * strtab
= NULL
;
12130 unsigned long int strtab_size
= 0;
12131 Elf_Internal_Sym
* symtab
;
12132 unsigned long si
, num_syms
;
12134 if ((section
->sh_type
!= SHT_SYMTAB
12135 && section
->sh_type
!= SHT_DYNSYM
)
12137 && section
->sh_type
== SHT_SYMTAB
))
12140 if (section
->sh_entsize
== 0)
12142 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12143 printable_section_name (filedata
, section
));
12147 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12148 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12149 "\nSymbol table '%s' contains %lu entries:\n",
12151 printable_section_name (filedata
, section
),
12155 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12157 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12159 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12160 if (symtab
== NULL
)
12163 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12165 strtab
= filedata
->string_table
;
12166 strtab_size
= filedata
->string_table_length
;
12168 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12170 Elf_Internal_Shdr
* string_sec
;
12172 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12174 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12175 1, string_sec
->sh_size
,
12176 _("string table"));
12177 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12180 for (si
= 0; si
< num_syms
; si
++)
12181 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12182 strtab
, strtab_size
);
12185 if (strtab
!= filedata
->string_table
)
12191 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12193 if (do_histogram
&& filedata
->buckets
!= NULL
)
12195 unsigned long * lengths
;
12196 unsigned long * counts
;
12199 unsigned long maxlength
= 0;
12200 unsigned long nzero_counts
= 0;
12201 unsigned long nsyms
= 0;
12204 printf (ngettext ("\nHistogram for bucket list length "
12205 "(total of %lu bucket):\n",
12206 "\nHistogram for bucket list length "
12207 "(total of %lu buckets):\n",
12208 (unsigned long) filedata
->nbuckets
),
12209 (unsigned long) filedata
->nbuckets
);
12211 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12212 sizeof (*lengths
));
12213 if (lengths
== NULL
)
12215 error (_("Out of memory allocating space for histogram buckets\n"));
12218 visited
= xcmalloc (filedata
->nchains
, 1);
12219 memset (visited
, 0, filedata
->nchains
);
12221 printf (_(" Length Number %% of total Coverage\n"));
12222 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12224 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12227 if (maxlength
< ++lengths
[hn
])
12229 if (si
>= filedata
->nchains
|| visited
[si
])
12231 error (_("histogram chain is corrupt\n"));
12239 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12240 if (counts
== NULL
)
12243 error (_("Out of memory allocating space for histogram counts\n"));
12247 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12248 ++counts
[lengths
[hn
]];
12250 if (filedata
->nbuckets
> 0)
12253 printf (" 0 %-10lu (%5.1f%%)\n",
12254 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12255 for (i
= 1; i
<= maxlength
; ++i
)
12257 nzero_counts
+= counts
[i
] * i
;
12258 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12259 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12260 (nzero_counts
* 100.0) / nsyms
);
12268 free (filedata
->buckets
);
12269 filedata
->buckets
= NULL
;
12270 filedata
->nbuckets
= 0;
12271 free (filedata
->chains
);
12272 filedata
->chains
= NULL
;
12274 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12276 unsigned long * lengths
;
12277 unsigned long * counts
;
12279 unsigned long maxlength
= 0;
12280 unsigned long nzero_counts
= 0;
12281 unsigned long nsyms
= 0;
12283 printf (ngettext ("\nHistogram for `%s' bucket list length "
12284 "(total of %lu bucket):\n",
12285 "\nHistogram for `%s' bucket list length "
12286 "(total of %lu buckets):\n",
12287 (unsigned long) filedata
->ngnubuckets
),
12288 GNU_HASH_SECTION_NAME (filedata
),
12289 (unsigned long) filedata
->ngnubuckets
);
12291 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12292 sizeof (*lengths
));
12293 if (lengths
== NULL
)
12295 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12299 printf (_(" Length Number %% of total Coverage\n"));
12301 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12302 if (filedata
->gnubuckets
[hn
] != 0)
12304 bfd_vma off
, length
= 1;
12306 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12307 /* PR 17531 file: 010-77222-0.004. */
12308 off
< filedata
->ngnuchains
12309 && (filedata
->gnuchains
[off
] & 1) == 0;
12312 lengths
[hn
] = length
;
12313 if (length
> maxlength
)
12314 maxlength
= length
;
12318 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12319 if (counts
== NULL
)
12322 error (_("Out of memory allocating space for gnu histogram counts\n"));
12326 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12327 ++counts
[lengths
[hn
]];
12329 if (filedata
->ngnubuckets
> 0)
12332 printf (" 0 %-10lu (%5.1f%%)\n",
12333 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12334 for (j
= 1; j
<= maxlength
; ++j
)
12336 nzero_counts
+= counts
[j
] * j
;
12337 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12338 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12339 (nzero_counts
* 100.0) / nsyms
);
12346 free (filedata
->gnubuckets
);
12347 filedata
->gnubuckets
= NULL
;
12348 filedata
->ngnubuckets
= 0;
12349 free (filedata
->gnuchains
);
12350 filedata
->gnuchains
= NULL
;
12351 filedata
->ngnuchains
= 0;
12352 free (filedata
->mipsxlat
);
12353 filedata
->mipsxlat
= NULL
;
12357 free (filedata
->gnubuckets
);
12358 filedata
->gnubuckets
= NULL
;
12359 filedata
->ngnubuckets
= 0;
12360 free (filedata
->gnuchains
);
12361 filedata
->gnuchains
= NULL
;
12362 filedata
->ngnuchains
= 0;
12363 free (filedata
->mipsxlat
);
12364 filedata
->mipsxlat
= NULL
;
12365 free (filedata
->buckets
);
12366 filedata
->buckets
= NULL
;
12367 filedata
->nbuckets
= 0;
12368 free (filedata
->chains
);
12369 filedata
->chains
= NULL
;
12374 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12378 if (filedata
->dynamic_syminfo
== NULL
12380 /* No syminfo, this is ok. */
12383 /* There better should be a dynamic symbol section. */
12384 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12387 if (filedata
->dynamic_addr
)
12388 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12389 "contains %d entry:\n",
12390 "\nDynamic info segment at offset 0x%lx "
12391 "contains %d entries:\n",
12392 filedata
->dynamic_syminfo_nent
),
12393 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12395 printf (_(" Num: Name BoundTo Flags\n"));
12396 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12398 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12400 printf ("%4d: ", i
);
12401 if (i
>= filedata
->num_dynamic_syms
)
12402 printf (_("<corrupt index>"));
12403 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12404 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12405 filedata
->dynamic_symbols
[i
].st_name
));
12407 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12410 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12412 case SYMINFO_BT_SELF
:
12413 fputs ("SELF ", stdout
);
12415 case SYMINFO_BT_PARENT
:
12416 fputs ("PARENT ", stdout
);
12419 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12420 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12421 && VALID_DYNAMIC_NAME (filedata
,
12422 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12424 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12425 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12429 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12433 if (flags
& SYMINFO_FLG_DIRECT
)
12434 printf (" DIRECT");
12435 if (flags
& SYMINFO_FLG_PASSTHRU
)
12436 printf (" PASSTHRU");
12437 if (flags
& SYMINFO_FLG_COPY
)
12439 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12440 printf (" LAZYLOAD");
12448 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12449 is contained by the region START .. END. The types of ADDR, START
12450 and END should all be the same. Note both ADDR + NELEM and END
12451 point to just beyond the end of the regions that are being tested. */
12452 #define IN_RANGE(START,END,ADDR,NELEM) \
12453 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12455 /* Check to see if the given reloc needs to be handled in a target specific
12456 manner. If so then process the reloc and return TRUE otherwise return
12459 If called with reloc == NULL, then this is a signal that reloc processing
12460 for the current section has finished, and any saved state should be
12464 target_specific_reloc_handling (Filedata
* filedata
,
12465 Elf_Internal_Rela
* reloc
,
12466 unsigned char * start
,
12467 unsigned char * end
,
12468 Elf_Internal_Sym
* symtab
,
12469 unsigned long num_syms
)
12471 unsigned int reloc_type
= 0;
12472 unsigned long sym_index
= 0;
12476 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12477 sym_index
= get_reloc_symindex (reloc
->r_info
);
12480 switch (filedata
->file_header
.e_machine
)
12483 case EM_MSP430_OLD
:
12485 static Elf_Internal_Sym
* saved_sym
= NULL
;
12493 switch (reloc_type
)
12495 case 10: /* R_MSP430_SYM_DIFF */
12496 if (uses_msp430x_relocs (filedata
))
12498 /* Fall through. */
12499 case 21: /* R_MSP430X_SYM_DIFF */
12501 if (sym_index
>= num_syms
)
12502 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12505 saved_sym
= symtab
+ sym_index
;
12508 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12509 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12510 goto handle_sym_diff
;
12512 case 5: /* R_MSP430_16_BYTE */
12513 case 9: /* R_MSP430_8 */
12514 if (uses_msp430x_relocs (filedata
))
12516 goto handle_sym_diff
;
12518 case 2: /* R_MSP430_ABS16 */
12519 case 15: /* R_MSP430X_ABS16 */
12520 if (! uses_msp430x_relocs (filedata
))
12522 goto handle_sym_diff
;
12525 if (saved_sym
!= NULL
)
12527 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12530 if (sym_index
>= num_syms
)
12531 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12535 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12536 - saved_sym
->st_value
);
12538 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12539 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12542 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12543 (long) reloc
->r_offset
);
12552 if (saved_sym
!= NULL
)
12553 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12560 case EM_CYGNUS_MN10300
:
12562 static Elf_Internal_Sym
* saved_sym
= NULL
;
12570 switch (reloc_type
)
12572 case 34: /* R_MN10300_ALIGN */
12574 case 33: /* R_MN10300_SYM_DIFF */
12575 if (sym_index
>= num_syms
)
12576 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12579 saved_sym
= symtab
+ sym_index
;
12582 case 1: /* R_MN10300_32 */
12583 case 2: /* R_MN10300_16 */
12584 if (saved_sym
!= NULL
)
12586 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12589 if (sym_index
>= num_syms
)
12590 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12594 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12595 - saved_sym
->st_value
);
12597 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12598 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12600 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12601 (long) reloc
->r_offset
);
12609 if (saved_sym
!= NULL
)
12610 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12618 static bfd_vma saved_sym1
= 0;
12619 static bfd_vma saved_sym2
= 0;
12620 static bfd_vma value
;
12624 saved_sym1
= saved_sym2
= 0;
12628 switch (reloc_type
)
12630 case 0x80: /* R_RL78_SYM. */
12631 saved_sym1
= saved_sym2
;
12632 if (sym_index
>= num_syms
)
12633 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12637 saved_sym2
= symtab
[sym_index
].st_value
;
12638 saved_sym2
+= reloc
->r_addend
;
12642 case 0x83: /* R_RL78_OPsub. */
12643 value
= saved_sym1
- saved_sym2
;
12644 saved_sym2
= saved_sym1
= 0;
12648 case 0x41: /* R_RL78_ABS32. */
12649 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12650 byte_put (start
+ reloc
->r_offset
, value
, 4);
12652 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12653 (long) reloc
->r_offset
);
12657 case 0x43: /* R_RL78_ABS16. */
12658 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12659 byte_put (start
+ reloc
->r_offset
, value
, 2);
12661 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12662 (long) reloc
->r_offset
);
12676 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12677 DWARF debug sections. This is a target specific test. Note - we do not
12678 go through the whole including-target-headers-multiple-times route, (as
12679 we have already done with <elf/h8.h>) because this would become very
12680 messy and even then this function would have to contain target specific
12681 information (the names of the relocs instead of their numeric values).
12682 FIXME: This is not the correct way to solve this problem. The proper way
12683 is to have target specific reloc sizing and typing functions created by
12684 the reloc-macros.h header, in the same way that it already creates the
12685 reloc naming functions. */
12688 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12690 /* Please keep this table alpha-sorted for ease of visual lookup. */
12691 switch (filedata
->file_header
.e_machine
)
12695 return reloc_type
== 1; /* R_386_32. */
12697 return reloc_type
== 1; /* R_68K_32. */
12699 return reloc_type
== 1; /* R_860_32. */
12701 return reloc_type
== 2; /* R_960_32. */
12703 return (reloc_type
== 258
12704 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12706 return reloc_type
== 11; /* R_BPF_DATA_32 */
12707 case EM_ADAPTEVA_EPIPHANY
:
12708 return reloc_type
== 3;
12710 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12712 return reloc_type
== 1; /* R_ARC_32. */
12713 case EM_ARC_COMPACT
:
12714 case EM_ARC_COMPACT2
:
12715 return reloc_type
== 4; /* R_ARC_32. */
12717 return reloc_type
== 2; /* R_ARM_ABS32 */
12720 return reloc_type
== 1;
12722 return reloc_type
== 0x12; /* R_byte4_data. */
12724 return reloc_type
== 3; /* R_CRIS_32. */
12726 return reloc_type
== 3; /* R_CR16_NUM32. */
12728 return reloc_type
== 15; /* R_CRX_NUM32. */
12730 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12731 case EM_CYGNUS_FRV
:
12732 return reloc_type
== 1;
12733 case EM_CYGNUS_D10V
:
12735 return reloc_type
== 6; /* R_D10V_32. */
12736 case EM_CYGNUS_D30V
:
12738 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12740 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12741 case EM_CYGNUS_FR30
:
12743 return reloc_type
== 3; /* R_FR30_32. */
12745 return reloc_type
== 1; /* R_FT32_32. */
12749 return reloc_type
== 1; /* R_H8_DIR32. */
12751 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12752 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12753 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12754 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12757 return reloc_type
== 2; /* R_IP2K_32. */
12759 return reloc_type
== 2; /* R_IQ2000_32. */
12760 case EM_LATTICEMICO32
:
12761 return reloc_type
== 3; /* R_LM32_32. */
12764 return reloc_type
== 3; /* R_M32C_32. */
12766 return reloc_type
== 34; /* R_M32R_32_RELA. */
12769 return reloc_type
== 6; /* R_M68HC11_32. */
12771 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12772 reloc_type
== 6; /* R_S12Z_CW32. */
12774 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12775 case EM_CYGNUS_MEP
:
12776 return reloc_type
== 4; /* R_MEP_32. */
12778 return reloc_type
== 2; /* R_METAG_ADDR32. */
12779 case EM_MICROBLAZE
:
12780 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12782 return reloc_type
== 2; /* R_MIPS_32. */
12784 return reloc_type
== 4; /* R_MMIX_32. */
12785 case EM_CYGNUS_MN10200
:
12787 return reloc_type
== 1; /* R_MN10200_32. */
12788 case EM_CYGNUS_MN10300
:
12790 return reloc_type
== 1; /* R_MN10300_32. */
12792 return reloc_type
== 1; /* R_MOXIE_32. */
12793 case EM_MSP430_OLD
:
12795 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12797 return reloc_type
== 2; /* R_MT_32. */
12799 return reloc_type
== 20; /* R_NDS32_RELA. */
12800 case EM_ALTERA_NIOS2
:
12801 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12803 return reloc_type
== 1; /* R_NIOS_32. */
12805 return reloc_type
== 1; /* R_OR1K_32. */
12807 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12808 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12809 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12812 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12814 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12816 return reloc_type
== 1; /* R_PPC_ADDR32. */
12818 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12820 return reloc_type
== 1; /* R_RISCV_32. */
12822 return reloc_type
== 1; /* R_RL78_DIR32. */
12824 return reloc_type
== 1; /* R_RX_DIR32. */
12826 return reloc_type
== 1; /* R_I370_ADDR31. */
12829 return reloc_type
== 4; /* R_S390_32. */
12831 return reloc_type
== 8; /* R_SCORE_ABS32. */
12833 return reloc_type
== 1; /* R_SH_DIR32. */
12834 case EM_SPARC32PLUS
:
12837 return reloc_type
== 3 /* R_SPARC_32. */
12838 || reloc_type
== 23; /* R_SPARC_UA32. */
12840 return reloc_type
== 6; /* R_SPU_ADDR32 */
12842 return reloc_type
== 1; /* R_C6000_ABS32. */
12844 return reloc_type
== 2; /* R_TILEGX_32. */
12846 return reloc_type
== 1; /* R_TILEPRO_32. */
12847 case EM_CYGNUS_V850
:
12849 return reloc_type
== 6; /* R_V850_ABS32. */
12851 return reloc_type
== 0x33; /* R_V810_WORD. */
12853 return reloc_type
== 1; /* R_VAX_32. */
12855 return reloc_type
== 3; /* R_VISIUM_32. */
12856 case EM_WEBASSEMBLY
:
12857 return reloc_type
== 1; /* R_WASM32_32. */
12861 return reloc_type
== 10; /* R_X86_64_32. */
12864 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12866 return reloc_type
== 4; /* R_XGATE_32. */
12868 return reloc_type
== 1; /* R_XSTROMY16_32. */
12869 case EM_XTENSA_OLD
:
12871 return reloc_type
== 1; /* R_XTENSA_32. */
12873 return reloc_type
== 6; /* R_Z80_32. */
12876 static unsigned int prev_warn
= 0;
12878 /* Avoid repeating the same warning multiple times. */
12879 if (prev_warn
!= filedata
->file_header
.e_machine
)
12880 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12881 filedata
->file_header
.e_machine
);
12882 prev_warn
= filedata
->file_header
.e_machine
;
12888 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12889 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12892 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12894 switch (filedata
->file_header
.e_machine
)
12895 /* Please keep this table alpha-sorted for ease of visual lookup. */
12899 return reloc_type
== 2; /* R_386_PC32. */
12901 return reloc_type
== 4; /* R_68K_PC32. */
12903 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12904 case EM_ADAPTEVA_EPIPHANY
:
12905 return reloc_type
== 6;
12907 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12908 case EM_ARC_COMPACT
:
12909 case EM_ARC_COMPACT2
:
12910 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12912 return reloc_type
== 3; /* R_ARM_REL32 */
12915 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12916 case EM_MICROBLAZE
:
12917 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12919 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12921 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12923 return reloc_type
== 26; /* R_PPC_REL32. */
12925 return reloc_type
== 26; /* R_PPC64_REL32. */
12927 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12930 return reloc_type
== 5; /* R_390_PC32. */
12932 return reloc_type
== 2; /* R_SH_REL32. */
12933 case EM_SPARC32PLUS
:
12936 return reloc_type
== 6; /* R_SPARC_DISP32. */
12938 return reloc_type
== 13; /* R_SPU_REL32. */
12940 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12942 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12944 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12948 return reloc_type
== 2; /* R_X86_64_PC32. */
12950 return reloc_type
== 4; /* R_VAX_PCREL32. */
12951 case EM_XTENSA_OLD
:
12953 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12955 /* Do not abort or issue an error message here. Not all targets use
12956 pc-relative 32-bit relocs in their DWARF debug information and we
12957 have already tested for target coverage in is_32bit_abs_reloc. A
12958 more helpful warning message will be generated by apply_relocations
12959 anyway, so just return. */
12964 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12965 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12968 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12970 switch (filedata
->file_header
.e_machine
)
12973 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12975 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12977 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12978 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12980 return reloc_type
== 80; /* R_PARISC_DIR64. */
12982 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12984 return reloc_type
== 2; /* R_RISCV_64. */
12985 case EM_SPARC32PLUS
:
12988 return reloc_type
== 32 /* R_SPARC_64. */
12989 || reloc_type
== 54; /* R_SPARC_UA64. */
12993 return reloc_type
== 1; /* R_X86_64_64. */
12996 return reloc_type
== 22; /* R_S390_64. */
12998 return reloc_type
== 1; /* R_TILEGX_64. */
13000 return reloc_type
== 18; /* R_MIPS_64. */
13006 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13007 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13010 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13012 switch (filedata
->file_header
.e_machine
)
13015 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13017 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13019 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13020 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13022 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13024 return reloc_type
== 44; /* R_PPC64_REL64. */
13025 case EM_SPARC32PLUS
:
13028 return reloc_type
== 46; /* R_SPARC_DISP64. */
13032 return reloc_type
== 24; /* R_X86_64_PC64. */
13035 return reloc_type
== 23; /* R_S390_PC64. */
13037 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13043 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13044 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13047 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13049 switch (filedata
->file_header
.e_machine
)
13051 case EM_CYGNUS_MN10200
:
13053 return reloc_type
== 4; /* R_MN10200_24. */
13055 return reloc_type
== 5; /* R_FT32_20. */
13057 return reloc_type
== 5; /* R_Z80_24. */
13063 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13064 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13067 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13069 /* Please keep this table alpha-sorted for ease of visual lookup. */
13070 switch (filedata
->file_header
.e_machine
)
13073 case EM_ARC_COMPACT
:
13074 case EM_ARC_COMPACT2
:
13075 return reloc_type
== 2; /* R_ARC_16. */
13076 case EM_ADAPTEVA_EPIPHANY
:
13077 return reloc_type
== 5;
13080 return reloc_type
== 4; /* R_AVR_16. */
13081 case EM_CYGNUS_D10V
:
13083 return reloc_type
== 3; /* R_D10V_16. */
13085 return reloc_type
== 2; /* R_FT32_16. */
13089 return reloc_type
== R_H8_DIR16
;
13092 return reloc_type
== 1; /* R_IP2K_16. */
13095 return reloc_type
== 1; /* R_M32C_16 */
13096 case EM_CYGNUS_MN10200
:
13098 return reloc_type
== 2; /* R_MN10200_16. */
13099 case EM_CYGNUS_MN10300
:
13101 return reloc_type
== 2; /* R_MN10300_16. */
13103 if (uses_msp430x_relocs (filedata
))
13104 return reloc_type
== 2; /* R_MSP430_ABS16. */
13105 /* Fall through. */
13106 case EM_MSP430_OLD
:
13107 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13109 return reloc_type
== 19; /* R_NDS32_RELA. */
13110 case EM_ALTERA_NIOS2
:
13111 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13113 return reloc_type
== 9; /* R_NIOS_16. */
13115 return reloc_type
== 2; /* R_OR1K_16. */
13117 return reloc_type
== 55; /* R_RISCV_SET16. */
13119 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13121 return reloc_type
== 2; /* R_C6000_ABS16. */
13123 return reloc_type
== 2; /* R_VISIUM_16. */
13126 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13128 return reloc_type
== 3; /* R_XGATE_16. */
13130 return reloc_type
== 4; /* R_Z80_16. */
13136 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13137 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13140 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13142 switch (filedata
->file_header
.e_machine
)
13145 return reloc_type
== 54; /* R_RISCV_SET8. */
13147 return reloc_type
== 1; /* R_Z80_8. */
13153 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13154 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13157 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13159 switch (filedata
->file_header
.e_machine
)
13162 return reloc_type
== 53; /* R_RISCV_SET6. */
13168 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13169 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13172 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13174 /* Please keep this table alpha-sorted for ease of visual lookup. */
13175 switch (filedata
->file_header
.e_machine
)
13178 return reloc_type
== 35; /* R_RISCV_ADD32. */
13184 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13185 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13188 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13190 /* Please keep this table alpha-sorted for ease of visual lookup. */
13191 switch (filedata
->file_header
.e_machine
)
13194 return reloc_type
== 39; /* R_RISCV_SUB32. */
13200 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13201 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13204 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13206 /* Please keep this table alpha-sorted for ease of visual lookup. */
13207 switch (filedata
->file_header
.e_machine
)
13210 return reloc_type
== 36; /* R_RISCV_ADD64. */
13216 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13217 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13220 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13222 /* Please keep this table alpha-sorted for ease of visual lookup. */
13223 switch (filedata
->file_header
.e_machine
)
13226 return reloc_type
== 40; /* R_RISCV_SUB64. */
13232 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13233 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13236 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13238 /* Please keep this table alpha-sorted for ease of visual lookup. */
13239 switch (filedata
->file_header
.e_machine
)
13242 return reloc_type
== 34; /* R_RISCV_ADD16. */
13248 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13249 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13252 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13254 /* Please keep this table alpha-sorted for ease of visual lookup. */
13255 switch (filedata
->file_header
.e_machine
)
13258 return reloc_type
== 38; /* R_RISCV_SUB16. */
13264 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13265 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13268 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13270 /* Please keep this table alpha-sorted for ease of visual lookup. */
13271 switch (filedata
->file_header
.e_machine
)
13274 return reloc_type
== 33; /* R_RISCV_ADD8. */
13280 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13281 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13284 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13286 /* Please keep this table alpha-sorted for ease of visual lookup. */
13287 switch (filedata
->file_header
.e_machine
)
13290 return reloc_type
== 37; /* R_RISCV_SUB8. */
13296 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13297 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13300 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13302 switch (filedata
->file_header
.e_machine
)
13305 return reloc_type
== 52; /* R_RISCV_SUB6. */
13311 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13312 relocation entries (possibly formerly used for SHT_GROUP sections). */
13315 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13317 switch (filedata
->file_header
.e_machine
)
13319 case EM_386
: /* R_386_NONE. */
13320 case EM_68K
: /* R_68K_NONE. */
13321 case EM_ADAPTEVA_EPIPHANY
:
13322 case EM_ALPHA
: /* R_ALPHA_NONE. */
13323 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13324 case EM_ARC
: /* R_ARC_NONE. */
13325 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13326 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13327 case EM_ARM
: /* R_ARM_NONE. */
13328 case EM_C166
: /* R_XC16X_NONE. */
13329 case EM_CRIS
: /* R_CRIS_NONE. */
13330 case EM_FT32
: /* R_FT32_NONE. */
13331 case EM_IA_64
: /* R_IA64_NONE. */
13332 case EM_K1OM
: /* R_X86_64_NONE. */
13333 case EM_L1OM
: /* R_X86_64_NONE. */
13334 case EM_M32R
: /* R_M32R_NONE. */
13335 case EM_MIPS
: /* R_MIPS_NONE. */
13336 case EM_MN10300
: /* R_MN10300_NONE. */
13337 case EM_MOXIE
: /* R_MOXIE_NONE. */
13338 case EM_NIOS32
: /* R_NIOS_NONE. */
13339 case EM_OR1K
: /* R_OR1K_NONE. */
13340 case EM_PARISC
: /* R_PARISC_NONE. */
13341 case EM_PPC64
: /* R_PPC64_NONE. */
13342 case EM_PPC
: /* R_PPC_NONE. */
13343 case EM_RISCV
: /* R_RISCV_NONE. */
13344 case EM_S390
: /* R_390_NONE. */
13346 case EM_SH
: /* R_SH_NONE. */
13347 case EM_SPARC32PLUS
:
13348 case EM_SPARC
: /* R_SPARC_NONE. */
13350 case EM_TILEGX
: /* R_TILEGX_NONE. */
13351 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13352 case EM_TI_C6000
:/* R_C6000_NONE. */
13353 case EM_X86_64
: /* R_X86_64_NONE. */
13355 case EM_Z80
: /* R_Z80_NONE. */
13356 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13357 return reloc_type
== 0;
13360 return reloc_type
== 0 || reloc_type
== 256;
13363 return (reloc_type
== 0 /* R_AVR_NONE. */
13364 || reloc_type
== 30 /* R_AVR_DIFF8. */
13365 || reloc_type
== 31 /* R_AVR_DIFF16. */
13366 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13368 return reloc_type
== 3; /* R_METAG_NONE. */
13370 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13371 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13372 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13373 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13374 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13376 return (reloc_type
== 0 /* R_PRU_NONE. */
13377 || reloc_type
== 65 /* R_PRU_DIFF8. */
13378 || reloc_type
== 66 /* R_PRU_DIFF16. */
13379 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13380 case EM_XTENSA_OLD
:
13382 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13383 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13384 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13385 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13386 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13387 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13388 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13389 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13390 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13391 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13396 /* Returns TRUE if there is a relocation against
13397 section NAME at OFFSET bytes. */
13400 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13402 Elf_Internal_Rela
* relocs
;
13403 Elf_Internal_Rela
* rp
;
13405 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13408 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13410 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13411 if (rp
->r_offset
== offset
)
13417 /* Apply relocations to a section.
13418 Returns TRUE upon success, FALSE otherwise.
13419 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13420 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13421 will be set to the number of relocs loaded.
13423 Note: So far support has been added only for those relocations
13424 which can be found in debug sections. FIXME: Add support for
13425 more relocations ? */
13428 apply_relocations (Filedata
* filedata
,
13429 const Elf_Internal_Shdr
* section
,
13430 unsigned char * start
,
13431 bfd_size_type size
,
13432 void ** relocs_return
,
13433 unsigned long * num_relocs_return
)
13435 Elf_Internal_Shdr
* relsec
;
13436 unsigned char * end
= start
+ size
;
13438 if (relocs_return
!= NULL
)
13440 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13441 * num_relocs_return
= 0;
13444 if (filedata
->file_header
.e_type
!= ET_REL
)
13445 /* No relocs to apply. */
13448 /* Find the reloc section associated with the section. */
13449 for (relsec
= filedata
->section_headers
;
13450 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13453 bfd_boolean is_rela
;
13454 unsigned long num_relocs
;
13455 Elf_Internal_Rela
* relocs
;
13456 Elf_Internal_Rela
* rp
;
13457 Elf_Internal_Shdr
* symsec
;
13458 Elf_Internal_Sym
* symtab
;
13459 unsigned long num_syms
;
13460 Elf_Internal_Sym
* sym
;
13462 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13463 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13464 || filedata
->section_headers
+ relsec
->sh_info
!= section
13465 || relsec
->sh_size
== 0
13466 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13469 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13470 if (symsec
->sh_type
!= SHT_SYMTAB
13471 && symsec
->sh_type
!= SHT_DYNSYM
)
13474 is_rela
= relsec
->sh_type
== SHT_RELA
;
13478 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13479 relsec
->sh_size
, & relocs
, & num_relocs
))
13484 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13485 relsec
->sh_size
, & relocs
, & num_relocs
))
13489 /* SH uses RELA but uses in place value instead of the addend field. */
13490 if (filedata
->file_header
.e_machine
== EM_SH
)
13493 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13495 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13498 unsigned int reloc_type
;
13499 unsigned int reloc_size
;
13500 bfd_boolean reloc_inplace
= FALSE
;
13501 bfd_boolean reloc_subtract
= FALSE
;
13502 unsigned char * rloc
;
13503 unsigned long sym_index
;
13505 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13507 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13509 else if (is_none_reloc (filedata
, reloc_type
))
13511 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13512 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13514 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13515 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13517 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13519 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13521 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13522 || is_6bit_abs_reloc (filedata
, reloc_type
))
13524 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13526 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13529 reloc_inplace
= TRUE
;
13531 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13533 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13536 reloc_inplace
= TRUE
;
13538 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13540 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13543 reloc_inplace
= TRUE
;
13545 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13547 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13550 reloc_inplace
= TRUE
;
13552 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13556 reloc_inplace
= TRUE
;
13560 static unsigned int prev_reloc
= 0;
13562 if (reloc_type
!= prev_reloc
)
13563 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13564 reloc_type
, printable_section_name (filedata
, section
));
13565 prev_reloc
= reloc_type
;
13569 rloc
= start
+ rp
->r_offset
;
13570 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13572 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13573 (unsigned long) rp
->r_offset
,
13574 printable_section_name (filedata
, section
));
13578 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13579 if (sym_index
>= num_syms
)
13581 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13582 sym_index
, printable_section_name (filedata
, section
));
13585 sym
= symtab
+ sym_index
;
13587 /* If the reloc has a symbol associated with it,
13588 make sure that it is of an appropriate type.
13590 Relocations against symbols without type can happen.
13591 Gcc -feliminate-dwarf2-dups may generate symbols
13592 without type for debug info.
13594 Icc generates relocations against function symbols
13595 instead of local labels.
13597 Relocations against object symbols can happen, eg when
13598 referencing a global array. For an example of this see
13599 the _clz.o binary in libgcc.a. */
13601 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13602 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13604 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13605 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13606 printable_section_name (filedata
, relsec
),
13607 (long int)(rp
- relocs
));
13613 addend
+= rp
->r_addend
;
13614 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13615 partial_inplace. */
13617 || (filedata
->file_header
.e_machine
== EM_XTENSA
13618 && reloc_type
== 1)
13619 || ((filedata
->file_header
.e_machine
== EM_PJ
13620 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13621 && reloc_type
== 1)
13622 || ((filedata
->file_header
.e_machine
== EM_D30V
13623 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13624 && reloc_type
== 12)
13627 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13628 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13630 addend
+= byte_get (rloc
, reloc_size
);
13633 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13634 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13636 /* On HPPA, all pc-relative relocations are biased by 8. */
13637 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13639 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13642 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13643 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13645 if (reloc_subtract
)
13646 addend
-= sym
->st_value
;
13648 addend
+= sym
->st_value
;
13649 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13650 byte_put (rloc
, addend
, reloc_size
);
13652 else if (reloc_subtract
)
13653 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13655 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13659 /* Let the target specific reloc processing code know that
13660 we have finished with these relocs. */
13661 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13665 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13666 * num_relocs_return
= num_relocs
;
13677 #ifdef SUPPORT_DISASSEMBLY
13679 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13681 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13683 /* FIXME: XXX -- to be done --- XXX */
13689 /* Reads in the contents of SECTION from FILE, returning a pointer
13690 to a malloc'ed buffer or NULL if something went wrong. */
13693 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13695 bfd_size_type num_bytes
= section
->sh_size
;
13697 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13699 printf (_("Section '%s' has no data to dump.\n"),
13700 printable_section_name (filedata
, section
));
13704 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13705 _("section contents"));
13708 /* Uncompresses a section that was compressed using zlib, in place. */
13711 uncompress_section_contents (unsigned char ** buffer
,
13712 dwarf_size_type uncompressed_size
,
13713 dwarf_size_type
* size
)
13715 dwarf_size_type compressed_size
= *size
;
13716 unsigned char * compressed_buffer
= *buffer
;
13717 unsigned char * uncompressed_buffer
;
13721 /* It is possible the section consists of several compressed
13722 buffers concatenated together, so we uncompress in a loop. */
13723 /* PR 18313: The state field in the z_stream structure is supposed
13724 to be invisible to the user (ie us), but some compilers will
13725 still complain about it being used without initialisation. So
13726 we first zero the entire z_stream structure and then set the fields
13728 memset (& strm
, 0, sizeof strm
);
13729 strm
.avail_in
= compressed_size
;
13730 strm
.next_in
= (Bytef
*) compressed_buffer
;
13731 strm
.avail_out
= uncompressed_size
;
13732 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13734 rc
= inflateInit (& strm
);
13735 while (strm
.avail_in
> 0)
13739 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13740 + (uncompressed_size
- strm
.avail_out
));
13741 rc
= inflate (&strm
, Z_FINISH
);
13742 if (rc
!= Z_STREAM_END
)
13744 rc
= inflateReset (& strm
);
13746 rc
= inflateEnd (& strm
);
13748 || strm
.avail_out
!= 0)
13751 *buffer
= uncompressed_buffer
;
13752 *size
= uncompressed_size
;
13756 free (uncompressed_buffer
);
13757 /* Indicate decompression failure. */
13763 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13765 Elf_Internal_Shdr
* relsec
;
13766 bfd_size_type num_bytes
;
13767 unsigned char * data
;
13768 unsigned char * end
;
13769 unsigned char * real_start
;
13770 unsigned char * start
;
13771 bfd_boolean some_strings_shown
;
13773 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13775 /* PR 21820: Do not fail if the section was empty. */
13776 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13778 num_bytes
= section
->sh_size
;
13780 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13782 if (decompress_dumps
)
13784 dwarf_size_type new_size
= num_bytes
;
13785 dwarf_size_type uncompressed_size
= 0;
13787 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13789 Elf_Internal_Chdr chdr
;
13790 unsigned int compression_header_size
13791 = get_compression_header (& chdr
, (unsigned char *) start
,
13793 if (compression_header_size
== 0)
13794 /* An error message will have already been generated
13795 by get_compression_header. */
13798 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13800 warn (_("section '%s' has unsupported compress type: %d\n"),
13801 printable_section_name (filedata
, section
), chdr
.ch_type
);
13804 uncompressed_size
= chdr
.ch_size
;
13805 start
+= compression_header_size
;
13806 new_size
-= compression_header_size
;
13808 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13810 /* Read the zlib header. In this case, it should be "ZLIB"
13811 followed by the uncompressed section size, 8 bytes in
13812 big-endian order. */
13813 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13814 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13815 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13816 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13817 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13818 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13819 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13820 uncompressed_size
+= start
[11];
13825 if (uncompressed_size
)
13827 if (uncompress_section_contents (& start
,
13828 uncompressed_size
, & new_size
))
13829 num_bytes
= new_size
;
13832 error (_("Unable to decompress section %s\n"),
13833 printable_section_name (filedata
, section
));
13838 start
= real_start
;
13841 /* If the section being dumped has relocations against it the user might
13842 be expecting these relocations to have been applied. Check for this
13843 case and issue a warning message in order to avoid confusion.
13844 FIXME: Maybe we ought to have an option that dumps a section with
13845 relocs applied ? */
13846 for (relsec
= filedata
->section_headers
;
13847 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13850 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13851 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13852 || filedata
->section_headers
+ relsec
->sh_info
!= section
13853 || relsec
->sh_size
== 0
13854 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13857 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13862 end
= start
+ num_bytes
;
13863 some_strings_shown
= FALSE
;
13865 #ifdef HAVE_MBSTATE_T
13867 /* Initialise the multibyte conversion state. */
13868 memset (& state
, 0, sizeof (state
));
13871 bfd_boolean continuing
= FALSE
;
13875 while (!ISPRINT (* data
))
13876 if (++ data
>= end
)
13881 size_t maxlen
= end
- data
;
13886 continuing
= FALSE
;
13891 /* PR 11128: Use two separate invocations in order to work
13892 around bugs in the Solaris 8 implementation of printf. */
13893 printf (" [%6tx] ", data
- start
);
13895 printf (" [%6Ix] ", (size_t) (data
- start
));
13910 /* PR 25543: Treat new-lines as string-ending characters. */
13919 /* Do not print control characters directly as they can affect terminal
13920 settings. Such characters usually appear in the names generated
13921 by the assembler for local labels. */
13924 printf ("^%c", c
+ 0x40);
13926 else if (ISPRINT (c
))
13933 #ifdef HAVE_MBSTATE_T
13936 /* Let printf do the hard work of displaying multibyte characters. */
13937 printf ("%.1s", data
- 1);
13938 #ifdef HAVE_MBSTATE_T
13939 /* Try to find out how many bytes made up the character that was
13940 just printed. Advance the symbol pointer past the bytes that
13942 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13946 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13956 printf (_("<corrupt>\n"));
13959 some_strings_shown
= TRUE
;
13963 if (! some_strings_shown
)
13964 printf (_(" No strings found in this section."));
13977 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13978 Filedata
* filedata
,
13979 bfd_boolean relocate
)
13981 Elf_Internal_Shdr
* relsec
;
13982 bfd_size_type bytes
;
13983 bfd_size_type section_size
;
13985 unsigned char * data
;
13986 unsigned char * real_start
;
13987 unsigned char * start
;
13989 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13991 /* PR 21820: Do not fail if the section was empty. */
13992 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13994 section_size
= section
->sh_size
;
13996 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13998 if (decompress_dumps
)
14000 dwarf_size_type new_size
= section_size
;
14001 dwarf_size_type uncompressed_size
= 0;
14003 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14005 Elf_Internal_Chdr chdr
;
14006 unsigned int compression_header_size
14007 = get_compression_header (& chdr
, start
, section_size
);
14009 if (compression_header_size
== 0)
14010 /* An error message will have already been generated
14011 by get_compression_header. */
14014 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14016 warn (_("section '%s' has unsupported compress type: %d\n"),
14017 printable_section_name (filedata
, section
), chdr
.ch_type
);
14020 uncompressed_size
= chdr
.ch_size
;
14021 start
+= compression_header_size
;
14022 new_size
-= compression_header_size
;
14024 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14026 /* Read the zlib header. In this case, it should be "ZLIB"
14027 followed by the uncompressed section size, 8 bytes in
14028 big-endian order. */
14029 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14030 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14031 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14032 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14033 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14034 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14035 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14036 uncompressed_size
+= start
[11];
14041 if (uncompressed_size
)
14043 if (uncompress_section_contents (& start
, uncompressed_size
,
14046 section_size
= new_size
;
14050 error (_("Unable to decompress section %s\n"),
14051 printable_section_name (filedata
, section
));
14052 /* FIXME: Print the section anyway ? */
14057 start
= real_start
;
14062 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14067 /* If the section being dumped has relocations against it the user might
14068 be expecting these relocations to have been applied. Check for this
14069 case and issue a warning message in order to avoid confusion.
14070 FIXME: Maybe we ought to have an option that dumps a section with
14071 relocs applied ? */
14072 for (relsec
= filedata
->section_headers
;
14073 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14076 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14077 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14078 || filedata
->section_headers
+ relsec
->sh_info
!= section
14079 || relsec
->sh_size
== 0
14080 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14083 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14088 addr
= section
->sh_addr
;
14089 bytes
= section_size
;
14098 lbytes
= (bytes
> 16 ? 16 : bytes
);
14100 printf (" 0x%8.8lx ", (unsigned long) addr
);
14102 for (j
= 0; j
< 16; j
++)
14105 printf ("%2.2x", data
[j
]);
14113 for (j
= 0; j
< lbytes
; j
++)
14116 if (k
>= ' ' && k
< 0x7f)
14139 #ifdef ENABLE_LIBCTF
14140 static ctf_sect_t
*
14141 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14143 buf
->cts_name
= SECTION_NAME (shdr
);
14144 buf
->cts_size
= shdr
->sh_size
;
14145 buf
->cts_entsize
= shdr
->sh_entsize
;
14150 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14151 it is passed, or a pointer to newly-allocated storage, in which case
14152 dump_ctf() will free it when it no longer needs it. */
14155 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14156 char *s
, void *arg
)
14158 const char *blanks
= arg
;
14161 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14166 /* Dump one CTF archive member. */
14169 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
14171 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
14172 const char *things
[] = {"Header", "Labels", "Data objects",
14173 "Function objects", "Variables", "Types", "Strings",
14175 const char **thing
;
14178 /* Only print out the name of non-default-named archive members.
14179 The name .ctf appears everywhere, even for things that aren't
14180 really archives, so printing it out is liable to be confusing.
14182 The parent, if there is one, is the default-owned archive member:
14183 avoid importing it into itself. (This does no harm, but looks
14186 if (strcmp (name
, ".ctf") != 0)
14188 printf (_("\nCTF archive member: %s:\n"), name
);
14189 ctf_import (ctf
, parent
);
14192 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14194 ctf_dump_state_t
*s
= NULL
;
14197 printf ("\n %s:\n", *thing
);
14198 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14199 (void *) " ")) != NULL
)
14201 printf ("%s\n", item
);
14205 if (ctf_errno (ctf
))
14207 error (_("Iteration failed: %s, %s\n"), *thing
,
14208 ctf_errmsg (ctf_errno (ctf
)));
14216 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14218 Elf_Internal_Shdr
* parent_sec
= NULL
;
14219 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14220 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14221 void * data
= NULL
;
14222 void * symdata
= NULL
;
14223 void * strdata
= NULL
;
14224 void * parentdata
= NULL
;
14225 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14226 ctf_sect_t
* symsectp
= NULL
;
14227 ctf_sect_t
* strsectp
= NULL
;
14228 ctf_archive_t
* ctfa
= NULL
;
14229 ctf_archive_t
* parenta
= NULL
, *lookparent
;
14230 ctf_file_t
* parent
= NULL
;
14233 bfd_boolean ret
= FALSE
;
14235 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14236 data
= get_section_contents (section
, filedata
);
14237 ctfsect
.cts_data
= data
;
14239 if (!dump_ctf_symtab_name
)
14240 dump_ctf_symtab_name
= strdup (".symtab");
14242 if (!dump_ctf_strtab_name
)
14243 dump_ctf_strtab_name
= strdup (".strtab");
14245 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14247 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14249 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14252 if ((symdata
= (void *) get_data (NULL
, filedata
,
14253 symtab_sec
->sh_offset
, 1,
14254 symtab_sec
->sh_size
,
14255 _("symbols"))) == NULL
)
14257 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14258 symsect
.cts_data
= symdata
;
14260 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14262 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14264 error (_("No string table section named %s\n"),
14265 dump_ctf_strtab_name
);
14268 if ((strdata
= (void *) get_data (NULL
, filedata
,
14269 strtab_sec
->sh_offset
, 1,
14270 strtab_sec
->sh_size
,
14271 _("strings"))) == NULL
)
14273 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14274 strsect
.cts_data
= strdata
;
14276 if (dump_ctf_parent_name
)
14278 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14280 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14283 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14284 parent_sec
->sh_offset
, 1,
14285 parent_sec
->sh_size
,
14286 _("CTF parent"))) == NULL
)
14288 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14289 parentsect
.cts_data
= parentdata
;
14292 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
14293 libctf papers over the difference, so we can pretend it is always an
14294 archive. Possibly open the parent as well, if one was specified. */
14296 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14298 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14304 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
14307 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14310 lookparent
= parenta
;
14315 /* Assume that the applicable parent archive member is the default one.
14316 (This is what all known implementations are expected to do, if they
14317 put CTFs and their parents in archives together.) */
14318 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
14320 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14326 printf (_("\nDump of CTF section '%s':\n"),
14327 printable_section_name (filedata
, section
));
14329 if (ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
) != 0)
14333 ctf_file_close (parent
);
14335 ctf_close (parenta
);
14345 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14346 const Elf_Internal_Shdr
* sec
,
14349 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14351 Filedata
* filedata
= (Filedata
*) data
;
14353 if (section
->start
!= NULL
)
14355 /* If it is already loaded, do nothing. */
14356 if (streq (section
->filename
, filedata
->file_name
))
14358 free (section
->start
);
14361 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14362 section
->address
= sec
->sh_addr
;
14363 section
->user_data
= NULL
;
14364 section
->filename
= filedata
->file_name
;
14365 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14367 sec
->sh_size
, buf
);
14368 if (section
->start
== NULL
)
14372 unsigned char *start
= section
->start
;
14373 dwarf_size_type size
= sec
->sh_size
;
14374 dwarf_size_type uncompressed_size
= 0;
14376 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14378 Elf_Internal_Chdr chdr
;
14379 unsigned int compression_header_size
;
14381 if (size
< (is_32bit_elf
14382 ? sizeof (Elf32_External_Chdr
)
14383 : sizeof (Elf64_External_Chdr
)))
14385 warn (_("compressed section %s is too small to contain a compression header\n"),
14390 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14391 if (compression_header_size
== 0)
14392 /* An error message will have already been generated
14393 by get_compression_header. */
14396 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14398 warn (_("section '%s' has unsupported compress type: %d\n"),
14399 section
->name
, chdr
.ch_type
);
14402 uncompressed_size
= chdr
.ch_size
;
14403 start
+= compression_header_size
;
14404 size
-= compression_header_size
;
14406 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14408 /* Read the zlib header. In this case, it should be "ZLIB"
14409 followed by the uncompressed section size, 8 bytes in
14410 big-endian order. */
14411 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14412 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14413 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14414 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14415 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14416 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14417 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14418 uncompressed_size
+= start
[11];
14423 if (uncompressed_size
)
14425 if (uncompress_section_contents (&start
, uncompressed_size
,
14428 /* Free the compressed buffer, update the section buffer
14429 and the section size if uncompress is successful. */
14430 free (section
->start
);
14431 section
->start
= start
;
14435 error (_("Unable to decompress section %s\n"),
14436 printable_section_name (filedata
, sec
));
14441 section
->size
= size
;
14444 if (section
->start
== NULL
)
14447 if (debug_displays
[debug
].relocate
)
14449 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14450 & section
->reloc_info
, & section
->num_relocs
))
14455 section
->reloc_info
= NULL
;
14456 section
->num_relocs
= 0;
14462 #if HAVE_LIBDEBUGINFOD
14463 /* Return a hex string representation of the build-id. */
14465 get_build_id (void * data
)
14467 Filedata
* filedata
= (Filedata
*)data
;
14468 Elf_Internal_Shdr
* shdr
;
14471 /* Iterate through notes to find note.gnu.build-id.
14472 FIXME: Only the first note in any note section is examined. */
14473 for (i
= 0, shdr
= filedata
->section_headers
;
14474 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14477 if (shdr
->sh_type
!= SHT_NOTE
)
14482 size_t data_remaining
;
14484 Elf_External_Note
* enote
;
14485 Elf_Internal_Note inote
;
14487 bfd_vma offset
= shdr
->sh_offset
;
14488 bfd_vma align
= shdr
->sh_addralign
;
14489 bfd_vma length
= shdr
->sh_size
;
14491 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14497 else if (align
!= 4 && align
!= 8)
14503 end
= (char *) enote
+ length
;
14504 data_remaining
= end
- (char *) enote
;
14506 if (!is_ia64_vms (filedata
))
14508 min_notesz
= offsetof (Elf_External_Note
, name
);
14509 if (data_remaining
< min_notesz
)
14512 malformed note encountered in section %s whilst scanning for build-id note\n"),
14513 printable_section_name (filedata
, shdr
));
14517 data_remaining
-= min_notesz
;
14519 inote
.type
= BYTE_GET (enote
->type
);
14520 inote
.namesz
= BYTE_GET (enote
->namesz
);
14521 inote
.namedata
= enote
->name
;
14522 inote
.descsz
= BYTE_GET (enote
->descsz
);
14523 inote
.descdata
= ((char *) enote
14524 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14525 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14526 next
= ((char *) enote
14527 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14531 Elf64_External_VMS_Note
*vms_enote
;
14533 /* PR binutils/15191
14534 Make sure that there is enough data to read. */
14535 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14536 if (data_remaining
< min_notesz
)
14539 malformed note encountered in section %s whilst scanning for build-id note\n"),
14540 printable_section_name (filedata
, shdr
));
14544 data_remaining
-= min_notesz
;
14546 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14547 inote
.type
= BYTE_GET (vms_enote
->type
);
14548 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14549 inote
.namedata
= vms_enote
->name
;
14550 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14551 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14552 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14553 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14556 /* Skip malformed notes. */
14557 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14558 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14559 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14560 || ((size_t) (next
- inote
.descdata
)
14561 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14564 malformed note encountered in section %s whilst scanning for build-id note\n"),
14565 printable_section_name (filedata
, shdr
));
14570 /* Check if this is the build-id note. If so then convert the build-id
14571 bytes to a hex string. */
14572 if (inote
.namesz
> 0
14573 && const_strneq (inote
.namedata
, "GNU")
14574 && inote
.type
== NT_GNU_BUILD_ID
)
14579 build_id
= malloc (inote
.descsz
* 2 + 1);
14580 if (build_id
== NULL
)
14586 for (j
= 0; j
< inote
.descsz
; ++j
)
14587 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14588 build_id
[inote
.descsz
* 2] = '\0';
14591 return (unsigned char *) build_id
;
14598 #endif /* HAVE_LIBDEBUGINFOD */
14600 /* If this is not NULL, load_debug_section will only look for sections
14601 within the list of sections given here. */
14602 static unsigned int * section_subset
= NULL
;
14605 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14607 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14608 Elf_Internal_Shdr
* sec
;
14609 Filedata
* filedata
= (Filedata
*) data
;
14611 /* Without section headers we cannot find any sections. */
14612 if (filedata
->section_headers
== NULL
)
14615 if (filedata
->string_table
== NULL
14616 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14617 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14619 Elf_Internal_Shdr
* strs
;
14621 /* Read in the string table, so that we have section names to scan. */
14622 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14624 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14626 filedata
->string_table
14627 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14628 1, strs
->sh_size
, _("string table"));
14630 filedata
->string_table_length
14631 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14635 /* Locate the debug section. */
14636 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14638 section
->name
= section
->uncompressed_name
;
14641 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14643 section
->name
= section
->compressed_name
;
14648 /* If we're loading from a subset of sections, and we've loaded
14649 a section matching this name before, it's likely that it's a
14651 if (section_subset
!= NULL
)
14652 free_debug_section (debug
);
14654 return load_specific_debug_section (debug
, sec
, data
);
14658 free_debug_section (enum dwarf_section_display_enum debug
)
14660 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14662 if (section
->start
== NULL
)
14665 free ((char *) section
->start
);
14666 section
->start
= NULL
;
14667 section
->address
= 0;
14670 free (section
->reloc_info
);
14671 section
->reloc_info
= NULL
;
14672 section
->num_relocs
= 0;
14676 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14678 char * name
= SECTION_NAME (section
);
14679 const char * print_name
= printable_section_name (filedata
, section
);
14680 bfd_size_type length
;
14681 bfd_boolean result
= TRUE
;
14684 length
= section
->sh_size
;
14687 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14690 if (section
->sh_type
== SHT_NOBITS
)
14692 /* There is no point in dumping the contents of a debugging section
14693 which has the NOBITS type - the bits in the file will be random.
14694 This can happen when a file containing a .eh_frame section is
14695 stripped with the --only-keep-debug command line option. */
14696 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14701 if (const_strneq (name
, ".gnu.linkonce.wi."))
14702 name
= ".debug_info";
14704 /* See if we know how to display the contents of this section. */
14705 for (i
= 0; i
< max
; i
++)
14707 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14708 struct dwarf_section_display
* display
= debug_displays
+ i
;
14709 struct dwarf_section
* sec
= & display
->section
;
14711 if (streq (sec
->uncompressed_name
, name
)
14712 || (id
== line
&& const_strneq (name
, ".debug_line."))
14713 || streq (sec
->compressed_name
, name
))
14715 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14718 free_debug_section (id
);
14720 if (i
== line
&& const_strneq (name
, ".debug_line."))
14722 else if (streq (sec
->uncompressed_name
, name
))
14723 sec
->name
= sec
->uncompressed_name
;
14725 sec
->name
= sec
->compressed_name
;
14727 if (load_specific_debug_section (id
, section
, filedata
))
14729 /* If this debug section is part of a CU/TU set in a .dwp file,
14730 restrict load_debug_section to the sections in that set. */
14731 section_subset
= find_cu_tu_set (filedata
, shndx
);
14733 result
&= display
->display (sec
, filedata
);
14735 section_subset
= NULL
;
14737 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14738 free_debug_section (id
);
14746 printf (_("Unrecognized debug section: %s\n"), print_name
);
14753 /* Set DUMP_SECTS for all sections where dumps were requested
14754 based on section name. */
14757 initialise_dumps_byname (Filedata
* filedata
)
14759 struct dump_list_entry
* cur
;
14761 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14764 bfd_boolean any
= FALSE
;
14766 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14767 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14769 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14774 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14780 process_section_contents (Filedata
* filedata
)
14782 Elf_Internal_Shdr
* section
;
14784 bfd_boolean res
= TRUE
;
14789 initialise_dumps_byname (filedata
);
14791 for (i
= 0, section
= filedata
->section_headers
;
14792 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14795 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14797 #ifdef SUPPORT_DISASSEMBLY
14798 if (dump
& DISASS_DUMP
)
14800 if (! disassemble_section (section
, filedata
))
14804 if (dump
& HEX_DUMP
)
14806 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14810 if (dump
& RELOC_DUMP
)
14812 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14816 if (dump
& STRING_DUMP
)
14818 if (! dump_section_as_strings (section
, filedata
))
14822 if (dump
& DEBUG_DUMP
)
14824 if (! display_debug_section (i
, section
, filedata
))
14828 #ifdef ENABLE_LIBCTF
14829 if (dump
& CTF_DUMP
)
14831 if (! dump_section_as_ctf (section
, filedata
))
14837 /* Check to see if the user requested a
14838 dump of a section that does not exist. */
14839 while (i
< filedata
->dump
.num_dump_sects
)
14841 if (filedata
->dump
.dump_sects
[i
])
14843 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14853 process_mips_fpe_exception (int mask
)
14857 bfd_boolean first
= TRUE
;
14859 if (mask
& OEX_FPU_INEX
)
14860 fputs ("INEX", stdout
), first
= FALSE
;
14861 if (mask
& OEX_FPU_UFLO
)
14862 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14863 if (mask
& OEX_FPU_OFLO
)
14864 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14865 if (mask
& OEX_FPU_DIV0
)
14866 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14867 if (mask
& OEX_FPU_INVAL
)
14868 printf ("%sINVAL", first
? "" : "|");
14871 fputs ("0", stdout
);
14874 /* Display's the value of TAG at location P. If TAG is
14875 greater than 0 it is assumed to be an unknown tag, and
14876 a message is printed to this effect. Otherwise it is
14877 assumed that a message has already been printed.
14879 If the bottom bit of TAG is set it assumed to have a
14880 string value, otherwise it is assumed to have an integer
14883 Returns an updated P pointing to the first unread byte
14884 beyond the end of TAG's value.
14886 Reads at or beyond END will not be made. */
14888 static unsigned char *
14889 display_tag_value (signed int tag
,
14891 const unsigned char * const end
)
14896 printf (" Tag_unknown_%d: ", tag
);
14900 warn (_("<corrupt tag>\n"));
14904 /* PR 17531 file: 027-19978-0.004. */
14905 size_t maxlen
= (end
- p
) - 1;
14910 print_symbol ((int) maxlen
, (const char *) p
);
14911 p
+= strnlen ((char *) p
, maxlen
) + 1;
14915 printf (_("<corrupt string tag>"));
14916 p
= (unsigned char *) end
;
14922 READ_ULEB (val
, p
, end
);
14923 printf ("%ld (0x%lx)\n", val
, val
);
14930 /* ARC ABI attributes section. */
14932 static unsigned char *
14933 display_arc_attribute (unsigned char * p
,
14934 const unsigned char * const end
)
14939 READ_ULEB (tag
, p
, end
);
14943 case Tag_ARC_PCS_config
:
14944 READ_ULEB (val
, p
, end
);
14945 printf (" Tag_ARC_PCS_config: ");
14949 printf (_("Absent/Non standard\n"));
14952 printf (_("Bare metal/mwdt\n"));
14955 printf (_("Bare metal/newlib\n"));
14958 printf (_("Linux/uclibc\n"));
14961 printf (_("Linux/glibc\n"));
14964 printf (_("Unknown\n"));
14969 case Tag_ARC_CPU_base
:
14970 READ_ULEB (val
, p
, end
);
14971 printf (" Tag_ARC_CPU_base: ");
14976 printf (_("Absent\n"));
14978 case TAG_CPU_ARC6xx
:
14979 printf ("ARC6xx\n");
14981 case TAG_CPU_ARC7xx
:
14982 printf ("ARC7xx\n");
14984 case TAG_CPU_ARCEM
:
14985 printf ("ARCEM\n");
14987 case TAG_CPU_ARCHS
:
14988 printf ("ARCHS\n");
14993 case Tag_ARC_CPU_variation
:
14994 READ_ULEB (val
, p
, end
);
14995 printf (" Tag_ARC_CPU_variation: ");
14999 if (val
> 0 && val
< 16)
15000 printf ("Core%d\n", val
);
15002 printf ("Unknown\n");
15006 printf (_("Absent\n"));
15011 case Tag_ARC_CPU_name
:
15012 printf (" Tag_ARC_CPU_name: ");
15013 p
= display_tag_value (-1, p
, end
);
15016 case Tag_ARC_ABI_rf16
:
15017 READ_ULEB (val
, p
, end
);
15018 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15021 case Tag_ARC_ABI_osver
:
15022 READ_ULEB (val
, p
, end
);
15023 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15026 case Tag_ARC_ABI_pic
:
15027 case Tag_ARC_ABI_sda
:
15028 READ_ULEB (val
, p
, end
);
15029 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15030 : " Tag_ARC_ABI_pic: ");
15034 printf (_("Absent\n"));
15043 printf (_("Unknown\n"));
15048 case Tag_ARC_ABI_tls
:
15049 READ_ULEB (val
, p
, end
);
15050 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15053 case Tag_ARC_ABI_enumsize
:
15054 READ_ULEB (val
, p
, end
);
15055 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15059 case Tag_ARC_ABI_exceptions
:
15060 READ_ULEB (val
, p
, end
);
15061 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15065 case Tag_ARC_ABI_double_size
:
15066 READ_ULEB (val
, p
, end
);
15067 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15070 case Tag_ARC_ISA_config
:
15071 printf (" Tag_ARC_ISA_config: ");
15072 p
= display_tag_value (-1, p
, end
);
15075 case Tag_ARC_ISA_apex
:
15076 printf (" Tag_ARC_ISA_apex: ");
15077 p
= display_tag_value (-1, p
, end
);
15080 case Tag_ARC_ISA_mpy_option
:
15081 READ_ULEB (val
, p
, end
);
15082 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15085 case Tag_ARC_ATR_version
:
15086 READ_ULEB (val
, p
, end
);
15087 printf (" Tag_ARC_ATR_version: %d\n", val
);
15091 return display_tag_value (tag
& 1, p
, end
);
15097 /* ARM EABI attributes section. */
15102 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15104 const char ** table
;
15105 } arm_attr_public_tag
;
15107 static const char * arm_attr_tag_CPU_arch
[] =
15108 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15109 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15110 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15111 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15112 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15113 {"No", "Thumb-1", "Thumb-2", "Yes"};
15114 static const char * arm_attr_tag_FP_arch
[] =
15115 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15116 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15117 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15118 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15119 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15120 "NEON for ARMv8.1"};
15121 static const char * arm_attr_tag_PCS_config
[] =
15122 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15123 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15124 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15125 {"V6", "SB", "TLS", "Unused"};
15126 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15127 {"Absolute", "PC-relative", "SB-relative", "None"};
15128 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15129 {"Absolute", "PC-relative", "None"};
15130 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15131 {"None", "direct", "GOT-indirect"};
15132 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15133 {"None", "??? 1", "2", "??? 3", "4"};
15134 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15135 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15136 {"Unused", "Needed", "Sign only"};
15137 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15138 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15139 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15140 {"Unused", "Finite", "RTABI", "IEEE 754"};
15141 static const char * arm_attr_tag_ABI_enum_size
[] =
15142 {"Unused", "small", "int", "forced to int"};
15143 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15144 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15145 static const char * arm_attr_tag_ABI_VFP_args
[] =
15146 {"AAPCS", "VFP registers", "custom", "compatible"};
15147 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15148 {"AAPCS", "WMMX registers", "custom"};
15149 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15150 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15151 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15152 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15153 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15154 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15155 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15156 static const char * arm_attr_tag_FP_HP_extension
[] =
15157 {"Not Allowed", "Allowed"};
15158 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15159 {"None", "IEEE 754", "Alternative Format"};
15160 static const char * arm_attr_tag_DSP_extension
[] =
15161 {"Follow architecture", "Allowed"};
15162 static const char * arm_attr_tag_MPextension_use
[] =
15163 {"Not Allowed", "Allowed"};
15164 static const char * arm_attr_tag_DIV_use
[] =
15165 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15166 "Allowed in v7-A with integer division extension"};
15167 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15168 static const char * arm_attr_tag_Virtualization_use
[] =
15169 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15170 "TrustZone and Virtualization Extensions"};
15171 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15172 {"Not Allowed", "Allowed"};
15174 static const char * arm_attr_tag_MVE_arch
[] =
15175 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15177 #define LOOKUP(id, name) \
15178 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15179 static arm_attr_public_tag arm_attr_public_tags
[] =
15181 {4, "CPU_raw_name", 1, NULL
},
15182 {5, "CPU_name", 1, NULL
},
15183 LOOKUP(6, CPU_arch
),
15184 {7, "CPU_arch_profile", 0, NULL
},
15185 LOOKUP(8, ARM_ISA_use
),
15186 LOOKUP(9, THUMB_ISA_use
),
15187 LOOKUP(10, FP_arch
),
15188 LOOKUP(11, WMMX_arch
),
15189 LOOKUP(12, Advanced_SIMD_arch
),
15190 LOOKUP(13, PCS_config
),
15191 LOOKUP(14, ABI_PCS_R9_use
),
15192 LOOKUP(15, ABI_PCS_RW_data
),
15193 LOOKUP(16, ABI_PCS_RO_data
),
15194 LOOKUP(17, ABI_PCS_GOT_use
),
15195 LOOKUP(18, ABI_PCS_wchar_t
),
15196 LOOKUP(19, ABI_FP_rounding
),
15197 LOOKUP(20, ABI_FP_denormal
),
15198 LOOKUP(21, ABI_FP_exceptions
),
15199 LOOKUP(22, ABI_FP_user_exceptions
),
15200 LOOKUP(23, ABI_FP_number_model
),
15201 {24, "ABI_align_needed", 0, NULL
},
15202 {25, "ABI_align_preserved", 0, NULL
},
15203 LOOKUP(26, ABI_enum_size
),
15204 LOOKUP(27, ABI_HardFP_use
),
15205 LOOKUP(28, ABI_VFP_args
),
15206 LOOKUP(29, ABI_WMMX_args
),
15207 LOOKUP(30, ABI_optimization_goals
),
15208 LOOKUP(31, ABI_FP_optimization_goals
),
15209 {32, "compatibility", 0, NULL
},
15210 LOOKUP(34, CPU_unaligned_access
),
15211 LOOKUP(36, FP_HP_extension
),
15212 LOOKUP(38, ABI_FP_16bit_format
),
15213 LOOKUP(42, MPextension_use
),
15214 LOOKUP(44, DIV_use
),
15215 LOOKUP(46, DSP_extension
),
15216 LOOKUP(48, MVE_arch
),
15217 {64, "nodefaults", 0, NULL
},
15218 {65, "also_compatible_with", 0, NULL
},
15219 LOOKUP(66, T2EE_use
),
15220 {67, "conformance", 1, NULL
},
15221 LOOKUP(68, Virtualization_use
),
15222 LOOKUP(70, MPextension_use_legacy
)
15226 static unsigned char *
15227 display_arm_attribute (unsigned char * p
,
15228 const unsigned char * const end
)
15232 arm_attr_public_tag
* attr
;
15236 READ_ULEB (tag
, p
, end
);
15238 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15240 if (arm_attr_public_tags
[i
].tag
== tag
)
15242 attr
= &arm_attr_public_tags
[i
];
15249 printf (" Tag_%s: ", attr
->name
);
15250 switch (attr
->type
)
15255 case 7: /* Tag_CPU_arch_profile. */
15256 READ_ULEB (val
, p
, end
);
15259 case 0: printf (_("None\n")); break;
15260 case 'A': printf (_("Application\n")); break;
15261 case 'R': printf (_("Realtime\n")); break;
15262 case 'M': printf (_("Microcontroller\n")); break;
15263 case 'S': printf (_("Application or Realtime\n")); break;
15264 default: printf ("??? (%d)\n", val
); break;
15268 case 24: /* Tag_align_needed. */
15269 READ_ULEB (val
, p
, end
);
15272 case 0: printf (_("None\n")); break;
15273 case 1: printf (_("8-byte\n")); break;
15274 case 2: printf (_("4-byte\n")); break;
15275 case 3: printf ("??? 3\n"); break;
15278 printf (_("8-byte and up to %d-byte extended\n"),
15281 printf ("??? (%d)\n", val
);
15286 case 25: /* Tag_align_preserved. */
15287 READ_ULEB (val
, p
, end
);
15290 case 0: printf (_("None\n")); break;
15291 case 1: printf (_("8-byte, except leaf SP\n")); break;
15292 case 2: printf (_("8-byte\n")); break;
15293 case 3: printf ("??? 3\n"); break;
15296 printf (_("8-byte and up to %d-byte extended\n"),
15299 printf ("??? (%d)\n", val
);
15304 case 32: /* Tag_compatibility. */
15306 READ_ULEB (val
, p
, end
);
15307 printf (_("flag = %d, vendor = "), val
);
15310 size_t maxlen
= (end
- p
) - 1;
15312 print_symbol ((int) maxlen
, (const char *) p
);
15313 p
+= strnlen ((char *) p
, maxlen
) + 1;
15317 printf (_("<corrupt>"));
15318 p
= (unsigned char *) end
;
15324 case 64: /* Tag_nodefaults. */
15325 /* PR 17531: file: 001-505008-0.01. */
15328 printf (_("True\n"));
15331 case 65: /* Tag_also_compatible_with. */
15332 READ_ULEB (val
, p
, end
);
15333 if (val
== 6 /* Tag_CPU_arch. */)
15335 READ_ULEB (val
, p
, end
);
15336 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15337 printf ("??? (%d)\n", val
);
15339 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15343 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15348 printf (_("<unknown: %d>\n"), tag
);
15354 return display_tag_value (-1, p
, end
);
15356 return display_tag_value (0, p
, end
);
15359 assert (attr
->type
& 0x80);
15360 READ_ULEB (val
, p
, end
);
15361 type
= attr
->type
& 0x7f;
15363 printf ("??? (%d)\n", val
);
15365 printf ("%s\n", attr
->table
[val
]);
15370 return display_tag_value (tag
, p
, end
);
15373 static unsigned char *
15374 display_gnu_attribute (unsigned char * p
,
15375 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15376 const unsigned char * const end
)
15381 READ_ULEB (tag
, p
, end
);
15383 /* Tag_compatibility is the only generic GNU attribute defined at
15387 READ_ULEB (val
, p
, end
);
15389 printf (_("flag = %d, vendor = "), val
);
15392 printf (_("<corrupt>\n"));
15393 warn (_("corrupt vendor attribute\n"));
15399 size_t maxlen
= (end
- p
) - 1;
15401 print_symbol ((int) maxlen
, (const char *) p
);
15402 p
+= strnlen ((char *) p
, maxlen
) + 1;
15406 printf (_("<corrupt>"));
15407 p
= (unsigned char *) end
;
15414 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15415 return display_proc_gnu_attribute (p
, tag
, end
);
15417 return display_tag_value (tag
, p
, end
);
15420 static unsigned char *
15421 display_m68k_gnu_attribute (unsigned char * p
,
15423 const unsigned char * const end
)
15427 if (tag
== Tag_GNU_M68K_ABI_FP
)
15429 printf (" Tag_GNU_M68K_ABI_FP: ");
15432 printf (_("<corrupt>\n"));
15435 READ_ULEB (val
, p
, end
);
15438 printf ("(%#x), ", val
);
15443 printf (_("unspecified hard/soft float\n"));
15446 printf (_("hard float\n"));
15449 printf (_("soft float\n"));
15455 return display_tag_value (tag
& 1, p
, end
);
15458 static unsigned char *
15459 display_power_gnu_attribute (unsigned char * p
,
15461 const unsigned char * const end
)
15465 if (tag
== Tag_GNU_Power_ABI_FP
)
15467 printf (" Tag_GNU_Power_ABI_FP: ");
15470 printf (_("<corrupt>\n"));
15473 READ_ULEB (val
, p
, end
);
15476 printf ("(%#x), ", val
);
15481 printf (_("unspecified hard/soft float, "));
15484 printf (_("hard float, "));
15487 printf (_("soft float, "));
15490 printf (_("single-precision hard float, "));
15497 printf (_("unspecified long double\n"));
15500 printf (_("128-bit IBM long double\n"));
15503 printf (_("64-bit long double\n"));
15506 printf (_("128-bit IEEE long double\n"));
15512 if (tag
== Tag_GNU_Power_ABI_Vector
)
15514 printf (" Tag_GNU_Power_ABI_Vector: ");
15517 printf (_("<corrupt>\n"));
15520 READ_ULEB (val
, p
, end
);
15523 printf ("(%#x), ", val
);
15528 printf (_("unspecified\n"));
15531 printf (_("generic\n"));
15534 printf ("AltiVec\n");
15543 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15545 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15548 printf (_("<corrupt>\n"));
15551 READ_ULEB (val
, p
, end
);
15554 printf ("(%#x), ", val
);
15559 printf (_("unspecified\n"));
15562 printf ("r3/r4\n");
15565 printf (_("memory\n"));
15574 return display_tag_value (tag
& 1, p
, end
);
15577 static unsigned char *
15578 display_s390_gnu_attribute (unsigned char * p
,
15580 const unsigned char * const end
)
15584 if (tag
== Tag_GNU_S390_ABI_Vector
)
15586 printf (" Tag_GNU_S390_ABI_Vector: ");
15587 READ_ULEB (val
, p
, end
);
15592 printf (_("any\n"));
15595 printf (_("software\n"));
15598 printf (_("hardware\n"));
15601 printf ("??? (%d)\n", val
);
15607 return display_tag_value (tag
& 1, p
, end
);
15611 display_sparc_hwcaps (unsigned int mask
)
15615 bfd_boolean first
= TRUE
;
15617 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15618 fputs ("mul32", stdout
), first
= FALSE
;
15619 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15620 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15621 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15622 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15623 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15624 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15625 if (mask
& ELF_SPARC_HWCAP_POPC
)
15626 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15627 if (mask
& ELF_SPARC_HWCAP_VIS
)
15628 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15629 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15630 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15631 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15632 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15633 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15634 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15635 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15636 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15637 if (mask
& ELF_SPARC_HWCAP_HPC
)
15638 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15639 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15640 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15641 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15642 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15643 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15644 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15645 if (mask
& ELF_SPARC_HWCAP_IMA
)
15646 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15647 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15648 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15651 fputc ('0', stdout
);
15652 fputc ('\n', stdout
);
15656 display_sparc_hwcaps2 (unsigned int mask
)
15660 bfd_boolean first
= TRUE
;
15662 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15663 fputs ("fjathplus", stdout
), first
= FALSE
;
15664 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15665 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15666 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15667 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15668 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15669 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15670 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15671 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15672 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15673 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15674 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15675 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15676 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15677 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15678 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15679 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15680 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15681 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15682 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15683 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15686 fputc ('0', stdout
);
15687 fputc ('\n', stdout
);
15690 static unsigned char *
15691 display_sparc_gnu_attribute (unsigned char * p
,
15693 const unsigned char * const end
)
15697 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15699 READ_ULEB (val
, p
, end
);
15700 printf (" Tag_GNU_Sparc_HWCAPS: ");
15701 display_sparc_hwcaps (val
);
15704 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15706 READ_ULEB (val
, p
, end
);
15707 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15708 display_sparc_hwcaps2 (val
);
15712 return display_tag_value (tag
, p
, end
);
15716 print_mips_fp_abi_value (unsigned int val
)
15720 case Val_GNU_MIPS_ABI_FP_ANY
:
15721 printf (_("Hard or soft float\n"));
15723 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15724 printf (_("Hard float (double precision)\n"));
15726 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15727 printf (_("Hard float (single precision)\n"));
15729 case Val_GNU_MIPS_ABI_FP_SOFT
:
15730 printf (_("Soft float\n"));
15732 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15733 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15735 case Val_GNU_MIPS_ABI_FP_XX
:
15736 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15738 case Val_GNU_MIPS_ABI_FP_64
:
15739 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15741 case Val_GNU_MIPS_ABI_FP_64A
:
15742 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15744 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15745 printf (_("NaN 2008 compatibility\n"));
15748 printf ("??? (%d)\n", val
);
15753 static unsigned char *
15754 display_mips_gnu_attribute (unsigned char * p
,
15756 const unsigned char * const end
)
15758 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15762 printf (" Tag_GNU_MIPS_ABI_FP: ");
15763 READ_ULEB (val
, p
, end
);
15764 print_mips_fp_abi_value (val
);
15768 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15772 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15773 READ_ULEB (val
, p
, end
);
15777 case Val_GNU_MIPS_ABI_MSA_ANY
:
15778 printf (_("Any MSA or not\n"));
15780 case Val_GNU_MIPS_ABI_MSA_128
:
15781 printf (_("128-bit MSA\n"));
15784 printf ("??? (%d)\n", val
);
15790 return display_tag_value (tag
& 1, p
, end
);
15793 static unsigned char *
15794 display_tic6x_attribute (unsigned char * p
,
15795 const unsigned char * const end
)
15800 READ_ULEB (tag
, p
, end
);
15805 printf (" Tag_ISA: ");
15806 READ_ULEB (val
, p
, end
);
15810 case C6XABI_Tag_ISA_none
:
15811 printf (_("None\n"));
15813 case C6XABI_Tag_ISA_C62X
:
15816 case C6XABI_Tag_ISA_C67X
:
15819 case C6XABI_Tag_ISA_C67XP
:
15820 printf ("C67x+\n");
15822 case C6XABI_Tag_ISA_C64X
:
15825 case C6XABI_Tag_ISA_C64XP
:
15826 printf ("C64x+\n");
15828 case C6XABI_Tag_ISA_C674X
:
15829 printf ("C674x\n");
15832 printf ("??? (%d)\n", val
);
15837 case Tag_ABI_wchar_t
:
15838 printf (" Tag_ABI_wchar_t: ");
15839 READ_ULEB (val
, p
, end
);
15843 printf (_("Not used\n"));
15846 printf (_("2 bytes\n"));
15849 printf (_("4 bytes\n"));
15852 printf ("??? (%d)\n", val
);
15857 case Tag_ABI_stack_align_needed
:
15858 printf (" Tag_ABI_stack_align_needed: ");
15859 READ_ULEB (val
, p
, end
);
15863 printf (_("8-byte\n"));
15866 printf (_("16-byte\n"));
15869 printf ("??? (%d)\n", val
);
15874 case Tag_ABI_stack_align_preserved
:
15875 READ_ULEB (val
, p
, end
);
15876 printf (" Tag_ABI_stack_align_preserved: ");
15880 printf (_("8-byte\n"));
15883 printf (_("16-byte\n"));
15886 printf ("??? (%d)\n", val
);
15892 READ_ULEB (val
, p
, end
);
15893 printf (" Tag_ABI_DSBT: ");
15897 printf (_("DSBT addressing not used\n"));
15900 printf (_("DSBT addressing used\n"));
15903 printf ("??? (%d)\n", val
);
15909 READ_ULEB (val
, p
, end
);
15910 printf (" Tag_ABI_PID: ");
15914 printf (_("Data addressing position-dependent\n"));
15917 printf (_("Data addressing position-independent, GOT near DP\n"));
15920 printf (_("Data addressing position-independent, GOT far from DP\n"));
15923 printf ("??? (%d)\n", val
);
15929 READ_ULEB (val
, p
, end
);
15930 printf (" Tag_ABI_PIC: ");
15934 printf (_("Code addressing position-dependent\n"));
15937 printf (_("Code addressing position-independent\n"));
15940 printf ("??? (%d)\n", val
);
15945 case Tag_ABI_array_object_alignment
:
15946 READ_ULEB (val
, p
, end
);
15947 printf (" Tag_ABI_array_object_alignment: ");
15951 printf (_("8-byte\n"));
15954 printf (_("4-byte\n"));
15957 printf (_("16-byte\n"));
15960 printf ("??? (%d)\n", val
);
15965 case Tag_ABI_array_object_align_expected
:
15966 READ_ULEB (val
, p
, end
);
15967 printf (" Tag_ABI_array_object_align_expected: ");
15971 printf (_("8-byte\n"));
15974 printf (_("4-byte\n"));
15977 printf (_("16-byte\n"));
15980 printf ("??? (%d)\n", val
);
15985 case Tag_ABI_compatibility
:
15987 READ_ULEB (val
, p
, end
);
15988 printf (" Tag_ABI_compatibility: ");
15989 printf (_("flag = %d, vendor = "), val
);
15992 size_t maxlen
= (end
- p
) - 1;
15994 print_symbol ((int) maxlen
, (const char *) p
);
15995 p
+= strnlen ((char *) p
, maxlen
) + 1;
15999 printf (_("<corrupt>"));
16000 p
= (unsigned char *) end
;
16006 case Tag_ABI_conformance
:
16008 printf (" Tag_ABI_conformance: \"");
16011 size_t maxlen
= (end
- p
) - 1;
16013 print_symbol ((int) maxlen
, (const char *) p
);
16014 p
+= strnlen ((char *) p
, maxlen
) + 1;
16018 printf (_("<corrupt>"));
16019 p
= (unsigned char *) end
;
16026 return display_tag_value (tag
, p
, end
);
16030 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16032 unsigned long addr
= 0;
16033 size_t bytes
= end
- p
;
16040 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16042 printf (" 0x%8.8lx ", addr
);
16044 for (j
= 0; j
< 16; j
++)
16047 printf ("%2.2x", p
[j
]);
16055 for (j
= 0; j
< lbytes
; j
++)
16058 if (k
>= ' ' && k
< 0x7f)
16074 static unsigned char *
16075 display_msp430x_attribute (unsigned char * p
,
16076 const unsigned char * const end
)
16081 READ_ULEB (tag
, p
, end
);
16085 case OFBA_MSPABI_Tag_ISA
:
16086 printf (" Tag_ISA: ");
16087 READ_ULEB (val
, p
, end
);
16090 case 0: printf (_("None\n")); break;
16091 case 1: printf (_("MSP430\n")); break;
16092 case 2: printf (_("MSP430X\n")); break;
16093 default: printf ("??? (%d)\n", val
); break;
16097 case OFBA_MSPABI_Tag_Code_Model
:
16098 printf (" Tag_Code_Model: ");
16099 READ_ULEB (val
, p
, end
);
16102 case 0: printf (_("None\n")); break;
16103 case 1: printf (_("Small\n")); break;
16104 case 2: printf (_("Large\n")); break;
16105 default: printf ("??? (%d)\n", val
); break;
16109 case OFBA_MSPABI_Tag_Data_Model
:
16110 printf (" Tag_Data_Model: ");
16111 READ_ULEB (val
, p
, end
);
16114 case 0: printf (_("None\n")); break;
16115 case 1: printf (_("Small\n")); break;
16116 case 2: printf (_("Large\n")); break;
16117 case 3: printf (_("Restricted Large\n")); break;
16118 default: printf ("??? (%d)\n", val
); break;
16123 printf (_(" <unknown tag %d>: "), tag
);
16130 size_t maxlen
= (end
- p
) - 1;
16132 print_symbol ((int) maxlen
, (const char *) p
);
16133 p
+= strnlen ((char *) p
, maxlen
) + 1;
16137 printf (_("<corrupt>"));
16138 p
= (unsigned char *) end
;
16144 READ_ULEB (val
, p
, end
);
16145 printf ("%d (0x%x)\n", val
, val
);
16154 static unsigned char *
16155 display_msp430_gnu_attribute (unsigned char * p
,
16157 const unsigned char * const end
)
16159 if (tag
== Tag_GNU_MSP430_Data_Region
)
16163 printf (" Tag_GNU_MSP430_Data_Region: ");
16164 READ_ULEB (val
, p
, end
);
16168 case Val_GNU_MSP430_Data_Region_Any
:
16169 printf (_("Any Region\n"));
16171 case Val_GNU_MSP430_Data_Region_Lower
:
16172 printf (_("Lower Region Only\n"));
16175 printf ("??? (%u)\n", val
);
16179 return display_tag_value (tag
& 1, p
, end
);
16182 struct riscv_attr_tag_t
{
16187 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16189 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16192 T(priv_spec_minor
),
16193 T(priv_spec_revision
),
16194 T(unaligned_access
),
16199 static unsigned char *
16200 display_riscv_attribute (unsigned char *p
,
16201 const unsigned char * const end
)
16205 struct riscv_attr_tag_t
*attr
= NULL
;
16208 READ_ULEB (tag
, p
, end
);
16210 /* Find the name of attribute. */
16211 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16213 if (riscv_attr_tag
[i
].tag
== tag
)
16215 attr
= &riscv_attr_tag
[i
];
16221 printf (" %s: ", attr
->name
);
16223 return display_tag_value (tag
, p
, end
);
16227 case Tag_RISCV_priv_spec
:
16228 case Tag_RISCV_priv_spec_minor
:
16229 case Tag_RISCV_priv_spec_revision
:
16230 READ_ULEB (val
, p
, end
);
16231 printf (_("%u\n"), val
);
16233 case Tag_RISCV_unaligned_access
:
16234 READ_ULEB (val
, p
, end
);
16238 printf (_("No unaligned access\n"));
16241 printf (_("Unaligned access\n"));
16245 case Tag_RISCV_stack_align
:
16246 READ_ULEB (val
, p
, end
);
16247 printf (_("%u-bytes\n"), val
);
16249 case Tag_RISCV_arch
:
16250 p
= display_tag_value (-1, p
, end
);
16253 return display_tag_value (tag
, p
, end
);
16260 process_attributes (Filedata
* filedata
,
16261 const char * public_name
,
16262 unsigned int proc_type
,
16263 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16264 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16266 Elf_Internal_Shdr
* sect
;
16268 bfd_boolean res
= TRUE
;
16270 /* Find the section header so that we get the size. */
16271 for (i
= 0, sect
= filedata
->section_headers
;
16272 i
< filedata
->file_header
.e_shnum
;
16275 unsigned char * contents
;
16278 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16281 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16282 sect
->sh_size
, _("attributes"));
16283 if (contents
== NULL
)
16290 /* The first character is the version of the attributes.
16291 Currently only version 1, (aka 'A') is recognised here. */
16294 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16299 bfd_vma section_len
;
16301 section_len
= sect
->sh_size
- 1;
16304 while (section_len
> 0)
16307 unsigned int namelen
;
16308 bfd_boolean public_section
;
16309 bfd_boolean gnu_section
;
16311 if (section_len
<= 4)
16313 error (_("Tag section ends prematurely\n"));
16317 attr_len
= byte_get (p
, 4);
16320 if (attr_len
> section_len
)
16322 error (_("Bad attribute length (%u > %u)\n"),
16323 (unsigned) attr_len
, (unsigned) section_len
);
16324 attr_len
= section_len
;
16327 /* PR 17531: file: 001-101425-0.004 */
16328 else if (attr_len
< 5)
16330 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16335 section_len
-= attr_len
;
16338 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16339 if (namelen
== 0 || namelen
>= attr_len
)
16341 error (_("Corrupt attribute section name\n"));
16346 printf (_("Attribute Section: "));
16347 print_symbol (INT_MAX
, (const char *) p
);
16350 if (public_name
&& streq ((char *) p
, public_name
))
16351 public_section
= TRUE
;
16353 public_section
= FALSE
;
16355 if (streq ((char *) p
, "gnu"))
16356 gnu_section
= TRUE
;
16358 gnu_section
= FALSE
;
16361 attr_len
-= namelen
;
16363 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16368 unsigned char * end
;
16370 /* PR binutils/17531: Safe handling of corrupt files. */
16373 error (_("Unused bytes at end of section\n"));
16380 size
= byte_get (p
, 4);
16381 if (size
> attr_len
)
16383 error (_("Bad subsection length (%u > %u)\n"),
16384 (unsigned) size
, (unsigned) attr_len
);
16388 /* PR binutils/17531: Safe handling of corrupt files. */
16391 error (_("Bad subsection length (%u < 6)\n"),
16399 end
= p
+ size
- 1;
16400 assert (end
<= contents
+ sect
->sh_size
);
16406 printf (_("File Attributes\n"));
16409 printf (_("Section Attributes:"));
16412 printf (_("Symbol Attributes:"));
16413 /* Fall through. */
16417 READ_ULEB (val
, p
, end
);
16420 printf (" %d", val
);
16425 printf (_("Unknown tag: %d\n"), tag
);
16426 public_section
= FALSE
;
16430 if (public_section
&& display_pub_attribute
!= NULL
)
16433 p
= display_pub_attribute (p
, end
);
16436 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16439 p
= display_gnu_attribute (p
,
16440 display_proc_gnu_attribute
,
16446 printf (_(" Unknown attribute:\n"));
16447 display_raw_attribute (p
, end
);
16462 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16463 Print the Address, Access and Initial fields of an entry at VMA ADDR
16464 and return the VMA of the next entry, or -1 if there was a problem.
16465 Does not read from DATA_END or beyond. */
16468 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16469 unsigned char * data_end
)
16472 print_vma (addr
, LONG_HEX
);
16474 if (addr
< pltgot
+ 0xfff0)
16475 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16477 printf ("%10s", "");
16480 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16484 unsigned char * from
= data
+ addr
- pltgot
;
16486 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16488 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16489 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16490 return (bfd_vma
) -1;
16494 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16495 print_vma (entry
, LONG_HEX
);
16498 return addr
+ (is_32bit_elf
? 4 : 8);
16501 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16502 PLTGOT. Print the Address and Initial fields of an entry at VMA
16503 ADDR and return the VMA of the next entry. */
16506 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16509 print_vma (addr
, LONG_HEX
);
16512 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16517 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16518 print_vma (entry
, LONG_HEX
);
16520 return addr
+ (is_32bit_elf
? 4 : 8);
16524 print_mips_ases (unsigned int mask
)
16526 if (mask
& AFL_ASE_DSP
)
16527 fputs ("\n\tDSP ASE", stdout
);
16528 if (mask
& AFL_ASE_DSPR2
)
16529 fputs ("\n\tDSP R2 ASE", stdout
);
16530 if (mask
& AFL_ASE_DSPR3
)
16531 fputs ("\n\tDSP R3 ASE", stdout
);
16532 if (mask
& AFL_ASE_EVA
)
16533 fputs ("\n\tEnhanced VA Scheme", stdout
);
16534 if (mask
& AFL_ASE_MCU
)
16535 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16536 if (mask
& AFL_ASE_MDMX
)
16537 fputs ("\n\tMDMX ASE", stdout
);
16538 if (mask
& AFL_ASE_MIPS3D
)
16539 fputs ("\n\tMIPS-3D ASE", stdout
);
16540 if (mask
& AFL_ASE_MT
)
16541 fputs ("\n\tMT ASE", stdout
);
16542 if (mask
& AFL_ASE_SMARTMIPS
)
16543 fputs ("\n\tSmartMIPS ASE", stdout
);
16544 if (mask
& AFL_ASE_VIRT
)
16545 fputs ("\n\tVZ ASE", stdout
);
16546 if (mask
& AFL_ASE_MSA
)
16547 fputs ("\n\tMSA ASE", stdout
);
16548 if (mask
& AFL_ASE_MIPS16
)
16549 fputs ("\n\tMIPS16 ASE", stdout
);
16550 if (mask
& AFL_ASE_MICROMIPS
)
16551 fputs ("\n\tMICROMIPS ASE", stdout
);
16552 if (mask
& AFL_ASE_XPA
)
16553 fputs ("\n\tXPA ASE", stdout
);
16554 if (mask
& AFL_ASE_MIPS16E2
)
16555 fputs ("\n\tMIPS16e2 ASE", stdout
);
16556 if (mask
& AFL_ASE_CRC
)
16557 fputs ("\n\tCRC ASE", stdout
);
16558 if (mask
& AFL_ASE_GINV
)
16559 fputs ("\n\tGINV ASE", stdout
);
16560 if (mask
& AFL_ASE_LOONGSON_MMI
)
16561 fputs ("\n\tLoongson MMI ASE", stdout
);
16562 if (mask
& AFL_ASE_LOONGSON_CAM
)
16563 fputs ("\n\tLoongson CAM ASE", stdout
);
16564 if (mask
& AFL_ASE_LOONGSON_EXT
)
16565 fputs ("\n\tLoongson EXT ASE", stdout
);
16566 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16567 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16569 fprintf (stdout
, "\n\t%s", _("None"));
16570 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16571 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16575 print_mips_isa_ext (unsigned int isa_ext
)
16580 fputs (_("None"), stdout
);
16583 fputs ("RMI XLR", stdout
);
16585 case AFL_EXT_OCTEON3
:
16586 fputs ("Cavium Networks Octeon3", stdout
);
16588 case AFL_EXT_OCTEON2
:
16589 fputs ("Cavium Networks Octeon2", stdout
);
16591 case AFL_EXT_OCTEONP
:
16592 fputs ("Cavium Networks OcteonP", stdout
);
16594 case AFL_EXT_OCTEON
:
16595 fputs ("Cavium Networks Octeon", stdout
);
16598 fputs ("Toshiba R5900", stdout
);
16601 fputs ("MIPS R4650", stdout
);
16604 fputs ("LSI R4010", stdout
);
16607 fputs ("NEC VR4100", stdout
);
16610 fputs ("Toshiba R3900", stdout
);
16612 case AFL_EXT_10000
:
16613 fputs ("MIPS R10000", stdout
);
16616 fputs ("Broadcom SB-1", stdout
);
16619 fputs ("NEC VR4111/VR4181", stdout
);
16622 fputs ("NEC VR4120", stdout
);
16625 fputs ("NEC VR5400", stdout
);
16628 fputs ("NEC VR5500", stdout
);
16630 case AFL_EXT_LOONGSON_2E
:
16631 fputs ("ST Microelectronics Loongson 2E", stdout
);
16633 case AFL_EXT_LOONGSON_2F
:
16634 fputs ("ST Microelectronics Loongson 2F", stdout
);
16636 case AFL_EXT_INTERAPTIV_MR2
:
16637 fputs ("Imagination interAptiv MR2", stdout
);
16640 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16645 get_mips_reg_size (int reg_size
)
16647 return (reg_size
== AFL_REG_NONE
) ? 0
16648 : (reg_size
== AFL_REG_32
) ? 32
16649 : (reg_size
== AFL_REG_64
) ? 64
16650 : (reg_size
== AFL_REG_128
) ? 128
16655 process_mips_specific (Filedata
* filedata
)
16657 Elf_Internal_Dyn
* entry
;
16658 Elf_Internal_Shdr
*sect
= NULL
;
16659 size_t liblist_offset
= 0;
16660 size_t liblistno
= 0;
16661 size_t conflictsno
= 0;
16662 size_t options_offset
= 0;
16663 size_t conflicts_offset
= 0;
16664 size_t pltrelsz
= 0;
16666 bfd_vma pltgot
= 0;
16667 bfd_vma mips_pltgot
= 0;
16668 bfd_vma jmprel
= 0;
16669 bfd_vma local_gotno
= 0;
16670 bfd_vma gotsym
= 0;
16671 bfd_vma symtabno
= 0;
16672 bfd_boolean res
= TRUE
;
16674 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16675 display_mips_gnu_attribute
))
16678 sect
= find_section (filedata
, ".MIPS.abiflags");
16682 Elf_External_ABIFlags_v0
*abiflags_ext
;
16683 Elf_Internal_ABIFlags_v0 abiflags_in
;
16685 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16687 error (_("Corrupt MIPS ABI Flags section.\n"));
16692 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16693 sect
->sh_size
, _("MIPS ABI Flags section"));
16696 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16697 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16698 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16699 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16700 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16701 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16702 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16703 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16704 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16705 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16706 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16708 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16709 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16710 if (abiflags_in
.isa_rev
> 1)
16711 printf ("r%d", abiflags_in
.isa_rev
);
16712 printf ("\nGPR size: %d",
16713 get_mips_reg_size (abiflags_in
.gpr_size
));
16714 printf ("\nCPR1 size: %d",
16715 get_mips_reg_size (abiflags_in
.cpr1_size
));
16716 printf ("\nCPR2 size: %d",
16717 get_mips_reg_size (abiflags_in
.cpr2_size
));
16718 fputs ("\nFP ABI: ", stdout
);
16719 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16720 fputs ("ISA Extension: ", stdout
);
16721 print_mips_isa_ext (abiflags_in
.isa_ext
);
16722 fputs ("\nASEs:", stdout
);
16723 print_mips_ases (abiflags_in
.ases
);
16724 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16725 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16726 fputc ('\n', stdout
);
16727 free (abiflags_ext
);
16732 /* We have a lot of special sections. Thanks SGI! */
16733 if (filedata
->dynamic_section
== NULL
)
16735 /* No dynamic information available. See if there is static GOT. */
16736 sect
= find_section (filedata
, ".got");
16739 unsigned char *data_end
;
16740 unsigned char *data
;
16744 pltgot
= sect
->sh_addr
;
16747 addr_size
= (is_32bit_elf
? 4 : 8);
16748 end
= pltgot
+ sect
->sh_size
;
16750 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16752 _("Global Offset Table data"));
16753 /* PR 12855: Null data is handled gracefully throughout. */
16754 data_end
= data
+ (end
- pltgot
);
16756 printf (_("\nStatic GOT:\n"));
16757 printf (_(" Canonical gp value: "));
16758 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16761 /* In a dynamic binary GOT[0] is reserved for the dynamic
16762 loader to store the lazy resolver pointer, however in
16763 a static binary it may well have been omitted and GOT
16764 reduced to a table of addresses.
16765 PR 21344: Check for the entry being fully available
16766 before fetching it. */
16768 && data
+ ent
- pltgot
+ addr_size
<= data_end
16769 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16771 printf (_(" Reserved entries:\n"));
16772 printf (_(" %*s %10s %*s\n"),
16773 addr_size
* 2, _("Address"), _("Access"),
16774 addr_size
* 2, _("Value"));
16775 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16777 if (ent
== (bfd_vma
) -1)
16778 goto sgot_print_fail
;
16780 /* Check for the MSB of GOT[1] being set, identifying a
16781 GNU object. This entry will be used by some runtime
16782 loaders, to store the module pointer. Otherwise this
16783 is an ordinary local entry.
16784 PR 21344: Check for the entry being fully available
16785 before fetching it. */
16787 && data
+ ent
- pltgot
+ addr_size
<= data_end
16788 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16789 >> (addr_size
* 8 - 1)) != 0)
16791 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16793 if (ent
== (bfd_vma
) -1)
16794 goto sgot_print_fail
;
16799 if (data
!= NULL
&& ent
< end
)
16801 printf (_(" Local entries:\n"));
16802 printf (" %*s %10s %*s\n",
16803 addr_size
* 2, _("Address"), _("Access"),
16804 addr_size
* 2, _("Value"));
16807 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16809 if (ent
== (bfd_vma
) -1)
16810 goto sgot_print_fail
;
16821 for (entry
= filedata
->dynamic_section
;
16822 /* PR 17531 file: 012-50589-0.004. */
16823 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16824 && entry
->d_tag
!= DT_NULL
);
16826 switch (entry
->d_tag
)
16828 case DT_MIPS_LIBLIST
:
16830 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16831 liblistno
* sizeof (Elf32_External_Lib
));
16833 case DT_MIPS_LIBLISTNO
:
16834 liblistno
= entry
->d_un
.d_val
;
16836 case DT_MIPS_OPTIONS
:
16837 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16839 case DT_MIPS_CONFLICT
:
16841 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16842 conflictsno
* sizeof (Elf32_External_Conflict
));
16844 case DT_MIPS_CONFLICTNO
:
16845 conflictsno
= entry
->d_un
.d_val
;
16848 pltgot
= entry
->d_un
.d_ptr
;
16850 case DT_MIPS_LOCAL_GOTNO
:
16851 local_gotno
= entry
->d_un
.d_val
;
16853 case DT_MIPS_GOTSYM
:
16854 gotsym
= entry
->d_un
.d_val
;
16856 case DT_MIPS_SYMTABNO
:
16857 symtabno
= entry
->d_un
.d_val
;
16859 case DT_MIPS_PLTGOT
:
16860 mips_pltgot
= entry
->d_un
.d_ptr
;
16863 pltrel
= entry
->d_un
.d_val
;
16866 pltrelsz
= entry
->d_un
.d_val
;
16869 jmprel
= entry
->d_un
.d_ptr
;
16875 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16877 Elf32_External_Lib
* elib
;
16880 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16881 sizeof (Elf32_External_Lib
),
16883 _("liblist section data"));
16886 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16887 "\nSection '.liblist' contains %lu entries:\n",
16888 (unsigned long) liblistno
),
16889 (unsigned long) liblistno
);
16890 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16893 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16900 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16901 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16902 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16903 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16904 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16906 tmp
= gmtime (&atime
);
16907 snprintf (timebuf
, sizeof (timebuf
),
16908 "%04u-%02u-%02uT%02u:%02u:%02u",
16909 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16910 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16912 printf ("%3lu: ", (unsigned long) cnt
);
16913 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
16914 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
16916 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16917 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16918 liblist
.l_version
);
16920 if (liblist
.l_flags
== 0)
16924 static const struct
16931 { " EXACT_MATCH", LL_EXACT_MATCH
},
16932 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16933 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16934 { " EXPORTS", LL_EXPORTS
},
16935 { " DELAY_LOAD", LL_DELAY_LOAD
},
16936 { " DELTA", LL_DELTA
}
16938 int flags
= liblist
.l_flags
;
16941 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16942 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16944 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16945 flags
^= l_flags_vals
[fcnt
].bit
;
16948 printf (" %#x", (unsigned int) flags
);
16960 if (options_offset
!= 0)
16962 Elf_External_Options
* eopt
;
16965 sect
= filedata
->section_headers
;
16967 /* Find the section header so that we get the size. */
16968 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16969 /* PR 17533 file: 012-277276-0.004. */
16972 error (_("No MIPS_OPTIONS header found\n"));
16976 if (sect
->sh_size
< sizeof (* eopt
))
16978 error (_("The MIPS options section is too small.\n"));
16982 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16983 sect
->sh_size
, _("options"));
16986 Elf_Internal_Options option
;
16989 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16991 Elf_External_Options
* eoption
;
16992 unsigned int optsize
;
16994 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16996 optsize
= BYTE_GET (eoption
->size
);
16998 /* PR 17531: file: ffa0fa3b. */
16999 if (optsize
< sizeof (* eopt
)
17000 || optsize
> sect
->sh_size
- offset
)
17002 error (_("Invalid size (%u) for MIPS option\n"),
17011 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17012 "\nSection '%s' contains %d entries:\n",
17014 printable_section_name (filedata
, sect
), cnt
);
17020 Elf_External_Options
* eoption
;
17022 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17024 option
.kind
= BYTE_GET (eoption
->kind
);
17025 option
.size
= BYTE_GET (eoption
->size
);
17026 option
.section
= BYTE_GET (eoption
->section
);
17027 option
.info
= BYTE_GET (eoption
->info
);
17029 switch (option
.kind
)
17032 /* This shouldn't happen. */
17033 printf (" NULL %" PRId16
" %" PRIx32
,
17034 option
.section
, option
.info
);
17038 printf (" REGINFO ");
17039 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17041 Elf32_External_RegInfo
* ereg
;
17042 Elf32_RegInfo reginfo
;
17045 if (option
.size
< (sizeof (Elf_External_Options
)
17046 + sizeof (Elf32_External_RegInfo
)))
17048 printf (_("<corrupt>\n"));
17049 error (_("Truncated MIPS REGINFO option\n"));
17054 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17056 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17057 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17058 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17059 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17060 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17061 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17063 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17064 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17066 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17067 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17068 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17069 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17074 Elf64_External_RegInfo
* ereg
;
17075 Elf64_Internal_RegInfo reginfo
;
17077 if (option
.size
< (sizeof (Elf_External_Options
)
17078 + sizeof (Elf64_External_RegInfo
)))
17080 printf (_("<corrupt>\n"));
17081 error (_("Truncated MIPS REGINFO option\n"));
17086 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
17087 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17088 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17089 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17090 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17091 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17092 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17094 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
17095 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17097 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17098 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17099 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17100 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17102 offset
+= option
.size
;
17105 case ODK_EXCEPTIONS
:
17106 fputs (" EXCEPTIONS fpe_min(", stdout
);
17107 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
17108 fputs (") fpe_max(", stdout
);
17109 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
17110 fputs (")", stdout
);
17112 if (option
.info
& OEX_PAGE0
)
17113 fputs (" PAGE0", stdout
);
17114 if (option
.info
& OEX_SMM
)
17115 fputs (" SMM", stdout
);
17116 if (option
.info
& OEX_FPDBUG
)
17117 fputs (" FPDBUG", stdout
);
17118 if (option
.info
& OEX_DISMISS
)
17119 fputs (" DISMISS", stdout
);
17123 fputs (" PAD ", stdout
);
17124 if (option
.info
& OPAD_PREFIX
)
17125 fputs (" PREFIX", stdout
);
17126 if (option
.info
& OPAD_POSTFIX
)
17127 fputs (" POSTFIX", stdout
);
17128 if (option
.info
& OPAD_SYMBOL
)
17129 fputs (" SYMBOL", stdout
);
17133 fputs (" HWPATCH ", stdout
);
17134 if (option
.info
& OHW_R4KEOP
)
17135 fputs (" R4KEOP", stdout
);
17136 if (option
.info
& OHW_R8KPFETCH
)
17137 fputs (" R8KPFETCH", stdout
);
17138 if (option
.info
& OHW_R5KEOP
)
17139 fputs (" R5KEOP", stdout
);
17140 if (option
.info
& OHW_R5KCVTL
)
17141 fputs (" R5KCVTL", stdout
);
17145 fputs (" FILL ", stdout
);
17146 /* XXX Print content of info word? */
17150 fputs (" TAGS ", stdout
);
17151 /* XXX Print content of info word? */
17155 fputs (" HWAND ", stdout
);
17156 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17157 fputs (" R4KEOP_CHECKED", stdout
);
17158 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17159 fputs (" R4KEOP_CLEAN", stdout
);
17163 fputs (" HWOR ", stdout
);
17164 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17165 fputs (" R4KEOP_CHECKED", stdout
);
17166 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17167 fputs (" R4KEOP_CLEAN", stdout
);
17171 printf (" GP_GROUP %#06x self-contained %#06x",
17172 option
.info
& OGP_GROUP
,
17173 (option
.info
& OGP_SELF
) >> 16);
17177 printf (" IDENT %#06x self-contained %#06x",
17178 option
.info
& OGP_GROUP
,
17179 (option
.info
& OGP_SELF
) >> 16);
17183 /* This shouldn't happen. */
17184 printf (" %3d ??? %" PRId16
" %" PRIx32
,
17185 option
.kind
, option
.section
, option
.info
);
17189 len
= sizeof (* eopt
);
17190 while (len
< option
.size
)
17192 unsigned char datum
= *((unsigned char *) eoption
+ len
);
17194 if (ISPRINT (datum
))
17195 printf ("%c", datum
);
17197 printf ("\\%03o", datum
);
17200 fputs ("\n", stdout
);
17202 offset
+= option
.size
;
17210 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17212 Elf32_Conflict
* iconf
;
17215 if (filedata
->dynamic_symbols
== NULL
)
17217 error (_("conflict list found without a dynamic symbol table\n"));
17221 /* PR 21345 - print a slightly more helpful error message
17222 if we are sure that the cmalloc will fail. */
17223 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17225 error (_("Overlarge number of conflicts detected: %lx\n"),
17226 (long) conflictsno
);
17230 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17233 error (_("Out of memory allocating space for dynamic conflicts\n"));
17239 Elf32_External_Conflict
* econf32
;
17241 econf32
= (Elf32_External_Conflict
*)
17242 get_data (NULL
, filedata
, conflicts_offset
,
17243 sizeof (*econf32
), conflictsno
, _("conflict"));
17250 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17251 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17257 Elf64_External_Conflict
* econf64
;
17259 econf64
= (Elf64_External_Conflict
*)
17260 get_data (NULL
, filedata
, conflicts_offset
,
17261 sizeof (*econf64
), conflictsno
, _("conflict"));
17268 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17269 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17274 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17275 "\nSection '.conflict' contains %lu entries:\n",
17276 (unsigned long) conflictsno
),
17277 (unsigned long) conflictsno
);
17278 puts (_(" Num: Index Value Name"));
17280 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17282 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17284 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17285 printf (_("<corrupt symbol index>"));
17288 Elf_Internal_Sym
* psym
;
17290 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17291 print_vma (psym
->st_value
, FULL_HEX
);
17293 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17294 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17296 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17304 if (pltgot
!= 0 && local_gotno
!= 0)
17306 bfd_vma ent
, local_end
, global_end
;
17308 unsigned char * data
;
17309 unsigned char * data_end
;
17313 addr_size
= (is_32bit_elf
? 4 : 8);
17314 local_end
= pltgot
+ local_gotno
* addr_size
;
17316 /* PR binutils/17533 file: 012-111227-0.004 */
17317 if (symtabno
< gotsym
)
17319 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17320 (unsigned long) gotsym
, (unsigned long) symtabno
);
17324 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17325 /* PR 17531: file: 54c91a34. */
17326 if (global_end
< local_end
)
17328 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17332 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17333 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17334 global_end
- pltgot
, 1,
17335 _("Global Offset Table data"));
17336 /* PR 12855: Null data is handled gracefully throughout. */
17337 data_end
= data
+ (global_end
- pltgot
);
17339 printf (_("\nPrimary GOT:\n"));
17340 printf (_(" Canonical gp value: "));
17341 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17344 printf (_(" Reserved entries:\n"));
17345 printf (_(" %*s %10s %*s Purpose\n"),
17346 addr_size
* 2, _("Address"), _("Access"),
17347 addr_size
* 2, _("Initial"));
17348 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17349 printf (_(" Lazy resolver\n"));
17350 if (ent
== (bfd_vma
) -1)
17351 goto got_print_fail
;
17353 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17354 This entry will be used by some runtime loaders, to store the
17355 module pointer. Otherwise this is an ordinary local entry.
17356 PR 21344: Check for the entry being fully available before
17359 && data
+ ent
- pltgot
+ addr_size
<= data_end
17360 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17361 >> (addr_size
* 8 - 1)) != 0)
17363 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17364 printf (_(" Module pointer (GNU extension)\n"));
17365 if (ent
== (bfd_vma
) -1)
17366 goto got_print_fail
;
17370 if (data
!= NULL
&& ent
< local_end
)
17372 printf (_(" Local entries:\n"));
17373 printf (" %*s %10s %*s\n",
17374 addr_size
* 2, _("Address"), _("Access"),
17375 addr_size
* 2, _("Initial"));
17376 while (ent
< local_end
)
17378 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17380 if (ent
== (bfd_vma
) -1)
17381 goto got_print_fail
;
17386 if (data
!= NULL
&& gotsym
< symtabno
)
17390 printf (_(" Global entries:\n"));
17391 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17392 addr_size
* 2, _("Address"),
17394 addr_size
* 2, _("Initial"),
17395 addr_size
* 2, _("Sym.Val."),
17397 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17398 _("Ndx"), _("Name"));
17400 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17402 for (i
= gotsym
; i
< symtabno
; i
++)
17404 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17407 if (filedata
->dynamic_symbols
== NULL
)
17408 printf (_("<no dynamic symbols>"));
17409 else if (i
< filedata
->num_dynamic_syms
)
17411 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17413 print_vma (psym
->st_value
, LONG_HEX
);
17414 printf (" %-7s %3s ",
17415 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17416 get_symbol_index_type (filedata
, psym
->st_shndx
));
17418 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17419 print_symbol (sym_width
,
17420 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17422 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17425 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17426 (unsigned long) i
);
17429 if (ent
== (bfd_vma
) -1)
17439 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17442 size_t offset
, rel_offset
;
17443 unsigned long count
, i
;
17444 unsigned char * data
;
17445 int addr_size
, sym_width
;
17446 Elf_Internal_Rela
* rels
;
17448 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17449 if (pltrel
== DT_RELA
)
17451 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17456 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17461 addr_size
= (is_32bit_elf
? 4 : 8);
17462 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17464 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17465 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17466 1, _("Procedure Linkage Table data"));
17470 printf ("\nPLT GOT:\n\n");
17471 printf (_(" Reserved entries:\n"));
17472 printf (_(" %*s %*s Purpose\n"),
17473 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17474 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17475 printf (_(" PLT lazy resolver\n"));
17476 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17477 printf (_(" Module pointer\n"));
17480 printf (_(" Entries:\n"));
17481 printf (" %*s %*s %*s %-7s %3s %s\n",
17482 addr_size
* 2, _("Address"),
17483 addr_size
* 2, _("Initial"),
17484 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17485 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17486 for (i
= 0; i
< count
; i
++)
17488 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17490 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17493 if (idx
>= filedata
->num_dynamic_syms
)
17494 printf (_("<corrupt symbol index: %lu>"), idx
);
17497 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17499 print_vma (psym
->st_value
, LONG_HEX
);
17500 printf (" %-7s %3s ",
17501 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17502 get_symbol_index_type (filedata
, psym
->st_shndx
));
17503 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17504 print_symbol (sym_width
,
17505 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17507 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17521 process_nds32_specific (Filedata
* filedata
)
17523 Elf_Internal_Shdr
*sect
= NULL
;
17525 sect
= find_section (filedata
, ".nds32_e_flags");
17526 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17528 unsigned char *buf
;
17531 printf ("\nNDS32 elf flags section:\n");
17532 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17533 _("NDS32 elf flags section"));
17538 flag
= byte_get (buf
, 4);
17540 switch (flag
& 0x3)
17543 printf ("(VEC_SIZE):\tNo entry.\n");
17546 printf ("(VEC_SIZE):\t4 bytes\n");
17549 printf ("(VEC_SIZE):\t16 bytes\n");
17552 printf ("(VEC_SIZE):\treserved\n");
17561 process_gnu_liblist (Filedata
* filedata
)
17563 Elf_Internal_Shdr
* section
;
17564 Elf_Internal_Shdr
* string_sec
;
17565 Elf32_External_Lib
* elib
;
17567 size_t strtab_size
;
17569 unsigned long num_liblist
;
17571 bfd_boolean res
= TRUE
;
17576 for (i
= 0, section
= filedata
->section_headers
;
17577 i
< filedata
->file_header
.e_shnum
;
17580 switch (section
->sh_type
)
17582 case SHT_GNU_LIBLIST
:
17583 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17586 elib
= (Elf32_External_Lib
*)
17587 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17588 _("liblist section data"));
17596 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17597 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17598 string_sec
->sh_size
,
17599 _("liblist string table"));
17601 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17608 strtab_size
= string_sec
->sh_size
;
17610 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17611 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17612 "\nLibrary list section '%s' contains %lu entries:\n",
17614 printable_section_name (filedata
, section
),
17617 puts (_(" Library Time Stamp Checksum Version Flags"));
17619 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17627 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17628 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17629 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17630 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17631 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17633 tmp
= gmtime (&atime
);
17634 snprintf (timebuf
, sizeof (timebuf
),
17635 "%04u-%02u-%02uT%02u:%02u:%02u",
17636 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17637 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17639 printf ("%3lu: ", (unsigned long) cnt
);
17641 printf ("%-20s", liblist
.l_name
< strtab_size
17642 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17644 printf ("%-20.20s", liblist
.l_name
< strtab_size
17645 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17646 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17647 liblist
.l_version
, liblist
.l_flags
);
17658 static const char *
17659 get_note_type (Filedata
* filedata
, unsigned e_type
)
17661 static char buff
[64];
17663 if (filedata
->file_header
.e_type
== ET_CORE
)
17667 return _("NT_AUXV (auxiliary vector)");
17669 return _("NT_PRSTATUS (prstatus structure)");
17671 return _("NT_FPREGSET (floating point registers)");
17673 return _("NT_PRPSINFO (prpsinfo structure)");
17674 case NT_TASKSTRUCT
:
17675 return _("NT_TASKSTRUCT (task structure)");
17677 return _("NT_PRXFPREG (user_xfpregs structure)");
17679 return _("NT_PPC_VMX (ppc Altivec registers)");
17681 return _("NT_PPC_VSX (ppc VSX registers)");
17683 return _("NT_PPC_TAR (ppc TAR register)");
17685 return _("NT_PPC_PPR (ppc PPR register)");
17687 return _("NT_PPC_DSCR (ppc DSCR register)");
17689 return _("NT_PPC_EBB (ppc EBB registers)");
17691 return _("NT_PPC_PMU (ppc PMU registers)");
17692 case NT_PPC_TM_CGPR
:
17693 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17694 case NT_PPC_TM_CFPR
:
17695 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17696 case NT_PPC_TM_CVMX
:
17697 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17698 case NT_PPC_TM_CVSX
:
17699 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17700 case NT_PPC_TM_SPR
:
17701 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17702 case NT_PPC_TM_CTAR
:
17703 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17704 case NT_PPC_TM_CPPR
:
17705 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17706 case NT_PPC_TM_CDSCR
:
17707 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17709 return _("NT_386_TLS (x86 TLS information)");
17710 case NT_386_IOPERM
:
17711 return _("NT_386_IOPERM (x86 I/O permissions)");
17712 case NT_X86_XSTATE
:
17713 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17714 case NT_S390_HIGH_GPRS
:
17715 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17716 case NT_S390_TIMER
:
17717 return _("NT_S390_TIMER (s390 timer register)");
17718 case NT_S390_TODCMP
:
17719 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17720 case NT_S390_TODPREG
:
17721 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17723 return _("NT_S390_CTRS (s390 control registers)");
17724 case NT_S390_PREFIX
:
17725 return _("NT_S390_PREFIX (s390 prefix register)");
17726 case NT_S390_LAST_BREAK
:
17727 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17728 case NT_S390_SYSTEM_CALL
:
17729 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17731 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17732 case NT_S390_VXRS_LOW
:
17733 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17734 case NT_S390_VXRS_HIGH
:
17735 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17736 case NT_S390_GS_CB
:
17737 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17738 case NT_S390_GS_BC
:
17739 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17741 return _("NT_ARM_VFP (arm VFP registers)");
17743 return _("NT_ARM_TLS (AArch TLS registers)");
17744 case NT_ARM_HW_BREAK
:
17745 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17746 case NT_ARM_HW_WATCH
:
17747 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17749 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17751 return _("NT_PSTATUS (pstatus structure)");
17753 return _("NT_FPREGS (floating point registers)");
17755 return _("NT_PSINFO (psinfo structure)");
17757 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17759 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17760 case NT_WIN32PSTATUS
:
17761 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17763 return _("NT_SIGINFO (siginfo_t data)");
17765 return _("NT_FILE (mapped files)");
17773 return _("NT_VERSION (version)");
17775 return _("NT_ARCH (architecture)");
17776 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17778 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17784 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17789 print_core_note (Elf_Internal_Note
*pnote
)
17791 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17792 bfd_vma count
, page_size
;
17793 unsigned char *descdata
, *filenames
, *descend
;
17795 if (pnote
->type
!= NT_FILE
)
17805 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17806 /* Still "successful". */
17811 if (pnote
->descsz
< 2 * addr_size
)
17813 error (_(" Malformed note - too short for header\n"));
17817 descdata
= (unsigned char *) pnote
->descdata
;
17818 descend
= descdata
+ pnote
->descsz
;
17820 if (descdata
[pnote
->descsz
- 1] != '\0')
17822 error (_(" Malformed note - does not end with \\0\n"));
17826 count
= byte_get (descdata
, addr_size
);
17827 descdata
+= addr_size
;
17829 page_size
= byte_get (descdata
, addr_size
);
17830 descdata
+= addr_size
;
17832 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17833 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17835 error (_(" Malformed note - too short for supplied file count\n"));
17839 printf (_(" Page size: "));
17840 print_vma (page_size
, DEC
);
17843 printf (_(" %*s%*s%*s\n"),
17844 (int) (2 + 2 * addr_size
), _("Start"),
17845 (int) (4 + 2 * addr_size
), _("End"),
17846 (int) (4 + 2 * addr_size
), _("Page Offset"));
17847 filenames
= descdata
+ count
* 3 * addr_size
;
17848 while (count
-- > 0)
17850 bfd_vma start
, end
, file_ofs
;
17852 if (filenames
== descend
)
17854 error (_(" Malformed note - filenames end too early\n"));
17858 start
= byte_get (descdata
, addr_size
);
17859 descdata
+= addr_size
;
17860 end
= byte_get (descdata
, addr_size
);
17861 descdata
+= addr_size
;
17862 file_ofs
= byte_get (descdata
, addr_size
);
17863 descdata
+= addr_size
;
17866 print_vma (start
, FULL_HEX
);
17868 print_vma (end
, FULL_HEX
);
17870 print_vma (file_ofs
, FULL_HEX
);
17871 printf ("\n %s\n", filenames
);
17873 filenames
+= 1 + strlen ((char *) filenames
);
17879 static const char *
17880 get_gnu_elf_note_type (unsigned e_type
)
17882 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17885 case NT_GNU_ABI_TAG
:
17886 return _("NT_GNU_ABI_TAG (ABI version tag)");
17888 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17889 case NT_GNU_BUILD_ID
:
17890 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17891 case NT_GNU_GOLD_VERSION
:
17892 return _("NT_GNU_GOLD_VERSION (gold version)");
17893 case NT_GNU_PROPERTY_TYPE_0
:
17894 return _("NT_GNU_PROPERTY_TYPE_0");
17895 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17896 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17897 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17898 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17901 static char buff
[64];
17903 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17910 decode_x86_compat_isa (unsigned int bitmask
)
17914 unsigned int bit
= bitmask
& (- bitmask
);
17919 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17922 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17925 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17928 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17931 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17934 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17937 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17940 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17943 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17946 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17949 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17952 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17953 printf ("AVX512F");
17955 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17956 printf ("AVX512CD");
17958 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17959 printf ("AVX512ER");
17961 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17962 printf ("AVX512PF");
17964 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17965 printf ("AVX512VL");
17967 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17968 printf ("AVX512DQ");
17970 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17971 printf ("AVX512BW");
17974 printf (_("<unknown: %x>"), bit
);
17983 decode_x86_isa (unsigned int bitmask
)
17987 printf (_("<None>"));
17993 unsigned int bit
= bitmask
& (- bitmask
);
17998 case GNU_PROPERTY_X86_ISA_1_CMOV
:
18001 case GNU_PROPERTY_X86_ISA_1_SSE
:
18004 case GNU_PROPERTY_X86_ISA_1_SSE2
:
18007 case GNU_PROPERTY_X86_ISA_1_SSE3
:
18010 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
18013 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
18016 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
18019 case GNU_PROPERTY_X86_ISA_1_AVX
:
18022 case GNU_PROPERTY_X86_ISA_1_AVX2
:
18025 case GNU_PROPERTY_X86_ISA_1_FMA
:
18028 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
18029 printf ("AVX512F");
18031 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
18032 printf ("AVX512CD");
18034 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
18035 printf ("AVX512ER");
18037 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
18038 printf ("AVX512PF");
18040 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
18041 printf ("AVX512VL");
18043 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
18044 printf ("AVX512DQ");
18046 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
18047 printf ("AVX512BW");
18049 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
18050 printf ("AVX512_4FMAPS");
18052 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
18053 printf ("AVX512_4VNNIW");
18055 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
18056 printf ("AVX512_BITALG");
18058 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
18059 printf ("AVX512_IFMA");
18061 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
18062 printf ("AVX512_VBMI");
18064 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
18065 printf ("AVX512_VBMI2");
18067 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
18068 printf ("AVX512_VNNI");
18070 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
18071 printf ("AVX512_BF16");
18074 printf (_("<unknown: %x>"), bit
);
18083 decode_x86_feature_1 (unsigned int bitmask
)
18087 printf (_("<None>"));
18093 unsigned int bit
= bitmask
& (- bitmask
);
18098 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18101 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18105 printf (_("<unknown: %x>"), bit
);
18114 decode_x86_feature_2 (unsigned int bitmask
)
18118 printf (_("<None>"));
18124 unsigned int bit
= bitmask
& (- bitmask
);
18129 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18132 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18135 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18138 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18141 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18144 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18147 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18150 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18153 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18154 printf ("XSAVEOPT");
18156 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18160 printf (_("<unknown: %x>"), bit
);
18169 decode_aarch64_feature_1_and (unsigned int bitmask
)
18173 unsigned int bit
= bitmask
& (- bitmask
);
18178 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18182 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18187 printf (_("<unknown: %x>"), bit
);
18196 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18198 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18199 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18200 unsigned int size
= is_32bit_elf
? 4 : 8;
18202 printf (_(" Properties: "));
18204 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18206 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18210 while (ptr
< ptr_end
)
18214 unsigned int datasz
;
18216 if ((size_t) (ptr_end
- ptr
) < 8)
18218 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18222 type
= byte_get (ptr
, 4);
18223 datasz
= byte_get (ptr
+ 4, 4);
18227 if (datasz
> (size_t) (ptr_end
- ptr
))
18229 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18234 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18236 if (filedata
->file_header
.e_machine
== EM_X86_64
18237 || filedata
->file_header
.e_machine
== EM_IAMCU
18238 || filedata
->file_header
.e_machine
== EM_386
)
18240 unsigned int bitmask
;
18243 bitmask
= byte_get (ptr
, 4);
18249 case GNU_PROPERTY_X86_ISA_1_USED
:
18251 printf (_("x86 ISA used: <corrupt length: %#x> "),
18255 printf ("x86 ISA used: ");
18256 decode_x86_isa (bitmask
);
18260 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18262 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18266 printf ("x86 ISA needed: ");
18267 decode_x86_isa (bitmask
);
18271 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18273 printf (_("x86 feature: <corrupt length: %#x> "),
18277 printf ("x86 feature: ");
18278 decode_x86_feature_1 (bitmask
);
18282 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18284 printf (_("x86 feature used: <corrupt length: %#x> "),
18288 printf ("x86 feature used: ");
18289 decode_x86_feature_2 (bitmask
);
18293 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18295 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18298 printf ("x86 feature needed: ");
18299 decode_x86_feature_2 (bitmask
);
18303 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18305 printf (_("x86 ISA used: <corrupt length: %#x> "),
18309 printf ("x86 ISA used: ");
18310 decode_x86_compat_isa (bitmask
);
18314 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18316 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18320 printf ("x86 ISA needed: ");
18321 decode_x86_compat_isa (bitmask
);
18329 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18331 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18333 printf ("AArch64 feature: ");
18335 printf (_("<corrupt length: %#x> "), datasz
);
18337 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18346 case GNU_PROPERTY_STACK_SIZE
:
18347 printf (_("stack size: "));
18348 if (datasz
!= size
)
18349 printf (_("<corrupt length: %#x> "), datasz
);
18351 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18354 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18355 printf ("no copy on protected ");
18357 printf (_("<corrupt length: %#x> "), datasz
);
18365 if (type
< GNU_PROPERTY_LOPROC
)
18366 printf (_("<unknown type %#x data: "), type
);
18367 else if (type
< GNU_PROPERTY_LOUSER
)
18368 printf (_("<procesor-specific type %#x data: "), type
);
18370 printf (_("<application-specific type %#x data: "), type
);
18371 for (j
= 0; j
< datasz
; ++j
)
18372 printf ("%02x ", ptr
[j
] & 0xff);
18376 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18377 if (ptr
== ptr_end
)
18390 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18392 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18393 switch (pnote
->type
)
18395 case NT_GNU_BUILD_ID
:
18399 printf (_(" Build ID: "));
18400 for (i
= 0; i
< pnote
->descsz
; ++i
)
18401 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18406 case NT_GNU_ABI_TAG
:
18408 unsigned long os
, major
, minor
, subminor
;
18409 const char *osname
;
18411 /* PR 17531: file: 030-599401-0.004. */
18412 if (pnote
->descsz
< 16)
18414 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18418 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18419 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18420 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18421 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18425 case GNU_ABI_TAG_LINUX
:
18428 case GNU_ABI_TAG_HURD
:
18431 case GNU_ABI_TAG_SOLARIS
:
18432 osname
= "Solaris";
18434 case GNU_ABI_TAG_FREEBSD
:
18435 osname
= "FreeBSD";
18437 case GNU_ABI_TAG_NETBSD
:
18440 case GNU_ABI_TAG_SYLLABLE
:
18441 osname
= "Syllable";
18443 case GNU_ABI_TAG_NACL
:
18447 osname
= "Unknown";
18451 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18452 major
, minor
, subminor
);
18456 case NT_GNU_GOLD_VERSION
:
18460 printf (_(" Version: "));
18461 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18462 printf ("%c", pnote
->descdata
[i
]);
18469 unsigned long num_entries
, mask
;
18471 /* Hardware capabilities information. Word 0 is the number of entries.
18472 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18473 is a series of entries, where each entry is a single byte followed
18474 by a nul terminated string. The byte gives the bit number to test
18475 if enabled in the bitmask. */
18476 printf (_(" Hardware Capabilities: "));
18477 if (pnote
->descsz
< 8)
18479 error (_("<corrupt GNU_HWCAP>\n"));
18482 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18483 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18484 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18485 /* FIXME: Add code to display the entries... */
18489 case NT_GNU_PROPERTY_TYPE_0
:
18490 print_gnu_property_note (filedata
, pnote
);
18494 /* Handle unrecognised types. An error message should have already been
18495 created by get_gnu_elf_note_type(), so all that we need to do is to
18496 display the data. */
18500 printf (_(" Description data: "));
18501 for (i
= 0; i
< pnote
->descsz
; ++i
)
18502 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18511 static const char *
18512 get_v850_elf_note_type (enum v850_notes n_type
)
18514 static char buff
[64];
18518 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18519 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18520 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18521 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18522 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18523 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18525 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18531 print_v850_note (Elf_Internal_Note
* pnote
)
18535 if (pnote
->descsz
!= 4)
18538 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18542 printf (_("not set\n"));
18546 switch (pnote
->type
)
18548 case V850_NOTE_ALIGNMENT
:
18551 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18552 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18556 case V850_NOTE_DATA_SIZE
:
18559 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18560 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18564 case V850_NOTE_FPU_INFO
:
18567 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18568 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18572 case V850_NOTE_MMU_INFO
:
18573 case V850_NOTE_CACHE_INFO
:
18574 case V850_NOTE_SIMD_INFO
:
18575 if (val
== EF_RH850_SIMD
)
18577 printf (_("yes\n"));
18583 /* An 'unknown note type' message will already have been displayed. */
18587 printf (_("unknown value: %x\n"), val
);
18592 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18594 unsigned int version
;
18596 switch (pnote
->type
)
18598 case NT_NETBSD_IDENT
:
18599 if (pnote
->descsz
< 1)
18601 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18602 if ((version
/ 10000) % 100)
18603 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18604 version
, version
/ 100000000, (version
/ 1000000) % 100,
18605 (version
/ 10000) % 100 > 26 ? "Z" : "",
18606 'A' + (version
/ 10000) % 26);
18608 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18609 version
, version
/ 100000000, (version
/ 1000000) % 100,
18610 (version
/ 100) % 100);
18613 case NT_NETBSD_MARCH
:
18614 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18618 #ifdef NT_NETBSD_PAX
18619 case NT_NETBSD_PAX
:
18620 if (pnote
->descsz
< 1)
18622 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18623 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18624 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18625 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18626 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18627 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18628 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18629 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18634 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18635 pnote
->descsz
, pnote
->type
);
18639 static const char *
18640 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18644 case NT_FREEBSD_THRMISC
:
18645 return _("NT_THRMISC (thrmisc structure)");
18646 case NT_FREEBSD_PROCSTAT_PROC
:
18647 return _("NT_PROCSTAT_PROC (proc data)");
18648 case NT_FREEBSD_PROCSTAT_FILES
:
18649 return _("NT_PROCSTAT_FILES (files data)");
18650 case NT_FREEBSD_PROCSTAT_VMMAP
:
18651 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18652 case NT_FREEBSD_PROCSTAT_GROUPS
:
18653 return _("NT_PROCSTAT_GROUPS (groups data)");
18654 case NT_FREEBSD_PROCSTAT_UMASK
:
18655 return _("NT_PROCSTAT_UMASK (umask data)");
18656 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18657 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18658 case NT_FREEBSD_PROCSTAT_OSREL
:
18659 return _("NT_PROCSTAT_OSREL (osreldate data)");
18660 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18661 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18662 case NT_FREEBSD_PROCSTAT_AUXV
:
18663 return _("NT_PROCSTAT_AUXV (auxv data)");
18664 case NT_FREEBSD_PTLWPINFO
:
18665 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18667 return get_note_type (filedata
, e_type
);
18670 static const char *
18671 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18673 static char buff
[64];
18677 case NT_NETBSDCORE_PROCINFO
:
18678 /* NetBSD core "procinfo" structure. */
18679 return _("NetBSD procinfo structure");
18681 #ifdef NT_NETBSDCORE_AUXV
18682 case NT_NETBSDCORE_AUXV
:
18683 return _("NetBSD ELF auxiliary vector data");
18686 #ifdef NT_NETBSDCORE_LWPSTATUS
18687 case NT_NETBSDCORE_LWPSTATUS
:
18688 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18692 /* As of Jan 2020 there are no other machine-independent notes
18693 defined for NetBSD core files. If the note type is less
18694 than the start of the machine-dependent note types, we don't
18697 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18699 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18705 switch (filedata
->file_header
.e_machine
)
18707 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18708 and PT_GETFPREGS == mach+2. */
18713 case EM_SPARC32PLUS
:
18717 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18718 return _("PT_GETREGS (reg structure)");
18719 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18720 return _("PT_GETFPREGS (fpreg structure)");
18726 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18727 There's also old PT___GETREGS40 == mach + 1 for old reg
18728 structure which lacks GBR. */
18732 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18733 return _("PT___GETREGS40 (old reg structure)");
18734 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18735 return _("PT_GETREGS (reg structure)");
18736 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18737 return _("PT_GETFPREGS (fpreg structure)");
18743 /* On all other arch's, PT_GETREGS == mach+1 and
18744 PT_GETFPREGS == mach+3. */
18748 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18749 return _("PT_GETREGS (reg structure)");
18750 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18751 return _("PT_GETFPREGS (fpreg structure)");
18757 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18758 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18762 static const char *
18763 get_stapsdt_note_type (unsigned e_type
)
18765 static char buff
[64];
18770 return _("NT_STAPSDT (SystemTap probe descriptors)");
18776 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18781 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18783 size_t len
, maxlen
;
18784 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18785 char *data
= pnote
->descdata
;
18786 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18787 bfd_vma pc
, base_addr
, semaphore
;
18788 char *provider
, *probe
, *arg_fmt
;
18790 if (pnote
->descsz
< (addr_size
* 3))
18791 goto stapdt_note_too_small
;
18793 pc
= byte_get ((unsigned char *) data
, addr_size
);
18796 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18799 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18802 if (data
>= data_end
)
18803 goto stapdt_note_too_small
;
18804 maxlen
= data_end
- data
;
18805 len
= strnlen (data
, maxlen
);
18812 goto stapdt_note_too_small
;
18814 if (data
>= data_end
)
18815 goto stapdt_note_too_small
;
18816 maxlen
= data_end
- data
;
18817 len
= strnlen (data
, maxlen
);
18824 goto stapdt_note_too_small
;
18826 if (data
>= data_end
)
18827 goto stapdt_note_too_small
;
18828 maxlen
= data_end
- data
;
18829 len
= strnlen (data
, maxlen
);
18836 goto stapdt_note_too_small
;
18838 printf (_(" Provider: %s\n"), provider
);
18839 printf (_(" Name: %s\n"), probe
);
18840 printf (_(" Location: "));
18841 print_vma (pc
, FULL_HEX
);
18842 printf (_(", Base: "));
18843 print_vma (base_addr
, FULL_HEX
);
18844 printf (_(", Semaphore: "));
18845 print_vma (semaphore
, FULL_HEX
);
18847 printf (_(" Arguments: %s\n"), arg_fmt
);
18849 return data
== data_end
;
18851 stapdt_note_too_small
:
18852 printf (_(" <corrupt - note is too small>\n"));
18853 error (_("corrupt stapdt note - the data size is too small\n"));
18857 static const char *
18858 get_ia64_vms_note_type (unsigned e_type
)
18860 static char buff
[64];
18865 return _("NT_VMS_MHD (module header)");
18867 return _("NT_VMS_LNM (language name)");
18869 return _("NT_VMS_SRC (source files)");
18871 return "NT_VMS_TITLE";
18873 return _("NT_VMS_EIDC (consistency check)");
18874 case NT_VMS_FPMODE
:
18875 return _("NT_VMS_FPMODE (FP mode)");
18876 case NT_VMS_LINKTIME
:
18877 return "NT_VMS_LINKTIME";
18878 case NT_VMS_IMGNAM
:
18879 return _("NT_VMS_IMGNAM (image name)");
18881 return _("NT_VMS_IMGID (image id)");
18882 case NT_VMS_LINKID
:
18883 return _("NT_VMS_LINKID (link id)");
18884 case NT_VMS_IMGBID
:
18885 return _("NT_VMS_IMGBID (build id)");
18886 case NT_VMS_GSTNAM
:
18887 return _("NT_VMS_GSTNAM (sym table name)");
18888 case NT_VMS_ORIG_DYN
:
18889 return "NT_VMS_ORIG_DYN";
18890 case NT_VMS_PATCHTIME
:
18891 return "NT_VMS_PATCHTIME";
18893 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18899 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18901 int maxlen
= pnote
->descsz
;
18903 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18904 goto desc_size_fail
;
18906 switch (pnote
->type
)
18910 goto desc_size_fail
;
18912 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18914 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18915 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18916 if (l
+ 34 < maxlen
)
18918 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18919 if (l
+ 35 < maxlen
)
18920 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18922 printf (_(" Module version : <missing>\n"));
18926 printf (_(" Module name : <missing>\n"));
18927 printf (_(" Module version : <missing>\n"));
18932 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18936 case NT_VMS_FPMODE
:
18937 printf (_(" Floating Point mode: "));
18939 goto desc_size_fail
;
18940 /* FIXME: Generate an error if descsz > 8 ? */
18942 printf ("0x%016" BFD_VMA_FMT
"x\n",
18943 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18946 case NT_VMS_LINKTIME
:
18947 printf (_(" Link time: "));
18949 goto desc_size_fail
;
18950 /* FIXME: Generate an error if descsz > 8 ? */
18953 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18957 case NT_VMS_PATCHTIME
:
18958 printf (_(" Patch time: "));
18960 goto desc_size_fail
;
18961 /* FIXME: Generate an error if descsz > 8 ? */
18964 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18968 case NT_VMS_ORIG_DYN
:
18970 goto desc_size_fail
;
18972 printf (_(" Major id: %u, minor id: %u\n"),
18973 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18974 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18975 printf (_(" Last modified : "));
18977 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18978 printf (_("\n Link flags : "));
18979 printf ("0x%016" BFD_VMA_FMT
"x\n",
18980 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18981 printf (_(" Header flags: 0x%08x\n"),
18982 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18983 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18987 case NT_VMS_IMGNAM
:
18988 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18991 case NT_VMS_GSTNAM
:
18992 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18996 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18999 case NT_VMS_LINKID
:
19000 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
19010 printf (_(" <corrupt - data size is too small>\n"));
19011 error (_("corrupt IA64 note: data size is too small\n"));
19015 struct build_attr_cache
{
19016 Filedata
*filedata
;
19018 unsigned long strtablen
;
19019 Elf_Internal_Sym
*symtab
;
19020 unsigned long nsyms
;
19023 /* Find the symbol associated with a build attribute that is attached
19024 to address OFFSET. If PNAME is non-NULL then store the name of
19025 the symbol (if found) in the provided pointer, Returns NULL if a
19026 symbol could not be found. */
19028 static Elf_Internal_Sym
*
19029 get_symbol_for_build_attribute (Filedata
* filedata
,
19030 unsigned long offset
,
19031 bfd_boolean is_open_attr
,
19032 const char ** pname
)
19034 Elf_Internal_Sym
*saved_sym
= NULL
;
19035 Elf_Internal_Sym
*sym
;
19037 if (filedata
->section_headers
!= NULL
19038 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
19040 Elf_Internal_Shdr
* symsec
;
19042 free (ba_cache
.strtab
);
19043 ba_cache
.strtab
= NULL
;
19044 free (ba_cache
.symtab
);
19045 ba_cache
.symtab
= NULL
;
19047 /* Load the symbol and string sections. */
19048 for (symsec
= filedata
->section_headers
;
19049 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19052 if (symsec
->sh_type
== SHT_SYMTAB
19053 && get_symtab (filedata
, symsec
,
19054 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19055 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19058 ba_cache
.filedata
= filedata
;
19061 if (ba_cache
.symtab
== NULL
)
19064 /* Find a symbol whose value matches offset. */
19065 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19066 if (sym
->st_value
== offset
)
19068 if (sym
->st_name
>= ba_cache
.strtablen
)
19069 /* Huh ? This should not happen. */
19072 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19075 /* The AArch64 and ARM architectures define mapping symbols
19076 (eg $d, $x, $t) which we want to ignore. */
19077 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19078 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19079 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19084 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19085 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19086 FUNC symbols entirely. */
19087 switch (ELF_ST_TYPE (sym
->st_info
))
19094 /* If the symbol has a size associated
19095 with it then we can stop searching. */
19096 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19101 /* Ignore function symbols. */
19108 switch (ELF_ST_BIND (sym
->st_info
))
19111 if (saved_sym
== NULL
19112 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19117 if (saved_sym
== NULL
)
19127 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19135 if (saved_sym
&& pname
)
19136 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19141 /* Returns true iff addr1 and addr2 are in the same section. */
19144 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19146 Elf_Internal_Shdr
* a1
;
19147 Elf_Internal_Shdr
* a2
;
19149 a1
= find_section_by_address (filedata
, addr1
);
19150 a2
= find_section_by_address (filedata
, addr2
);
19152 return a1
== a2
&& a1
!= NULL
;
19156 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19157 Filedata
* filedata
)
19159 static unsigned long global_offset
= 0;
19160 static unsigned long global_end
= 0;
19161 static unsigned long func_offset
= 0;
19162 static unsigned long func_end
= 0;
19164 Elf_Internal_Sym
* sym
;
19166 unsigned long start
;
19168 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19170 switch (pnote
->descsz
)
19173 /* A zero-length description means that the range of
19174 the previous note of the same type should be used. */
19177 if (global_end
> global_offset
)
19178 printf (_(" Applies to region from %#lx to %#lx\n"),
19179 global_offset
, global_end
);
19181 printf (_(" Applies to region from %#lx\n"), global_offset
);
19185 if (func_end
> func_offset
)
19186 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19188 printf (_(" Applies to region from %#lx\n"), func_offset
);
19193 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19200 /* FIXME: We should check that version 3+ notes are being used here... */
19201 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19202 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19206 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19212 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19213 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19217 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19218 printf (_(" <invalid descsz>"));
19223 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19224 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19225 in order to avoid them being confused with the start address of the
19226 first function in the file... */
19227 if (sym
== NULL
&& is_open_attr
)
19228 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19231 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19232 end
= start
+ sym
->st_size
;
19236 /* FIXME: Need to properly allow for section alignment.
19237 16 is just the alignment used on x86_64. */
19239 && start
> BFD_ALIGN (global_end
, 16)
19240 /* Build notes are not guaranteed to be organised in order of
19241 increasing address, but we should find the all of the notes
19242 for one section in the same place. */
19243 && same_section (filedata
, start
, global_end
))
19244 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19245 global_end
+ 1, start
- 1);
19247 printf (_(" Applies to region from %#lx"), start
);
19248 global_offset
= start
;
19252 printf (_(" to %#lx"), end
);
19258 printf (_(" Applies to region from %#lx"), start
);
19259 func_offset
= start
;
19263 printf (_(" to %#lx"), end
);
19269 printf (_(" (%s)"), name
);
19276 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19278 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19279 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19280 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19282 char name_attribute
;
19283 const char * expected_types
;
19284 const char * name
= pnote
->namedata
;
19288 if (name
== NULL
|| pnote
->namesz
< 2)
19290 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19291 print_symbol (-20, _(" <corrupt name>"));
19300 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19301 if (name
[0] == 'G' && name
[1] == 'A')
19303 if (pnote
->namesz
< 4)
19305 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19306 print_symbol (-20, _(" <corrupt name>"));
19315 switch ((name_type
= * name
))
19317 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19318 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19319 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19320 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19321 printf ("%c", * name
);
19325 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19326 print_symbol (-20, _("<unknown name type>"));
19333 switch ((name_attribute
= * name
))
19335 case GNU_BUILD_ATTRIBUTE_VERSION
:
19336 text
= _("<version>");
19337 expected_types
= string_expected
;
19340 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19341 text
= _("<stack prot>");
19342 expected_types
= "!+*";
19345 case GNU_BUILD_ATTRIBUTE_RELRO
:
19346 text
= _("<relro>");
19347 expected_types
= bool_expected
;
19350 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19351 text
= _("<stack size>");
19352 expected_types
= number_expected
;
19355 case GNU_BUILD_ATTRIBUTE_TOOL
:
19356 text
= _("<tool>");
19357 expected_types
= string_expected
;
19360 case GNU_BUILD_ATTRIBUTE_ABI
:
19362 expected_types
= "$*";
19365 case GNU_BUILD_ATTRIBUTE_PIC
:
19367 expected_types
= number_expected
;
19370 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19371 text
= _("<short enum>");
19372 expected_types
= bool_expected
;
19376 if (ISPRINT (* name
))
19378 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19380 if (len
> left
&& ! do_wide
)
19382 printf ("%.*s:", len
, name
);
19388 static char tmpbuf
[128];
19390 error (_("unrecognised byte in name field: %d\n"), * name
);
19391 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19395 expected_types
= "*$!+";
19400 left
-= printf ("%s", text
);
19402 if (strchr (expected_types
, name_type
) == NULL
)
19403 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19405 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19407 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19408 (unsigned long) pnote
->namesz
,
19409 (long) (name
- pnote
->namedata
));
19413 if (left
< 1 && ! do_wide
)
19418 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19420 unsigned int bytes
;
19421 unsigned long long val
= 0;
19422 unsigned int shift
= 0;
19423 char * decoded
= NULL
;
19425 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19427 /* The -1 is because the name field is always 0 terminated, and we
19428 want to be able to ensure that the shift in the while loop below
19429 will not overflow. */
19432 if (bytes
> sizeof (val
))
19434 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19436 bytes
= sizeof (val
);
19438 /* We do not bother to warn if bytes == 0 as this can
19439 happen with some early versions of the gcc plugin. */
19443 unsigned long byte
= (* name
++) & 0xff;
19445 val
|= byte
<< shift
;
19449 switch (name_attribute
)
19451 case GNU_BUILD_ATTRIBUTE_PIC
:
19454 case 0: decoded
= "static"; break;
19455 case 1: decoded
= "pic"; break;
19456 case 2: decoded
= "PIC"; break;
19457 case 3: decoded
= "pie"; break;
19458 case 4: decoded
= "PIE"; break;
19462 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19465 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19466 case 0: decoded
= "off"; break;
19467 case 1: decoded
= "on"; break;
19468 case 2: decoded
= "all"; break;
19469 case 3: decoded
= "strong"; break;
19470 case 4: decoded
= "explicit"; break;
19478 if (decoded
!= NULL
)
19480 print_symbol (-left
, decoded
);
19491 left
-= printf ("0x%llx", val
);
19493 left
-= printf ("0x%-.*llx", left
, val
);
19497 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19498 left
-= print_symbol (- left
, name
);
19500 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19501 left
-= print_symbol (- left
, "true");
19503 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19504 left
-= print_symbol (- left
, "false");
19508 if (do_wide
&& left
> 0)
19509 printf ("%-*s", left
, " ");
19514 /* Note that by the ELF standard, the name field is already null byte
19515 terminated, and namesz includes the terminating null byte.
19516 I.E. the value of namesz for the name "FSF" is 4.
19518 If the value of namesz is zero, there is no name present. */
19521 process_note (Elf_Internal_Note
* pnote
,
19522 Filedata
* filedata
)
19524 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19527 if (pnote
->namesz
== 0)
19528 /* If there is no note name, then use the default set of
19529 note type strings. */
19530 nt
= get_note_type (filedata
, pnote
->type
);
19532 else if (const_strneq (pnote
->namedata
, "GNU"))
19533 /* GNU-specific object file notes. */
19534 nt
= get_gnu_elf_note_type (pnote
->type
);
19536 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19537 /* FreeBSD-specific core file notes. */
19538 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19540 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19541 /* NetBSD-specific core file notes. */
19542 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19544 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19545 /* NetBSD-specific core file notes. */
19546 return process_netbsd_elf_note (pnote
);
19548 else if (const_strneq (pnote
->namedata
, "PaX"))
19549 /* NetBSD-specific core file notes. */
19550 return process_netbsd_elf_note (pnote
);
19552 else if (strneq (pnote
->namedata
, "SPU/", 4))
19554 /* SPU-specific core file notes. */
19555 nt
= pnote
->namedata
+ 4;
19559 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19560 /* VMS/ia64-specific file notes. */
19561 nt
= get_ia64_vms_note_type (pnote
->type
);
19563 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19564 nt
= get_stapsdt_note_type (pnote
->type
);
19567 /* Don't recognize this note name; just use the default set of
19568 note type strings. */
19569 nt
= get_note_type (filedata
, pnote
->type
);
19573 if (((const_strneq (pnote
->namedata
, "GA")
19574 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19575 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19576 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19577 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19578 print_gnu_build_attribute_name (pnote
);
19580 print_symbol (-20, name
);
19583 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19585 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19587 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19588 return print_ia64_vms_note (pnote
);
19589 else if (const_strneq (pnote
->namedata
, "GNU"))
19590 return print_gnu_note (filedata
, pnote
);
19591 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19592 return print_stapsdt_note (pnote
);
19593 else if (const_strneq (pnote
->namedata
, "CORE"))
19594 return print_core_note (pnote
);
19595 else if (((const_strneq (pnote
->namedata
, "GA")
19596 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19597 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19598 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19599 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19600 return print_gnu_build_attribute_description (pnote
, filedata
);
19606 printf (_(" description data: "));
19607 for (i
= 0; i
< pnote
->descsz
; i
++)
19608 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19620 process_notes_at (Filedata
* filedata
,
19621 Elf_Internal_Shdr
* section
,
19626 Elf_External_Note
* pnotes
;
19627 Elf_External_Note
* external
;
19629 bfd_boolean res
= TRUE
;
19636 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19639 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19647 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19650 if (pnotes
== NULL
)
19656 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19658 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19659 (unsigned long) offset
, (unsigned long) length
);
19661 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19662 specifies that notes should be aligned to 4 bytes in 32-bit
19663 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19664 we also support 4 byte alignment in 64-bit objects. If section
19665 alignment is less than 4, we treate alignment as 4 bytes. */
19668 else if (align
!= 4 && align
!= 8)
19670 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19676 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19678 end
= (char *) pnotes
+ length
;
19679 while ((char *) external
< end
)
19681 Elf_Internal_Note inote
;
19684 char * temp
= NULL
;
19685 size_t data_remaining
= end
- (char *) external
;
19687 if (!is_ia64_vms (filedata
))
19689 /* PR binutils/15191
19690 Make sure that there is enough data to read. */
19691 min_notesz
= offsetof (Elf_External_Note
, name
);
19692 if (data_remaining
< min_notesz
)
19694 warn (ngettext ("Corrupt note: only %ld byte remains, "
19695 "not enough for a full note\n",
19696 "Corrupt note: only %ld bytes remain, "
19697 "not enough for a full note\n",
19699 (long) data_remaining
);
19702 data_remaining
-= min_notesz
;
19704 inote
.type
= BYTE_GET (external
->type
);
19705 inote
.namesz
= BYTE_GET (external
->namesz
);
19706 inote
.namedata
= external
->name
;
19707 inote
.descsz
= BYTE_GET (external
->descsz
);
19708 inote
.descdata
= ((char *) external
19709 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19710 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19711 next
= ((char *) external
19712 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19716 Elf64_External_VMS_Note
*vms_external
;
19718 /* PR binutils/15191
19719 Make sure that there is enough data to read. */
19720 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19721 if (data_remaining
< min_notesz
)
19723 warn (ngettext ("Corrupt note: only %ld byte remains, "
19724 "not enough for a full note\n",
19725 "Corrupt note: only %ld bytes remain, "
19726 "not enough for a full note\n",
19728 (long) data_remaining
);
19731 data_remaining
-= min_notesz
;
19733 vms_external
= (Elf64_External_VMS_Note
*) external
;
19734 inote
.type
= BYTE_GET (vms_external
->type
);
19735 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19736 inote
.namedata
= vms_external
->name
;
19737 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19738 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19739 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19740 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19743 /* PR 17531: file: 3443835e. */
19744 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19745 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19746 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19747 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19748 || ((size_t) (next
- inote
.descdata
)
19749 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19751 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19752 (unsigned long) ((char *) external
- (char *) pnotes
));
19753 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19754 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19758 external
= (Elf_External_Note
*) next
;
19760 /* Verify that name is null terminated. It appears that at least
19761 one version of Linux (RedHat 6.0) generates corefiles that don't
19762 comply with the ELF spec by failing to include the null byte in
19764 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19766 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19768 temp
= (char *) malloc (inote
.namesz
+ 1);
19771 error (_("Out of memory allocating space for inote name\n"));
19776 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19777 inote
.namedata
= temp
;
19779 inote
.namedata
[inote
.namesz
] = 0;
19782 if (! process_note (& inote
, filedata
))
19795 process_corefile_note_segments (Filedata
* filedata
)
19797 Elf_Internal_Phdr
* segment
;
19799 bfd_boolean res
= TRUE
;
19801 if (! get_program_headers (filedata
))
19804 for (i
= 0, segment
= filedata
->program_headers
;
19805 i
< filedata
->file_header
.e_phnum
;
19808 if (segment
->p_type
== PT_NOTE
)
19809 if (! process_notes_at (filedata
, NULL
,
19810 (bfd_vma
) segment
->p_offset
,
19811 (bfd_vma
) segment
->p_filesz
,
19812 (bfd_vma
) segment
->p_align
))
19820 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19822 Elf_External_Note
* pnotes
;
19823 Elf_External_Note
* external
;
19825 bfd_boolean res
= TRUE
;
19830 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19832 if (pnotes
== NULL
)
19836 end
= (char*) pnotes
+ length
;
19838 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19839 (unsigned long) offset
, (unsigned long) length
);
19841 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19843 Elf_External_Note
* next
;
19844 Elf_Internal_Note inote
;
19846 inote
.type
= BYTE_GET (external
->type
);
19847 inote
.namesz
= BYTE_GET (external
->namesz
);
19848 inote
.namedata
= external
->name
;
19849 inote
.descsz
= BYTE_GET (external
->descsz
);
19850 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19851 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19853 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19855 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19856 inote
.descdata
= inote
.namedata
;
19860 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19862 if ( ((char *) next
> end
)
19863 || ((char *) next
< (char *) pnotes
))
19865 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19866 (unsigned long) ((char *) external
- (char *) pnotes
));
19867 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19868 inote
.type
, inote
.namesz
, inote
.descsz
);
19874 /* Prevent out-of-bounds indexing. */
19875 if ( inote
.namedata
+ inote
.namesz
> end
19876 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19878 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19879 (unsigned long) ((char *) external
- (char *) pnotes
));
19880 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19881 inote
.type
, inote
.namesz
, inote
.descsz
);
19885 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19887 if (! print_v850_note (& inote
))
19890 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19891 inote
.namesz
, inote
.descsz
);
19901 process_note_sections (Filedata
* filedata
)
19903 Elf_Internal_Shdr
* section
;
19905 unsigned int n
= 0;
19906 bfd_boolean res
= TRUE
;
19908 for (i
= 0, section
= filedata
->section_headers
;
19909 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19912 if (section
->sh_type
== SHT_NOTE
)
19914 if (! process_notes_at (filedata
, section
,
19915 (bfd_vma
) section
->sh_offset
,
19916 (bfd_vma
) section
->sh_size
,
19917 (bfd_vma
) section
->sh_addralign
))
19922 if (( filedata
->file_header
.e_machine
== EM_V800
19923 || filedata
->file_header
.e_machine
== EM_V850
19924 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19925 && section
->sh_type
== SHT_RENESAS_INFO
)
19927 if (! process_v850_notes (filedata
,
19928 (bfd_vma
) section
->sh_offset
,
19929 (bfd_vma
) section
->sh_size
))
19936 /* Try processing NOTE segments instead. */
19937 return process_corefile_note_segments (filedata
);
19943 process_notes (Filedata
* filedata
)
19945 /* If we have not been asked to display the notes then do nothing. */
19949 if (filedata
->file_header
.e_type
!= ET_CORE
)
19950 return process_note_sections (filedata
);
19952 /* No program headers means no NOTE segment. */
19953 if (filedata
->file_header
.e_phnum
> 0)
19954 return process_corefile_note_segments (filedata
);
19956 printf (_("No note segments present in the core file.\n"));
19960 static unsigned char *
19961 display_public_gnu_attributes (unsigned char * start
,
19962 const unsigned char * const end
)
19964 printf (_(" Unknown GNU attribute: %s\n"), start
);
19966 start
+= strnlen ((char *) start
, end
- start
);
19967 display_raw_attribute (start
, end
);
19969 return (unsigned char *) end
;
19972 static unsigned char *
19973 display_generic_attribute (unsigned char * start
,
19975 const unsigned char * const end
)
19978 return (unsigned char *) end
;
19980 return display_tag_value (tag
, start
, end
);
19984 process_arch_specific (Filedata
* filedata
)
19989 switch (filedata
->file_header
.e_machine
)
19992 case EM_ARC_COMPACT
:
19993 case EM_ARC_COMPACT2
:
19994 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19995 display_arc_attribute
,
19996 display_generic_attribute
);
19998 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19999 display_arm_attribute
,
20000 display_generic_attribute
);
20003 case EM_MIPS_RS3_LE
:
20004 return process_mips_specific (filedata
);
20007 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
20008 display_msp430x_attribute
,
20009 display_msp430_gnu_attribute
);
20012 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
20013 display_riscv_attribute
,
20014 display_generic_attribute
);
20017 return process_nds32_specific (filedata
);
20020 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20021 display_m68k_gnu_attribute
);
20025 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20026 display_power_gnu_attribute
);
20030 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20031 display_s390_gnu_attribute
);
20034 case EM_SPARC32PLUS
:
20036 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20037 display_sparc_gnu_attribute
);
20040 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
20041 display_tic6x_attribute
,
20042 display_generic_attribute
);
20045 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20046 display_public_gnu_attributes
,
20047 display_generic_attribute
);
20052 get_file_header (Filedata
* filedata
)
20054 /* Read in the identity array. */
20055 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20058 /* Determine how to read the rest of the header. */
20059 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20064 byte_get
= byte_get_little_endian
;
20065 byte_put
= byte_put_little_endian
;
20068 byte_get
= byte_get_big_endian
;
20069 byte_put
= byte_put_big_endian
;
20073 /* For now we only support 32 bit and 64 bit ELF files. */
20074 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20076 /* Read in the rest of the header. */
20079 Elf32_External_Ehdr ehdr32
;
20081 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20084 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20085 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20086 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20087 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20088 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20089 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20090 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20091 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20092 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20093 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20094 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20095 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20096 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20100 Elf64_External_Ehdr ehdr64
;
20102 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20103 we will not be able to cope with the 64bit data found in
20104 64 ELF files. Detect this now and abort before we start
20105 overwriting things. */
20106 if (sizeof (bfd_vma
) < 8)
20108 error (_("This instance of readelf has been built without support for a\n\
20109 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20113 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20116 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20117 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20118 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20119 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20120 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20121 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20122 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20123 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20124 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20125 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20126 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20127 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20128 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20131 if (filedata
->file_header
.e_shoff
)
20133 /* There may be some extensions in the first section header. Don't
20134 bomb if we can't read it. */
20136 get_32bit_section_headers (filedata
, TRUE
);
20138 get_64bit_section_headers (filedata
, TRUE
);
20145 close_file (Filedata
* filedata
)
20149 if (filedata
->handle
)
20150 fclose (filedata
->handle
);
20156 close_debug_file (void * data
)
20158 close_file ((Filedata
*) data
);
20162 open_file (const char * pathname
)
20164 struct stat statbuf
;
20165 Filedata
* filedata
= NULL
;
20167 if (stat (pathname
, & statbuf
) < 0
20168 || ! S_ISREG (statbuf
.st_mode
))
20171 filedata
= calloc (1, sizeof * filedata
);
20172 if (filedata
== NULL
)
20175 filedata
->handle
= fopen (pathname
, "rb");
20176 if (filedata
->handle
== NULL
)
20179 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20180 filedata
->file_name
= pathname
;
20182 if (! get_file_header (filedata
))
20185 if (filedata
->file_header
.e_shoff
)
20189 /* Read the section headers again, this time for real. */
20191 res
= get_32bit_section_headers (filedata
, FALSE
);
20193 res
= get_64bit_section_headers (filedata
, FALSE
);
20204 if (filedata
->handle
)
20205 fclose (filedata
->handle
);
20212 open_debug_file (const char * pathname
)
20214 return open_file (pathname
);
20217 /* Process one ELF object file according to the command line options.
20218 This file may actually be stored in an archive. The file is
20219 positioned at the start of the ELF object. Returns TRUE if no
20220 problems were encountered, FALSE otherwise. */
20223 process_object (Filedata
* filedata
)
20225 bfd_boolean have_separate_files
;
20229 if (! get_file_header (filedata
))
20231 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20235 /* Initialise per file variables. */
20236 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20237 filedata
->version_info
[i
] = 0;
20239 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20240 filedata
->dynamic_info
[i
] = 0;
20241 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20242 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20244 /* Process the file. */
20246 printf (_("\nFile: %s\n"), filedata
->file_name
);
20248 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20249 Note we do this even if cmdline_dump_sects is empty because we
20250 must make sure that the dump_sets array is zeroed out before each
20251 object file is processed. */
20252 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20253 memset (filedata
->dump
.dump_sects
, 0,
20254 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20256 if (cmdline
.num_dump_sects
> 0)
20258 if (filedata
->dump
.num_dump_sects
== 0)
20259 /* A sneaky way of allocating the dump_sects array. */
20260 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20262 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20263 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20264 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20267 if (! process_file_header (filedata
))
20270 if (! process_section_headers (filedata
))
20272 /* Without loaded section headers we cannot process lots of things. */
20273 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20275 if (! do_using_dynamic
)
20276 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20279 if (! process_section_groups (filedata
))
20280 /* Without loaded section groups we cannot process unwind. */
20283 res
= process_program_headers (filedata
);
20285 res
= process_dynamic_section (filedata
);
20287 if (! process_relocs (filedata
))
20290 if (! process_unwind (filedata
))
20293 if (! process_symbol_table (filedata
))
20296 if (! process_syminfo (filedata
))
20299 if (! process_version_sections (filedata
))
20302 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20303 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20305 have_separate_files
= FALSE
;
20307 if (! process_section_contents (filedata
))
20310 if (have_separate_files
)
20314 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20316 if (! process_section_headers (d
->handle
))
20318 else if (! process_section_contents (d
->handle
))
20322 /* The file handles are closed by the call to free_debug_memory() below. */
20325 if (! process_notes (filedata
))
20328 if (! process_gnu_liblist (filedata
))
20331 if (! process_arch_specific (filedata
))
20334 free (filedata
->program_headers
);
20335 filedata
->program_headers
= NULL
;
20337 free (filedata
->section_headers
);
20338 filedata
->section_headers
= NULL
;
20340 free (filedata
->string_table
);
20341 filedata
->string_table
= NULL
;
20342 filedata
->string_table_length
= 0;
20344 free (filedata
->dump
.dump_sects
);
20345 filedata
->dump
.dump_sects
= NULL
;
20346 filedata
->dump
.num_dump_sects
= 0;
20348 free (filedata
->dynamic_strings
);
20349 filedata
->dynamic_strings
= NULL
;
20350 filedata
->dynamic_strings_length
= 0;
20352 free (filedata
->dynamic_symbols
);
20353 filedata
->dynamic_symbols
= NULL
;
20354 filedata
->num_dynamic_syms
= 0;
20356 free (filedata
->dynamic_syminfo
);
20357 filedata
->dynamic_syminfo
= NULL
;
20359 free (filedata
->dynamic_section
);
20360 filedata
->dynamic_section
= NULL
;
20362 while (filedata
->symtab_shndx_list
!= NULL
)
20364 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20365 free (filedata
->symtab_shndx_list
);
20366 filedata
->symtab_shndx_list
= next
;
20369 free (filedata
->section_headers_groups
);
20370 filedata
->section_headers_groups
= NULL
;
20372 if (filedata
->section_groups
)
20374 struct group_list
* g
;
20375 struct group_list
* next
;
20377 for (i
= 0; i
< filedata
->group_count
; i
++)
20379 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20386 free (filedata
->section_groups
);
20387 filedata
->section_groups
= NULL
;
20390 free_debug_memory ();
20395 /* Process an ELF archive.
20396 On entry the file is positioned just after the ARMAG string.
20397 Returns TRUE upon success, FALSE otherwise. */
20400 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20402 struct archive_info arch
;
20403 struct archive_info nested_arch
;
20405 bfd_boolean ret
= TRUE
;
20409 /* The ARCH structure is used to hold information about this archive. */
20410 arch
.file_name
= NULL
;
20412 arch
.index_array
= NULL
;
20413 arch
.sym_table
= NULL
;
20414 arch
.longnames
= NULL
;
20416 /* The NESTED_ARCH structure is used as a single-item cache of information
20417 about a nested archive (when members of a thin archive reside within
20418 another regular archive file). */
20419 nested_arch
.file_name
= NULL
;
20420 nested_arch
.file
= NULL
;
20421 nested_arch
.index_array
= NULL
;
20422 nested_arch
.sym_table
= NULL
;
20423 nested_arch
.longnames
= NULL
;
20425 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20426 filedata
->file_size
, is_thin_archive
,
20427 do_archive_index
) != 0)
20433 if (do_archive_index
)
20435 if (arch
.sym_table
== NULL
)
20436 error (_("%s: unable to dump the index as none was found\n"),
20437 filedata
->file_name
);
20440 unsigned long i
, l
;
20441 unsigned long current_pos
;
20443 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20444 "in the symbol table)\n"),
20445 filedata
->file_name
, (unsigned long) arch
.index_num
,
20448 current_pos
= ftell (filedata
->handle
);
20450 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20453 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20456 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20459 if (member_name
!= NULL
)
20461 char * qualified_name
20462 = make_qualified_name (&arch
, &nested_arch
,
20465 if (qualified_name
!= NULL
)
20467 printf (_("Contents of binary %s at offset "),
20469 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20471 free (qualified_name
);
20473 free (member_name
);
20477 if (l
>= arch
.sym_size
)
20479 error (_("%s: end of the symbol table reached "
20480 "before the end of the index\n"),
20481 filedata
->file_name
);
20485 /* PR 17531: file: 0b6630b2. */
20486 printf ("\t%.*s\n",
20487 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20488 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20491 if (arch
.uses_64bit_indices
)
20496 if (l
< arch
.sym_size
)
20498 error (ngettext ("%s: %ld byte remains in the symbol table, "
20499 "but without corresponding entries in "
20500 "the index table\n",
20501 "%s: %ld bytes remain in the symbol table, "
20502 "but without corresponding entries in "
20503 "the index table\n",
20504 arch
.sym_size
- l
),
20505 filedata
->file_name
, arch
.sym_size
- l
);
20509 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20511 error (_("%s: failed to seek back to start of object files "
20512 "in the archive\n"),
20513 filedata
->file_name
);
20519 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20520 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20521 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20522 && !do_section_groups
&& !do_dyn_syms
)
20524 ret
= TRUE
; /* Archive index only. */
20533 char * qualified_name
;
20535 /* Read the next archive header. */
20536 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20538 error (_("%s: failed to seek to next archive header\n"),
20543 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20544 if (got
!= sizeof arch
.arhdr
)
20548 /* PR 24049 - we cannot use filedata->file_name as this will
20549 have already been freed. */
20550 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20555 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20557 error (_("%s: did not find a valid archive header\n"),
20563 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20565 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20566 if (filedata
->archive_file_size
& 01)
20567 ++filedata
->archive_file_size
;
20569 name
= get_archive_member_name (&arch
, &nested_arch
);
20572 error (_("%s: bad archive file name\n"), arch
.file_name
);
20576 namelen
= strlen (name
);
20578 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20579 if (qualified_name
== NULL
)
20581 error (_("%s: bad archive file name\n"), arch
.file_name
);
20587 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20589 /* This is a proxy for an external member of a thin archive. */
20590 Filedata
* member_filedata
;
20591 char * member_file_name
= adjust_relative_path
20592 (filedata
->file_name
, name
, namelen
);
20595 if (member_file_name
== NULL
)
20597 free (qualified_name
);
20602 member_filedata
= open_file (member_file_name
);
20603 if (member_filedata
== NULL
)
20605 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20606 free (member_file_name
);
20607 free (qualified_name
);
20612 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20613 member_filedata
->file_name
= qualified_name
;
20615 if (! process_object (member_filedata
))
20618 close_file (member_filedata
);
20619 free (member_file_name
);
20621 else if (is_thin_archive
)
20623 Filedata thin_filedata
;
20625 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20627 /* PR 15140: Allow for corrupt thin archives. */
20628 if (nested_arch
.file
== NULL
)
20630 error (_("%s: contains corrupt thin archive: %s\n"),
20631 qualified_name
, name
);
20632 free (qualified_name
);
20639 /* This is a proxy for a member of a nested archive. */
20640 filedata
->archive_file_offset
20641 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20643 /* The nested archive file will have been opened and setup by
20644 get_archive_member_name. */
20645 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20648 error (_("%s: failed to seek to archive member.\n"),
20649 nested_arch
.file_name
);
20650 free (qualified_name
);
20655 thin_filedata
.handle
= nested_arch
.file
;
20656 thin_filedata
.file_name
= qualified_name
;
20658 if (! process_object (& thin_filedata
))
20664 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20665 filedata
->file_name
= qualified_name
;
20666 if (! process_object (filedata
))
20668 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20669 /* Stop looping with "negative" archive_file_size. */
20670 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20671 arch
.next_arhdr_offset
= -1ul;
20674 free (qualified_name
);
20678 if (nested_arch
.file
!= NULL
)
20679 fclose (nested_arch
.file
);
20680 release_archive (&nested_arch
);
20681 release_archive (&arch
);
20687 process_file (char * file_name
)
20689 Filedata
* filedata
= NULL
;
20690 struct stat statbuf
;
20691 char armag
[SARMAG
];
20692 bfd_boolean ret
= TRUE
;
20694 if (stat (file_name
, &statbuf
) < 0)
20696 if (errno
== ENOENT
)
20697 error (_("'%s': No such file\n"), file_name
);
20699 error (_("Could not locate '%s'. System error message: %s\n"),
20700 file_name
, strerror (errno
));
20704 if (! S_ISREG (statbuf
.st_mode
))
20706 error (_("'%s' is not an ordinary file\n"), file_name
);
20710 filedata
= calloc (1, sizeof * filedata
);
20711 if (filedata
== NULL
)
20713 error (_("Out of memory allocating file data structure\n"));
20717 filedata
->file_name
= file_name
;
20718 filedata
->handle
= fopen (file_name
, "rb");
20719 if (filedata
->handle
== NULL
)
20721 error (_("Input file '%s' is not readable.\n"), file_name
);
20726 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20728 error (_("%s: Failed to read file's magic number\n"), file_name
);
20729 fclose (filedata
->handle
);
20734 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20736 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20738 if (! process_archive (filedata
, FALSE
))
20741 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20743 if ( ! process_archive (filedata
, TRUE
))
20748 if (do_archive_index
&& !check_all
)
20749 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20752 rewind (filedata
->handle
);
20753 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20755 if (! process_object (filedata
))
20759 fclose (filedata
->handle
);
20760 free (filedata
->section_headers
);
20761 free (filedata
->program_headers
);
20762 free (filedata
->string_table
);
20763 free (filedata
->dump
.dump_sects
);
20766 free (ba_cache
.strtab
);
20767 ba_cache
.strtab
= NULL
;
20768 free (ba_cache
.symtab
);
20769 ba_cache
.symtab
= NULL
;
20770 ba_cache
.filedata
= NULL
;
20775 #ifdef SUPPORT_DISASSEMBLY
20776 /* Needed by the i386 disassembler. For extra credit, someone could
20777 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20781 print_address (unsigned int addr
, FILE * outfile
)
20783 fprintf (outfile
,"0x%8.8x", addr
);
20786 /* Needed by the i386 disassembler. */
20789 db_task_printsym (unsigned int addr
)
20791 print_address (addr
, stderr
);
20796 main (int argc
, char ** argv
)
20800 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20801 setlocale (LC_MESSAGES
, "");
20803 #if defined (HAVE_SETLOCALE)
20804 setlocale (LC_CTYPE
, "");
20806 bindtextdomain (PACKAGE
, LOCALEDIR
);
20807 textdomain (PACKAGE
);
20809 expandargv (&argc
, &argv
);
20811 parse_args (& cmdline
, argc
, argv
);
20813 if (optind
< (argc
- 1))
20814 /* When displaying information for more than one file,
20815 prefix the information with the file name. */
20817 else if (optind
>= argc
)
20819 /* Ensure that the warning is always displayed. */
20822 warn (_("Nothing to do.\n"));
20827 while (optind
< argc
)
20828 if (! process_file (argv
[optind
++]))
20831 free (cmdline
.dump_sects
);
20833 free (dump_ctf_symtab_name
);
20834 free (dump_ctf_strtab_name
);
20835 free (dump_ctf_parent_name
);
20837 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;