1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/csky.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
107 #include "elf/epiphany.h"
108 #include "elf/fr30.h"
110 #include "elf/ft32.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/s12z.h"
126 #include "elf/mcore.h"
128 #include "elf/metag.h"
129 #include "elf/microblaze.h"
130 #include "elf/mips.h"
131 #include "elf/mmix.h"
132 #include "elf/mn10200.h"
133 #include "elf/mn10300.h"
134 #include "elf/moxie.h"
136 #include "elf/msp430.h"
137 #include "elf/nds32.h"
139 #include "elf/nios2.h"
140 #include "elf/or1k.h"
143 #include "elf/ppc64.h"
145 #include "elf/riscv.h"
146 #include "elf/rl78.h"
148 #include "elf/s390.h"
149 #include "elf/score.h"
151 #include "elf/sparc.h"
153 #include "elf/tic6x.h"
154 #include "elf/tilegx.h"
155 #include "elf/tilepro.h"
156 #include "elf/v850.h"
158 #include "elf/visium.h"
159 #include "elf/wasm32.h"
160 #include "elf/x86-64.h"
161 #include "elf/xc16x.h"
162 #include "elf/xgate.h"
163 #include "elf/xstormy16.h"
164 #include "elf/xtensa.h"
168 #include "libiberty.h"
169 #include "safe-ctype.h"
170 #include "filenames.h"
173 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
176 typedef struct elf_section_list
178 Elf_Internal_Shdr
* hdr
;
179 struct elf_section_list
* next
;
182 /* Flag bits indicating particular types of dump. */
183 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
184 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
187 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
190 typedef unsigned char dump_type
;
192 /* A linked list of the section names for which dumps were requested. */
193 struct dump_list_entry
197 struct dump_list_entry
* next
;
200 /* A dynamic array of flags indicating for which sections a dump
201 has been requested via command line switches. */
204 dump_type
* dump_sects
;
205 unsigned int num_dump_sects
;
208 static struct dump_data cmdline
;
210 static struct dump_list_entry
* dump_sects_byname
;
212 char * program_name
= "readelf";
214 static bfd_boolean show_name
= FALSE
;
215 static bfd_boolean do_dynamic
= FALSE
;
216 static bfd_boolean do_syms
= FALSE
;
217 static bfd_boolean do_dyn_syms
= FALSE
;
218 static bfd_boolean do_reloc
= FALSE
;
219 static bfd_boolean do_sections
= FALSE
;
220 static bfd_boolean do_section_groups
= FALSE
;
221 static bfd_boolean do_section_details
= FALSE
;
222 static bfd_boolean do_segments
= FALSE
;
223 static bfd_boolean do_unwind
= FALSE
;
224 static bfd_boolean do_using_dynamic
= FALSE
;
225 static bfd_boolean do_header
= FALSE
;
226 static bfd_boolean do_dump
= FALSE
;
227 static bfd_boolean do_version
= FALSE
;
228 static bfd_boolean do_histogram
= FALSE
;
229 static bfd_boolean do_debugging
= FALSE
;
230 static bfd_boolean do_ctf
= FALSE
;
231 static bfd_boolean do_arch
= FALSE
;
232 static bfd_boolean do_notes
= FALSE
;
233 static bfd_boolean do_archive_index
= FALSE
;
234 static bfd_boolean check_all
= FALSE
;
235 static bfd_boolean is_32bit_elf
= FALSE
;
236 static bfd_boolean decompress_dumps
= FALSE
;
238 static char *dump_ctf_parent_name
;
239 static char *dump_ctf_symtab_name
;
240 static char *dump_ctf_strtab_name
;
244 struct group_list
* next
;
245 unsigned int section_index
;
250 struct group_list
* root
;
251 unsigned int group_index
;
254 typedef struct filedata
256 const char * file_name
;
258 bfd_size_type file_size
;
259 Elf_Internal_Ehdr file_header
;
260 Elf_Internal_Shdr
* section_headers
;
261 Elf_Internal_Phdr
* program_headers
;
263 unsigned long string_table_length
;
264 unsigned long archive_file_offset
;
265 unsigned long archive_file_size
;
266 unsigned long dynamic_addr
;
267 bfd_size_type dynamic_size
;
269 Elf_Internal_Dyn
* dynamic_section
;
270 Elf_Internal_Shdr
* dynamic_strtab_section
;
271 char * dynamic_strings
;
272 unsigned long dynamic_strings_length
;
273 Elf_Internal_Shdr
* dynamic_symtab_section
;
274 unsigned long num_dynamic_syms
;
275 Elf_Internal_Sym
* dynamic_symbols
;
276 bfd_vma version_info
[16];
277 unsigned int dynamic_syminfo_nent
;
278 Elf_Internal_Syminfo
* dynamic_syminfo
;
279 unsigned long dynamic_syminfo_offset
;
280 bfd_size_type nbuckets
;
281 bfd_size_type nchains
;
284 bfd_size_type ngnubuckets
;
285 bfd_size_type ngnuchains
;
286 bfd_vma
* gnubuckets
;
290 char program_interpreter
[PATH_MAX
];
291 bfd_vma dynamic_info
[DT_ENCODING
];
292 bfd_vma dynamic_info_DT_GNU_HASH
;
293 bfd_vma dynamic_info_DT_MIPS_XHASH
;
294 elf_section_list
* symtab_shndx_list
;
296 struct group
* section_groups
;
297 struct group
** section_headers_groups
;
298 /* A dynamic array of flags indicating for which sections a dump of
299 some kind has been requested. It is reset on a per-object file
300 basis and then initialised from the cmdline_dump_sects array,
301 the results of interpreting the -w switch, and the
302 dump_sects_byname list. */
303 struct dump_data dump
;
306 /* How to print a vma value. */
307 typedef enum print_mode
319 /* Versioned symbol info. */
320 enum versioned_symbol_info
327 static const char * get_symbol_version_string
328 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
329 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
333 #define SECTION_NAME(X) \
334 ((X) == NULL ? _("<none>") \
335 : filedata->string_table == NULL ? _("<no-strings>") \
336 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
337 : filedata->string_table + (X)->sh_name))
339 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
341 #define GET_ELF_SYMBOLS(file, section, sym_count) \
342 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
343 : get_64bit_elf_symbols (file, section, sym_count))
345 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
346 (strtab != NULL && offset < strtab_size)
347 #define VALID_DYNAMIC_NAME(filedata, offset) \
348 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
349 filedata->dynamic_strings_length, offset)
350 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
351 already been called and verified that the string exists. */
352 #define GET_DYNAMIC_NAME(filedata, offset) \
353 (filedata->dynamic_strings + offset)
355 #define REMOVE_ARCH_BITS(ADDR) \
358 if (filedata->file_header.e_machine == EM_ARM) \
363 /* Get the correct GNU hash section name. */
364 #define GNU_HASH_SECTION_NAME(filedata) \
365 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
367 /* Print a BFD_VMA to an internal buffer, for use in error messages.
368 BFD_FMA_FMT can't be used in translated strings. */
371 bfd_vmatoa (char *fmtch
, bfd_vma value
)
373 /* bfd_vmatoa is used more then once in a printf call for output.
374 Cycle through an array of buffers. */
375 static int buf_pos
= 0;
376 static struct bfd_vmatoa_buf
383 ret
= buf
[buf_pos
++].place
;
384 buf_pos
%= ARRAY_SIZE (buf
);
386 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
387 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
391 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
392 OFFSET + the offset of the current archive member, if we are examining an
393 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
394 allocate a buffer using malloc and fill that. In either case return the
395 pointer to the start of the retrieved data or NULL if something went wrong.
396 If something does go wrong and REASON is not NULL then emit an error
397 message using REASON as part of the context. */
400 get_data (void * var
,
402 unsigned long offset
,
408 bfd_size_type amt
= size
* nmemb
;
410 if (size
== 0 || nmemb
== 0)
413 /* If the size_t type is smaller than the bfd_size_type, eg because
414 you are building a 32-bit tool on a 64-bit host, then make sure
415 that when the sizes are cast to (size_t) no information is lost. */
416 if ((size_t) size
!= size
417 || (size_t) nmemb
!= nmemb
418 || (size_t) amt
!= amt
)
421 error (_("Size truncation prevents reading %s"
422 " elements of size %s for %s\n"),
423 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
427 /* Check for size overflow. */
428 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
431 error (_("Size overflow prevents reading %s"
432 " elements of size %s for %s\n"),
433 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
437 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
438 attempting to allocate memory when the read is bound to fail. */
439 if (filedata
->archive_file_offset
> filedata
->file_size
440 || offset
> filedata
->file_size
- filedata
->archive_file_offset
441 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
444 error (_("Reading %s bytes extends past end of file for %s\n"),
445 bfd_vmatoa ("u", amt
), reason
);
449 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
453 error (_("Unable to seek to 0x%lx for %s\n"),
454 filedata
->archive_file_offset
+ offset
, reason
);
461 /* + 1 so that we can '\0' terminate invalid string table sections. */
462 mvar
= malloc ((size_t) amt
+ 1);
467 error (_("Out of memory allocating %s bytes for %s\n"),
468 bfd_vmatoa ("u", amt
), reason
);
472 ((char *) mvar
)[amt
] = '\0';
475 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
478 error (_("Unable to read in %s bytes of %s\n"),
479 bfd_vmatoa ("u", amt
), reason
);
488 /* Print a VMA value in the MODE specified.
489 Returns the number of characters displayed. */
492 print_vma (bfd_vma vma
, print_mode mode
)
504 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
511 return printf ("%5" BFD_VMA_FMT
"d", vma
);
517 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
520 return printf ("%" BFD_VMA_FMT
"d", vma
);
523 return printf ("%" BFD_VMA_FMT
"u", vma
);
526 /* FIXME: Report unrecognised mode ? */
531 /* Display a symbol on stdout. Handles the display of control characters and
532 multibye characters (assuming the host environment supports them).
534 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
536 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
537 padding as necessary.
539 Returns the number of emitted characters. */
542 print_symbol (signed int width
, const char *symbol
)
544 bfd_boolean extra_padding
= FALSE
;
545 signed int num_printed
= 0;
546 #ifdef HAVE_MBSTATE_T
549 unsigned int width_remaining
;
553 /* Keep the width positive. This helps the code below. */
555 extra_padding
= TRUE
;
561 /* Set the remaining width to a very large value.
562 This simplifies the code below. */
563 width_remaining
= INT_MAX
;
565 width_remaining
= width
;
567 #ifdef HAVE_MBSTATE_T
568 /* Initialise the multibyte conversion state. */
569 memset (& state
, 0, sizeof (state
));
572 while (width_remaining
)
575 const char c
= *symbol
++;
580 /* Do not print control characters directly as they can affect terminal
581 settings. Such characters usually appear in the names generated
582 by the assembler for local labels. */
585 if (width_remaining
< 2)
588 printf ("^%c", c
+ 0x40);
589 width_remaining
-= 2;
592 else if (ISPRINT (c
))
600 #ifdef HAVE_MBSTATE_T
603 /* Let printf do the hard work of displaying multibyte characters. */
604 printf ("%.1s", symbol
- 1);
608 #ifdef HAVE_MBSTATE_T
609 /* Try to find out how many bytes made up the character that was
610 just printed. Advance the symbol pointer past the bytes that
612 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
616 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
621 if (extra_padding
&& num_printed
< width
)
623 /* Fill in the remaining spaces. */
624 printf ("%-*s", width
- num_printed
, " ");
631 /* Returns a pointer to a static buffer containing a printable version of
632 the given section's name. Like print_symbol, except that it does not try
633 to print multibyte characters, it just interprets them as hex values. */
636 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
638 #define MAX_PRINT_SEC_NAME_LEN 128
639 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
640 const char * name
= SECTION_NAME (sec
);
641 char * buf
= sec_name_buf
;
643 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
645 while ((c
= * name
++) != 0)
656 else if (ISPRINT (c
))
663 static char hex
[17] = "0123456789ABCDEF";
668 * buf
++ = hex
[(c
& 0xf0) >> 4];
669 * buf
++ = hex
[c
& 0x0f];
683 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
685 if (ndx
>= filedata
->file_header
.e_shnum
)
686 return _("<corrupt>");
688 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
691 /* Return a pointer to section NAME, or NULL if no such section exists. */
693 static Elf_Internal_Shdr
*
694 find_section (Filedata
* filedata
, const char * name
)
698 if (filedata
->section_headers
== NULL
)
701 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
702 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
703 return filedata
->section_headers
+ i
;
708 /* Return a pointer to a section containing ADDR, or NULL if no such
711 static Elf_Internal_Shdr
*
712 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
716 if (filedata
->section_headers
== NULL
)
719 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
721 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
723 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
730 static Elf_Internal_Shdr
*
731 find_section_by_type (Filedata
* filedata
, unsigned int type
)
735 if (filedata
->section_headers
== NULL
)
738 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
740 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
742 if (sec
->sh_type
== type
)
749 /* Return a pointer to section NAME, or NULL if no such section exists,
750 restricted to the list of sections given in SET. */
752 static Elf_Internal_Shdr
*
753 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
757 if (filedata
->section_headers
== NULL
)
762 while ((i
= *set
++) > 0)
764 /* See PR 21156 for a reproducer. */
765 if (i
>= filedata
->file_header
.e_shnum
)
766 continue; /* FIXME: Should we issue an error message ? */
768 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
769 return filedata
->section_headers
+ i
;
773 return find_section (filedata
, name
);
776 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
777 This OS has so many departures from the ELF standard that we test it at
780 static inline bfd_boolean
781 is_ia64_vms (Filedata
* filedata
)
783 return filedata
->file_header
.e_machine
== EM_IA_64
784 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
787 /* Guess the relocation size commonly used by the specific machines. */
790 guess_is_rela (unsigned int e_machine
)
794 /* Targets that use REL relocations. */
811 /* Targets that use RELA relocations. */
815 case EM_ADAPTEVA_EPIPHANY
:
817 case EM_ALTERA_NIOS2
:
820 case EM_ARC_COMPACT2
:
841 case EM_LATTICEMICO32
:
850 case EM_CYGNUS_MN10200
:
852 case EM_CYGNUS_MN10300
:
888 case EM_MICROBLAZE_OLD
:
910 warn (_("Don't know about relocations on this machine architecture\n"));
915 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
916 Returns TRUE upon success, FALSE otherwise. If successful then a
917 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
918 and the number of relocs loaded is placed in *NRELASP. It is the caller's
919 responsibility to free the allocated buffer. */
922 slurp_rela_relocs (Filedata
* filedata
,
923 unsigned long rel_offset
,
924 unsigned long rel_size
,
925 Elf_Internal_Rela
** relasp
,
926 unsigned long * nrelasp
)
928 Elf_Internal_Rela
* relas
;
934 Elf32_External_Rela
* erelas
;
936 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
937 rel_size
, _("32-bit relocation data"));
941 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
943 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
944 sizeof (Elf_Internal_Rela
));
949 error (_("out of memory parsing relocs\n"));
953 for (i
= 0; i
< nrelas
; i
++)
955 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
956 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
957 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
964 Elf64_External_Rela
* erelas
;
966 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
967 rel_size
, _("64-bit relocation data"));
971 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
973 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
974 sizeof (Elf_Internal_Rela
));
979 error (_("out of memory parsing relocs\n"));
983 for (i
= 0; i
< nrelas
; i
++)
985 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
986 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
987 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
989 /* The #ifdef BFD64 below is to prevent a compile time
990 warning. We know that if we do not have a 64 bit data
991 type that we will never execute this code anyway. */
993 if (filedata
->file_header
.e_machine
== EM_MIPS
994 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
996 /* In little-endian objects, r_info isn't really a
997 64-bit little-endian value: it has a 32-bit
998 little-endian symbol index followed by four
999 individual byte fields. Reorder INFO
1001 bfd_vma inf
= relas
[i
].r_info
;
1002 inf
= (((inf
& 0xffffffff) << 32)
1003 | ((inf
>> 56) & 0xff)
1004 | ((inf
>> 40) & 0xff00)
1005 | ((inf
>> 24) & 0xff0000)
1006 | ((inf
>> 8) & 0xff000000));
1007 relas
[i
].r_info
= inf
;
1020 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1021 Returns TRUE upon success, FALSE otherwise. If successful then a
1022 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1023 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1024 responsibility to free the allocated buffer. */
1027 slurp_rel_relocs (Filedata
* filedata
,
1028 unsigned long rel_offset
,
1029 unsigned long rel_size
,
1030 Elf_Internal_Rela
** relsp
,
1031 unsigned long * nrelsp
)
1033 Elf_Internal_Rela
* rels
;
1039 Elf32_External_Rel
* erels
;
1041 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1042 rel_size
, _("32-bit relocation data"));
1046 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1048 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1053 error (_("out of memory parsing relocs\n"));
1057 for (i
= 0; i
< nrels
; i
++)
1059 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1060 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1061 rels
[i
].r_addend
= 0;
1068 Elf64_External_Rel
* erels
;
1070 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1071 rel_size
, _("64-bit relocation data"));
1075 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1077 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1082 error (_("out of memory parsing relocs\n"));
1086 for (i
= 0; i
< nrels
; i
++)
1088 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1089 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1090 rels
[i
].r_addend
= 0;
1092 /* The #ifdef BFD64 below is to prevent a compile time
1093 warning. We know that if we do not have a 64 bit data
1094 type that we will never execute this code anyway. */
1096 if (filedata
->file_header
.e_machine
== EM_MIPS
1097 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1099 /* In little-endian objects, r_info isn't really a
1100 64-bit little-endian value: it has a 32-bit
1101 little-endian symbol index followed by four
1102 individual byte fields. Reorder INFO
1104 bfd_vma inf
= rels
[i
].r_info
;
1105 inf
= (((inf
& 0xffffffff) << 32)
1106 | ((inf
>> 56) & 0xff)
1107 | ((inf
>> 40) & 0xff00)
1108 | ((inf
>> 24) & 0xff0000)
1109 | ((inf
>> 8) & 0xff000000));
1110 rels
[i
].r_info
= inf
;
1123 /* Returns the reloc type extracted from the reloc info field. */
1126 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1129 return ELF32_R_TYPE (reloc_info
);
1131 switch (filedata
->file_header
.e_machine
)
1134 /* Note: We assume that reloc_info has already been adjusted for us. */
1135 return ELF64_MIPS_R_TYPE (reloc_info
);
1138 return ELF64_R_TYPE_ID (reloc_info
);
1141 return ELF64_R_TYPE (reloc_info
);
1145 /* Return the symbol index extracted from the reloc info field. */
1148 get_reloc_symindex (bfd_vma reloc_info
)
1150 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1153 static inline bfd_boolean
1154 uses_msp430x_relocs (Filedata
* filedata
)
1157 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1158 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1159 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1160 /* TI compiler uses ELFOSABI_NONE. */
1161 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1164 /* Display the contents of the relocation data found at the specified
1168 dump_relocations (Filedata
* filedata
,
1169 unsigned long rel_offset
,
1170 unsigned long rel_size
,
1171 Elf_Internal_Sym
* symtab
,
1172 unsigned long nsyms
,
1174 unsigned long strtablen
,
1176 bfd_boolean is_dynsym
)
1179 Elf_Internal_Rela
* rels
;
1180 bfd_boolean res
= TRUE
;
1182 if (is_rela
== UNKNOWN
)
1183 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1187 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1192 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1201 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1203 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1208 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1210 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1218 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1220 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1225 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1227 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1231 for (i
= 0; i
< rel_size
; i
++)
1236 bfd_vma symtab_index
;
1239 offset
= rels
[i
].r_offset
;
1240 inf
= rels
[i
].r_info
;
1242 type
= get_reloc_type (filedata
, inf
);
1243 symtab_index
= get_reloc_symindex (inf
);
1247 printf ("%8.8lx %8.8lx ",
1248 (unsigned long) offset
& 0xffffffff,
1249 (unsigned long) inf
& 0xffffffff);
1253 #if BFD_HOST_64BIT_LONG
1255 ? "%16.16lx %16.16lx "
1256 : "%12.12lx %12.12lx ",
1258 #elif BFD_HOST_64BIT_LONG_LONG
1261 ? "%16.16llx %16.16llx "
1262 : "%12.12llx %12.12llx ",
1266 ? "%16.16I64x %16.16I64x "
1267 : "%12.12I64x %12.12I64x ",
1272 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1273 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1274 _bfd_int64_high (offset
),
1275 _bfd_int64_low (offset
),
1276 _bfd_int64_high (inf
),
1277 _bfd_int64_low (inf
));
1281 switch (filedata
->file_header
.e_machine
)
1288 rtype
= elf_aarch64_reloc_type (type
);
1292 case EM_CYGNUS_M32R
:
1293 rtype
= elf_m32r_reloc_type (type
);
1298 rtype
= elf_i386_reloc_type (type
);
1303 rtype
= elf_m68hc11_reloc_type (type
);
1307 rtype
= elf_s12z_reloc_type (type
);
1311 rtype
= elf_m68k_reloc_type (type
);
1315 rtype
= elf_i960_reloc_type (type
);
1320 rtype
= elf_avr_reloc_type (type
);
1323 case EM_OLD_SPARCV9
:
1324 case EM_SPARC32PLUS
:
1327 rtype
= elf_sparc_reloc_type (type
);
1331 rtype
= elf_spu_reloc_type (type
);
1335 rtype
= v800_reloc_type (type
);
1338 case EM_CYGNUS_V850
:
1339 rtype
= v850_reloc_type (type
);
1343 case EM_CYGNUS_D10V
:
1344 rtype
= elf_d10v_reloc_type (type
);
1348 case EM_CYGNUS_D30V
:
1349 rtype
= elf_d30v_reloc_type (type
);
1353 rtype
= elf_dlx_reloc_type (type
);
1357 rtype
= elf_sh_reloc_type (type
);
1361 case EM_CYGNUS_MN10300
:
1362 rtype
= elf_mn10300_reloc_type (type
);
1366 case EM_CYGNUS_MN10200
:
1367 rtype
= elf_mn10200_reloc_type (type
);
1371 case EM_CYGNUS_FR30
:
1372 rtype
= elf_fr30_reloc_type (type
);
1376 rtype
= elf_frv_reloc_type (type
);
1380 rtype
= elf_csky_reloc_type (type
);
1384 rtype
= elf_ft32_reloc_type (type
);
1388 rtype
= elf_mcore_reloc_type (type
);
1392 rtype
= elf_mmix_reloc_type (type
);
1396 rtype
= elf_moxie_reloc_type (type
);
1400 if (uses_msp430x_relocs (filedata
))
1402 rtype
= elf_msp430x_reloc_type (type
);
1407 rtype
= elf_msp430_reloc_type (type
);
1411 rtype
= elf_nds32_reloc_type (type
);
1415 rtype
= elf_ppc_reloc_type (type
);
1419 rtype
= elf_ppc64_reloc_type (type
);
1423 case EM_MIPS_RS3_LE
:
1424 rtype
= elf_mips_reloc_type (type
);
1428 rtype
= elf_riscv_reloc_type (type
);
1432 rtype
= elf_alpha_reloc_type (type
);
1436 rtype
= elf_arm_reloc_type (type
);
1440 case EM_ARC_COMPACT
:
1441 case EM_ARC_COMPACT2
:
1442 rtype
= elf_arc_reloc_type (type
);
1446 rtype
= elf_hppa_reloc_type (type
);
1452 rtype
= elf_h8_reloc_type (type
);
1456 rtype
= elf_or1k_reloc_type (type
);
1461 rtype
= elf_pj_reloc_type (type
);
1464 rtype
= elf_ia64_reloc_type (type
);
1468 rtype
= elf_cris_reloc_type (type
);
1472 rtype
= elf_i860_reloc_type (type
);
1478 rtype
= elf_x86_64_reloc_type (type
);
1482 rtype
= i370_reloc_type (type
);
1487 rtype
= elf_s390_reloc_type (type
);
1491 rtype
= elf_score_reloc_type (type
);
1495 rtype
= elf_xstormy16_reloc_type (type
);
1499 rtype
= elf_crx_reloc_type (type
);
1503 rtype
= elf_vax_reloc_type (type
);
1507 rtype
= elf_visium_reloc_type (type
);
1511 rtype
= elf_bpf_reloc_type (type
);
1514 case EM_ADAPTEVA_EPIPHANY
:
1515 rtype
= elf_epiphany_reloc_type (type
);
1520 rtype
= elf_ip2k_reloc_type (type
);
1524 rtype
= elf_iq2000_reloc_type (type
);
1529 rtype
= elf_xtensa_reloc_type (type
);
1532 case EM_LATTICEMICO32
:
1533 rtype
= elf_lm32_reloc_type (type
);
1538 rtype
= elf_m32c_reloc_type (type
);
1542 rtype
= elf_mt_reloc_type (type
);
1546 rtype
= elf_bfin_reloc_type (type
);
1550 rtype
= elf_mep_reloc_type (type
);
1554 rtype
= elf_cr16_reloc_type (type
);
1558 case EM_MICROBLAZE_OLD
:
1559 rtype
= elf_microblaze_reloc_type (type
);
1563 rtype
= elf_rl78_reloc_type (type
);
1567 rtype
= elf_rx_reloc_type (type
);
1571 rtype
= elf_metag_reloc_type (type
);
1576 rtype
= elf_xc16x_reloc_type (type
);
1580 rtype
= elf_tic6x_reloc_type (type
);
1584 rtype
= elf_tilegx_reloc_type (type
);
1588 rtype
= elf_tilepro_reloc_type (type
);
1591 case EM_WEBASSEMBLY
:
1592 rtype
= elf_wasm32_reloc_type (type
);
1596 rtype
= elf_xgate_reloc_type (type
);
1599 case EM_ALTERA_NIOS2
:
1600 rtype
= elf_nios2_reloc_type (type
);
1604 rtype
= elf_pru_reloc_type (type
);
1608 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1609 rtype
= elf_nfp3200_reloc_type (type
);
1611 rtype
= elf_nfp_reloc_type (type
);
1615 rtype
= elf_z80_reloc_type (type
);
1620 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1622 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1624 if (filedata
->file_header
.e_machine
== EM_ALPHA
1626 && streq (rtype
, "R_ALPHA_LITUSE")
1629 switch (rels
[i
].r_addend
)
1631 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1632 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1633 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1634 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1635 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1636 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1637 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1638 default: rtype
= NULL
;
1642 printf (" (%s)", rtype
);
1646 printf (_("<unknown addend: %lx>"),
1647 (unsigned long) rels
[i
].r_addend
);
1651 else if (symtab_index
)
1653 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1655 error (_(" bad symbol index: %08lx in reloc\n"),
1656 (unsigned long) symtab_index
);
1661 Elf_Internal_Sym
* psym
;
1662 const char * version_string
;
1663 enum versioned_symbol_info sym_info
;
1664 unsigned short vna_other
;
1666 psym
= symtab
+ symtab_index
;
1669 = get_symbol_version_string (filedata
, is_dynsym
,
1678 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1682 unsigned int width
= is_32bit_elf
? 8 : 14;
1684 /* Relocations against GNU_IFUNC symbols do not use the value
1685 of the symbol as the address to relocate against. Instead
1686 they invoke the function named by the symbol and use its
1687 result as the address for relocation.
1689 To indicate this to the user, do not display the value of
1690 the symbol in the "Symbols's Value" field. Instead show
1691 its name followed by () as a hint that the symbol is
1695 || psym
->st_name
== 0
1696 || psym
->st_name
>= strtablen
)
1699 name
= strtab
+ psym
->st_name
;
1701 len
= print_symbol (width
, name
);
1703 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1705 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1709 print_vma (psym
->st_value
, LONG_HEX
);
1711 printf (is_32bit_elf
? " " : " ");
1714 if (psym
->st_name
== 0)
1716 const char * sec_name
= "<null>";
1719 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1721 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1722 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1723 else if (psym
->st_shndx
== SHN_ABS
)
1725 else if (psym
->st_shndx
== SHN_COMMON
)
1726 sec_name
= "COMMON";
1727 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1728 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1729 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1730 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1731 sec_name
= "SCOMMON";
1732 else if (filedata
->file_header
.e_machine
== EM_MIPS
1733 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1734 sec_name
= "SUNDEF";
1735 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1736 || filedata
->file_header
.e_machine
== EM_L1OM
1737 || filedata
->file_header
.e_machine
== EM_K1OM
)
1738 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1739 sec_name
= "LARGE_COMMON";
1740 else if (filedata
->file_header
.e_machine
== EM_IA_64
1741 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1742 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1743 sec_name
= "ANSI_COM";
1744 else if (is_ia64_vms (filedata
)
1745 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1746 sec_name
= "VMS_SYMVEC";
1749 sprintf (name_buf
, "<section 0x%x>",
1750 (unsigned int) psym
->st_shndx
);
1751 sec_name
= name_buf
;
1754 print_symbol (22, sec_name
);
1756 else if (strtab
== NULL
)
1757 printf (_("<string table index: %3ld>"), psym
->st_name
);
1758 else if (psym
->st_name
>= strtablen
)
1760 error (_("<corrupt string table index: %3ld>\n"),
1766 print_symbol (22, strtab
+ psym
->st_name
);
1768 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1774 bfd_vma off
= rels
[i
].r_addend
;
1776 if ((bfd_signed_vma
) off
< 0)
1777 printf (" - %" BFD_VMA_FMT
"x", - off
);
1779 printf (" + %" BFD_VMA_FMT
"x", off
);
1785 bfd_vma off
= rels
[i
].r_addend
;
1787 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1788 if ((bfd_signed_vma
) off
< 0)
1789 printf ("-%" BFD_VMA_FMT
"x", - off
);
1791 printf ("%" BFD_VMA_FMT
"x", off
);
1794 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1796 && streq (rtype
, "R_SPARC_OLO10"))
1797 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1802 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1804 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1805 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1806 const char * rtype2
= elf_mips_reloc_type (type2
);
1807 const char * rtype3
= elf_mips_reloc_type (type3
);
1809 printf (" Type2: ");
1812 printf (_("unrecognized: %-7lx"),
1813 (unsigned long) type2
& 0xffffffff);
1815 printf ("%-17.17s", rtype2
);
1817 printf ("\n Type3: ");
1820 printf (_("unrecognized: %-7lx"),
1821 (unsigned long) type3
& 0xffffffff);
1823 printf ("%-17.17s", rtype3
);
1836 get_aarch64_dynamic_type (unsigned long type
)
1840 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1841 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1842 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1849 get_mips_dynamic_type (unsigned long type
)
1853 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1854 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1855 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1856 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1857 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1858 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1859 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1860 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1861 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1862 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1863 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1864 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1865 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1866 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1867 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1868 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1869 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1870 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1871 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1872 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1873 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1874 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1875 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1876 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1877 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1878 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1879 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1880 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1881 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1882 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1883 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1884 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1885 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1886 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1887 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1888 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1889 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1890 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1891 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1892 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1893 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1894 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1895 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1896 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1897 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1898 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1899 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1906 get_sparc64_dynamic_type (unsigned long type
)
1910 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1917 get_ppc_dynamic_type (unsigned long type
)
1921 case DT_PPC_GOT
: return "PPC_GOT";
1922 case DT_PPC_OPT
: return "PPC_OPT";
1929 get_ppc64_dynamic_type (unsigned long type
)
1933 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1934 case DT_PPC64_OPD
: return "PPC64_OPD";
1935 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1936 case DT_PPC64_OPT
: return "PPC64_OPT";
1943 get_parisc_dynamic_type (unsigned long type
)
1947 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1948 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1949 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1950 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1951 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1952 case DT_HP_PREINIT
: return "HP_PREINIT";
1953 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1954 case DT_HP_NEEDED
: return "HP_NEEDED";
1955 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1956 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1957 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1958 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1959 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1960 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1961 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1962 case DT_HP_FILTERED
: return "HP_FILTERED";
1963 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1964 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1965 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1966 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1967 case DT_PLT
: return "PLT";
1968 case DT_PLT_SIZE
: return "PLT_SIZE";
1969 case DT_DLT
: return "DLT";
1970 case DT_DLT_SIZE
: return "DLT_SIZE";
1977 get_ia64_dynamic_type (unsigned long type
)
1981 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1982 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1983 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1984 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1985 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1986 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1987 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1988 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1989 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1990 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1991 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1992 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1993 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1994 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1995 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1996 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1997 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1998 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1999 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2000 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2001 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2002 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2003 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2004 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2005 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2006 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2007 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2008 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2009 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2010 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2011 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2018 get_solaris_section_type (unsigned long type
)
2022 case 0x6fffffee: return "SUNW_ancillary";
2023 case 0x6fffffef: return "SUNW_capchain";
2024 case 0x6ffffff0: return "SUNW_capinfo";
2025 case 0x6ffffff1: return "SUNW_symsort";
2026 case 0x6ffffff2: return "SUNW_tlssort";
2027 case 0x6ffffff3: return "SUNW_LDYNSYM";
2028 case 0x6ffffff4: return "SUNW_dof";
2029 case 0x6ffffff5: return "SUNW_cap";
2030 case 0x6ffffff6: return "SUNW_SIGNATURE";
2031 case 0x6ffffff7: return "SUNW_ANNOTATE";
2032 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2033 case 0x6ffffff9: return "SUNW_DEBUG";
2034 case 0x6ffffffa: return "SUNW_move";
2035 case 0x6ffffffb: return "SUNW_COMDAT";
2036 case 0x6ffffffc: return "SUNW_syminfo";
2037 case 0x6ffffffd: return "SUNW_verdef";
2038 case 0x6ffffffe: return "SUNW_verneed";
2039 case 0x6fffffff: return "SUNW_versym";
2040 case 0x70000000: return "SPARC_GOTDATA";
2041 default: return NULL
;
2046 get_alpha_dynamic_type (unsigned long type
)
2050 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2051 default: return NULL
;
2056 get_score_dynamic_type (unsigned long type
)
2060 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2061 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2062 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2063 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2064 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2065 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2066 default: return NULL
;
2071 get_tic6x_dynamic_type (unsigned long type
)
2075 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2076 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2077 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2078 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2079 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2080 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2081 default: return NULL
;
2086 get_nios2_dynamic_type (unsigned long type
)
2090 case DT_NIOS2_GP
: return "NIOS2_GP";
2091 default: return NULL
;
2096 get_solaris_dynamic_type (unsigned long type
)
2100 case 0x6000000d: return "SUNW_AUXILIARY";
2101 case 0x6000000e: return "SUNW_RTLDINF";
2102 case 0x6000000f: return "SUNW_FILTER";
2103 case 0x60000010: return "SUNW_CAP";
2104 case 0x60000011: return "SUNW_SYMTAB";
2105 case 0x60000012: return "SUNW_SYMSZ";
2106 case 0x60000013: return "SUNW_SORTENT";
2107 case 0x60000014: return "SUNW_SYMSORT";
2108 case 0x60000015: return "SUNW_SYMSORTSZ";
2109 case 0x60000016: return "SUNW_TLSSORT";
2110 case 0x60000017: return "SUNW_TLSSORTSZ";
2111 case 0x60000018: return "SUNW_CAPINFO";
2112 case 0x60000019: return "SUNW_STRPAD";
2113 case 0x6000001a: return "SUNW_CAPCHAIN";
2114 case 0x6000001b: return "SUNW_LDMACH";
2115 case 0x6000001d: return "SUNW_CAPCHAINENT";
2116 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2117 case 0x60000021: return "SUNW_PARENT";
2118 case 0x60000023: return "SUNW_ASLR";
2119 case 0x60000025: return "SUNW_RELAX";
2120 case 0x60000029: return "SUNW_NXHEAP";
2121 case 0x6000002b: return "SUNW_NXSTACK";
2123 case 0x70000001: return "SPARC_REGISTER";
2124 case 0x7ffffffd: return "AUXILIARY";
2125 case 0x7ffffffe: return "USED";
2126 case 0x7fffffff: return "FILTER";
2128 default: return NULL
;
2133 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2135 static char buff
[64];
2139 case DT_NULL
: return "NULL";
2140 case DT_NEEDED
: return "NEEDED";
2141 case DT_PLTRELSZ
: return "PLTRELSZ";
2142 case DT_PLTGOT
: return "PLTGOT";
2143 case DT_HASH
: return "HASH";
2144 case DT_STRTAB
: return "STRTAB";
2145 case DT_SYMTAB
: return "SYMTAB";
2146 case DT_RELA
: return "RELA";
2147 case DT_RELASZ
: return "RELASZ";
2148 case DT_RELAENT
: return "RELAENT";
2149 case DT_STRSZ
: return "STRSZ";
2150 case DT_SYMENT
: return "SYMENT";
2151 case DT_INIT
: return "INIT";
2152 case DT_FINI
: return "FINI";
2153 case DT_SONAME
: return "SONAME";
2154 case DT_RPATH
: return "RPATH";
2155 case DT_SYMBOLIC
: return "SYMBOLIC";
2156 case DT_REL
: return "REL";
2157 case DT_RELSZ
: return "RELSZ";
2158 case DT_RELENT
: return "RELENT";
2159 case DT_PLTREL
: return "PLTREL";
2160 case DT_DEBUG
: return "DEBUG";
2161 case DT_TEXTREL
: return "TEXTREL";
2162 case DT_JMPREL
: return "JMPREL";
2163 case DT_BIND_NOW
: return "BIND_NOW";
2164 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2165 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2166 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2167 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2168 case DT_RUNPATH
: return "RUNPATH";
2169 case DT_FLAGS
: return "FLAGS";
2171 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2172 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2173 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2175 case DT_CHECKSUM
: return "CHECKSUM";
2176 case DT_PLTPADSZ
: return "PLTPADSZ";
2177 case DT_MOVEENT
: return "MOVEENT";
2178 case DT_MOVESZ
: return "MOVESZ";
2179 case DT_FEATURE
: return "FEATURE";
2180 case DT_POSFLAG_1
: return "POSFLAG_1";
2181 case DT_SYMINSZ
: return "SYMINSZ";
2182 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2184 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2185 case DT_CONFIG
: return "CONFIG";
2186 case DT_DEPAUDIT
: return "DEPAUDIT";
2187 case DT_AUDIT
: return "AUDIT";
2188 case DT_PLTPAD
: return "PLTPAD";
2189 case DT_MOVETAB
: return "MOVETAB";
2190 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2192 case DT_VERSYM
: return "VERSYM";
2194 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2195 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2196 case DT_RELACOUNT
: return "RELACOUNT";
2197 case DT_RELCOUNT
: return "RELCOUNT";
2198 case DT_FLAGS_1
: return "FLAGS_1";
2199 case DT_VERDEF
: return "VERDEF";
2200 case DT_VERDEFNUM
: return "VERDEFNUM";
2201 case DT_VERNEED
: return "VERNEED";
2202 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2204 case DT_AUXILIARY
: return "AUXILIARY";
2205 case DT_USED
: return "USED";
2206 case DT_FILTER
: return "FILTER";
2208 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2209 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2210 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2211 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2212 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2213 case DT_GNU_HASH
: return "GNU_HASH";
2216 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2218 const char * result
;
2220 switch (filedata
->file_header
.e_machine
)
2223 result
= get_aarch64_dynamic_type (type
);
2226 case EM_MIPS_RS3_LE
:
2227 result
= get_mips_dynamic_type (type
);
2230 result
= get_sparc64_dynamic_type (type
);
2233 result
= get_ppc_dynamic_type (type
);
2236 result
= get_ppc64_dynamic_type (type
);
2239 result
= get_ia64_dynamic_type (type
);
2242 result
= get_alpha_dynamic_type (type
);
2245 result
= get_score_dynamic_type (type
);
2248 result
= get_tic6x_dynamic_type (type
);
2250 case EM_ALTERA_NIOS2
:
2251 result
= get_nios2_dynamic_type (type
);
2254 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2255 result
= get_solaris_dynamic_type (type
);
2264 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2266 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2267 || (filedata
->file_header
.e_machine
== EM_PARISC
2268 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2270 const char * result
;
2272 switch (filedata
->file_header
.e_machine
)
2275 result
= get_parisc_dynamic_type (type
);
2278 result
= get_ia64_dynamic_type (type
);
2281 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2282 result
= get_solaris_dynamic_type (type
);
2291 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2295 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2302 get_file_type (unsigned e_type
)
2304 static char buff
[64];
2308 case ET_NONE
: return _("NONE (None)");
2309 case ET_REL
: return _("REL (Relocatable file)");
2310 case ET_EXEC
: return _("EXEC (Executable file)");
2311 case ET_DYN
: return _("DYN (Shared object file)");
2312 case ET_CORE
: return _("CORE (Core file)");
2315 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2316 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2317 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2318 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2320 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2326 get_machine_name (unsigned e_machine
)
2328 static char buff
[64]; /* XXX */
2332 /* Please keep this switch table sorted by increasing EM_ value. */
2334 case EM_NONE
: return _("None");
2335 case EM_M32
: return "WE32100";
2336 case EM_SPARC
: return "Sparc";
2337 case EM_386
: return "Intel 80386";
2338 case EM_68K
: return "MC68000";
2339 case EM_88K
: return "MC88000";
2340 case EM_IAMCU
: return "Intel MCU";
2341 case EM_860
: return "Intel 80860";
2342 case EM_MIPS
: return "MIPS R3000";
2343 case EM_S370
: return "IBM System/370";
2345 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2346 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2347 case EM_PARISC
: return "HPPA";
2348 case EM_VPP550
: return "Fujitsu VPP500";
2349 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2350 case EM_960
: return "Intel 80960";
2351 case EM_PPC
: return "PowerPC";
2353 case EM_PPC64
: return "PowerPC64";
2355 case EM_S390
: return "IBM S/390";
2356 case EM_SPU
: return "SPU";
2358 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2359 case EM_FR20
: return "Fujitsu FR20";
2360 case EM_RH32
: return "TRW RH32";
2361 case EM_MCORE
: return "MCORE";
2363 case EM_ARM
: return "ARM";
2364 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2365 case EM_SH
: return "Renesas / SuperH SH";
2366 case EM_SPARCV9
: return "Sparc v9";
2367 case EM_TRICORE
: return "Siemens Tricore";
2368 case EM_ARC
: return "ARC";
2369 case EM_H8_300
: return "Renesas H8/300";
2370 case EM_H8_300H
: return "Renesas H8/300H";
2371 case EM_H8S
: return "Renesas H8S";
2372 case EM_H8_500
: return "Renesas H8/500";
2374 case EM_IA_64
: return "Intel IA-64";
2375 case EM_MIPS_X
: return "Stanford MIPS-X";
2376 case EM_COLDFIRE
: return "Motorola Coldfire";
2377 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2378 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2379 case EM_PCP
: return "Siemens PCP";
2380 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2381 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2382 case EM_STARCORE
: return "Motorola Star*Core processor";
2383 case EM_ME16
: return "Toyota ME16 processor";
2385 case EM_ST100
: return "STMicroelectronics ST100 processor";
2386 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2387 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2388 case EM_PDSP
: return "Sony DSP processor";
2389 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2390 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2391 case EM_FX66
: return "Siemens FX66 microcontroller";
2392 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2393 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2394 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2396 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2397 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2398 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2399 case EM_SVX
: return "Silicon Graphics SVx";
2400 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2401 case EM_VAX
: return "Digital VAX";
2402 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2403 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2404 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2405 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2407 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2408 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2409 case EM_PRISM
: return "Vitesse Prism";
2411 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2412 case EM_CYGNUS_FR30
:
2413 case EM_FR30
: return "Fujitsu FR30";
2414 case EM_CYGNUS_D10V
:
2415 case EM_D10V
: return "d10v";
2416 case EM_CYGNUS_D30V
:
2417 case EM_D30V
: return "d30v";
2418 case EM_CYGNUS_V850
:
2419 case EM_V850
: return "Renesas V850";
2420 case EM_CYGNUS_M32R
:
2421 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2422 case EM_CYGNUS_MN10300
:
2423 case EM_MN10300
: return "mn10300";
2425 case EM_CYGNUS_MN10200
:
2426 case EM_MN10200
: return "mn10200";
2427 case EM_PJ
: return "picoJava";
2428 case EM_OR1K
: return "OpenRISC 1000";
2429 case EM_ARC_COMPACT
: return "ARCompact";
2431 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2432 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2433 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2434 case EM_NS32K
: return "National Semiconductor 32000 series";
2435 case EM_TPC
: return "Tenor Network TPC processor";
2436 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2438 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2440 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2441 case EM_MAX
: return "MAX Processor";
2442 case EM_CR
: return "National Semiconductor CompactRISC";
2443 case EM_F2MC16
: return "Fujitsu F2MC16";
2444 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2445 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2446 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2447 case EM_SEP
: return "Sharp embedded microprocessor";
2448 case EM_ARCA
: return "Arca RISC microprocessor";
2450 case EM_UNICORE
: return "Unicore";
2451 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2452 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2453 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2454 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2455 case EM_XGATE
: return "Motorola XGATE embedded processor";
2457 case EM_XC16X
: return "Infineon Technologies xc16x";
2458 case EM_M16C
: return "Renesas M16C series microprocessors";
2459 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2460 case EM_CE
: return "Freescale Communication Engine RISC core";
2462 case EM_M32C
: return "Renesas M32c";
2464 case EM_TSK3000
: return "Altium TSK3000 core";
2465 case EM_RS08
: return "Freescale RS08 embedded processor";
2466 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2467 case EM_SCORE
: return "SUNPLUS S+Core";
2468 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2469 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2470 case EM_LATTICEMICO32
: return "Lattice Mico32";
2471 case EM_SE_C17
: return "Seiko Epson C17 family";
2473 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2474 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2475 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2476 case EM_TI_PRU
: return "TI PRU I/O processor";
2478 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2479 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2480 case EM_R32C
: return "Renesas R32C series microprocessors";
2481 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2482 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2483 case EM_8051
: return "Intel 8051 and variants";
2484 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2485 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2486 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2487 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2489 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2490 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2491 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2492 case EM_RX
: return "Renesas RX";
2493 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2494 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2495 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2498 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2499 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2500 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2502 case EM_L1OM
: return "Intel L1OM";
2503 case EM_K1OM
: return "Intel K1OM";
2504 case EM_INTEL182
: return "Intel (reserved)";
2505 case EM_AARCH64
: return "AArch64";
2506 case EM_ARM184
: return "ARM (reserved)";
2507 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2508 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2509 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2510 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2512 case EM_CUDA
: return "NVIDIA CUDA architecture";
2513 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2514 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2515 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2516 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2517 case EM_ARC_COMPACT2
: return "ARCv2";
2518 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2519 case EM_RL78
: return "Renesas RL78";
2520 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2521 case EM_78K0R
: return "Renesas 78K0R";
2523 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2524 case EM_BA1
: return "Beyond BA1 CPU architecture";
2525 case EM_BA2
: return "Beyond BA2 CPU architecture";
2526 case EM_XCORE
: return "XMOS xCORE processor family";
2527 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2529 case EM_KM32
: return "KM211 KM32 32-bit processor";
2530 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2531 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2532 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2533 case EM_KVARC
: return "KM211 KVARC processor";
2534 case EM_CDP
: return "Paneve CDP architecture family";
2535 case EM_COGE
: return "Cognitive Smart Memory Processor";
2536 case EM_COOL
: return "Bluechip Systems CoolEngine";
2537 case EM_NORC
: return "Nanoradio Optimized RISC";
2538 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2540 case EM_Z80
: return "Zilog Z80";
2541 case EM_VISIUM
: return "CDS VISIUMcore processor";
2542 case EM_FT32
: return "FTDI Chip FT32";
2543 case EM_MOXIE
: return "Moxie";
2544 case EM_AMDGPU
: return "AMD GPU";
2545 case EM_RISCV
: return "RISC-V";
2546 case EM_LANAI
: return "Lanai 32-bit processor";
2547 case EM_BPF
: return "Linux BPF";
2548 case EM_NFP
: return "Netronome Flow Processor";
2550 /* Large numbers... */
2551 case EM_MT
: return "Morpho Techologies MT processor";
2552 case EM_ALPHA
: return "Alpha";
2553 case EM_WEBASSEMBLY
: return "Web Assembly";
2554 case EM_DLX
: return "OpenDLX";
2555 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2556 case EM_IQ2000
: return "Vitesse IQ2000";
2558 case EM_NIOS32
: return "Altera Nios";
2559 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2560 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2561 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2562 case EM_S12Z
: return "Freescale S12Z";
2563 case EM_CSKY
: return "C-SKY";
2566 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2572 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2574 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2575 other compilers don't a specific architecture type in the e_flags, and
2576 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2577 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2580 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2581 but also sets a specific architecture type in the e_flags field.
2583 However, when decoding the flags we don't worry if we see an
2584 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2585 ARCEM architecture type. */
2587 switch (e_flags
& EF_ARC_MACH_MSK
)
2589 /* We only expect these to occur for EM_ARC_COMPACT2. */
2590 case EF_ARC_CPU_ARCV2EM
:
2591 strcat (buf
, ", ARC EM");
2593 case EF_ARC_CPU_ARCV2HS
:
2594 strcat (buf
, ", ARC HS");
2597 /* We only expect these to occur for EM_ARC_COMPACT. */
2598 case E_ARC_MACH_ARC600
:
2599 strcat (buf
, ", ARC600");
2601 case E_ARC_MACH_ARC601
:
2602 strcat (buf
, ", ARC601");
2604 case E_ARC_MACH_ARC700
:
2605 strcat (buf
, ", ARC700");
2608 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2609 new ELF with new architecture being read by an old version of
2610 readelf, or (c) An ELF built with non-GNU compiler that does not
2611 set the architecture in the e_flags. */
2613 if (e_machine
== EM_ARC_COMPACT
)
2614 strcat (buf
, ", Unknown ARCompact");
2616 strcat (buf
, ", Unknown ARC");
2620 switch (e_flags
& EF_ARC_OSABI_MSK
)
2622 case E_ARC_OSABI_ORIG
:
2623 strcat (buf
, ", (ABI:legacy)");
2625 case E_ARC_OSABI_V2
:
2626 strcat (buf
, ", (ABI:v2)");
2628 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2629 case E_ARC_OSABI_V3
:
2630 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2632 case E_ARC_OSABI_V4
:
2633 strcat (buf
, ", v4 ABI");
2636 strcat (buf
, ", unrecognised ARC OSABI flag");
2642 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2645 bfd_boolean unknown
= FALSE
;
2647 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2648 e_flags
&= ~ EF_ARM_EABIMASK
;
2650 /* Handle "generic" ARM flags. */
2651 if (e_flags
& EF_ARM_RELEXEC
)
2653 strcat (buf
, ", relocatable executable");
2654 e_flags
&= ~ EF_ARM_RELEXEC
;
2657 if (e_flags
& EF_ARM_PIC
)
2659 strcat (buf
, ", position independent");
2660 e_flags
&= ~ EF_ARM_PIC
;
2663 /* Now handle EABI specific flags. */
2667 strcat (buf
, ", <unrecognized EABI>");
2672 case EF_ARM_EABI_VER1
:
2673 strcat (buf
, ", Version1 EABI");
2678 /* Process flags one bit at a time. */
2679 flag
= e_flags
& - e_flags
;
2684 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2685 strcat (buf
, ", sorted symbol tables");
2695 case EF_ARM_EABI_VER2
:
2696 strcat (buf
, ", Version2 EABI");
2701 /* Process flags one bit at a time. */
2702 flag
= e_flags
& - e_flags
;
2707 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2708 strcat (buf
, ", sorted symbol tables");
2711 case EF_ARM_DYNSYMSUSESEGIDX
:
2712 strcat (buf
, ", dynamic symbols use segment index");
2715 case EF_ARM_MAPSYMSFIRST
:
2716 strcat (buf
, ", mapping symbols precede others");
2726 case EF_ARM_EABI_VER3
:
2727 strcat (buf
, ", Version3 EABI");
2730 case EF_ARM_EABI_VER4
:
2731 strcat (buf
, ", Version4 EABI");
2736 /* Process flags one bit at a time. */
2737 flag
= e_flags
& - e_flags
;
2743 strcat (buf
, ", BE8");
2747 strcat (buf
, ", LE8");
2757 case EF_ARM_EABI_VER5
:
2758 strcat (buf
, ", Version5 EABI");
2763 /* Process flags one bit at a time. */
2764 flag
= e_flags
& - e_flags
;
2770 strcat (buf
, ", BE8");
2774 strcat (buf
, ", LE8");
2777 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2778 strcat (buf
, ", soft-float ABI");
2781 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2782 strcat (buf
, ", hard-float ABI");
2792 case EF_ARM_EABI_UNKNOWN
:
2793 strcat (buf
, ", GNU EABI");
2798 /* Process flags one bit at a time. */
2799 flag
= e_flags
& - e_flags
;
2804 case EF_ARM_INTERWORK
:
2805 strcat (buf
, ", interworking enabled");
2808 case EF_ARM_APCS_26
:
2809 strcat (buf
, ", uses APCS/26");
2812 case EF_ARM_APCS_FLOAT
:
2813 strcat (buf
, ", uses APCS/float");
2817 strcat (buf
, ", position independent");
2821 strcat (buf
, ", 8 bit structure alignment");
2824 case EF_ARM_NEW_ABI
:
2825 strcat (buf
, ", uses new ABI");
2828 case EF_ARM_OLD_ABI
:
2829 strcat (buf
, ", uses old ABI");
2832 case EF_ARM_SOFT_FLOAT
:
2833 strcat (buf
, ", software FP");
2836 case EF_ARM_VFP_FLOAT
:
2837 strcat (buf
, ", VFP");
2840 case EF_ARM_MAVERICK_FLOAT
:
2841 strcat (buf
, ", Maverick FP");
2852 strcat (buf
,_(", <unknown>"));
2856 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2858 --size
; /* Leave space for null terminator. */
2860 switch (e_flags
& EF_AVR_MACH
)
2862 case E_AVR_MACH_AVR1
:
2863 strncat (buf
, ", avr:1", size
);
2865 case E_AVR_MACH_AVR2
:
2866 strncat (buf
, ", avr:2", size
);
2868 case E_AVR_MACH_AVR25
:
2869 strncat (buf
, ", avr:25", size
);
2871 case E_AVR_MACH_AVR3
:
2872 strncat (buf
, ", avr:3", size
);
2874 case E_AVR_MACH_AVR31
:
2875 strncat (buf
, ", avr:31", size
);
2877 case E_AVR_MACH_AVR35
:
2878 strncat (buf
, ", avr:35", size
);
2880 case E_AVR_MACH_AVR4
:
2881 strncat (buf
, ", avr:4", size
);
2883 case E_AVR_MACH_AVR5
:
2884 strncat (buf
, ", avr:5", size
);
2886 case E_AVR_MACH_AVR51
:
2887 strncat (buf
, ", avr:51", size
);
2889 case E_AVR_MACH_AVR6
:
2890 strncat (buf
, ", avr:6", size
);
2892 case E_AVR_MACH_AVRTINY
:
2893 strncat (buf
, ", avr:100", size
);
2895 case E_AVR_MACH_XMEGA1
:
2896 strncat (buf
, ", avr:101", size
);
2898 case E_AVR_MACH_XMEGA2
:
2899 strncat (buf
, ", avr:102", size
);
2901 case E_AVR_MACH_XMEGA3
:
2902 strncat (buf
, ", avr:103", size
);
2904 case E_AVR_MACH_XMEGA4
:
2905 strncat (buf
, ", avr:104", size
);
2907 case E_AVR_MACH_XMEGA5
:
2908 strncat (buf
, ", avr:105", size
);
2910 case E_AVR_MACH_XMEGA6
:
2911 strncat (buf
, ", avr:106", size
);
2913 case E_AVR_MACH_XMEGA7
:
2914 strncat (buf
, ", avr:107", size
);
2917 strncat (buf
, ", avr:<unknown>", size
);
2921 size
-= strlen (buf
);
2922 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2923 strncat (buf
, ", link-relax", size
);
2927 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2933 bfd_boolean has_fpu
= FALSE
;
2936 static const char *ABI_STRINGS
[] =
2938 "ABI v0", /* use r5 as return register; only used in N1213HC */
2939 "ABI v1", /* use r0 as return register */
2940 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2941 "ABI v2fp", /* for FPU */
2945 static const char *VER_STRINGS
[] =
2947 "Andes ELF V1.3 or older",
2951 static const char *ARCH_STRINGS
[] =
2960 abi
= EF_NDS_ABI
& e_flags
;
2961 arch
= EF_NDS_ARCH
& e_flags
;
2962 config
= EF_NDS_INST
& e_flags
;
2963 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2965 memset (buf
, 0, size
);
2972 case E_NDS_ABI_V2FP
:
2973 case E_NDS_ABI_AABI
:
2974 case E_NDS_ABI_V2FP_PLUS
:
2975 /* In case there are holes in the array. */
2976 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2980 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2986 case E_NDS32_ELF_VER_1_2
:
2987 case E_NDS32_ELF_VER_1_3
:
2988 case E_NDS32_ELF_VER_1_4
:
2989 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2993 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2997 if (E_NDS_ABI_V0
== abi
)
2999 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3000 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3001 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3002 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3008 case E_NDS_ARCH_STAR_V1_0
:
3009 case E_NDS_ARCH_STAR_V2_0
:
3010 case E_NDS_ARCH_STAR_V3_0
:
3011 case E_NDS_ARCH_STAR_V3_M
:
3012 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3016 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3017 /* ARCH version determines how the e_flags are interpreted.
3018 If it is unknown, we cannot proceed. */
3022 /* Newer ABI; Now handle architecture specific flags. */
3023 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3025 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3026 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3028 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3029 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3031 if (config
& E_NDS32_HAS_DIV_INST
)
3032 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3034 if (config
& E_NDS32_HAS_16BIT_INST
)
3035 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3039 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3041 if (version
<= E_NDS32_ELF_VER_1_3
)
3042 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3044 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3047 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3048 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3050 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3051 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3053 if (config
& E_NDS32_HAS_16BIT_INST
)
3055 if (version
<= E_NDS32_ELF_VER_1_3
)
3056 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3058 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3062 if (config
& E_NDS32_HAS_EXT_INST
)
3063 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3065 if (config
& E_NDS32_HAS_EXT2_INST
)
3066 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3068 if (config
& E_NDS32_HAS_FPU_INST
)
3071 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3074 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3077 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3080 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3083 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3088 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3090 case E_NDS32_FPU_REG_8SP_4DP
:
3091 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3093 case E_NDS32_FPU_REG_16SP_8DP
:
3094 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3096 case E_NDS32_FPU_REG_32SP_16DP
:
3097 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3099 case E_NDS32_FPU_REG_32SP_32DP
:
3100 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3105 if (config
& E_NDS32_HAS_AUDIO_INST
)
3106 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3108 if (config
& E_NDS32_HAS_STRING_INST
)
3109 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3111 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3112 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3114 if (config
& E_NDS32_HAS_VIDEO_INST
)
3116 if (version
<= E_NDS32_ELF_VER_1_3
)
3117 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3119 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3122 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3123 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3125 if (config
& E_NDS32_HAS_L2C_INST
)
3126 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3130 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3132 static char buf
[1024];
3143 case EM_ARC_COMPACT2
:
3144 case EM_ARC_COMPACT
:
3145 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3149 decode_ARM_machine_flags (e_flags
, buf
);
3153 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3157 if (e_flags
& EF_BFIN_PIC
)
3158 strcat (buf
, ", PIC");
3160 if (e_flags
& EF_BFIN_FDPIC
)
3161 strcat (buf
, ", FDPIC");
3163 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3164 strcat (buf
, ", code in L1");
3166 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3167 strcat (buf
, ", data in L1");
3172 switch (e_flags
& EF_FRV_CPU_MASK
)
3174 case EF_FRV_CPU_GENERIC
:
3178 strcat (buf
, ", fr???");
3181 case EF_FRV_CPU_FR300
:
3182 strcat (buf
, ", fr300");
3185 case EF_FRV_CPU_FR400
:
3186 strcat (buf
, ", fr400");
3188 case EF_FRV_CPU_FR405
:
3189 strcat (buf
, ", fr405");
3192 case EF_FRV_CPU_FR450
:
3193 strcat (buf
, ", fr450");
3196 case EF_FRV_CPU_FR500
:
3197 strcat (buf
, ", fr500");
3199 case EF_FRV_CPU_FR550
:
3200 strcat (buf
, ", fr550");
3203 case EF_FRV_CPU_SIMPLE
:
3204 strcat (buf
, ", simple");
3206 case EF_FRV_CPU_TOMCAT
:
3207 strcat (buf
, ", tomcat");
3213 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3214 strcat (buf
, ", m68000");
3215 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3216 strcat (buf
, ", cpu32");
3217 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3218 strcat (buf
, ", fido_a");
3221 char const * isa
= _("unknown");
3222 char const * mac
= _("unknown mac");
3223 char const * additional
= NULL
;
3225 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3227 case EF_M68K_CF_ISA_A_NODIV
:
3229 additional
= ", nodiv";
3231 case EF_M68K_CF_ISA_A
:
3234 case EF_M68K_CF_ISA_A_PLUS
:
3237 case EF_M68K_CF_ISA_B_NOUSP
:
3239 additional
= ", nousp";
3241 case EF_M68K_CF_ISA_B
:
3244 case EF_M68K_CF_ISA_C
:
3247 case EF_M68K_CF_ISA_C_NODIV
:
3249 additional
= ", nodiv";
3252 strcat (buf
, ", cf, isa ");
3255 strcat (buf
, additional
);
3256 if (e_flags
& EF_M68K_CF_FLOAT
)
3257 strcat (buf
, ", float");
3258 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3263 case EF_M68K_CF_MAC
:
3266 case EF_M68K_CF_EMAC
:
3269 case EF_M68K_CF_EMAC_B
:
3282 switch (e_flags
& EF_MEP_CPU_MASK
)
3284 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3285 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3286 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3287 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3288 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3289 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3290 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3293 switch (e_flags
& EF_MEP_COP_MASK
)
3295 case EF_MEP_COP_NONE
: break;
3296 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3297 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3298 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3299 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3300 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3303 if (e_flags
& EF_MEP_LIBRARY
)
3304 strcat (buf
, ", Built for Library");
3306 if (e_flags
& EF_MEP_INDEX_MASK
)
3307 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3308 e_flags
& EF_MEP_INDEX_MASK
);
3310 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3311 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3312 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3316 if (e_flags
& EF_PPC_EMB
)
3317 strcat (buf
, ", emb");
3319 if (e_flags
& EF_PPC_RELOCATABLE
)
3320 strcat (buf
, _(", relocatable"));
3322 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3323 strcat (buf
, _(", relocatable-lib"));
3327 if (e_flags
& EF_PPC64_ABI
)
3329 char abi
[] = ", abiv0";
3331 abi
[6] += e_flags
& EF_PPC64_ABI
;
3337 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3338 strcat (buf
, ", RH850 ABI");
3340 if (e_flags
& EF_V800_850E3
)
3341 strcat (buf
, ", V3 architecture");
3343 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3344 strcat (buf
, ", FPU not used");
3346 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3347 strcat (buf
, ", regmode: COMMON");
3349 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3350 strcat (buf
, ", r4 not used");
3352 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3353 strcat (buf
, ", r30 not used");
3355 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3356 strcat (buf
, ", r5 not used");
3358 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3359 strcat (buf
, ", r2 not used");
3361 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3363 switch (e_flags
& - e_flags
)
3365 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3366 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3367 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3368 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3369 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3370 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3371 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3372 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3373 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3374 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3375 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3376 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3383 case EM_CYGNUS_V850
:
3384 switch (e_flags
& EF_V850_ARCH
)
3386 case E_V850E3V5_ARCH
:
3387 strcat (buf
, ", v850e3v5");
3389 case E_V850E2V3_ARCH
:
3390 strcat (buf
, ", v850e2v3");
3393 strcat (buf
, ", v850e2");
3396 strcat (buf
, ", v850e1");
3399 strcat (buf
, ", v850e");
3402 strcat (buf
, ", v850");
3405 strcat (buf
, _(", unknown v850 architecture variant"));
3411 case EM_CYGNUS_M32R
:
3412 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3413 strcat (buf
, ", m32r");
3417 case EM_MIPS_RS3_LE
:
3418 if (e_flags
& EF_MIPS_NOREORDER
)
3419 strcat (buf
, ", noreorder");
3421 if (e_flags
& EF_MIPS_PIC
)
3422 strcat (buf
, ", pic");
3424 if (e_flags
& EF_MIPS_CPIC
)
3425 strcat (buf
, ", cpic");
3427 if (e_flags
& EF_MIPS_UCODE
)
3428 strcat (buf
, ", ugen_reserved");
3430 if (e_flags
& EF_MIPS_ABI2
)
3431 strcat (buf
, ", abi2");
3433 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3434 strcat (buf
, ", odk first");
3436 if (e_flags
& EF_MIPS_32BITMODE
)
3437 strcat (buf
, ", 32bitmode");
3439 if (e_flags
& EF_MIPS_NAN2008
)
3440 strcat (buf
, ", nan2008");
3442 if (e_flags
& EF_MIPS_FP64
)
3443 strcat (buf
, ", fp64");
3445 switch ((e_flags
& EF_MIPS_MACH
))
3447 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3448 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3449 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3450 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3451 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3452 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3453 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3454 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3455 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3456 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3457 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3458 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3459 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3460 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3461 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3462 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3463 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3464 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3465 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3466 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3467 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3469 /* We simply ignore the field in this case to avoid confusion:
3470 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3473 default: strcat (buf
, _(", unknown CPU")); break;
3476 switch ((e_flags
& EF_MIPS_ABI
))
3478 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3479 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3480 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3481 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3483 /* We simply ignore the field in this case to avoid confusion:
3484 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3485 This means it is likely to be an o32 file, but not for
3488 default: strcat (buf
, _(", unknown ABI")); break;
3491 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3492 strcat (buf
, ", mdmx");
3494 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3495 strcat (buf
, ", mips16");
3497 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3498 strcat (buf
, ", micromips");
3500 switch ((e_flags
& EF_MIPS_ARCH
))
3502 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3503 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3504 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3505 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3506 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3507 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3508 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3509 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3510 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3511 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3512 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3513 default: strcat (buf
, _(", unknown ISA")); break;
3518 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3522 switch (EF_NFP_MACH (e_flags
))
3524 case E_NFP_MACH_3200
:
3525 strcat (buf
, ", NFP-32xx");
3527 case E_NFP_MACH_6000
:
3528 strcat (buf
, ", NFP-6xxx");
3534 if (e_flags
& EF_RISCV_RVC
)
3535 strcat (buf
, ", RVC");
3537 if (e_flags
& EF_RISCV_RVE
)
3538 strcat (buf
, ", RVE");
3540 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3542 case EF_RISCV_FLOAT_ABI_SOFT
:
3543 strcat (buf
, ", soft-float ABI");
3546 case EF_RISCV_FLOAT_ABI_SINGLE
:
3547 strcat (buf
, ", single-float ABI");
3550 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3551 strcat (buf
, ", double-float ABI");
3554 case EF_RISCV_FLOAT_ABI_QUAD
:
3555 strcat (buf
, ", quad-float ABI");
3561 switch ((e_flags
& EF_SH_MACH_MASK
))
3563 case EF_SH1
: strcat (buf
, ", sh1"); break;
3564 case EF_SH2
: strcat (buf
, ", sh2"); break;
3565 case EF_SH3
: strcat (buf
, ", sh3"); break;
3566 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3567 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3568 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3569 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3570 case EF_SH4
: strcat (buf
, ", sh4"); break;
3571 case EF_SH5
: strcat (buf
, ", sh5"); break;
3572 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3573 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3574 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3575 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3576 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3577 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3578 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3579 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3580 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3581 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3582 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3583 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3584 default: strcat (buf
, _(", unknown ISA")); break;
3587 if (e_flags
& EF_SH_PIC
)
3588 strcat (buf
, ", pic");
3590 if (e_flags
& EF_SH_FDPIC
)
3591 strcat (buf
, ", fdpic");
3595 if (e_flags
& EF_OR1K_NODELAY
)
3596 strcat (buf
, ", no delay");
3600 if (e_flags
& EF_SPARC_32PLUS
)
3601 strcat (buf
, ", v8+");
3603 if (e_flags
& EF_SPARC_SUN_US1
)
3604 strcat (buf
, ", ultrasparcI");
3606 if (e_flags
& EF_SPARC_SUN_US3
)
3607 strcat (buf
, ", ultrasparcIII");
3609 if (e_flags
& EF_SPARC_HAL_R1
)
3610 strcat (buf
, ", halr1");
3612 if (e_flags
& EF_SPARC_LEDATA
)
3613 strcat (buf
, ", ledata");
3615 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3616 strcat (buf
, ", tso");
3618 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3619 strcat (buf
, ", pso");
3621 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3622 strcat (buf
, ", rmo");
3626 switch (e_flags
& EF_PARISC_ARCH
)
3628 case EFA_PARISC_1_0
:
3629 strcpy (buf
, ", PA-RISC 1.0");
3631 case EFA_PARISC_1_1
:
3632 strcpy (buf
, ", PA-RISC 1.1");
3634 case EFA_PARISC_2_0
:
3635 strcpy (buf
, ", PA-RISC 2.0");
3640 if (e_flags
& EF_PARISC_TRAPNIL
)
3641 strcat (buf
, ", trapnil");
3642 if (e_flags
& EF_PARISC_EXT
)
3643 strcat (buf
, ", ext");
3644 if (e_flags
& EF_PARISC_LSB
)
3645 strcat (buf
, ", lsb");
3646 if (e_flags
& EF_PARISC_WIDE
)
3647 strcat (buf
, ", wide");
3648 if (e_flags
& EF_PARISC_NO_KABP
)
3649 strcat (buf
, ", no kabp");
3650 if (e_flags
& EF_PARISC_LAZYSWAP
)
3651 strcat (buf
, ", lazyswap");
3656 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3657 strcat (buf
, ", new calling convention");
3659 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3660 strcat (buf
, ", gnu calling convention");
3664 if ((e_flags
& EF_IA_64_ABI64
))
3665 strcat (buf
, ", 64-bit");
3667 strcat (buf
, ", 32-bit");
3668 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3669 strcat (buf
, ", reduced fp model");
3670 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3671 strcat (buf
, ", no function descriptors, constant gp");
3672 else if ((e_flags
& EF_IA_64_CONS_GP
))
3673 strcat (buf
, ", constant gp");
3674 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3675 strcat (buf
, ", absolute");
3676 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3678 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3679 strcat (buf
, ", vms_linkages");
3680 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3682 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3684 case EF_IA_64_VMS_COMCOD_WARNING
:
3685 strcat (buf
, ", warning");
3687 case EF_IA_64_VMS_COMCOD_ERROR
:
3688 strcat (buf
, ", error");
3690 case EF_IA_64_VMS_COMCOD_ABORT
:
3691 strcat (buf
, ", abort");
3694 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3695 e_flags
& EF_IA_64_VMS_COMCOD
);
3696 strcat (buf
, ", <unknown>");
3702 if ((e_flags
& EF_VAX_NONPIC
))
3703 strcat (buf
, ", non-PIC");
3704 if ((e_flags
& EF_VAX_DFLOAT
))
3705 strcat (buf
, ", D-Float");
3706 if ((e_flags
& EF_VAX_GFLOAT
))
3707 strcat (buf
, ", G-Float");
3711 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3712 strcat (buf
, ", mcm");
3713 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3714 strcat (buf
, ", mcm24");
3715 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3716 strcat (buf
, ", gr6");
3720 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3722 case E_FLAG_RL78_ANY_CPU
: break;
3723 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3724 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3725 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3727 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3728 strcat (buf
, ", 64-bit doubles");
3732 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3733 strcat (buf
, ", 64-bit doubles");
3734 if (e_flags
& E_FLAG_RX_DSP
)
3735 strcat (buf
, ", dsp");
3736 if (e_flags
& E_FLAG_RX_PID
)
3737 strcat (buf
, ", pid");
3738 if (e_flags
& E_FLAG_RX_ABI
)
3739 strcat (buf
, ", RX ABI");
3740 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3741 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3742 ? ", uses String instructions" : ", bans String instructions");
3743 if (e_flags
& E_FLAG_RX_V2
)
3744 strcat (buf
, ", V2");
3745 if (e_flags
& E_FLAG_RX_V3
)
3746 strcat (buf
, ", V3");
3750 if (e_flags
& EF_S390_HIGH_GPRS
)
3751 strcat (buf
, ", highgprs");
3755 if ((e_flags
& EF_C6000_REL
))
3756 strcat (buf
, ", relocatable module");
3760 strcat (buf
, _(": architecture variant: "));
3761 switch (e_flags
& EF_MSP430_MACH
)
3763 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3764 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3765 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3766 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3767 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3768 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3769 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3770 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3771 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3772 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3773 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3774 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3775 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3776 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3777 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3779 strcat (buf
, _(": unknown")); break;
3782 if (e_flags
& ~ EF_MSP430_MACH
)
3783 strcat (buf
, _(": unknown extra flag bits also present"));
3787 switch (e_flags
& EF_Z80_MACH_MSK
)
3789 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3790 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3791 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3792 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3793 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3794 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3795 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3797 strcat (buf
, _(", unknown")); break;
3807 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3809 static char buff
[32];
3813 case ELFOSABI_NONE
: return "UNIX - System V";
3814 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3815 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3816 case ELFOSABI_GNU
: return "UNIX - GNU";
3817 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3818 case ELFOSABI_AIX
: return "UNIX - AIX";
3819 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3820 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3821 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3822 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3823 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3824 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3825 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3826 case ELFOSABI_AROS
: return "AROS";
3827 case ELFOSABI_FENIXOS
: return "FenixOS";
3828 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3829 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3832 switch (filedata
->file_header
.e_machine
)
3837 case ELFOSABI_ARM
: return "ARM";
3838 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3849 case ELFOSABI_STANDALONE
: return _("Standalone App");
3858 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3859 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3868 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3874 get_aarch64_segment_type (unsigned long type
)
3878 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3879 default: return NULL
;
3884 get_arm_segment_type (unsigned long type
)
3888 case PT_ARM_EXIDX
: return "EXIDX";
3889 default: return NULL
;
3894 get_s390_segment_type (unsigned long type
)
3898 case PT_S390_PGSTE
: return "S390_PGSTE";
3899 default: return NULL
;
3904 get_mips_segment_type (unsigned long type
)
3908 case PT_MIPS_REGINFO
: return "REGINFO";
3909 case PT_MIPS_RTPROC
: return "RTPROC";
3910 case PT_MIPS_OPTIONS
: return "OPTIONS";
3911 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3912 default: return NULL
;
3917 get_parisc_segment_type (unsigned long type
)
3921 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3922 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3923 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3924 default: return NULL
;
3929 get_ia64_segment_type (unsigned long type
)
3933 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3934 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3935 default: return NULL
;
3940 get_tic6x_segment_type (unsigned long type
)
3944 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3945 default: return NULL
;
3950 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3952 if (e_machine
== EM_PARISC
)
3955 case PT_HP_TLS
: return "HP_TLS";
3956 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3957 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3958 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3959 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3960 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3961 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3962 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3963 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3964 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3965 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3966 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3967 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3968 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3969 case PT_HP_STACK
: return "HP_STACK";
3970 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3971 default: return NULL
;
3974 if (e_machine
== EM_IA_64
)
3977 case PT_HP_TLS
: return "HP_TLS";
3978 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3979 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3980 case PT_IA_64_HP_STACK
: return "HP_STACK";
3981 default: return NULL
;
3988 get_solaris_segment_type (unsigned long type
)
3992 case 0x6464e550: return "PT_SUNW_UNWIND";
3993 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3994 case 0x6ffffff7: return "PT_LOSUNW";
3995 case 0x6ffffffa: return "PT_SUNWBSS";
3996 case 0x6ffffffb: return "PT_SUNWSTACK";
3997 case 0x6ffffffc: return "PT_SUNWDTRACE";
3998 case 0x6ffffffd: return "PT_SUNWCAP";
3999 case 0x6fffffff: return "PT_HISUNW";
4000 default: return NULL
;
4005 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4007 static char buff
[32];
4011 case PT_NULL
: return "NULL";
4012 case PT_LOAD
: return "LOAD";
4013 case PT_DYNAMIC
: return "DYNAMIC";
4014 case PT_INTERP
: return "INTERP";
4015 case PT_NOTE
: return "NOTE";
4016 case PT_SHLIB
: return "SHLIB";
4017 case PT_PHDR
: return "PHDR";
4018 case PT_TLS
: return "TLS";
4019 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4020 case PT_GNU_STACK
: return "GNU_STACK";
4021 case PT_GNU_RELRO
: return "GNU_RELRO";
4022 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4025 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4027 const char * result
;
4029 switch (filedata
->file_header
.e_machine
)
4032 result
= get_aarch64_segment_type (p_type
);
4035 result
= get_arm_segment_type (p_type
);
4038 case EM_MIPS_RS3_LE
:
4039 result
= get_mips_segment_type (p_type
);
4042 result
= get_parisc_segment_type (p_type
);
4045 result
= get_ia64_segment_type (p_type
);
4048 result
= get_tic6x_segment_type (p_type
);
4052 result
= get_s390_segment_type (p_type
);
4062 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4064 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4066 const char * result
= NULL
;
4068 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4071 case ELFOSABI_FREEBSD
:
4072 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4074 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4079 result
= get_hpux_segment_type (p_type
,
4080 filedata
->file_header
.e_machine
);
4082 case ELFOSABI_SOLARIS
:
4083 result
= get_solaris_segment_type (p_type
);
4091 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4094 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4101 get_arc_section_type_name (unsigned int sh_type
)
4105 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4113 get_mips_section_type_name (unsigned int sh_type
)
4117 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4118 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4119 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4120 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4121 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4122 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4123 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4124 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4125 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4126 case SHT_MIPS_RELD
: return "MIPS_RELD";
4127 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4128 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4129 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4130 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4131 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4132 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4133 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4134 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4135 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4136 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4137 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4138 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4139 case SHT_MIPS_LINE
: return "MIPS_LINE";
4140 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4141 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4142 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4143 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4144 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4145 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4146 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4147 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4148 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4149 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4150 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4151 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4152 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4153 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4154 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4155 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4156 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4157 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4165 get_parisc_section_type_name (unsigned int sh_type
)
4169 case SHT_PARISC_EXT
: return "PARISC_EXT";
4170 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4171 case SHT_PARISC_DOC
: return "PARISC_DOC";
4172 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4173 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4174 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4175 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4176 default: return NULL
;
4181 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4183 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4184 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4185 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4189 case SHT_IA_64_EXT
: return "IA_64_EXT";
4190 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4191 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4192 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4193 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4194 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4195 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4196 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4197 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4198 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4206 get_x86_64_section_type_name (unsigned int sh_type
)
4210 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4211 default: return NULL
;
4216 get_aarch64_section_type_name (unsigned int sh_type
)
4220 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4221 default: return NULL
;
4226 get_arm_section_type_name (unsigned int sh_type
)
4230 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4231 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4232 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4233 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4234 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4235 default: return NULL
;
4240 get_tic6x_section_type_name (unsigned int sh_type
)
4244 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4245 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4246 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4247 case SHT_TI_ICODE
: return "TI_ICODE";
4248 case SHT_TI_XREF
: return "TI_XREF";
4249 case SHT_TI_HANDLER
: return "TI_HANDLER";
4250 case SHT_TI_INITINFO
: return "TI_INITINFO";
4251 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4252 default: return NULL
;
4257 get_msp430x_section_type_name (unsigned int sh_type
)
4261 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4262 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4263 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4264 default: return NULL
;
4269 get_nfp_section_type_name (unsigned int sh_type
)
4273 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4274 case SHT_NFP_INITREG
: return "NFP_INITREG";
4275 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4276 default: return NULL
;
4281 get_v850_section_type_name (unsigned int sh_type
)
4285 case SHT_V850_SCOMMON
: return "V850 Small Common";
4286 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4287 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4288 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4289 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4290 default: return NULL
;
4295 get_riscv_section_type_name (unsigned int sh_type
)
4299 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4300 default: return NULL
;
4305 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4307 static char buff
[32];
4308 const char * result
;
4312 case SHT_NULL
: return "NULL";
4313 case SHT_PROGBITS
: return "PROGBITS";
4314 case SHT_SYMTAB
: return "SYMTAB";
4315 case SHT_STRTAB
: return "STRTAB";
4316 case SHT_RELA
: return "RELA";
4317 case SHT_HASH
: return "HASH";
4318 case SHT_DYNAMIC
: return "DYNAMIC";
4319 case SHT_NOTE
: return "NOTE";
4320 case SHT_NOBITS
: return "NOBITS";
4321 case SHT_REL
: return "REL";
4322 case SHT_SHLIB
: return "SHLIB";
4323 case SHT_DYNSYM
: return "DYNSYM";
4324 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4325 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4326 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4327 case SHT_GNU_HASH
: return "GNU_HASH";
4328 case SHT_GROUP
: return "GROUP";
4329 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4330 case SHT_GNU_verdef
: return "VERDEF";
4331 case SHT_GNU_verneed
: return "VERNEED";
4332 case SHT_GNU_versym
: return "VERSYM";
4333 case 0x6ffffff0: return "VERSYM";
4334 case 0x6ffffffc: return "VERDEF";
4335 case 0x7ffffffd: return "AUXILIARY";
4336 case 0x7fffffff: return "FILTER";
4337 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4340 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4342 switch (filedata
->file_header
.e_machine
)
4345 case EM_ARC_COMPACT
:
4346 case EM_ARC_COMPACT2
:
4347 result
= get_arc_section_type_name (sh_type
);
4350 case EM_MIPS_RS3_LE
:
4351 result
= get_mips_section_type_name (sh_type
);
4354 result
= get_parisc_section_type_name (sh_type
);
4357 result
= get_ia64_section_type_name (filedata
, sh_type
);
4362 result
= get_x86_64_section_type_name (sh_type
);
4365 result
= get_aarch64_section_type_name (sh_type
);
4368 result
= get_arm_section_type_name (sh_type
);
4371 result
= get_tic6x_section_type_name (sh_type
);
4374 result
= get_msp430x_section_type_name (sh_type
);
4377 result
= get_nfp_section_type_name (sh_type
);
4381 case EM_CYGNUS_V850
:
4382 result
= get_v850_section_type_name (sh_type
);
4385 result
= get_riscv_section_type_name (sh_type
);
4395 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4397 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4399 switch (filedata
->file_header
.e_machine
)
4402 result
= get_ia64_section_type_name (filedata
, sh_type
);
4405 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4406 result
= get_solaris_section_type (sh_type
);
4411 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4412 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4413 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4414 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4426 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4428 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4430 switch (filedata
->file_header
.e_machine
)
4434 case EM_CYGNUS_V850
:
4435 result
= get_v850_section_type_name (sh_type
);
4445 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4448 /* This message is probably going to be displayed in a 15
4449 character wide field, so put the hex value first. */
4450 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4456 #define OPTION_DEBUG_DUMP 512
4457 #define OPTION_DYN_SYMS 513
4458 #define OPTION_DWARF_DEPTH 514
4459 #define OPTION_DWARF_START 515
4460 #define OPTION_DWARF_CHECK 516
4461 #define OPTION_CTF_DUMP 517
4462 #define OPTION_CTF_PARENT 518
4463 #define OPTION_CTF_SYMBOLS 519
4464 #define OPTION_CTF_STRINGS 520
4466 static struct option options
[] =
4468 {"all", no_argument
, 0, 'a'},
4469 {"file-header", no_argument
, 0, 'h'},
4470 {"program-headers", no_argument
, 0, 'l'},
4471 {"headers", no_argument
, 0, 'e'},
4472 {"histogram", no_argument
, 0, 'I'},
4473 {"segments", no_argument
, 0, 'l'},
4474 {"sections", no_argument
, 0, 'S'},
4475 {"section-headers", no_argument
, 0, 'S'},
4476 {"section-groups", no_argument
, 0, 'g'},
4477 {"section-details", no_argument
, 0, 't'},
4478 {"full-section-name",no_argument
, 0, 'N'},
4479 {"symbols", no_argument
, 0, 's'},
4480 {"syms", no_argument
, 0, 's'},
4481 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4482 {"relocs", no_argument
, 0, 'r'},
4483 {"notes", no_argument
, 0, 'n'},
4484 {"dynamic", no_argument
, 0, 'd'},
4485 {"lint", no_argument
, 0, 'L'},
4486 {"enable-checks", no_argument
, 0, 'L'},
4487 {"arch-specific", no_argument
, 0, 'A'},
4488 {"version-info", no_argument
, 0, 'V'},
4489 {"use-dynamic", no_argument
, 0, 'D'},
4490 {"unwind", no_argument
, 0, 'u'},
4491 {"archive-index", no_argument
, 0, 'c'},
4492 {"hex-dump", required_argument
, 0, 'x'},
4493 {"relocated-dump", required_argument
, 0, 'R'},
4494 {"string-dump", required_argument
, 0, 'p'},
4495 {"decompress", no_argument
, 0, 'z'},
4496 #ifdef SUPPORT_DISASSEMBLY
4497 {"instruction-dump", required_argument
, 0, 'i'},
4499 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4501 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4502 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4503 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4505 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4507 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4508 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4509 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4511 {"version", no_argument
, 0, 'v'},
4512 {"wide", no_argument
, 0, 'W'},
4513 {"help", no_argument
, 0, 'H'},
4514 {0, no_argument
, 0, 0}
4518 usage (FILE * stream
)
4520 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4521 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4522 fprintf (stream
, _(" Options are:\n\
4523 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4524 -h --file-header Display the ELF file header\n\
4525 -l --program-headers Display the program headers\n\
4526 --segments An alias for --program-headers\n\
4527 -S --section-headers Display the sections' header\n\
4528 --sections An alias for --section-headers\n\
4529 -g --section-groups Display the section groups\n\
4530 -t --section-details Display the section details\n\
4531 -e --headers Equivalent to: -h -l -S\n\
4532 -s --syms Display the symbol table\n\
4533 --symbols An alias for --syms\n\
4534 --dyn-syms Display the dynamic symbol table\n\
4535 -n --notes Display the core notes (if present)\n\
4536 -r --relocs Display the relocations (if present)\n\
4537 -u --unwind Display the unwind info (if present)\n\
4538 -d --dynamic Display the dynamic section (if present)\n\
4539 -V --version-info Display the version sections (if present)\n\
4540 -A --arch-specific Display architecture specific information (if any)\n\
4541 -c --archive-index Display the symbol/file index in an archive\n\
4542 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4543 -L --lint|--enable-checks Display warning messages for possible problems\n\
4544 -x --hex-dump=<number|name>\n\
4545 Dump the contents of section <number|name> as bytes\n\
4546 -p --string-dump=<number|name>\n\
4547 Dump the contents of section <number|name> as strings\n\
4548 -R --relocated-dump=<number|name>\n\
4549 Dump the contents of section <number|name> as relocated bytes\n\
4550 -z --decompress Decompress section before dumping it\n\
4551 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4552 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4553 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4554 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4555 =addr,=cu_index,=links,=follow-links]\n\
4556 Display the contents of DWARF debug sections\n"));
4557 fprintf (stream
, _("\
4558 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4559 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4561 fprintf (stream
, _("\
4562 --ctf=<number|name> Display CTF info from section <number|name>\n\
4563 --ctf-parent=<number|name>\n\
4564 Use section <number|name> as the CTF parent\n\n\
4565 --ctf-symbols=<number|name>\n\
4566 Use section <number|name> as the CTF external symtab\n\n\
4567 --ctf-strings=<number|name>\n\
4568 Use section <number|name> as the CTF external strtab\n\n"));
4570 #ifdef SUPPORT_DISASSEMBLY
4571 fprintf (stream
, _("\
4572 -i --instruction-dump=<number|name>\n\
4573 Disassemble the contents of section <number|name>\n"));
4575 fprintf (stream
, _("\
4576 -I --histogram Display histogram of bucket list lengths\n\
4577 -W --wide Allow output width to exceed 80 characters\n\
4578 @<file> Read options from <file>\n\
4579 -H --help Display this information\n\
4580 -v --version Display the version number of readelf\n"));
4582 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4583 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4585 exit (stream
== stdout
? 0 : 1);
4588 /* Record the fact that the user wants the contents of section number
4589 SECTION to be displayed using the method(s) encoded as flags bits
4590 in TYPE. Note, TYPE can be zero if we are creating the array for
4594 request_dump_bynumber (struct dump_data
*dumpdata
,
4595 unsigned int section
, dump_type type
)
4597 if (section
>= dumpdata
->num_dump_sects
)
4599 dump_type
* new_dump_sects
;
4601 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4602 sizeof (* new_dump_sects
));
4604 if (new_dump_sects
== NULL
)
4605 error (_("Out of memory allocating dump request table.\n"));
4608 if (dumpdata
->dump_sects
)
4610 /* Copy current flag settings. */
4611 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4612 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4614 free (dumpdata
->dump_sects
);
4617 dumpdata
->dump_sects
= new_dump_sects
;
4618 dumpdata
->num_dump_sects
= section
+ 1;
4622 if (dumpdata
->dump_sects
)
4623 dumpdata
->dump_sects
[section
] |= type
;
4626 /* Request a dump by section name. */
4629 request_dump_byname (const char * section
, dump_type type
)
4631 struct dump_list_entry
* new_request
;
4633 new_request
= (struct dump_list_entry
*)
4634 malloc (sizeof (struct dump_list_entry
));
4636 error (_("Out of memory allocating dump request table.\n"));
4638 new_request
->name
= strdup (section
);
4639 if (!new_request
->name
)
4640 error (_("Out of memory allocating dump request table.\n"));
4642 new_request
->type
= type
;
4644 new_request
->next
= dump_sects_byname
;
4645 dump_sects_byname
= new_request
;
4649 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4655 section
= strtoul (optarg
, & cp
, 0);
4657 if (! *cp
&& section
>= 0)
4658 request_dump_bynumber (dumpdata
, section
, type
);
4660 request_dump_byname (optarg
, type
);
4664 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4671 while ((c
= getopt_long
4672 (argc
, argv
, "ADHILNR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4690 do_section_groups
= TRUE
;
4693 do_histogram
= TRUE
;
4698 do_section_groups
= TRUE
;
4703 do_section_details
= TRUE
;
4714 do_using_dynamic
= TRUE
;
4738 do_histogram
= TRUE
;
4744 do_archive_index
= TRUE
;
4750 request_dump (dumpdata
, HEX_DUMP
);
4753 request_dump (dumpdata
, STRING_DUMP
);
4756 request_dump (dumpdata
, RELOC_DUMP
);
4759 decompress_dumps
= TRUE
;
4765 do_debugging
= TRUE
;
4766 dwarf_select_sections_all ();
4770 do_debugging
= FALSE
;
4771 dwarf_select_sections_by_letters (optarg
);
4774 case OPTION_DEBUG_DUMP
:
4777 do_debugging
= TRUE
;
4780 do_debugging
= FALSE
;
4781 dwarf_select_sections_by_names (optarg
);
4784 case OPTION_DWARF_DEPTH
:
4788 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4791 case OPTION_DWARF_START
:
4795 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4798 case OPTION_DWARF_CHECK
:
4801 case OPTION_CTF_DUMP
:
4803 request_dump (dumpdata
, CTF_DUMP
);
4805 case OPTION_CTF_SYMBOLS
:
4806 dump_ctf_symtab_name
= strdup (optarg
);
4808 case OPTION_CTF_STRINGS
:
4809 dump_ctf_strtab_name
= strdup (optarg
);
4811 case OPTION_CTF_PARENT
:
4812 dump_ctf_parent_name
= strdup (optarg
);
4814 case OPTION_DYN_SYMS
:
4817 #ifdef SUPPORT_DISASSEMBLY
4819 request_dump (dumpdata
, DISASS_DUMP
);
4823 print_version (program_name
);
4832 /* xgettext:c-format */
4833 error (_("Invalid option '-%c'\n"), c
);
4840 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4841 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4842 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4843 && !do_section_groups
&& !do_archive_index
4849 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= TRUE
;
4850 do_segments
= do_header
= do_dump
= do_version
= TRUE
;
4851 do_histogram
= do_debugging
= do_arch
= do_notes
= TRUE
;
4852 do_section_groups
= do_archive_index
= do_dyn_syms
= TRUE
;
4860 get_elf_class (unsigned int elf_class
)
4862 static char buff
[32];
4866 case ELFCLASSNONE
: return _("none");
4867 case ELFCLASS32
: return "ELF32";
4868 case ELFCLASS64
: return "ELF64";
4870 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4876 get_data_encoding (unsigned int encoding
)
4878 static char buff
[32];
4882 case ELFDATANONE
: return _("none");
4883 case ELFDATA2LSB
: return _("2's complement, little endian");
4884 case ELFDATA2MSB
: return _("2's complement, big endian");
4886 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4891 /* Decode the data held in 'filedata->file_header'. */
4894 process_file_header (Filedata
* filedata
)
4896 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4898 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4899 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4900 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4901 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4904 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4908 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4914 printf (_("ELF Header:\n"));
4915 printf (_(" Magic: "));
4916 for (i
= 0; i
< EI_NIDENT
; i
++)
4917 printf ("%2.2x ", header
->e_ident
[i
]);
4919 printf (_(" Class: %s\n"),
4920 get_elf_class (header
->e_ident
[EI_CLASS
]));
4921 printf (_(" Data: %s\n"),
4922 get_data_encoding (header
->e_ident
[EI_DATA
]));
4923 printf (_(" Version: %d%s\n"),
4924 header
->e_ident
[EI_VERSION
],
4925 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4927 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4930 printf (_(" OS/ABI: %s\n"),
4931 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4932 printf (_(" ABI Version: %d\n"),
4933 header
->e_ident
[EI_ABIVERSION
]);
4934 printf (_(" Type: %s\n"),
4935 get_file_type (header
->e_type
));
4936 printf (_(" Machine: %s\n"),
4937 get_machine_name (header
->e_machine
));
4938 printf (_(" Version: 0x%lx\n"),
4941 printf (_(" Entry point address: "));
4942 print_vma (header
->e_entry
, PREFIX_HEX
);
4943 printf (_("\n Start of program headers: "));
4944 print_vma (header
->e_phoff
, DEC
);
4945 printf (_(" (bytes into file)\n Start of section headers: "));
4946 print_vma (header
->e_shoff
, DEC
);
4947 printf (_(" (bytes into file)\n"));
4949 printf (_(" Flags: 0x%lx%s\n"),
4951 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4952 printf (_(" Size of this header: %u (bytes)\n"),
4954 printf (_(" Size of program headers: %u (bytes)\n"),
4955 header
->e_phentsize
);
4956 printf (_(" Number of program headers: %u"),
4958 if (filedata
->section_headers
!= NULL
4959 && header
->e_phnum
== PN_XNUM
4960 && filedata
->section_headers
[0].sh_info
!= 0)
4962 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4963 printf (" (%u)", header
->e_phnum
);
4965 putc ('\n', stdout
);
4966 printf (_(" Size of section headers: %u (bytes)\n"),
4967 header
->e_shentsize
);
4968 printf (_(" Number of section headers: %u"),
4970 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4972 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4973 printf (" (%u)", header
->e_shnum
);
4975 putc ('\n', stdout
);
4976 printf (_(" Section header string table index: %u"),
4977 header
->e_shstrndx
);
4978 if (filedata
->section_headers
!= NULL
4979 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4981 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4982 printf (" (%u)", header
->e_shstrndx
);
4984 if (header
->e_shstrndx
!= SHN_UNDEF
4985 && header
->e_shstrndx
>= header
->e_shnum
)
4987 header
->e_shstrndx
= SHN_UNDEF
;
4988 printf (_(" <corrupt: out of range>"));
4990 putc ('\n', stdout
);
4993 if (filedata
->section_headers
!= NULL
)
4995 if (header
->e_phnum
== PN_XNUM
4996 && filedata
->section_headers
[0].sh_info
!= 0)
4997 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4998 if (header
->e_shnum
== SHN_UNDEF
)
4999 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5000 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5001 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5002 if (header
->e_shstrndx
>= header
->e_shnum
)
5003 header
->e_shstrndx
= SHN_UNDEF
;
5004 free (filedata
->section_headers
);
5005 filedata
->section_headers
= NULL
;
5011 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5012 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5015 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5017 Elf32_External_Phdr
* phdrs
;
5018 Elf32_External_Phdr
* external
;
5019 Elf_Internal_Phdr
* internal
;
5021 unsigned int size
= filedata
->file_header
.e_phentsize
;
5022 unsigned int num
= filedata
->file_header
.e_phnum
;
5024 /* PR binutils/17531: Cope with unexpected section header sizes. */
5025 if (size
== 0 || num
== 0)
5027 if (size
< sizeof * phdrs
)
5029 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5032 if (size
> sizeof * phdrs
)
5033 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5035 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5036 size
, num
, _("program headers"));
5040 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5041 i
< filedata
->file_header
.e_phnum
;
5042 i
++, internal
++, external
++)
5044 internal
->p_type
= BYTE_GET (external
->p_type
);
5045 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5046 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5047 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5048 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5049 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5050 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5051 internal
->p_align
= BYTE_GET (external
->p_align
);
5058 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5059 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5062 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5064 Elf64_External_Phdr
* phdrs
;
5065 Elf64_External_Phdr
* external
;
5066 Elf_Internal_Phdr
* internal
;
5068 unsigned int size
= filedata
->file_header
.e_phentsize
;
5069 unsigned int num
= filedata
->file_header
.e_phnum
;
5071 /* PR binutils/17531: Cope with unexpected section header sizes. */
5072 if (size
== 0 || num
== 0)
5074 if (size
< sizeof * phdrs
)
5076 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5079 if (size
> sizeof * phdrs
)
5080 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5082 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5083 size
, num
, _("program headers"));
5087 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5088 i
< filedata
->file_header
.e_phnum
;
5089 i
++, internal
++, external
++)
5091 internal
->p_type
= BYTE_GET (external
->p_type
);
5092 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5093 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5094 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5095 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5096 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5097 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5098 internal
->p_align
= BYTE_GET (external
->p_align
);
5105 /* Returns TRUE if the program headers were read into `program_headers'. */
5108 get_program_headers (Filedata
* filedata
)
5110 Elf_Internal_Phdr
* phdrs
;
5112 /* Check cache of prior read. */
5113 if (filedata
->program_headers
!= NULL
)
5116 /* Be kind to memory checkers by looking for
5117 e_phnum values which we know must be invalid. */
5118 if (filedata
->file_header
.e_phnum
5119 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5120 >= filedata
->file_size
)
5122 error (_("Too many program headers - %#x - the file is not that big\n"),
5123 filedata
->file_header
.e_phnum
);
5127 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5128 sizeof (Elf_Internal_Phdr
));
5131 error (_("Out of memory reading %u program headers\n"),
5132 filedata
->file_header
.e_phnum
);
5137 ? get_32bit_program_headers (filedata
, phdrs
)
5138 : get_64bit_program_headers (filedata
, phdrs
))
5140 filedata
->program_headers
= phdrs
;
5148 /* Returns TRUE if the program headers were loaded. */
5151 process_program_headers (Filedata
* filedata
)
5153 Elf_Internal_Phdr
* segment
;
5155 Elf_Internal_Phdr
* previous_load
= NULL
;
5157 filedata
->dynamic_addr
= 0;
5158 filedata
->dynamic_size
= 0;
5160 if (filedata
->file_header
.e_phnum
== 0)
5162 /* PR binutils/12467. */
5163 if (filedata
->file_header
.e_phoff
!= 0)
5165 warn (_("possibly corrupt ELF header - it has a non-zero program"
5166 " header offset, but no program headers\n"));
5169 else if (do_segments
)
5170 printf (_("\nThere are no program headers in this file.\n"));
5174 if (do_segments
&& !do_header
)
5176 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5177 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5178 printf (ngettext ("There is %d program header, starting at offset %s\n",
5179 "There are %d program headers, starting at offset %s\n",
5180 filedata
->file_header
.e_phnum
),
5181 filedata
->file_header
.e_phnum
,
5182 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5185 if (! get_program_headers (filedata
))
5190 if (filedata
->file_header
.e_phnum
> 1)
5191 printf (_("\nProgram Headers:\n"));
5193 printf (_("\nProgram Headers:\n"));
5197 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5200 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5204 (_(" Type Offset VirtAddr PhysAddr\n"));
5206 (_(" FileSiz MemSiz Flags Align\n"));
5210 for (i
= 0, segment
= filedata
->program_headers
;
5211 i
< filedata
->file_header
.e_phnum
;
5216 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5220 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5221 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5222 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5223 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5224 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5226 (segment
->p_flags
& PF_R
? 'R' : ' '),
5227 (segment
->p_flags
& PF_W
? 'W' : ' '),
5228 (segment
->p_flags
& PF_X
? 'E' : ' '));
5229 printf ("%#lx", (unsigned long) segment
->p_align
);
5233 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5234 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5237 print_vma (segment
->p_offset
, FULL_HEX
);
5241 print_vma (segment
->p_vaddr
, FULL_HEX
);
5243 print_vma (segment
->p_paddr
, FULL_HEX
);
5246 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5247 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5250 print_vma (segment
->p_filesz
, FULL_HEX
);
5254 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5255 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5258 print_vma (segment
->p_memsz
, FULL_HEX
);
5262 (segment
->p_flags
& PF_R
? 'R' : ' '),
5263 (segment
->p_flags
& PF_W
? 'W' : ' '),
5264 (segment
->p_flags
& PF_X
? 'E' : ' '));
5266 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5267 printf ("%#lx", (unsigned long) segment
->p_align
);
5270 print_vma (segment
->p_align
, PREFIX_HEX
);
5275 print_vma (segment
->p_offset
, FULL_HEX
);
5277 print_vma (segment
->p_vaddr
, FULL_HEX
);
5279 print_vma (segment
->p_paddr
, FULL_HEX
);
5281 print_vma (segment
->p_filesz
, FULL_HEX
);
5283 print_vma (segment
->p_memsz
, FULL_HEX
);
5285 (segment
->p_flags
& PF_R
? 'R' : ' '),
5286 (segment
->p_flags
& PF_W
? 'W' : ' '),
5287 (segment
->p_flags
& PF_X
? 'E' : ' '));
5288 print_vma (segment
->p_align
, PREFIX_HEX
);
5291 putc ('\n', stdout
);
5294 switch (segment
->p_type
)
5297 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5298 required by the ELF standard, several programs, including the Linux
5299 kernel, make use of non-ordered segments. */
5301 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5302 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5304 if (segment
->p_memsz
< segment
->p_filesz
)
5305 error (_("the segment's file size is larger than its memory size\n"));
5306 previous_load
= segment
;
5310 /* PR 20815 - Verify that the program header is loaded into memory. */
5311 if (i
> 0 && previous_load
!= NULL
)
5312 error (_("the PHDR segment must occur before any LOAD segment\n"));
5313 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5317 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5319 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5320 if (load
->p_type
== PT_LOAD
5321 && load
->p_offset
<= segment
->p_offset
5322 && (load
->p_offset
+ load
->p_filesz
5323 >= segment
->p_offset
+ segment
->p_filesz
)
5324 && load
->p_vaddr
<= segment
->p_vaddr
5325 && (load
->p_vaddr
+ load
->p_filesz
5326 >= segment
->p_vaddr
+ segment
->p_filesz
))
5329 if (j
== filedata
->file_header
.e_phnum
)
5330 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5335 if (filedata
->dynamic_addr
)
5336 error (_("more than one dynamic segment\n"));
5338 /* By default, assume that the .dynamic section is the first
5339 section in the DYNAMIC segment. */
5340 filedata
->dynamic_addr
= segment
->p_offset
;
5341 filedata
->dynamic_size
= segment
->p_filesz
;
5343 /* Try to locate the .dynamic section. If there is
5344 a section header table, we can easily locate it. */
5345 if (filedata
->section_headers
!= NULL
)
5347 Elf_Internal_Shdr
* sec
;
5349 sec
= find_section (filedata
, ".dynamic");
5350 if (sec
== NULL
|| sec
->sh_size
== 0)
5352 /* A corresponding .dynamic section is expected, but on
5353 IA-64/OpenVMS it is OK for it to be missing. */
5354 if (!is_ia64_vms (filedata
))
5355 error (_("no .dynamic section in the dynamic segment\n"));
5359 if (sec
->sh_type
== SHT_NOBITS
)
5361 filedata
->dynamic_size
= 0;
5365 filedata
->dynamic_addr
= sec
->sh_offset
;
5366 filedata
->dynamic_size
= sec
->sh_size
;
5368 /* The PT_DYNAMIC segment, which is used by the run-time
5369 loader, should exactly match the .dynamic section. */
5371 && (filedata
->dynamic_addr
!= segment
->p_offset
5372 || filedata
->dynamic_size
!= segment
->p_filesz
))
5374 the .dynamic section is not the same as the dynamic segment\n"));
5377 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5378 segment. Check this after matching against the section headers
5379 so we don't warn on debuginfo file (which have NOBITS .dynamic
5381 if (filedata
->dynamic_addr
> filedata
->file_size
5382 || (filedata
->dynamic_size
5383 > filedata
->file_size
- filedata
->dynamic_addr
))
5385 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5386 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5391 if (fseek (filedata
->handle
,
5392 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5394 error (_("Unable to find program interpreter name\n"));
5398 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5400 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5401 error (_("Internal error: failed to create format string to display program interpreter\n"));
5403 filedata
->program_interpreter
[0] = 0;
5404 if (fscanf (filedata
->handle
, fmt
,
5405 filedata
->program_interpreter
) <= 0)
5406 error (_("Unable to read program interpreter name\n"));
5409 printf (_(" [Requesting program interpreter: %s]\n"),
5410 filedata
->program_interpreter
);
5417 && filedata
->section_headers
!= NULL
5418 && filedata
->string_table
!= NULL
)
5420 printf (_("\n Section to Segment mapping:\n"));
5421 printf (_(" Segment Sections...\n"));
5423 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5426 Elf_Internal_Shdr
* section
;
5428 segment
= filedata
->program_headers
+ i
;
5429 section
= filedata
->section_headers
+ 1;
5431 printf (" %2.2d ", i
);
5433 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5435 if (!ELF_TBSS_SPECIAL (section
, segment
)
5436 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5437 printf ("%s ", printable_section_name (filedata
, section
));
5448 /* Find the file offset corresponding to VMA by using the program headers. */
5451 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5453 Elf_Internal_Phdr
* seg
;
5455 if (! get_program_headers (filedata
))
5457 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5461 for (seg
= filedata
->program_headers
;
5462 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5465 if (seg
->p_type
!= PT_LOAD
)
5468 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5469 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5470 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5473 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5474 (unsigned long) vma
);
5479 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5480 If PROBE is true, this is just a probe and we do not generate any error
5481 messages if the load fails. */
5484 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5486 Elf32_External_Shdr
* shdrs
;
5487 Elf_Internal_Shdr
* internal
;
5489 unsigned int size
= filedata
->file_header
.e_shentsize
;
5490 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5492 /* PR binutils/17531: Cope with unexpected section header sizes. */
5493 if (size
== 0 || num
== 0)
5495 if (size
< sizeof * shdrs
)
5498 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5501 if (!probe
&& size
> sizeof * shdrs
)
5502 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5504 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5506 probe
? NULL
: _("section headers"));
5510 free (filedata
->section_headers
);
5511 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5512 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5513 if (filedata
->section_headers
== NULL
)
5516 error (_("Out of memory reading %u section headers\n"), num
);
5521 for (i
= 0, internal
= filedata
->section_headers
;
5525 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5526 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5527 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5528 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5529 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5530 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5531 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5532 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5533 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5534 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5535 if (!probe
&& internal
->sh_link
> num
)
5536 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5537 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5538 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5545 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5548 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5550 Elf64_External_Shdr
* shdrs
;
5551 Elf_Internal_Shdr
* internal
;
5553 unsigned int size
= filedata
->file_header
.e_shentsize
;
5554 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5556 /* PR binutils/17531: Cope with unexpected section header sizes. */
5557 if (size
== 0 || num
== 0)
5560 if (size
< sizeof * shdrs
)
5563 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5567 if (! probe
&& size
> sizeof * shdrs
)
5568 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5570 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5571 filedata
->file_header
.e_shoff
,
5573 probe
? NULL
: _("section headers"));
5577 free (filedata
->section_headers
);
5578 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5579 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5580 if (filedata
->section_headers
== NULL
)
5583 error (_("Out of memory reading %u section headers\n"), num
);
5588 for (i
= 0, internal
= filedata
->section_headers
;
5592 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5593 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5594 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5595 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5596 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5597 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5598 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5599 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5600 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5601 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5602 if (!probe
&& internal
->sh_link
> num
)
5603 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5604 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5605 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5612 static Elf_Internal_Sym
*
5613 get_32bit_elf_symbols (Filedata
* filedata
,
5614 Elf_Internal_Shdr
* section
,
5615 unsigned long * num_syms_return
)
5617 unsigned long number
= 0;
5618 Elf32_External_Sym
* esyms
= NULL
;
5619 Elf_External_Sym_Shndx
* shndx
= NULL
;
5620 Elf_Internal_Sym
* isyms
= NULL
;
5621 Elf_Internal_Sym
* psym
;
5623 elf_section_list
* entry
;
5625 if (section
->sh_size
== 0)
5627 if (num_syms_return
!= NULL
)
5628 * num_syms_return
= 0;
5632 /* Run some sanity checks first. */
5633 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5635 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5636 printable_section_name (filedata
, section
),
5637 (unsigned long) section
->sh_entsize
);
5641 if (section
->sh_size
> filedata
->file_size
)
5643 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5644 printable_section_name (filedata
, section
),
5645 (unsigned long) section
->sh_size
);
5649 number
= section
->sh_size
/ section
->sh_entsize
;
5651 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5653 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5654 (unsigned long) section
->sh_size
,
5655 printable_section_name (filedata
, section
),
5656 (unsigned long) section
->sh_entsize
);
5660 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5661 section
->sh_size
, _("symbols"));
5666 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5668 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5673 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5677 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5678 entry
->hdr
->sh_offset
,
5679 1, entry
->hdr
->sh_size
,
5680 _("symbol table section indices"));
5684 /* PR17531: file: heap-buffer-overflow */
5685 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5687 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5688 printable_section_name (filedata
, entry
->hdr
),
5689 (unsigned long) entry
->hdr
->sh_size
,
5690 (unsigned long) section
->sh_size
);
5695 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5699 error (_("Out of memory reading %lu symbols\n"),
5700 (unsigned long) number
);
5704 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5706 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5707 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5708 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5709 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5710 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5712 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5713 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5714 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5715 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5716 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5723 if (num_syms_return
!= NULL
)
5724 * num_syms_return
= isyms
== NULL
? 0 : number
;
5729 static Elf_Internal_Sym
*
5730 get_64bit_elf_symbols (Filedata
* filedata
,
5731 Elf_Internal_Shdr
* section
,
5732 unsigned long * num_syms_return
)
5734 unsigned long number
= 0;
5735 Elf64_External_Sym
* esyms
= NULL
;
5736 Elf_External_Sym_Shndx
* shndx
= NULL
;
5737 Elf_Internal_Sym
* isyms
= NULL
;
5738 Elf_Internal_Sym
* psym
;
5740 elf_section_list
* entry
;
5742 if (section
->sh_size
== 0)
5744 if (num_syms_return
!= NULL
)
5745 * num_syms_return
= 0;
5749 /* Run some sanity checks first. */
5750 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5752 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5753 printable_section_name (filedata
, section
),
5754 (unsigned long) section
->sh_entsize
);
5758 if (section
->sh_size
> filedata
->file_size
)
5760 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5761 printable_section_name (filedata
, section
),
5762 (unsigned long) section
->sh_size
);
5766 number
= section
->sh_size
/ section
->sh_entsize
;
5768 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5770 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5771 (unsigned long) section
->sh_size
,
5772 printable_section_name (filedata
, section
),
5773 (unsigned long) section
->sh_entsize
);
5777 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5778 section
->sh_size
, _("symbols"));
5783 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5785 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5790 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5794 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5795 entry
->hdr
->sh_offset
,
5796 1, entry
->hdr
->sh_size
,
5797 _("symbol table section indices"));
5801 /* PR17531: file: heap-buffer-overflow */
5802 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5804 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5805 printable_section_name (filedata
, entry
->hdr
),
5806 (unsigned long) entry
->hdr
->sh_size
,
5807 (unsigned long) section
->sh_size
);
5812 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5816 error (_("Out of memory reading %lu symbols\n"),
5817 (unsigned long) number
);
5821 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5823 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5824 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5825 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5826 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5828 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5830 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5831 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5832 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5834 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5835 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5842 if (num_syms_return
!= NULL
)
5843 * num_syms_return
= isyms
== NULL
? 0 : number
;
5849 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5851 static char buff
[1024];
5853 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5855 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5856 bfd_vma os_flags
= 0;
5857 bfd_vma proc_flags
= 0;
5858 bfd_vma unknown_flags
= 0;
5866 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5867 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5868 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5869 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5870 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5871 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5872 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5873 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5874 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5875 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5876 /* IA-64 specific. */
5877 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5878 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5879 /* IA-64 OpenVMS specific. */
5880 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5881 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5882 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5883 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5884 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5885 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5887 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5888 /* SPARC specific. */
5889 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5890 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5892 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5893 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5894 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5896 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5898 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5901 if (do_section_details
)
5903 sprintf (buff
, "[%*.*lx]: ",
5904 field_size
, field_size
, (unsigned long) sh_flags
);
5905 p
+= field_size
+ 4;
5912 flag
= sh_flags
& - sh_flags
;
5915 if (do_section_details
)
5919 case SHF_WRITE
: sindex
= 0; break;
5920 case SHF_ALLOC
: sindex
= 1; break;
5921 case SHF_EXECINSTR
: sindex
= 2; break;
5922 case SHF_MERGE
: sindex
= 3; break;
5923 case SHF_STRINGS
: sindex
= 4; break;
5924 case SHF_INFO_LINK
: sindex
= 5; break;
5925 case SHF_LINK_ORDER
: sindex
= 6; break;
5926 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5927 case SHF_GROUP
: sindex
= 8; break;
5928 case SHF_TLS
: sindex
= 9; break;
5929 case SHF_EXCLUDE
: sindex
= 18; break;
5930 case SHF_COMPRESSED
: sindex
= 20; break;
5931 case SHF_GNU_MBIND
: sindex
= 24; break;
5935 switch (filedata
->file_header
.e_machine
)
5938 if (flag
== SHF_IA_64_SHORT
)
5940 else if (flag
== SHF_IA_64_NORECOV
)
5943 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5946 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5947 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5948 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5949 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5950 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5951 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5962 case EM_OLD_SPARCV9
:
5963 case EM_SPARC32PLUS
:
5966 if (flag
== SHF_ORDERED
)
5973 case SHF_ENTRYSECT
: sindex
= 21; break;
5974 case SHF_ARM_PURECODE
: sindex
= 22; break;
5975 case SHF_COMDEF
: sindex
= 23; break;
5980 if (flag
== SHF_PPC_VLE
)
5991 if (p
!= buff
+ field_size
+ 4)
5993 if (size
< (10 + 2))
5995 warn (_("Internal error: not enough buffer room for section flag info"));
5996 return _("<unknown>");
6003 size
-= flags
[sindex
].len
;
6004 p
= stpcpy (p
, flags
[sindex
].str
);
6006 else if (flag
& SHF_MASKOS
)
6008 else if (flag
& SHF_MASKPROC
)
6011 unknown_flags
|= flag
;
6017 case SHF_WRITE
: *p
= 'W'; break;
6018 case SHF_ALLOC
: *p
= 'A'; break;
6019 case SHF_EXECINSTR
: *p
= 'X'; break;
6020 case SHF_MERGE
: *p
= 'M'; break;
6021 case SHF_STRINGS
: *p
= 'S'; break;
6022 case SHF_INFO_LINK
: *p
= 'I'; break;
6023 case SHF_LINK_ORDER
: *p
= 'L'; break;
6024 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6025 case SHF_GROUP
: *p
= 'G'; break;
6026 case SHF_TLS
: *p
= 'T'; break;
6027 case SHF_EXCLUDE
: *p
= 'E'; break;
6028 case SHF_COMPRESSED
: *p
= 'C'; break;
6029 case SHF_GNU_MBIND
: *p
= 'D'; break;
6032 if ((filedata
->file_header
.e_machine
== EM_X86_64
6033 || filedata
->file_header
.e_machine
== EM_L1OM
6034 || filedata
->file_header
.e_machine
== EM_K1OM
)
6035 && flag
== SHF_X86_64_LARGE
)
6037 else if (filedata
->file_header
.e_machine
== EM_ARM
6038 && flag
== SHF_ARM_PURECODE
)
6040 else if (filedata
->file_header
.e_machine
== EM_PPC
6041 && flag
== SHF_PPC_VLE
)
6043 else if (flag
& SHF_MASKOS
)
6046 sh_flags
&= ~ SHF_MASKOS
;
6048 else if (flag
& SHF_MASKPROC
)
6051 sh_flags
&= ~ SHF_MASKPROC
;
6061 if (do_section_details
)
6065 size
-= 5 + field_size
;
6066 if (p
!= buff
+ field_size
+ 4)
6070 warn (_("Internal error: not enough buffer room for section flag info"));
6071 return _("<unknown>");
6077 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6078 (unsigned long) os_flags
);
6079 p
+= 5 + field_size
;
6083 size
-= 7 + field_size
;
6084 if (p
!= buff
+ field_size
+ 4)
6088 warn (_("Internal error: not enough buffer room for section flag info"));
6089 return _("<unknown>");
6095 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6096 (unsigned long) proc_flags
);
6097 p
+= 7 + field_size
;
6101 size
-= 10 + field_size
;
6102 if (p
!= buff
+ field_size
+ 4)
6106 warn (_("Internal error: not enough buffer room for section flag info"));
6107 return _("<unknown>");
6113 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6114 (unsigned long) unknown_flags
);
6115 p
+= 10 + field_size
;
6123 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6124 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6128 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6130 if (size
< sizeof (* echdr
))
6132 error (_("Compressed section is too small even for a compression header\n"));
6136 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6137 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6138 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6139 return sizeof (*echdr
);
6143 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6145 if (size
< sizeof (* echdr
))
6147 error (_("Compressed section is too small even for a compression header\n"));
6151 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6152 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6153 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6154 return sizeof (*echdr
);
6159 process_section_headers (Filedata
* filedata
)
6161 Elf_Internal_Shdr
* section
;
6164 free (filedata
->section_headers
);
6165 filedata
->section_headers
= NULL
;
6166 free (filedata
->dynamic_symbols
);
6167 filedata
->dynamic_symbols
= NULL
;
6168 filedata
->num_dynamic_syms
= 0;
6169 free (filedata
->dynamic_strings
);
6170 filedata
->dynamic_strings
= NULL
;
6171 filedata
->dynamic_strings_length
= 0;
6172 free (filedata
->dynamic_syminfo
);
6173 filedata
->dynamic_syminfo
= NULL
;
6174 while (filedata
->symtab_shndx_list
!= NULL
)
6176 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6177 free (filedata
->symtab_shndx_list
);
6178 filedata
->symtab_shndx_list
= next
;
6181 if (filedata
->file_header
.e_shnum
== 0)
6183 /* PR binutils/12467. */
6184 if (filedata
->file_header
.e_shoff
!= 0)
6186 warn (_("possibly corrupt ELF file header - it has a non-zero"
6187 " section header offset, but no section headers\n"));
6190 else if (do_sections
)
6191 printf (_("\nThere are no sections in this file.\n"));
6196 if (do_sections
&& !do_header
)
6197 printf (ngettext ("There is %d section header, "
6198 "starting at offset 0x%lx:\n",
6199 "There are %d section headers, "
6200 "starting at offset 0x%lx:\n",
6201 filedata
->file_header
.e_shnum
),
6202 filedata
->file_header
.e_shnum
,
6203 (unsigned long) filedata
->file_header
.e_shoff
);
6207 if (! get_32bit_section_headers (filedata
, FALSE
))
6212 if (! get_64bit_section_headers (filedata
, FALSE
))
6216 /* Read in the string table, so that we have names to display. */
6217 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6218 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6220 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6222 if (section
->sh_size
!= 0)
6224 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6225 1, section
->sh_size
,
6228 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6232 /* Scan the sections for the dynamic symbol table
6233 and dynamic string table and debug sections. */
6234 eh_addr_size
= is_32bit_elf
? 4 : 8;
6235 switch (filedata
->file_header
.e_machine
)
6238 case EM_MIPS_RS3_LE
:
6239 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6240 FDE addresses. However, the ABI also has a semi-official ILP32
6241 variant for which the normal FDE address size rules apply.
6243 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6244 section, where XX is the size of longs in bits. Unfortunately,
6245 earlier compilers provided no way of distinguishing ILP32 objects
6246 from LP64 objects, so if there's any doubt, we should assume that
6247 the official LP64 form is being used. */
6248 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6249 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6255 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6257 case E_H8_MACH_H8300
:
6258 case E_H8_MACH_H8300HN
:
6259 case E_H8_MACH_H8300SN
:
6260 case E_H8_MACH_H8300SXN
:
6263 case E_H8_MACH_H8300H
:
6264 case E_H8_MACH_H8300S
:
6265 case E_H8_MACH_H8300SX
:
6273 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6275 case EF_M32C_CPU_M16C
:
6282 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6285 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6286 if (section->sh_entsize != expected_entsize) \
6289 sprintf_vma (buf, section->sh_entsize); \
6290 /* Note: coded this way so that there is a single string for \
6292 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6293 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6294 (unsigned) expected_entsize); \
6295 section->sh_entsize = expected_entsize; \
6300 #define CHECK_ENTSIZE(section, i, type) \
6301 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6302 sizeof (Elf64_External_##type))
6304 for (i
= 0, section
= filedata
->section_headers
;
6305 i
< filedata
->file_header
.e_shnum
;
6308 char * name
= SECTION_NAME (section
);
6310 /* Run some sanity checks on the headers and
6311 possibly fill in some file data as well. */
6312 switch (section
->sh_type
)
6315 if (filedata
->dynamic_symbols
!= NULL
)
6317 error (_("File contains multiple dynamic symbol tables\n"));
6321 CHECK_ENTSIZE (section
, i
, Sym
);
6322 filedata
->dynamic_symbols
6323 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6324 filedata
->dynamic_symtab_section
= section
;
6328 if (streq (name
, ".dynstr"))
6330 if (filedata
->dynamic_strings
!= NULL
)
6332 error (_("File contains multiple dynamic string tables\n"));
6336 filedata
->dynamic_strings
6337 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6338 1, section
->sh_size
, _("dynamic strings"));
6339 filedata
->dynamic_strings_length
6340 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6341 filedata
->dynamic_strtab_section
= section
;
6345 case SHT_SYMTAB_SHNDX
:
6347 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6349 entry
->hdr
= section
;
6350 entry
->next
= filedata
->symtab_shndx_list
;
6351 filedata
->symtab_shndx_list
= entry
;
6356 CHECK_ENTSIZE (section
, i
, Sym
);
6360 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6364 CHECK_ENTSIZE (section
, i
, Rel
);
6365 if (do_checks
&& section
->sh_size
== 0)
6366 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6370 CHECK_ENTSIZE (section
, i
, Rela
);
6371 if (do_checks
&& section
->sh_size
== 0)
6372 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6377 /* Having a zero sized section is not illegal according to the
6378 ELF standard, but it might be an indication that something
6379 is wrong. So issue a warning if we are running in lint mode. */
6380 if (do_checks
&& section
->sh_size
== 0)
6381 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6388 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6389 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6390 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6391 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6392 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6393 && (const_strneq (name
, ".debug_")
6394 || const_strneq (name
, ".zdebug_")))
6397 name
+= sizeof (".zdebug_") - 1;
6399 name
+= sizeof (".debug_") - 1;
6402 || (do_debug_info
&& const_strneq (name
, "info"))
6403 || (do_debug_info
&& const_strneq (name
, "types"))
6404 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6405 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6406 || (do_debug_lines
&& const_strneq (name
, "line."))
6407 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6408 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6409 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6410 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6411 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6412 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6413 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6414 || (do_debug_frames
&& const_strneq (name
, "frame"))
6415 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6416 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6417 || (do_debug_str
&& const_strneq (name
, "str"))
6418 || (do_debug_loc
&& const_strneq (name
, "loc"))
6419 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6420 || (do_debug_addr
&& const_strneq (name
, "addr"))
6421 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6422 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6424 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6426 /* Linkonce section to be combined with .debug_info at link time. */
6427 else if ((do_debugging
|| do_debug_info
)
6428 && const_strneq (name
, ".gnu.linkonce.wi."))
6429 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6430 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6431 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6432 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6433 || streq (name
, ".debug_names")))
6434 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6435 /* Trace sections for Itanium VMS. */
6436 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6437 || do_trace_aranges
)
6438 && const_strneq (name
, ".trace_"))
6440 name
+= sizeof (".trace_") - 1;
6443 || (do_trace_info
&& streq (name
, "info"))
6444 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6445 || (do_trace_aranges
&& streq (name
, "aranges"))
6447 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6449 else if ((do_debugging
|| do_debug_links
)
6450 && (const_strneq (name
, ".gnu_debuglink")
6451 || const_strneq (name
, ".gnu_debugaltlink")))
6452 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6458 if (filedata
->file_header
.e_shnum
> 1)
6459 printf (_("\nSection Headers:\n"));
6461 printf (_("\nSection Header:\n"));
6465 if (do_section_details
)
6467 printf (_(" [Nr] Name\n"));
6468 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6472 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6476 if (do_section_details
)
6478 printf (_(" [Nr] Name\n"));
6479 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6483 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6487 if (do_section_details
)
6489 printf (_(" [Nr] Name\n"));
6490 printf (_(" Type Address Offset Link\n"));
6491 printf (_(" Size EntSize Info Align\n"));
6495 printf (_(" [Nr] Name Type Address Offset\n"));
6496 printf (_(" Size EntSize Flags Link Info Align\n"));
6500 if (do_section_details
)
6501 printf (_(" Flags\n"));
6503 for (i
= 0, section
= filedata
->section_headers
;
6504 i
< filedata
->file_header
.e_shnum
;
6507 /* Run some sanity checks on the section header. */
6509 /* Check the sh_link field. */
6510 switch (section
->sh_type
)
6514 if (section
->sh_link
== 0
6515 && (filedata
->file_header
.e_type
== ET_EXEC
6516 || filedata
->file_header
.e_type
== ET_DYN
))
6517 /* A dynamic relocation section where all entries use a
6518 zero symbol index need not specify a symtab section. */
6521 case SHT_SYMTAB_SHNDX
:
6525 case SHT_GNU_versym
:
6526 if (section
->sh_link
== 0
6527 || section
->sh_link
>= filedata
->file_header
.e_shnum
6528 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6529 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6530 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6531 i
, section
->sh_link
);
6537 case SHT_GNU_verneed
:
6538 case SHT_GNU_verdef
:
6539 case SHT_GNU_LIBLIST
:
6540 if (section
->sh_link
== 0
6541 || section
->sh_link
>= filedata
->file_header
.e_shnum
6542 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6543 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6544 i
, section
->sh_link
);
6547 case SHT_INIT_ARRAY
:
6548 case SHT_FINI_ARRAY
:
6549 case SHT_PREINIT_ARRAY
:
6550 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6551 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6552 i
, section
->sh_link
);
6556 /* FIXME: Add support for target specific section types. */
6557 #if 0 /* Currently we do not check other section types as there are too
6558 many special cases. Stab sections for example have a type
6559 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6561 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6562 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6563 i
, section
->sh_link
);
6568 /* Check the sh_info field. */
6569 switch (section
->sh_type
)
6573 if (section
->sh_info
== 0
6574 && (filedata
->file_header
.e_type
== ET_EXEC
6575 || filedata
->file_header
.e_type
== ET_DYN
))
6576 /* Dynamic relocations apply to segments, so they do not
6577 need to specify the section they relocate. */
6579 if (section
->sh_info
== 0
6580 || section
->sh_info
>= filedata
->file_header
.e_shnum
6581 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6582 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6583 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6584 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6585 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6586 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6587 /* FIXME: Are other section types valid ? */
6588 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6589 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6590 i
, section
->sh_info
);
6595 case SHT_SYMTAB_SHNDX
:
6596 case SHT_INIT_ARRAY
:
6597 case SHT_FINI_ARRAY
:
6598 case SHT_PREINIT_ARRAY
:
6599 if (section
->sh_info
!= 0)
6600 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6601 i
, section
->sh_info
);
6607 /* A symbol index - we assume that it is valid. */
6611 /* FIXME: Add support for target specific section types. */
6612 if (section
->sh_type
== SHT_NOBITS
)
6613 /* NOBITS section headers with non-zero sh_info fields can be
6614 created when a binary is stripped of everything but its debug
6615 information. The stripped sections have their headers
6616 preserved but their types set to SHT_NOBITS. So do not check
6617 this type of section. */
6619 else if (section
->sh_flags
& SHF_INFO_LINK
)
6621 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6622 warn (_("[%2u]: Expected link to another section in info field"), i
);
6624 else if (section
->sh_type
< SHT_LOOS
6625 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6626 && section
->sh_info
!= 0)
6627 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6628 i
, section
->sh_info
);
6632 /* Check the sh_size field. */
6633 if (section
->sh_size
> filedata
->file_size
6634 && section
->sh_type
!= SHT_NOBITS
6635 && section
->sh_type
!= SHT_NULL
6636 && section
->sh_type
< SHT_LOOS
)
6637 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6639 printf (" [%2u] ", i
);
6640 if (do_section_details
)
6641 printf ("%s\n ", printable_section_name (filedata
, section
));
6643 print_symbol (-17, SECTION_NAME (section
));
6645 printf (do_wide
? " %-15s " : " %-15.15s ",
6646 get_section_type_name (filedata
, section
->sh_type
));
6650 const char * link_too_big
= NULL
;
6652 print_vma (section
->sh_addr
, LONG_HEX
);
6654 printf ( " %6.6lx %6.6lx %2.2lx",
6655 (unsigned long) section
->sh_offset
,
6656 (unsigned long) section
->sh_size
,
6657 (unsigned long) section
->sh_entsize
);
6659 if (do_section_details
)
6660 fputs (" ", stdout
);
6662 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6664 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6667 /* The sh_link value is out of range. Normally this indicates
6668 an error but it can have special values in Solaris binaries. */
6669 switch (filedata
->file_header
.e_machine
)
6676 case EM_OLD_SPARCV9
:
6677 case EM_SPARC32PLUS
:
6680 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6681 link_too_big
= "BEFORE";
6682 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6683 link_too_big
= "AFTER";
6690 if (do_section_details
)
6692 if (link_too_big
!= NULL
&& * link_too_big
)
6693 printf ("<%s> ", link_too_big
);
6695 printf ("%2u ", section
->sh_link
);
6696 printf ("%3u %2lu\n", section
->sh_info
,
6697 (unsigned long) section
->sh_addralign
);
6700 printf ("%2u %3u %2lu\n",
6703 (unsigned long) section
->sh_addralign
);
6705 if (link_too_big
&& ! * link_too_big
)
6706 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6707 i
, section
->sh_link
);
6711 print_vma (section
->sh_addr
, LONG_HEX
);
6713 if ((long) section
->sh_offset
== section
->sh_offset
)
6714 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6718 print_vma (section
->sh_offset
, LONG_HEX
);
6721 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6722 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6726 print_vma (section
->sh_size
, LONG_HEX
);
6729 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6730 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6734 print_vma (section
->sh_entsize
, LONG_HEX
);
6737 if (do_section_details
)
6738 fputs (" ", stdout
);
6740 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6742 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6744 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6745 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6748 print_vma (section
->sh_addralign
, DEC
);
6752 else if (do_section_details
)
6755 print_vma (section
->sh_addr
, LONG_HEX
);
6756 if ((long) section
->sh_offset
== section
->sh_offset
)
6757 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6761 print_vma (section
->sh_offset
, LONG_HEX
);
6763 printf (" %u\n ", section
->sh_link
);
6764 print_vma (section
->sh_size
, LONG_HEX
);
6766 print_vma (section
->sh_entsize
, LONG_HEX
);
6768 printf (" %-16u %lu\n",
6770 (unsigned long) section
->sh_addralign
);
6775 print_vma (section
->sh_addr
, LONG_HEX
);
6776 if ((long) section
->sh_offset
== section
->sh_offset
)
6777 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6781 print_vma (section
->sh_offset
, LONG_HEX
);
6784 print_vma (section
->sh_size
, LONG_HEX
);
6786 print_vma (section
->sh_entsize
, LONG_HEX
);
6788 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6790 printf (" %2u %3u %lu\n",
6793 (unsigned long) section
->sh_addralign
);
6796 if (do_section_details
)
6798 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6799 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6801 /* Minimum section size is 12 bytes for 32-bit compression
6802 header + 12 bytes for compressed data header. */
6803 unsigned char buf
[24];
6805 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6806 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6807 sizeof (buf
), _("compression header")))
6809 Elf_Internal_Chdr chdr
;
6811 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6812 printf (_(" [<corrupt>]\n"));
6815 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6818 printf (_(" [<unknown>: 0x%x], "),
6820 print_vma (chdr
.ch_size
, LONG_HEX
);
6821 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6828 if (!do_section_details
)
6830 /* The ordering of the letters shown here matches the ordering of the
6831 corresponding SHF_xxx values, and hence the order in which these
6832 letters will be displayed to the user. */
6833 printf (_("Key to Flags:\n\
6834 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6835 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6836 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6837 if (filedata
->file_header
.e_machine
== EM_X86_64
6838 || filedata
->file_header
.e_machine
== EM_L1OM
6839 || filedata
->file_header
.e_machine
== EM_K1OM
)
6840 printf (_("l (large), "));
6841 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6842 printf (_("y (purecode), "));
6843 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6844 printf (_("v (VLE), "));
6845 printf ("p (processor specific)\n");
6852 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6853 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6854 char **strtab
, unsigned long *strtablen
)
6858 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6860 if (*symtab
== NULL
)
6863 if (symsec
->sh_link
!= 0)
6865 Elf_Internal_Shdr
*strsec
;
6867 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6869 error (_("Bad sh_link in symbol table section\n"));
6876 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6878 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6879 1, strsec
->sh_size
, _("string table"));
6880 if (*strtab
== NULL
)
6887 *strtablen
= strsec
->sh_size
;
6893 get_group_flags (unsigned int flags
)
6895 static char buff
[128];
6899 else if (flags
== GRP_COMDAT
)
6902 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6904 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6905 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6906 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6907 ? _("<unknown>") : ""));
6913 process_section_groups (Filedata
* filedata
)
6915 Elf_Internal_Shdr
* section
;
6917 struct group
* group
;
6918 Elf_Internal_Shdr
* symtab_sec
;
6919 Elf_Internal_Shdr
* strtab_sec
;
6920 Elf_Internal_Sym
* symtab
;
6921 unsigned long num_syms
;
6925 /* Don't process section groups unless needed. */
6926 if (!do_unwind
&& !do_section_groups
)
6929 if (filedata
->file_header
.e_shnum
== 0)
6931 if (do_section_groups
)
6932 printf (_("\nThere are no sections to group in this file.\n"));
6937 if (filedata
->section_headers
== NULL
)
6939 error (_("Section headers are not available!\n"));
6940 /* PR 13622: This can happen with a corrupt ELF header. */
6944 filedata
->section_headers_groups
6945 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6946 sizeof (struct group
*));
6948 if (filedata
->section_headers_groups
== NULL
)
6950 error (_("Out of memory reading %u section group headers\n"),
6951 filedata
->file_header
.e_shnum
);
6955 /* Scan the sections for the group section. */
6956 filedata
->group_count
= 0;
6957 for (i
= 0, section
= filedata
->section_headers
;
6958 i
< filedata
->file_header
.e_shnum
;
6960 if (section
->sh_type
== SHT_GROUP
)
6961 filedata
->group_count
++;
6963 if (filedata
->group_count
== 0)
6965 if (do_section_groups
)
6966 printf (_("\nThere are no section groups in this file.\n"));
6971 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
6972 sizeof (struct group
));
6974 if (filedata
->section_groups
== NULL
)
6976 error (_("Out of memory reading %lu groups\n"),
6977 (unsigned long) filedata
->group_count
);
6987 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
6988 i
< filedata
->file_header
.e_shnum
;
6991 if (section
->sh_type
== SHT_GROUP
)
6993 const char * name
= printable_section_name (filedata
, section
);
6994 const char * group_name
;
6995 unsigned char * start
;
6996 unsigned char * indices
;
6997 unsigned int entry
, j
, size
;
6998 Elf_Internal_Shdr
* sec
;
6999 Elf_Internal_Sym
* sym
;
7001 /* Get the symbol table. */
7002 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7003 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7006 error (_("Bad sh_link in group section `%s'\n"), name
);
7010 if (symtab_sec
!= sec
)
7014 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7019 error (_("Corrupt header in group section `%s'\n"), name
);
7023 if (section
->sh_info
>= num_syms
)
7025 error (_("Bad sh_info in group section `%s'\n"), name
);
7029 sym
= symtab
+ section
->sh_info
;
7031 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7033 if (sym
->st_shndx
== 0
7034 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7036 error (_("Bad sh_info in group section `%s'\n"), name
);
7040 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
7048 /* Get the string table. */
7049 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7057 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7062 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7063 1, strtab_sec
->sh_size
,
7065 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7067 group_name
= sym
->st_name
< strtab_size
7068 ? strtab
+ sym
->st_name
: _("<corrupt>");
7071 /* PR 17531: file: loop. */
7072 if (section
->sh_entsize
> section
->sh_size
)
7074 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7075 printable_section_name (filedata
, section
),
7076 (unsigned long) section
->sh_entsize
,
7077 (unsigned long) section
->sh_size
);
7081 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7082 1, section
->sh_size
,
7088 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7089 entry
= byte_get (indices
, 4);
7092 if (do_section_groups
)
7094 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7095 get_group_flags (entry
), i
, name
, group_name
, size
);
7097 printf (_(" [Index] Name\n"));
7100 group
->group_index
= i
;
7102 for (j
= 0; j
< size
; j
++)
7104 struct group_list
* g
;
7106 entry
= byte_get (indices
, 4);
7109 if (entry
>= filedata
->file_header
.e_shnum
)
7111 static unsigned num_group_errors
= 0;
7113 if (num_group_errors
++ < 10)
7115 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7116 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7117 if (num_group_errors
== 10)
7118 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7123 if (filedata
->section_headers_groups
[entry
] != NULL
)
7127 static unsigned num_errs
= 0;
7129 if (num_errs
++ < 10)
7131 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7133 filedata
->section_headers_groups
[entry
]->group_index
);
7135 warn (_("Further error messages about already contained group sections suppressed\n"));
7141 /* Intel C/C++ compiler may put section 0 in a
7142 section group. We just warn it the first time
7143 and ignore it afterwards. */
7144 static bfd_boolean warned
= FALSE
;
7147 error (_("section 0 in group section [%5u]\n"),
7148 filedata
->section_headers_groups
[entry
]->group_index
);
7154 filedata
->section_headers_groups
[entry
] = group
;
7156 if (do_section_groups
)
7158 sec
= filedata
->section_headers
+ entry
;
7159 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7162 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7163 g
->section_index
= entry
;
7164 g
->next
= group
->root
;
7179 /* Data used to display dynamic fixups. */
7181 struct ia64_vms_dynfixup
7183 bfd_vma needed_ident
; /* Library ident number. */
7184 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7185 bfd_vma fixup_needed
; /* Index of the library. */
7186 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7187 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7190 /* Data used to display dynamic relocations. */
7192 struct ia64_vms_dynimgrela
7194 bfd_vma img_rela_cnt
; /* Number of relocations. */
7195 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7198 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7202 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7203 struct ia64_vms_dynfixup
* fixup
,
7204 const char * strtab
,
7205 unsigned int strtab_sz
)
7207 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7209 const char * lib_name
;
7211 imfs
= get_data (NULL
, filedata
,
7212 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7213 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7214 _("dynamic section image fixups"));
7218 if (fixup
->needed
< strtab_sz
)
7219 lib_name
= strtab
+ fixup
->needed
;
7222 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7223 (unsigned long) fixup
->needed
);
7227 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7228 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7230 (_("Seg Offset Type SymVec DataType\n"));
7232 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7237 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7238 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7239 type
= BYTE_GET (imfs
[i
].type
);
7240 rtype
= elf_ia64_reloc_type (type
);
7242 printf (" 0x%08x ", type
);
7244 printf (" %-32s ", rtype
);
7245 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7246 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7253 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7256 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7258 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7261 imrs
= get_data (NULL
, filedata
,
7262 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7263 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7264 _("dynamic section image relocations"));
7268 printf (_("\nImage relocs\n"));
7270 (_("Seg Offset Type Addend Seg Sym Off\n"));
7272 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7277 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7278 printf ("%08" BFD_VMA_FMT
"x ",
7279 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7280 type
= BYTE_GET (imrs
[i
].type
);
7281 rtype
= elf_ia64_reloc_type (type
);
7283 printf ("0x%08x ", type
);
7285 printf ("%-31s ", rtype
);
7286 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7287 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7288 printf ("%08" BFD_VMA_FMT
"x\n",
7289 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7296 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7299 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7301 struct ia64_vms_dynfixup fixup
;
7302 struct ia64_vms_dynimgrela imgrela
;
7303 Elf_Internal_Dyn
*entry
;
7304 bfd_vma strtab_off
= 0;
7305 bfd_vma strtab_sz
= 0;
7306 char *strtab
= NULL
;
7307 bfd_boolean res
= TRUE
;
7309 memset (&fixup
, 0, sizeof (fixup
));
7310 memset (&imgrela
, 0, sizeof (imgrela
));
7312 /* Note: the order of the entries is specified by the OpenVMS specs. */
7313 for (entry
= filedata
->dynamic_section
;
7314 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7317 switch (entry
->d_tag
)
7319 case DT_IA_64_VMS_STRTAB_OFFSET
:
7320 strtab_off
= entry
->d_un
.d_val
;
7323 strtab_sz
= entry
->d_un
.d_val
;
7325 strtab
= get_data (NULL
, filedata
,
7326 filedata
->dynamic_addr
+ strtab_off
,
7327 1, strtab_sz
, _("dynamic string section"));
7332 case DT_IA_64_VMS_NEEDED_IDENT
:
7333 fixup
.needed_ident
= entry
->d_un
.d_val
;
7336 fixup
.needed
= entry
->d_un
.d_val
;
7338 case DT_IA_64_VMS_FIXUP_NEEDED
:
7339 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7341 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7342 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7344 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7345 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7346 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7349 case DT_IA_64_VMS_IMG_RELA_CNT
:
7350 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7352 case DT_IA_64_VMS_IMG_RELA_OFF
:
7353 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7354 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7375 dynamic_relocations
[] =
7377 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7378 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7379 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7382 /* Process the reloc section. */
7385 process_relocs (Filedata
* filedata
)
7387 unsigned long rel_size
;
7388 unsigned long rel_offset
;
7393 if (do_using_dynamic
)
7397 bfd_boolean has_dynamic_reloc
;
7400 has_dynamic_reloc
= FALSE
;
7402 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7404 is_rela
= dynamic_relocations
[i
].rela
;
7405 name
= dynamic_relocations
[i
].name
;
7406 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7407 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7410 has_dynamic_reloc
= TRUE
;
7412 if (is_rela
== UNKNOWN
)
7414 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7415 switch (filedata
->dynamic_info
[DT_PLTREL
])
7429 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7430 name
, rel_offset
, rel_size
);
7432 dump_relocations (filedata
,
7433 offset_from_vma (filedata
, rel_offset
, rel_size
),
7435 filedata
->dynamic_symbols
,
7436 filedata
->num_dynamic_syms
,
7437 filedata
->dynamic_strings
,
7438 filedata
->dynamic_strings_length
,
7439 is_rela
, TRUE
/* is_dynamic */);
7443 if (is_ia64_vms (filedata
))
7444 if (process_ia64_vms_dynamic_relocs (filedata
))
7445 has_dynamic_reloc
= TRUE
;
7447 if (! has_dynamic_reloc
)
7448 printf (_("\nThere are no dynamic relocations in this file.\n"));
7452 Elf_Internal_Shdr
* section
;
7454 bfd_boolean found
= FALSE
;
7456 for (i
= 0, section
= filedata
->section_headers
;
7457 i
< filedata
->file_header
.e_shnum
;
7460 if ( section
->sh_type
!= SHT_RELA
7461 && section
->sh_type
!= SHT_REL
)
7464 rel_offset
= section
->sh_offset
;
7465 rel_size
= section
->sh_size
;
7470 unsigned long num_rela
;
7472 printf (_("\nRelocation section "));
7474 if (filedata
->string_table
== NULL
)
7475 printf ("%d", section
->sh_name
);
7477 printf ("'%s'", printable_section_name (filedata
, section
));
7479 num_rela
= rel_size
/ section
->sh_entsize
;
7480 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7481 " at offset 0x%lx contains %lu entries:\n",
7483 rel_offset
, num_rela
);
7485 is_rela
= section
->sh_type
== SHT_RELA
;
7487 if (section
->sh_link
!= 0
7488 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7490 Elf_Internal_Shdr
* symsec
;
7491 Elf_Internal_Sym
* symtab
;
7492 unsigned long nsyms
;
7493 unsigned long strtablen
= 0;
7494 char * strtab
= NULL
;
7496 symsec
= filedata
->section_headers
+ section
->sh_link
;
7497 if (symsec
->sh_type
!= SHT_SYMTAB
7498 && symsec
->sh_type
!= SHT_DYNSYM
)
7501 if (!get_symtab (filedata
, symsec
,
7502 &symtab
, &nsyms
, &strtab
, &strtablen
))
7505 dump_relocations (filedata
, rel_offset
, rel_size
,
7506 symtab
, nsyms
, strtab
, strtablen
,
7508 symsec
->sh_type
== SHT_DYNSYM
);
7513 dump_relocations (filedata
, rel_offset
, rel_size
,
7514 NULL
, 0, NULL
, 0, is_rela
,
7515 FALSE
/* is_dynamic */);
7523 /* Users sometimes forget the -D option, so try to be helpful. */
7524 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7526 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7528 printf (_("\nThere are no static relocations in this file."));
7529 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7534 if (i
== ARRAY_SIZE (dynamic_relocations
))
7535 printf (_("\nThere are no relocations in this file.\n"));
7542 /* An absolute address consists of a section and an offset. If the
7543 section is NULL, the offset itself is the address, otherwise, the
7544 address equals to LOAD_ADDRESS(section) + offset. */
7548 unsigned short section
;
7552 /* Find the nearest symbol at or below ADDR. Returns the symbol
7553 name, if found, and the offset from the symbol to ADDR. */
7556 find_symbol_for_address (Filedata
* filedata
,
7557 Elf_Internal_Sym
* symtab
,
7558 unsigned long nsyms
,
7559 const char * strtab
,
7560 unsigned long strtab_size
,
7561 struct absaddr addr
,
7562 const char ** symname
,
7565 bfd_vma dist
= 0x100000;
7566 Elf_Internal_Sym
* sym
;
7567 Elf_Internal_Sym
* beg
;
7568 Elf_Internal_Sym
* end
;
7569 Elf_Internal_Sym
* best
= NULL
;
7571 REMOVE_ARCH_BITS (addr
.offset
);
7573 end
= symtab
+ nsyms
;
7579 sym
= beg
+ (end
- beg
) / 2;
7581 value
= sym
->st_value
;
7582 REMOVE_ARCH_BITS (value
);
7584 if (sym
->st_name
!= 0
7585 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7586 && addr
.offset
>= value
7587 && addr
.offset
- value
< dist
)
7590 dist
= addr
.offset
- value
;
7595 if (addr
.offset
< value
)
7603 *symname
= (best
->st_name
>= strtab_size
7604 ? _("<corrupt>") : strtab
+ best
->st_name
);
7610 *offset
= addr
.offset
;
7613 static /* signed */ int
7614 symcmp (const void *p
, const void *q
)
7616 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7617 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7619 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7622 /* Process the unwind section. */
7624 #include "unwind-ia64.h"
7626 struct ia64_unw_table_entry
7628 struct absaddr start
;
7630 struct absaddr info
;
7633 struct ia64_unw_aux_info
7635 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7636 unsigned long table_len
; /* Length of unwind table. */
7637 unsigned char * info
; /* Unwind info. */
7638 unsigned long info_size
; /* Size of unwind info. */
7639 bfd_vma info_addr
; /* Starting address of unwind info. */
7640 bfd_vma seg_base
; /* Starting address of segment. */
7641 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7642 unsigned long nsyms
; /* Number of symbols. */
7643 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7644 unsigned long nfuns
; /* Number of entries in funtab. */
7645 char * strtab
; /* The string table. */
7646 unsigned long strtab_size
; /* Size of string table. */
7650 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7652 struct ia64_unw_table_entry
* tp
;
7653 unsigned long j
, nfuns
;
7655 bfd_boolean res
= TRUE
;
7657 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7658 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7659 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7660 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7662 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7664 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7668 const unsigned char * dp
;
7669 const unsigned char * head
;
7670 const unsigned char * end
;
7671 const char * procname
;
7673 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7674 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7676 fputs ("\n<", stdout
);
7680 fputs (procname
, stdout
);
7683 printf ("+%lx", (unsigned long) offset
);
7686 fputs (">: [", stdout
);
7687 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7688 fputc ('-', stdout
);
7689 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7690 printf ("], info at +0x%lx\n",
7691 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7693 /* PR 17531: file: 86232b32. */
7694 if (aux
->info
== NULL
)
7697 offset
= tp
->info
.offset
;
7698 if (tp
->info
.section
)
7700 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7702 warn (_("Invalid section %u in table entry %ld\n"),
7703 tp
->info
.section
, (long) (tp
- aux
->table
));
7707 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7709 offset
-= aux
->info_addr
;
7710 /* PR 17531: file: 0997b4d1. */
7711 if (offset
>= aux
->info_size
7712 || aux
->info_size
- offset
< 8)
7714 warn (_("Invalid offset %lx in table entry %ld\n"),
7715 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7720 head
= aux
->info
+ offset
;
7721 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7723 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7724 (unsigned) UNW_VER (stamp
),
7725 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7726 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7727 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7728 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7730 if (UNW_VER (stamp
) != 1)
7732 printf (_("\tUnknown version.\n"));
7737 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7738 /* PR 17531: file: 16ceda89. */
7739 if (end
> aux
->info
+ aux
->info_size
)
7740 end
= aux
->info
+ aux
->info_size
;
7741 for (dp
= head
+ 8; dp
< end
;)
7742 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7751 slurp_ia64_unwind_table (Filedata
* filedata
,
7752 struct ia64_unw_aux_info
* aux
,
7753 Elf_Internal_Shdr
* sec
)
7755 unsigned long size
, nrelas
, i
;
7756 Elf_Internal_Phdr
* seg
;
7757 struct ia64_unw_table_entry
* tep
;
7758 Elf_Internal_Shdr
* relsec
;
7759 Elf_Internal_Rela
* rela
;
7760 Elf_Internal_Rela
* rp
;
7761 unsigned char * table
;
7763 Elf_Internal_Sym
* sym
;
7764 const char * relname
;
7768 /* First, find the starting address of the segment that includes
7771 if (filedata
->file_header
.e_phnum
)
7773 if (! get_program_headers (filedata
))
7776 for (seg
= filedata
->program_headers
;
7777 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7780 if (seg
->p_type
!= PT_LOAD
)
7783 if (sec
->sh_addr
>= seg
->p_vaddr
7784 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7786 aux
->seg_base
= seg
->p_vaddr
;
7792 /* Second, build the unwind table from the contents of the unwind section: */
7793 size
= sec
->sh_size
;
7794 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7799 aux
->table_len
= size
/ (3 * eh_addr_size
);
7800 aux
->table
= (struct ia64_unw_table_entry
*)
7801 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7804 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7806 tep
->start
.section
= SHN_UNDEF
;
7807 tep
->end
.section
= SHN_UNDEF
;
7808 tep
->info
.section
= SHN_UNDEF
;
7809 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7810 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7811 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7812 tep
->start
.offset
+= aux
->seg_base
;
7813 tep
->end
.offset
+= aux
->seg_base
;
7814 tep
->info
.offset
+= aux
->seg_base
;
7818 /* Third, apply any relocations to the unwind table: */
7819 for (relsec
= filedata
->section_headers
;
7820 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7823 if (relsec
->sh_type
!= SHT_RELA
7824 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7825 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7828 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7837 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7839 unsigned int sym_ndx
;
7840 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7841 relname
= elf_ia64_reloc_type (r_type
);
7843 /* PR 17531: file: 9fa67536. */
7844 if (relname
== NULL
)
7846 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7850 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7852 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7856 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7858 /* PR 17531: file: 5bc8d9bf. */
7859 if (i
>= aux
->table_len
)
7861 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7865 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7866 if (sym_ndx
>= aux
->nsyms
)
7868 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7872 sym
= aux
->symtab
+ sym_ndx
;
7874 switch (rp
->r_offset
/ eh_addr_size
% 3)
7877 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7878 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7881 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7882 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7885 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7886 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7900 ia64_process_unwind (Filedata
* filedata
)
7902 Elf_Internal_Shdr
* sec
;
7903 Elf_Internal_Shdr
* unwsec
= NULL
;
7904 unsigned long i
, unwcount
= 0, unwstart
= 0;
7905 struct ia64_unw_aux_info aux
;
7906 bfd_boolean res
= TRUE
;
7908 memset (& aux
, 0, sizeof (aux
));
7910 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7912 if (sec
->sh_type
== SHT_SYMTAB
)
7916 error (_("Multiple symbol tables encountered\n"));
7922 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7923 &aux
.strtab
, &aux
.strtab_size
))
7926 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7931 printf (_("\nThere are no unwind sections in this file.\n"));
7933 while (unwcount
-- > 0)
7938 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7939 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7940 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7945 /* We have already counted the number of SHT_IA64_UNWIND
7946 sections so the loop above should never fail. */
7947 assert (unwsec
!= NULL
);
7950 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7952 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7954 /* We need to find which section group it is in. */
7955 struct group_list
* g
;
7957 if (filedata
->section_headers_groups
== NULL
7958 || filedata
->section_headers_groups
[i
] == NULL
)
7959 i
= filedata
->file_header
.e_shnum
;
7962 g
= filedata
->section_headers_groups
[i
]->root
;
7964 for (; g
!= NULL
; g
= g
->next
)
7966 sec
= filedata
->section_headers
+ g
->section_index
;
7968 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7973 i
= filedata
->file_header
.e_shnum
;
7976 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7978 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7979 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7980 suffix
= SECTION_NAME (unwsec
) + len
;
7981 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7983 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7984 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7989 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7990 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7991 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7992 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7994 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7995 suffix
= SECTION_NAME (unwsec
) + len
;
7996 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7998 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7999 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8003 if (i
== filedata
->file_header
.e_shnum
)
8005 printf (_("\nCould not find unwind info section for "));
8007 if (filedata
->string_table
== NULL
)
8008 printf ("%d", unwsec
->sh_name
);
8010 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8014 aux
.info_addr
= sec
->sh_addr
;
8015 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8018 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8020 printf (_("\nUnwind section "));
8022 if (filedata
->string_table
== NULL
)
8023 printf ("%d", unwsec
->sh_name
);
8025 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8027 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8028 (unsigned long) unwsec
->sh_offset
,
8029 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8031 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8032 && aux
.table_len
> 0)
8033 dump_ia64_unwind (filedata
, & aux
);
8035 free ((char *) aux
.table
);
8036 free ((char *) aux
.info
);
8043 free ((char *) aux
.strtab
);
8048 struct hppa_unw_table_entry
8050 struct absaddr start
;
8052 unsigned int Cannot_unwind
:1; /* 0 */
8053 unsigned int Millicode
:1; /* 1 */
8054 unsigned int Millicode_save_sr0
:1; /* 2 */
8055 unsigned int Region_description
:2; /* 3..4 */
8056 unsigned int reserved1
:1; /* 5 */
8057 unsigned int Entry_SR
:1; /* 6 */
8058 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8059 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8060 unsigned int Args_stored
:1; /* 16 */
8061 unsigned int Variable_Frame
:1; /* 17 */
8062 unsigned int Separate_Package_Body
:1; /* 18 */
8063 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8064 unsigned int Stack_Overflow_Check
:1; /* 20 */
8065 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8066 unsigned int Ada_Region
:1; /* 22 */
8067 unsigned int cxx_info
:1; /* 23 */
8068 unsigned int cxx_try_catch
:1; /* 24 */
8069 unsigned int sched_entry_seq
:1; /* 25 */
8070 unsigned int reserved2
:1; /* 26 */
8071 unsigned int Save_SP
:1; /* 27 */
8072 unsigned int Save_RP
:1; /* 28 */
8073 unsigned int Save_MRP_in_frame
:1; /* 29 */
8074 unsigned int extn_ptr_defined
:1; /* 30 */
8075 unsigned int Cleanup_defined
:1; /* 31 */
8077 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8078 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8079 unsigned int Large_frame
:1; /* 2 */
8080 unsigned int Pseudo_SP_Set
:1; /* 3 */
8081 unsigned int reserved4
:1; /* 4 */
8082 unsigned int Total_frame_size
:27; /* 5..31 */
8085 struct hppa_unw_aux_info
8087 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8088 unsigned long table_len
; /* Length of unwind table. */
8089 bfd_vma seg_base
; /* Starting address of segment. */
8090 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8091 unsigned long nsyms
; /* Number of symbols. */
8092 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8093 unsigned long nfuns
; /* Number of entries in funtab. */
8094 char * strtab
; /* The string table. */
8095 unsigned long strtab_size
; /* Size of string table. */
8099 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8101 struct hppa_unw_table_entry
* tp
;
8102 unsigned long j
, nfuns
;
8103 bfd_boolean res
= TRUE
;
8105 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8106 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8107 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8108 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8110 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8112 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8115 const char * procname
;
8117 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8118 aux
->strtab_size
, tp
->start
, &procname
,
8121 fputs ("\n<", stdout
);
8125 fputs (procname
, stdout
);
8128 printf ("+%lx", (unsigned long) offset
);
8131 fputs (">: [", stdout
);
8132 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8133 fputc ('-', stdout
);
8134 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8137 #define PF(_m) if (tp->_m) printf (#_m " ");
8138 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8141 PF(Millicode_save_sr0
);
8142 /* PV(Region_description); */
8148 PF(Separate_Package_Body
);
8149 PF(Frame_Extension_Millicode
);
8150 PF(Stack_Overflow_Check
);
8151 PF(Two_Instruction_SP_Increment
);
8155 PF(sched_entry_seq
);
8158 PF(Save_MRP_in_frame
);
8159 PF(extn_ptr_defined
);
8160 PF(Cleanup_defined
);
8161 PF(MPE_XL_interrupt_marker
);
8162 PF(HP_UX_interrupt_marker
);
8165 PV(Total_frame_size
);
8178 slurp_hppa_unwind_table (Filedata
* filedata
,
8179 struct hppa_unw_aux_info
* aux
,
8180 Elf_Internal_Shdr
* sec
)
8182 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8183 Elf_Internal_Phdr
* seg
;
8184 struct hppa_unw_table_entry
* tep
;
8185 Elf_Internal_Shdr
* relsec
;
8186 Elf_Internal_Rela
* rela
;
8187 Elf_Internal_Rela
* rp
;
8188 unsigned char * table
;
8190 Elf_Internal_Sym
* sym
;
8191 const char * relname
;
8193 /* First, find the starting address of the segment that includes
8195 if (filedata
->file_header
.e_phnum
)
8197 if (! get_program_headers (filedata
))
8200 for (seg
= filedata
->program_headers
;
8201 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8204 if (seg
->p_type
!= PT_LOAD
)
8207 if (sec
->sh_addr
>= seg
->p_vaddr
8208 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8210 aux
->seg_base
= seg
->p_vaddr
;
8216 /* Second, build the unwind table from the contents of the unwind
8218 size
= sec
->sh_size
;
8219 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8225 nentries
= size
/ unw_ent_size
;
8226 size
= unw_ent_size
* nentries
;
8228 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8229 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8231 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8233 unsigned int tmp1
, tmp2
;
8235 tep
->start
.section
= SHN_UNDEF
;
8236 tep
->end
.section
= SHN_UNDEF
;
8238 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8239 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8240 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8241 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8243 tep
->start
.offset
+= aux
->seg_base
;
8244 tep
->end
.offset
+= aux
->seg_base
;
8246 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8247 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8248 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8249 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8250 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8251 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8252 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8253 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8254 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8255 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8256 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8257 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8258 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8259 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8260 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8261 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8262 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8263 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8264 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8265 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8266 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8267 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8268 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8269 tep
->Cleanup_defined
= tmp1
& 0x1;
8271 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8272 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8273 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8274 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8275 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8276 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8280 /* Third, apply any relocations to the unwind table. */
8281 for (relsec
= filedata
->section_headers
;
8282 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8285 if (relsec
->sh_type
!= SHT_RELA
8286 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8287 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8290 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8294 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8296 unsigned int sym_ndx
;
8297 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8298 relname
= elf_hppa_reloc_type (r_type
);
8300 if (relname
== NULL
)
8302 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8306 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8307 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8309 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8313 i
= rp
->r_offset
/ unw_ent_size
;
8314 if (i
>= aux
->table_len
)
8316 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8320 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8321 if (sym_ndx
>= aux
->nsyms
)
8323 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8327 sym
= aux
->symtab
+ sym_ndx
;
8329 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8332 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8333 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8336 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8337 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8347 aux
->table_len
= nentries
;
8353 hppa_process_unwind (Filedata
* filedata
)
8355 struct hppa_unw_aux_info aux
;
8356 Elf_Internal_Shdr
* unwsec
= NULL
;
8357 Elf_Internal_Shdr
* sec
;
8359 bfd_boolean res
= TRUE
;
8361 if (filedata
->string_table
== NULL
)
8364 memset (& aux
, 0, sizeof (aux
));
8366 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8368 if (sec
->sh_type
== SHT_SYMTAB
)
8372 error (_("Multiple symbol tables encountered\n"));
8378 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8379 &aux
.strtab
, &aux
.strtab_size
))
8382 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8387 printf (_("\nThere are no unwind sections in this file.\n"));
8389 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8391 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8393 unsigned long num_unwind
= sec
->sh_size
/ 16;
8395 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8396 "contains %lu entry:\n",
8397 "\nUnwind section '%s' at offset 0x%lx "
8398 "contains %lu entries:\n",
8400 printable_section_name (filedata
, sec
),
8401 (unsigned long) sec
->sh_offset
,
8404 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8407 if (res
&& aux
.table_len
> 0)
8409 if (! dump_hppa_unwind (filedata
, &aux
))
8413 free ((char *) aux
.table
);
8419 free ((char *) aux
.strtab
);
8426 unsigned char * data
; /* The unwind data. */
8427 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8428 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8429 unsigned long nrelas
; /* The number of relocations. */
8430 unsigned int rel_type
; /* REL or RELA ? */
8431 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8434 struct arm_unw_aux_info
8436 Filedata
* filedata
; /* The file containing the unwind sections. */
8437 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8438 unsigned long nsyms
; /* Number of symbols. */
8439 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8440 unsigned long nfuns
; /* Number of these symbols. */
8441 char * strtab
; /* The file's string table. */
8442 unsigned long strtab_size
; /* Size of string table. */
8446 arm_print_vma_and_name (Filedata
* filedata
,
8447 struct arm_unw_aux_info
* aux
,
8449 struct absaddr addr
)
8451 const char *procname
;
8454 if (addr
.section
== SHN_UNDEF
)
8457 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8458 aux
->strtab_size
, addr
, &procname
,
8461 print_vma (fn
, PREFIX_HEX
);
8465 fputs (" <", stdout
);
8466 fputs (procname
, stdout
);
8469 printf ("+0x%lx", (unsigned long) sym_offset
);
8470 fputc ('>', stdout
);
8477 arm_free_section (struct arm_section
*arm_sec
)
8479 free (arm_sec
->data
);
8480 free (arm_sec
->rela
);
8483 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8484 cached section and install SEC instead.
8485 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8486 and return its valued in * WORDP, relocating if necessary.
8487 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8488 relocation's offset in ADDR.
8489 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8490 into the string table of the symbol associated with the reloc. If no
8491 reloc was applied store -1 there.
8492 5) Return TRUE upon success, FALSE otherwise. */
8495 get_unwind_section_word (Filedata
* filedata
,
8496 struct arm_unw_aux_info
* aux
,
8497 struct arm_section
* arm_sec
,
8498 Elf_Internal_Shdr
* sec
,
8499 bfd_vma word_offset
,
8500 unsigned int * wordp
,
8501 struct absaddr
* addr
,
8504 Elf_Internal_Rela
*rp
;
8505 Elf_Internal_Sym
*sym
;
8506 const char * relname
;
8508 bfd_boolean wrapped
;
8510 if (sec
== NULL
|| arm_sec
== NULL
)
8513 addr
->section
= SHN_UNDEF
;
8516 if (sym_name
!= NULL
)
8517 *sym_name
= (bfd_vma
) -1;
8519 /* If necessary, update the section cache. */
8520 if (sec
!= arm_sec
->sec
)
8522 Elf_Internal_Shdr
*relsec
;
8524 arm_free_section (arm_sec
);
8527 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8528 sec
->sh_size
, _("unwind data"));
8529 arm_sec
->rela
= NULL
;
8530 arm_sec
->nrelas
= 0;
8532 for (relsec
= filedata
->section_headers
;
8533 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8536 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8537 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8538 /* PR 15745: Check the section type as well. */
8539 || (relsec
->sh_type
!= SHT_REL
8540 && relsec
->sh_type
!= SHT_RELA
))
8543 arm_sec
->rel_type
= relsec
->sh_type
;
8544 if (relsec
->sh_type
== SHT_REL
)
8546 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8548 & arm_sec
->rela
, & arm_sec
->nrelas
))
8551 else /* relsec->sh_type == SHT_RELA */
8553 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8555 & arm_sec
->rela
, & arm_sec
->nrelas
))
8561 arm_sec
->next_rela
= arm_sec
->rela
;
8564 /* If there is no unwind data we can do nothing. */
8565 if (arm_sec
->data
== NULL
)
8568 /* If the offset is invalid then fail. */
8569 if (/* PR 21343 *//* PR 18879 */
8571 || word_offset
> (sec
->sh_size
- 4)
8572 || ((bfd_signed_vma
) word_offset
) < 0)
8575 /* Get the word at the required offset. */
8576 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8578 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8579 if (arm_sec
->rela
== NULL
)
8585 /* Look through the relocs to find the one that applies to the provided offset. */
8587 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8589 bfd_vma prelval
, offset
;
8591 if (rp
->r_offset
> word_offset
&& !wrapped
)
8596 if (rp
->r_offset
> word_offset
)
8599 if (rp
->r_offset
& 3)
8601 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8602 (unsigned long) rp
->r_offset
);
8606 if (rp
->r_offset
< word_offset
)
8609 /* PR 17531: file: 027-161405-0.004 */
8610 if (aux
->symtab
== NULL
)
8613 if (arm_sec
->rel_type
== SHT_REL
)
8615 offset
= word
& 0x7fffffff;
8616 if (offset
& 0x40000000)
8617 offset
|= ~ (bfd_vma
) 0x7fffffff;
8619 else if (arm_sec
->rel_type
== SHT_RELA
)
8620 offset
= rp
->r_addend
;
8623 error (_("Unknown section relocation type %d encountered\n"),
8628 /* PR 17531 file: 027-1241568-0.004. */
8629 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8631 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8632 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8636 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8637 offset
+= sym
->st_value
;
8638 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8640 /* Check that we are processing the expected reloc type. */
8641 if (filedata
->file_header
.e_machine
== EM_ARM
)
8643 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8644 if (relname
== NULL
)
8646 warn (_("Skipping unknown ARM relocation type: %d\n"),
8647 (int) ELF32_R_TYPE (rp
->r_info
));
8651 if (streq (relname
, "R_ARM_NONE"))
8654 if (! streq (relname
, "R_ARM_PREL31"))
8656 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8660 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8662 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8663 if (relname
== NULL
)
8665 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8666 (int) ELF32_R_TYPE (rp
->r_info
));
8670 if (streq (relname
, "R_C6000_NONE"))
8673 if (! streq (relname
, "R_C6000_PREL31"))
8675 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8683 /* This function currently only supports ARM and TI unwinders. */
8684 warn (_("Only TI and ARM unwinders are currently supported\n"));
8688 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8689 addr
->section
= sym
->st_shndx
;
8690 addr
->offset
= offset
;
8693 * sym_name
= sym
->st_name
;
8698 arm_sec
->next_rela
= rp
;
8703 static const char *tic6x_unwind_regnames
[16] =
8705 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8706 "A14", "A13", "A12", "A11", "A10",
8707 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8711 decode_tic6x_unwind_regmask (unsigned int mask
)
8715 for (i
= 12; mask
; mask
>>= 1, i
--)
8719 fputs (tic6x_unwind_regnames
[i
], stdout
);
8721 fputs (", ", stdout
);
8727 if (remaining == 0 && more_words) \
8730 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8731 data_offset, & word, & addr, NULL)) \
8737 #define GET_OP(OP) \
8742 (OP) = word >> 24; \
8747 printf (_("[Truncated opcode]\n")); \
8750 printf ("0x%02x ", OP)
8753 decode_arm_unwind_bytecode (Filedata
* filedata
,
8754 struct arm_unw_aux_info
* aux
,
8756 unsigned int remaining
,
8757 unsigned int more_words
,
8758 bfd_vma data_offset
,
8759 Elf_Internal_Shdr
* data_sec
,
8760 struct arm_section
* data_arm_sec
)
8762 struct absaddr addr
;
8763 bfd_boolean res
= TRUE
;
8765 /* Decode the unwinding instructions. */
8768 unsigned int op
, op2
;
8777 printf (" 0x%02x ", op
);
8779 if ((op
& 0xc0) == 0x00)
8781 int offset
= ((op
& 0x3f) << 2) + 4;
8783 printf (" vsp = vsp + %d", offset
);
8785 else if ((op
& 0xc0) == 0x40)
8787 int offset
= ((op
& 0x3f) << 2) + 4;
8789 printf (" vsp = vsp - %d", offset
);
8791 else if ((op
& 0xf0) == 0x80)
8794 if (op
== 0x80 && op2
== 0)
8795 printf (_("Refuse to unwind"));
8798 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8799 bfd_boolean first
= TRUE
;
8803 for (i
= 0; i
< 12; i
++)
8804 if (mask
& (1 << i
))
8810 printf ("r%d", 4 + i
);
8815 else if ((op
& 0xf0) == 0x90)
8817 if (op
== 0x9d || op
== 0x9f)
8818 printf (_(" [Reserved]"));
8820 printf (" vsp = r%d", op
& 0x0f);
8822 else if ((op
& 0xf0) == 0xa0)
8824 int end
= 4 + (op
& 0x07);
8825 bfd_boolean first
= TRUE
;
8829 for (i
= 4; i
<= end
; i
++)
8845 else if (op
== 0xb0)
8846 printf (_(" finish"));
8847 else if (op
== 0xb1)
8850 if (op2
== 0 || (op2
& 0xf0) != 0)
8851 printf (_("[Spare]"));
8854 unsigned int mask
= op2
& 0x0f;
8855 bfd_boolean first
= TRUE
;
8859 for (i
= 0; i
< 12; i
++)
8860 if (mask
& (1 << i
))
8871 else if (op
== 0xb2)
8873 unsigned char buf
[9];
8874 unsigned int i
, len
;
8875 unsigned long offset
;
8877 for (i
= 0; i
< sizeof (buf
); i
++)
8880 if ((buf
[i
] & 0x80) == 0)
8883 if (i
== sizeof (buf
))
8885 error (_("corrupt change to vsp\n"));
8890 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8891 assert (len
== i
+ 1);
8892 offset
= offset
* 4 + 0x204;
8893 printf ("vsp = vsp + %ld", offset
);
8896 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8898 unsigned int first
, last
;
8905 printf ("pop {D%d", first
);
8907 printf ("-D%d", first
+ last
);
8910 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8912 unsigned int count
= op
& 0x07;
8916 printf ("-D%d", 8 + count
);
8919 else if (op
>= 0xc0 && op
<= 0xc5)
8921 unsigned int count
= op
& 0x07;
8923 printf (" pop {wR10");
8925 printf ("-wR%d", 10 + count
);
8928 else if (op
== 0xc6)
8930 unsigned int first
, last
;
8935 printf ("pop {wR%d", first
);
8937 printf ("-wR%d", first
+ last
);
8940 else if (op
== 0xc7)
8943 if (op2
== 0 || (op2
& 0xf0) != 0)
8944 printf (_("[Spare]"));
8947 unsigned int mask
= op2
& 0x0f;
8948 bfd_boolean first
= TRUE
;
8952 for (i
= 0; i
< 4; i
++)
8953 if (mask
& (1 << i
))
8959 printf ("wCGR%d", i
);
8966 printf (_(" [unsupported opcode]"));
8977 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8978 struct arm_unw_aux_info
* aux
,
8980 unsigned int remaining
,
8981 unsigned int more_words
,
8982 bfd_vma data_offset
,
8983 Elf_Internal_Shdr
* data_sec
,
8984 struct arm_section
* data_arm_sec
)
8986 struct absaddr addr
;
8988 /* Decode the unwinding instructions. */
8991 unsigned int op
, op2
;
9000 printf (" 0x%02x ", op
);
9002 if ((op
& 0xc0) == 0x00)
9004 int offset
= ((op
& 0x3f) << 3) + 8;
9005 printf (" sp = sp + %d", offset
);
9007 else if ((op
& 0xc0) == 0x80)
9010 if (op
== 0x80 && op2
== 0)
9011 printf (_("Refuse to unwind"));
9014 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9016 printf ("pop compact {");
9020 decode_tic6x_unwind_regmask (mask
);
9024 else if ((op
& 0xf0) == 0xc0)
9032 unsigned int offset
;
9036 /* Scan entire instruction first so that GET_OP output is not
9037 interleaved with disassembly. */
9039 for (i
= 0; nregs
< (op
& 0xf); i
++)
9045 regpos
[nregs
].offset
= i
* 2;
9046 regpos
[nregs
].reg
= reg
;
9053 regpos
[nregs
].offset
= i
* 2 + 1;
9054 regpos
[nregs
].reg
= reg
;
9059 printf (_("pop frame {"));
9062 printf (_("*corrupt* - no registers specified"));
9067 for (i
= i
* 2; i
> 0; i
--)
9069 if (regpos
[reg
].offset
== i
- 1)
9071 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9078 fputs (name
, stdout
);
9086 else if (op
== 0xd0)
9087 printf (" MOV FP, SP");
9088 else if (op
== 0xd1)
9089 printf (" __c6xabi_pop_rts");
9090 else if (op
== 0xd2)
9092 unsigned char buf
[9];
9093 unsigned int i
, len
;
9094 unsigned long offset
;
9096 for (i
= 0; i
< sizeof (buf
); i
++)
9099 if ((buf
[i
] & 0x80) == 0)
9102 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9103 if (i
== sizeof (buf
))
9105 warn (_("Corrupt stack pointer adjustment detected\n"));
9109 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9110 assert (len
== i
+ 1);
9111 offset
= offset
* 8 + 0x408;
9112 printf (_("sp = sp + %ld"), offset
);
9114 else if ((op
& 0xf0) == 0xe0)
9116 if ((op
& 0x0f) == 7)
9119 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9123 printf (_(" [unsupported opcode]"));
9132 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9136 offset
= word
& 0x7fffffff;
9137 if (offset
& 0x40000000)
9138 offset
|= ~ (bfd_vma
) 0x7fffffff;
9140 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9143 return offset
+ where
;
9147 decode_arm_unwind (Filedata
* filedata
,
9148 struct arm_unw_aux_info
* aux
,
9150 unsigned int remaining
,
9151 bfd_vma data_offset
,
9152 Elf_Internal_Shdr
* data_sec
,
9153 struct arm_section
* data_arm_sec
)
9156 unsigned int more_words
= 0;
9157 struct absaddr addr
;
9158 bfd_vma sym_name
= (bfd_vma
) -1;
9159 bfd_boolean res
= TRUE
;
9163 /* Fetch the first word.
9164 Note - when decoding an object file the address extracted
9165 here will always be 0. So we also pass in the sym_name
9166 parameter so that we can find the symbol associated with
9167 the personality routine. */
9168 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9169 & word
, & addr
, & sym_name
))
9176 addr
.section
= SHN_UNDEF
;
9180 if ((word
& 0x80000000) == 0)
9182 /* Expand prel31 for personality routine. */
9184 const char *procname
;
9186 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9187 printf (_(" Personality routine: "));
9189 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9190 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9192 procname
= aux
->strtab
+ sym_name
;
9193 print_vma (fn
, PREFIX_HEX
);
9196 fputs (" <", stdout
);
9197 fputs (procname
, stdout
);
9198 fputc ('>', stdout
);
9202 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9203 fputc ('\n', stdout
);
9205 /* The GCC personality routines use the standard compact
9206 encoding, starting with one byte giving the number of
9208 if (procname
!= NULL
9209 && (const_strneq (procname
, "__gcc_personality_v0")
9210 || const_strneq (procname
, "__gxx_personality_v0")
9211 || const_strneq (procname
, "__gcj_personality_v0")
9212 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9219 printf (_(" [Truncated data]\n"));
9222 more_words
= word
>> 24;
9232 /* ARM EHABI Section 6.3:
9234 An exception-handling table entry for the compact model looks like:
9238 1 0 index Data for personalityRoutine[index] */
9240 if (filedata
->file_header
.e_machine
== EM_ARM
9241 && (word
& 0x70000000))
9243 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9247 per_index
= (word
>> 24) & 0x7f;
9248 printf (_(" Compact model index: %d\n"), per_index
);
9255 else if (per_index
< 3)
9257 more_words
= (word
>> 16) & 0xff;
9263 switch (filedata
->file_header
.e_machine
)
9268 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9269 data_offset
, data_sec
, data_arm_sec
))
9274 warn (_("Unknown ARM compact model index encountered\n"));
9275 printf (_(" [reserved]\n"));
9283 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9284 data_offset
, data_sec
, data_arm_sec
))
9287 else if (per_index
< 5)
9289 if (((word
>> 17) & 0x7f) == 0x7f)
9290 printf (_(" Restore stack from frame pointer\n"));
9292 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9293 printf (_(" Registers restored: "));
9295 printf (" (compact) ");
9296 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9298 printf (_(" Return register: %s\n"),
9299 tic6x_unwind_regnames
[word
& 0xf]);
9302 printf (_(" [reserved (%d)]\n"), per_index
);
9306 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9307 filedata
->file_header
.e_machine
);
9311 /* Decode the descriptors. Not implemented. */
9317 dump_arm_unwind (Filedata
* filedata
,
9318 struct arm_unw_aux_info
* aux
,
9319 Elf_Internal_Shdr
* exidx_sec
)
9321 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9322 unsigned int i
, exidx_len
;
9323 unsigned long j
, nfuns
;
9324 bfd_boolean res
= TRUE
;
9326 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9327 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9328 exidx_len
= exidx_sec
->sh_size
/ 8;
9330 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9331 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9332 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9333 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9335 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9337 for (i
= 0; i
< exidx_len
; i
++)
9339 unsigned int exidx_fn
, exidx_entry
;
9340 struct absaddr fn_addr
, entry_addr
;
9343 fputc ('\n', stdout
);
9345 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9346 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9347 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9348 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9351 arm_free_section (& exidx_arm_sec
);
9352 arm_free_section (& extab_arm_sec
);
9356 /* ARM EHABI, Section 5:
9357 An index table entry consists of 2 words.
9358 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9359 if (exidx_fn
& 0x80000000)
9361 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9365 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9367 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9368 fputs (": ", stdout
);
9370 if (exidx_entry
== 1)
9372 print_vma (exidx_entry
, PREFIX_HEX
);
9373 fputs (" [cantunwind]\n", stdout
);
9375 else if (exidx_entry
& 0x80000000)
9377 print_vma (exidx_entry
, PREFIX_HEX
);
9378 fputc ('\n', stdout
);
9379 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9383 bfd_vma table
, table_offset
= 0;
9384 Elf_Internal_Shdr
*table_sec
;
9386 fputs ("@", stdout
);
9387 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9388 print_vma (table
, PREFIX_HEX
);
9391 /* Locate the matching .ARM.extab. */
9392 if (entry_addr
.section
!= SHN_UNDEF
9393 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9395 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9396 table_offset
= entry_addr
.offset
;
9398 if (table_offset
> table_sec
->sh_size
9399 || ((bfd_signed_vma
) table_offset
) < 0)
9401 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9402 (unsigned long) table_offset
,
9403 printable_section_name (filedata
, table_sec
));
9410 table_sec
= find_section_by_address (filedata
, table
);
9411 if (table_sec
!= NULL
)
9412 table_offset
= table
- table_sec
->sh_addr
;
9415 if (table_sec
== NULL
)
9417 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9418 (unsigned long) table
);
9423 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9432 arm_free_section (&exidx_arm_sec
);
9433 arm_free_section (&extab_arm_sec
);
9438 /* Used for both ARM and C6X unwinding tables. */
9441 arm_process_unwind (Filedata
* filedata
)
9443 struct arm_unw_aux_info aux
;
9444 Elf_Internal_Shdr
*unwsec
= NULL
;
9445 Elf_Internal_Shdr
*sec
;
9447 unsigned int sec_type
;
9448 bfd_boolean res
= TRUE
;
9450 switch (filedata
->file_header
.e_machine
)
9453 sec_type
= SHT_ARM_EXIDX
;
9457 sec_type
= SHT_C6000_UNWIND
;
9461 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9462 filedata
->file_header
.e_machine
);
9466 if (filedata
->string_table
== NULL
)
9469 memset (& aux
, 0, sizeof (aux
));
9470 aux
.filedata
= filedata
;
9472 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9474 if (sec
->sh_type
== SHT_SYMTAB
)
9478 error (_("Multiple symbol tables encountered\n"));
9484 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9485 &aux
.strtab
, &aux
.strtab_size
))
9488 else if (sec
->sh_type
== sec_type
)
9493 printf (_("\nThere are no unwind sections in this file.\n"));
9495 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9497 if (sec
->sh_type
== sec_type
)
9499 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9500 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9501 "contains %lu entry:\n",
9502 "\nUnwind section '%s' at offset 0x%lx "
9503 "contains %lu entries:\n",
9505 printable_section_name (filedata
, sec
),
9506 (unsigned long) sec
->sh_offset
,
9509 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9515 free ((char *) aux
.strtab
);
9521 process_unwind (Filedata
* filedata
)
9523 struct unwind_handler
9525 unsigned int machtype
;
9526 bfd_boolean (* handler
)(Filedata
*);
9529 { EM_ARM
, arm_process_unwind
},
9530 { EM_IA_64
, ia64_process_unwind
},
9531 { EM_PARISC
, hppa_process_unwind
},
9532 { EM_TI_C6000
, arm_process_unwind
},
9540 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9541 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9542 return handlers
[i
].handler (filedata
);
9544 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9545 get_machine_name (filedata
->file_header
.e_machine
));
9550 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9552 switch (entry
->d_tag
)
9554 case DT_AARCH64_BTI_PLT
:
9555 case DT_AARCH64_PAC_PLT
:
9558 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9565 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9567 switch (entry
->d_tag
)
9570 if (entry
->d_un
.d_val
== 0)
9574 static const char * opts
[] =
9576 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9577 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9578 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9579 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9583 bfd_boolean first
= TRUE
;
9585 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9586 if (entry
->d_un
.d_val
& (1 << cnt
))
9588 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9594 case DT_MIPS_IVERSION
:
9595 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9596 printf (_("Interface Version: %s"),
9597 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9601 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9602 /* Note: coded this way so that there is a single string for translation. */
9603 printf (_("<corrupt: %s>"), buf
);
9607 case DT_MIPS_TIME_STAMP
:
9611 time_t atime
= entry
->d_un
.d_val
;
9613 tmp
= gmtime (&atime
);
9614 /* PR 17531: file: 6accc532. */
9616 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9618 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9619 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9620 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9621 printf (_("Time Stamp: %s"), timebuf
);
9625 case DT_MIPS_RLD_VERSION
:
9626 case DT_MIPS_LOCAL_GOTNO
:
9627 case DT_MIPS_CONFLICTNO
:
9628 case DT_MIPS_LIBLISTNO
:
9629 case DT_MIPS_SYMTABNO
:
9630 case DT_MIPS_UNREFEXTNO
:
9631 case DT_MIPS_HIPAGENO
:
9632 case DT_MIPS_DELTA_CLASS_NO
:
9633 case DT_MIPS_DELTA_INSTANCE_NO
:
9634 case DT_MIPS_DELTA_RELOC_NO
:
9635 case DT_MIPS_DELTA_SYM_NO
:
9636 case DT_MIPS_DELTA_CLASSSYM_NO
:
9637 case DT_MIPS_COMPACT_SIZE
:
9638 print_vma (entry
->d_un
.d_val
, DEC
);
9642 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9643 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9644 /* Falls through. */
9647 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9653 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9655 switch (entry
->d_tag
)
9657 case DT_HP_DLD_FLAGS
:
9666 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9667 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9668 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9669 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9670 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9671 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9672 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9673 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9674 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9675 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9676 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9677 { DT_HP_GST
, "HP_GST" },
9678 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9679 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9680 { DT_HP_NODELETE
, "HP_NODELETE" },
9681 { DT_HP_GROUP
, "HP_GROUP" },
9682 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9684 bfd_boolean first
= TRUE
;
9686 bfd_vma val
= entry
->d_un
.d_val
;
9688 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9689 if (val
& flags
[cnt
].bit
)
9693 fputs (flags
[cnt
].str
, stdout
);
9695 val
^= flags
[cnt
].bit
;
9698 if (val
!= 0 || first
)
9702 print_vma (val
, HEX
);
9708 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9716 /* VMS vs Unix time offset and factor. */
9718 #define VMS_EPOCH_OFFSET 35067168000000000LL
9719 #define VMS_GRANULARITY_FACTOR 10000000
9721 /* Display a VMS time in a human readable format. */
9724 print_vms_time (bfd_int64_t vmstime
)
9729 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9730 tm
= gmtime (&unxtime
);
9731 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9732 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9733 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9738 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9740 switch (entry
->d_tag
)
9742 case DT_IA_64_PLT_RESERVE
:
9743 /* First 3 slots reserved. */
9744 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9746 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9749 case DT_IA_64_VMS_LINKTIME
:
9751 print_vms_time (entry
->d_un
.d_val
);
9755 case DT_IA_64_VMS_LNKFLAGS
:
9756 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9757 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9758 printf (" CALL_DEBUG");
9759 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9760 printf (" NOP0BUFS");
9761 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9762 printf (" P0IMAGE");
9763 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9764 printf (" MKTHREADS");
9765 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9766 printf (" UPCALLS");
9767 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9769 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9770 printf (" INITIALIZE");
9771 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9773 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9774 printf (" EXE_INIT");
9775 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9776 printf (" TBK_IN_IMG");
9777 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9778 printf (" DBG_IN_IMG");
9779 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9780 printf (" TBK_IN_DSF");
9781 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9782 printf (" DBG_IN_DSF");
9783 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9784 printf (" SIGNATURES");
9785 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9786 printf (" REL_SEG_OFF");
9790 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9797 get_32bit_dynamic_section (Filedata
* filedata
)
9799 Elf32_External_Dyn
* edyn
;
9800 Elf32_External_Dyn
* ext
;
9801 Elf_Internal_Dyn
* entry
;
9803 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9804 filedata
->dynamic_addr
, 1,
9805 filedata
->dynamic_size
,
9806 _("dynamic section"));
9810 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9811 might not have the luxury of section headers. Look for the DT_NULL
9812 terminator to determine the number of entries. */
9813 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9814 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9817 filedata
->dynamic_nent
++;
9818 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9822 filedata
->dynamic_section
9823 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9824 if (filedata
->dynamic_section
== NULL
)
9826 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9827 (unsigned long) filedata
->dynamic_nent
);
9832 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9833 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9836 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9837 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9846 get_64bit_dynamic_section (Filedata
* filedata
)
9848 Elf64_External_Dyn
* edyn
;
9849 Elf64_External_Dyn
* ext
;
9850 Elf_Internal_Dyn
* entry
;
9852 /* Read in the data. */
9853 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9854 filedata
->dynamic_addr
, 1,
9855 filedata
->dynamic_size
,
9856 _("dynamic section"));
9860 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9861 might not have the luxury of section headers. Look for the DT_NULL
9862 terminator to determine the number of entries. */
9863 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9864 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9865 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9868 filedata
->dynamic_nent
++;
9869 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9873 filedata
->dynamic_section
9874 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9875 if (filedata
->dynamic_section
== NULL
)
9877 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9878 (unsigned long) filedata
->dynamic_nent
);
9883 /* Convert from external to internal formats. */
9884 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9885 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9888 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9889 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9898 print_dynamic_flags (bfd_vma flags
)
9900 bfd_boolean first
= TRUE
;
9906 flag
= flags
& - flags
;
9916 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9917 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9918 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9919 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9920 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9921 default: fputs (_("unknown"), stdout
); break;
9928 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9930 unsigned char * e_data
;
9933 /* If the size_t type is smaller than the bfd_size_type, eg because
9934 you are building a 32-bit tool on a 64-bit host, then make sure
9935 that when (number) is cast to (size_t) no information is lost. */
9936 if (sizeof (size_t) < sizeof (bfd_size_type
)
9937 && (bfd_size_type
) ((size_t) number
) != number
)
9939 error (_("Size truncation prevents reading %s elements of size %u\n"),
9940 bfd_vmatoa ("u", number
), ent_size
);
9944 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9945 attempting to allocate memory when the read is bound to fail. */
9946 if (ent_size
* number
> filedata
->file_size
)
9948 error (_("Invalid number of dynamic entries: %s\n"),
9949 bfd_vmatoa ("u", number
));
9953 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9956 error (_("Out of memory reading %s dynamic entries\n"),
9957 bfd_vmatoa ("u", number
));
9961 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9963 error (_("Unable to read in %s bytes of dynamic data\n"),
9964 bfd_vmatoa ("u", number
* ent_size
));
9969 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
9972 error (_("Out of memory allocating space for %s dynamic entries\n"),
9973 bfd_vmatoa ("u", number
));
9979 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9986 static unsigned long
9987 get_num_dynamic_syms (Filedata
* filedata
)
9989 unsigned long num_of_syms
= 0;
9991 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
9994 if (filedata
->dynamic_info
[DT_HASH
])
9996 unsigned char nb
[8];
9997 unsigned char nc
[8];
9998 unsigned int hash_ent_size
= 4;
10000 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10001 || filedata
->file_header
.e_machine
== EM_S390
10002 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10003 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10006 if (fseek (filedata
->handle
,
10007 (filedata
->archive_file_offset
10008 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10009 sizeof nb
+ sizeof nc
)),
10012 error (_("Unable to seek to start of dynamic information\n"));
10016 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10018 error (_("Failed to read in number of buckets\n"));
10022 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10024 error (_("Failed to read in number of chains\n"));
10028 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10029 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10031 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10033 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10035 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10038 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10039 num_of_syms
= filedata
->nchains
;
10042 if (num_of_syms
== 0)
10044 free (filedata
->buckets
);
10045 filedata
->buckets
= NULL
;
10046 free (filedata
->chains
);
10047 filedata
->chains
= NULL
;
10048 filedata
->nbuckets
= 0;
10052 if (filedata
->dynamic_info_DT_GNU_HASH
)
10054 unsigned char nb
[16];
10055 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10056 bfd_vma buckets_vma
;
10059 if (fseek (filedata
->handle
,
10060 (filedata
->archive_file_offset
10061 + offset_from_vma (filedata
,
10062 filedata
->dynamic_info_DT_GNU_HASH
,
10066 error (_("Unable to seek to start of dynamic information\n"));
10070 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10072 error (_("Failed to read in number of buckets\n"));
10076 filedata
->ngnubuckets
= byte_get (nb
, 4);
10077 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10078 bitmaskwords
= byte_get (nb
+ 8, 4);
10079 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10081 buckets_vma
+= bitmaskwords
* 4;
10083 buckets_vma
+= bitmaskwords
* 8;
10085 if (fseek (filedata
->handle
,
10086 (filedata
->archive_file_offset
10087 + offset_from_vma (filedata
, buckets_vma
, 4)),
10090 error (_("Unable to seek to start of dynamic information\n"));
10094 filedata
->gnubuckets
10095 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10097 if (filedata
->gnubuckets
== NULL
)
10100 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10101 if (filedata
->gnubuckets
[i
] != 0)
10103 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10106 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10107 maxchain
= filedata
->gnubuckets
[i
];
10110 if (maxchain
== 0xffffffff)
10113 maxchain
-= filedata
->gnusymidx
;
10115 if (fseek (filedata
->handle
,
10116 (filedata
->archive_file_offset
10117 + offset_from_vma (filedata
,
10118 buckets_vma
+ 4 * (filedata
->ngnubuckets
10123 error (_("Unable to seek to start of dynamic information\n"));
10129 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10131 error (_("Failed to determine last chain length\n"));
10135 if (maxchain
+ 1 == 0)
10140 while ((byte_get (nb
, 4) & 1) == 0);
10142 if (fseek (filedata
->handle
,
10143 (filedata
->archive_file_offset
10144 + offset_from_vma (filedata
, (buckets_vma
10145 + 4 * filedata
->ngnubuckets
),
10149 error (_("Unable to seek to start of dynamic information\n"));
10153 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10154 filedata
->ngnuchains
= maxchain
;
10156 if (filedata
->gnuchains
== NULL
)
10159 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10161 if (fseek (filedata
->handle
,
10162 (filedata
->archive_file_offset
10163 + offset_from_vma (filedata
, (buckets_vma
10164 + 4 * (filedata
->ngnubuckets
10168 error (_("Unable to seek to start of dynamic information\n"));
10172 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10173 if (filedata
->mipsxlat
== NULL
)
10177 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10178 if (filedata
->gnubuckets
[hn
] != 0)
10180 bfd_vma si
= filedata
->gnubuckets
[hn
];
10181 bfd_vma off
= si
- filedata
->gnusymidx
;
10185 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10187 if (off
< filedata
->ngnuchains
10188 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10189 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10193 if (si
>= num_of_syms
)
10194 num_of_syms
= si
+ 1;
10198 while (off
< filedata
->ngnuchains
10199 && (filedata
->gnuchains
[off
++] & 1) == 0);
10202 if (num_of_syms
== 0)
10205 free (filedata
->mipsxlat
);
10206 filedata
->mipsxlat
= NULL
;
10207 free (filedata
->gnuchains
);
10208 filedata
->gnuchains
= NULL
;
10209 free (filedata
->gnubuckets
);
10210 filedata
->gnubuckets
= NULL
;
10211 filedata
->ngnubuckets
= 0;
10212 filedata
->ngnuchains
= 0;
10216 return num_of_syms
;
10219 /* Parse and display the contents of the dynamic section. */
10222 process_dynamic_section (Filedata
* filedata
)
10224 Elf_Internal_Dyn
* entry
;
10226 if (filedata
->dynamic_size
== 0)
10229 printf (_("\nThere is no dynamic section in this file.\n"));
10236 if (! get_32bit_dynamic_section (filedata
))
10241 if (! get_64bit_dynamic_section (filedata
))
10245 /* Find the appropriate symbol table. */
10246 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10248 unsigned long num_of_syms
;
10250 for (entry
= filedata
->dynamic_section
;
10251 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10253 if (entry
->d_tag
== DT_SYMTAB
)
10254 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10255 else if (entry
->d_tag
== DT_SYMENT
)
10256 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10257 else if (entry
->d_tag
== DT_HASH
)
10258 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10259 else if (entry
->d_tag
== DT_GNU_HASH
)
10260 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10261 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10262 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10263 && entry
->d_tag
== DT_MIPS_XHASH
)
10265 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10266 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10269 num_of_syms
= get_num_dynamic_syms (filedata
);
10271 if (num_of_syms
!= 0
10272 && filedata
->dynamic_symbols
== NULL
10273 && filedata
->dynamic_info
[DT_SYMTAB
]
10274 && filedata
->dynamic_info
[DT_SYMENT
])
10276 Elf_Internal_Phdr
*seg
;
10277 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10279 if (! get_program_headers (filedata
))
10281 error (_("Cannot interpret virtual addresses "
10282 "without program headers.\n"));
10286 for (seg
= filedata
->program_headers
;
10287 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10290 if (seg
->p_type
!= PT_LOAD
)
10293 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10295 /* See PR 21379 for a reproducer. */
10296 error (_("Invalid PT_LOAD entry\n"));
10300 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10301 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10303 /* Since we do not know how big the symbol table is,
10304 we default to reading in up to the end of PT_LOAD
10305 segment and processing that. This is overkill, I
10306 know, but it should work. */
10307 Elf_Internal_Shdr section
;
10308 section
.sh_offset
= (vma
- seg
->p_vaddr
10310 section
.sh_size
= (num_of_syms
10311 * filedata
->dynamic_info
[DT_SYMENT
]);
10312 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10315 && filedata
->dynamic_symtab_section
!= NULL
10316 && ((filedata
->dynamic_symtab_section
->sh_offset
10317 != section
.sh_offset
)
10318 || (filedata
->dynamic_symtab_section
->sh_size
10319 != section
.sh_size
)
10320 || (filedata
->dynamic_symtab_section
->sh_entsize
10321 != section
.sh_entsize
)))
10323 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10325 section
.sh_name
= filedata
->string_table_length
;
10326 filedata
->dynamic_symbols
10327 = GET_ELF_SYMBOLS (filedata
, §ion
,
10328 &filedata
->num_dynamic_syms
);
10329 if (filedata
->dynamic_symbols
== NULL
10330 || filedata
->num_dynamic_syms
!= num_of_syms
)
10332 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10341 /* Similarly find a string table. */
10342 if (filedata
->dynamic_strings
== NULL
)
10343 for (entry
= filedata
->dynamic_section
;
10344 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10347 if (entry
->d_tag
== DT_STRTAB
)
10348 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10350 if (entry
->d_tag
== DT_STRSZ
)
10351 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10353 if (filedata
->dynamic_info
[DT_STRTAB
]
10354 && filedata
->dynamic_info
[DT_STRSZ
])
10356 unsigned long offset
;
10357 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10359 offset
= offset_from_vma (filedata
,
10360 filedata
->dynamic_info
[DT_STRTAB
],
10363 && filedata
->dynamic_strtab_section
10364 && ((filedata
->dynamic_strtab_section
->sh_offset
10365 != (file_ptr
) offset
)
10366 || (filedata
->dynamic_strtab_section
->sh_size
10369 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10371 filedata
->dynamic_strings
10372 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10373 _("dynamic string table"));
10374 if (filedata
->dynamic_strings
== NULL
)
10376 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10380 filedata
->dynamic_strings_length
= str_tab_len
;
10385 /* And find the syminfo section if available. */
10386 if (filedata
->dynamic_syminfo
== NULL
)
10388 unsigned long syminsz
= 0;
10390 for (entry
= filedata
->dynamic_section
;
10391 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10394 if (entry
->d_tag
== DT_SYMINENT
)
10396 /* Note: these braces are necessary to avoid a syntax
10397 error from the SunOS4 C compiler. */
10398 /* PR binutils/17531: A corrupt file can trigger this test.
10399 So do not use an assert, instead generate an error message. */
10400 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10401 error (_("Bad value (%d) for SYMINENT entry\n"),
10402 (int) entry
->d_un
.d_val
);
10404 else if (entry
->d_tag
== DT_SYMINSZ
)
10405 syminsz
= entry
->d_un
.d_val
;
10406 else if (entry
->d_tag
== DT_SYMINFO
)
10407 filedata
->dynamic_syminfo_offset
10408 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10411 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10413 Elf_External_Syminfo
* extsyminfo
;
10414 Elf_External_Syminfo
* extsym
;
10415 Elf_Internal_Syminfo
* syminfo
;
10417 /* There is a syminfo section. Read the data. */
10418 extsyminfo
= (Elf_External_Syminfo
*)
10419 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10420 1, syminsz
, _("symbol information"));
10424 if (filedata
->dynamic_syminfo
!= NULL
)
10426 error (_("Multiple dynamic symbol information sections found\n"));
10427 free (filedata
->dynamic_syminfo
);
10429 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10430 if (filedata
->dynamic_syminfo
== NULL
)
10432 error (_("Out of memory allocating %lu bytes "
10433 "for dynamic symbol info\n"),
10434 (unsigned long) syminsz
);
10438 filedata
->dynamic_syminfo_nent
10439 = syminsz
/ sizeof (Elf_External_Syminfo
);
10440 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10441 syminfo
< (filedata
->dynamic_syminfo
10442 + filedata
->dynamic_syminfo_nent
);
10443 ++syminfo
, ++extsym
)
10445 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10446 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10453 if (do_dynamic
&& filedata
->dynamic_addr
)
10454 printf (ngettext ("\nDynamic section at offset 0x%lx "
10455 "contains %lu entry:\n",
10456 "\nDynamic section at offset 0x%lx "
10457 "contains %lu entries:\n",
10458 filedata
->dynamic_nent
),
10459 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10461 printf (_(" Tag Type Name/Value\n"));
10463 for (entry
= filedata
->dynamic_section
;
10464 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10469 const char * dtype
;
10472 print_vma (entry
->d_tag
, FULL_HEX
);
10473 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10474 printf (" (%s)%*s", dtype
,
10475 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10478 switch (entry
->d_tag
)
10482 print_dynamic_flags (entry
->d_un
.d_val
);
10492 switch (entry
->d_tag
)
10495 printf (_("Auxiliary library"));
10499 printf (_("Filter library"));
10503 printf (_("Configuration file"));
10507 printf (_("Dependency audit library"));
10511 printf (_("Audit library"));
10515 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10516 printf (": [%s]\n",
10517 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10521 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10530 printf (_("Flags:"));
10532 if (entry
->d_un
.d_val
== 0)
10533 printf (_(" None\n"));
10536 unsigned long int val
= entry
->d_un
.d_val
;
10538 if (val
& DTF_1_PARINIT
)
10540 printf (" PARINIT");
10541 val
^= DTF_1_PARINIT
;
10543 if (val
& DTF_1_CONFEXP
)
10545 printf (" CONFEXP");
10546 val
^= DTF_1_CONFEXP
;
10549 printf (" %lx", val
);
10558 printf (_("Flags:"));
10560 if (entry
->d_un
.d_val
== 0)
10561 printf (_(" None\n"));
10564 unsigned long int val
= entry
->d_un
.d_val
;
10566 if (val
& DF_P1_LAZYLOAD
)
10568 printf (" LAZYLOAD");
10569 val
^= DF_P1_LAZYLOAD
;
10571 if (val
& DF_P1_GROUPPERM
)
10573 printf (" GROUPPERM");
10574 val
^= DF_P1_GROUPPERM
;
10577 printf (" %lx", val
);
10586 printf (_("Flags:"));
10587 if (entry
->d_un
.d_val
== 0)
10588 printf (_(" None\n"));
10591 unsigned long int val
= entry
->d_un
.d_val
;
10593 if (val
& DF_1_NOW
)
10598 if (val
& DF_1_GLOBAL
)
10600 printf (" GLOBAL");
10601 val
^= DF_1_GLOBAL
;
10603 if (val
& DF_1_GROUP
)
10608 if (val
& DF_1_NODELETE
)
10610 printf (" NODELETE");
10611 val
^= DF_1_NODELETE
;
10613 if (val
& DF_1_LOADFLTR
)
10615 printf (" LOADFLTR");
10616 val
^= DF_1_LOADFLTR
;
10618 if (val
& DF_1_INITFIRST
)
10620 printf (" INITFIRST");
10621 val
^= DF_1_INITFIRST
;
10623 if (val
& DF_1_NOOPEN
)
10625 printf (" NOOPEN");
10626 val
^= DF_1_NOOPEN
;
10628 if (val
& DF_1_ORIGIN
)
10630 printf (" ORIGIN");
10631 val
^= DF_1_ORIGIN
;
10633 if (val
& DF_1_DIRECT
)
10635 printf (" DIRECT");
10636 val
^= DF_1_DIRECT
;
10638 if (val
& DF_1_TRANS
)
10643 if (val
& DF_1_INTERPOSE
)
10645 printf (" INTERPOSE");
10646 val
^= DF_1_INTERPOSE
;
10648 if (val
& DF_1_NODEFLIB
)
10650 printf (" NODEFLIB");
10651 val
^= DF_1_NODEFLIB
;
10653 if (val
& DF_1_NODUMP
)
10655 printf (" NODUMP");
10656 val
^= DF_1_NODUMP
;
10658 if (val
& DF_1_CONFALT
)
10660 printf (" CONFALT");
10661 val
^= DF_1_CONFALT
;
10663 if (val
& DF_1_ENDFILTEE
)
10665 printf (" ENDFILTEE");
10666 val
^= DF_1_ENDFILTEE
;
10668 if (val
& DF_1_DISPRELDNE
)
10670 printf (" DISPRELDNE");
10671 val
^= DF_1_DISPRELDNE
;
10673 if (val
& DF_1_DISPRELPND
)
10675 printf (" DISPRELPND");
10676 val
^= DF_1_DISPRELPND
;
10678 if (val
& DF_1_NODIRECT
)
10680 printf (" NODIRECT");
10681 val
^= DF_1_NODIRECT
;
10683 if (val
& DF_1_IGNMULDEF
)
10685 printf (" IGNMULDEF");
10686 val
^= DF_1_IGNMULDEF
;
10688 if (val
& DF_1_NOKSYMS
)
10690 printf (" NOKSYMS");
10691 val
^= DF_1_NOKSYMS
;
10693 if (val
& DF_1_NOHDR
)
10698 if (val
& DF_1_EDITED
)
10700 printf (" EDITED");
10701 val
^= DF_1_EDITED
;
10703 if (val
& DF_1_NORELOC
)
10705 printf (" NORELOC");
10706 val
^= DF_1_NORELOC
;
10708 if (val
& DF_1_SYMINTPOSE
)
10710 printf (" SYMINTPOSE");
10711 val
^= DF_1_SYMINTPOSE
;
10713 if (val
& DF_1_GLOBAUDIT
)
10715 printf (" GLOBAUDIT");
10716 val
^= DF_1_GLOBAUDIT
;
10718 if (val
& DF_1_SINGLETON
)
10720 printf (" SINGLETON");
10721 val
^= DF_1_SINGLETON
;
10723 if (val
& DF_1_STUB
)
10728 if (val
& DF_1_PIE
)
10733 if (val
& DF_1_KMOD
)
10738 if (val
& DF_1_WEAKFILTER
)
10740 printf (" WEAKFILTER");
10741 val
^= DF_1_WEAKFILTER
;
10743 if (val
& DF_1_NOCOMMON
)
10745 printf (" NOCOMMON");
10746 val
^= DF_1_NOCOMMON
;
10749 printf (" %lx", val
);
10756 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10758 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10778 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10784 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10785 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10791 switch (entry
->d_tag
)
10794 printf (_("Shared library: [%s]"), name
);
10796 if (streq (name
, filedata
->program_interpreter
))
10797 printf (_(" program interpreter"));
10801 printf (_("Library soname: [%s]"), name
);
10805 printf (_("Library rpath: [%s]"), name
);
10809 printf (_("Library runpath: [%s]"), name
);
10813 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10818 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10831 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10832 /* Fall through. */
10836 case DT_INIT_ARRAYSZ
:
10837 case DT_FINI_ARRAYSZ
:
10838 case DT_GNU_CONFLICTSZ
:
10839 case DT_GNU_LIBLISTSZ
:
10842 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10843 printf (_(" (bytes)\n"));
10848 case DT_VERNEEDNUM
:
10853 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10862 case DT_INIT_ARRAY
:
10863 case DT_FINI_ARRAY
:
10866 if (entry
->d_tag
== DT_USED
10867 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10869 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10873 printf (_("Not needed object: [%s]\n"), name
);
10878 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10884 /* The value of this entry is ignored. */
10889 case DT_GNU_PRELINKED
:
10893 time_t atime
= entry
->d_un
.d_val
;
10895 tmp
= gmtime (&atime
);
10896 /* PR 17533 file: 041-1244816-0.004. */
10898 printf (_("<corrupt time val: %lx"),
10899 (unsigned long) atime
);
10901 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10902 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10903 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10909 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10912 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10918 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10919 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10920 = entry
->d_un
.d_val
;
10924 switch (filedata
->file_header
.e_machine
)
10927 dynamic_section_aarch64_val (entry
);
10930 case EM_MIPS_RS3_LE
:
10931 dynamic_section_mips_val (filedata
, entry
);
10934 dynamic_section_parisc_val (entry
);
10937 dynamic_section_ia64_val (entry
);
10940 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10952 get_ver_flags (unsigned int flags
)
10954 static char buff
[128];
10961 if (flags
& VER_FLG_BASE
)
10962 strcat (buff
, "BASE");
10964 if (flags
& VER_FLG_WEAK
)
10966 if (flags
& VER_FLG_BASE
)
10967 strcat (buff
, " | ");
10969 strcat (buff
, "WEAK");
10972 if (flags
& VER_FLG_INFO
)
10974 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10975 strcat (buff
, " | ");
10977 strcat (buff
, "INFO");
10980 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10982 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10983 strcat (buff
, " | ");
10985 strcat (buff
, _("<unknown>"));
10991 /* Display the contents of the version sections. */
10994 process_version_sections (Filedata
* filedata
)
10996 Elf_Internal_Shdr
* section
;
10998 bfd_boolean found
= FALSE
;
11003 for (i
= 0, section
= filedata
->section_headers
;
11004 i
< filedata
->file_header
.e_shnum
;
11007 switch (section
->sh_type
)
11009 case SHT_GNU_verdef
:
11011 Elf_External_Verdef
* edefs
;
11018 printf (ngettext ("\nVersion definition section '%s' "
11019 "contains %u entry:\n",
11020 "\nVersion definition section '%s' "
11021 "contains %u entries:\n",
11023 printable_section_name (filedata
, section
),
11026 printf (_(" Addr: 0x"));
11027 printf_vma (section
->sh_addr
);
11028 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11029 (unsigned long) section
->sh_offset
, section
->sh_link
,
11030 printable_section_name_from_index (filedata
, section
->sh_link
));
11032 edefs
= (Elf_External_Verdef
*)
11033 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11034 _("version definition section"));
11037 endbuf
= (char *) edefs
+ section
->sh_size
;
11039 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11042 Elf_External_Verdef
* edef
;
11043 Elf_Internal_Verdef ent
;
11044 Elf_External_Verdaux
* eaux
;
11045 Elf_Internal_Verdaux aux
;
11046 unsigned long isum
;
11049 vstart
= ((char *) edefs
) + idx
;
11050 if (vstart
+ sizeof (*edef
) > endbuf
)
11053 edef
= (Elf_External_Verdef
*) vstart
;
11055 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11056 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11057 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11058 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11059 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11060 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11061 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11063 printf (_(" %#06lx: Rev: %d Flags: %s"),
11064 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11066 printf (_(" Index: %d Cnt: %d "),
11067 ent
.vd_ndx
, ent
.vd_cnt
);
11069 /* Check for overflow. */
11070 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11073 vstart
+= ent
.vd_aux
;
11075 if (vstart
+ sizeof (*eaux
) > endbuf
)
11077 eaux
= (Elf_External_Verdaux
*) vstart
;
11079 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11080 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11082 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11083 printf (_("Name: %s\n"),
11084 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11086 printf (_("Name index: %ld\n"), aux
.vda_name
);
11088 isum
= idx
+ ent
.vd_aux
;
11090 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11092 if (aux
.vda_next
< sizeof (*eaux
)
11093 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11095 warn (_("Invalid vda_next field of %lx\n"),
11100 /* Check for overflow. */
11101 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11104 isum
+= aux
.vda_next
;
11105 vstart
+= aux
.vda_next
;
11107 if (vstart
+ sizeof (*eaux
) > endbuf
)
11109 eaux
= (Elf_External_Verdaux
*) vstart
;
11111 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11112 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11114 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11115 printf (_(" %#06lx: Parent %d: %s\n"),
11117 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11119 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11120 isum
, j
, aux
.vda_name
);
11123 if (j
< ent
.vd_cnt
)
11124 printf (_(" Version def aux past end of section\n"));
11127 file: id:000001,src:000172+005151,op:splice,rep:2. */
11128 if (ent
.vd_next
< sizeof (*edef
)
11129 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11131 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11132 cnt
= section
->sh_info
;
11135 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11138 idx
+= ent
.vd_next
;
11141 if (cnt
< section
->sh_info
)
11142 printf (_(" Version definition past end of section\n"));
11148 case SHT_GNU_verneed
:
11150 Elf_External_Verneed
* eneed
;
11157 printf (ngettext ("\nVersion needs section '%s' "
11158 "contains %u entry:\n",
11159 "\nVersion needs section '%s' "
11160 "contains %u entries:\n",
11162 printable_section_name (filedata
, section
), section
->sh_info
);
11164 printf (_(" Addr: 0x"));
11165 printf_vma (section
->sh_addr
);
11166 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11167 (unsigned long) section
->sh_offset
, section
->sh_link
,
11168 printable_section_name_from_index (filedata
, section
->sh_link
));
11170 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11171 section
->sh_offset
, 1,
11173 _("Version Needs section"));
11176 endbuf
= (char *) eneed
+ section
->sh_size
;
11178 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11180 Elf_External_Verneed
* entry
;
11181 Elf_Internal_Verneed ent
;
11182 unsigned long isum
;
11186 vstart
= ((char *) eneed
) + idx
;
11187 if (vstart
+ sizeof (*entry
) > endbuf
)
11190 entry
= (Elf_External_Verneed
*) vstart
;
11192 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11193 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11194 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11195 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11196 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11198 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11200 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11201 printf (_(" File: %s"),
11202 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11204 printf (_(" File: %lx"), ent
.vn_file
);
11206 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11208 /* Check for overflow. */
11209 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11211 vstart
+= ent
.vn_aux
;
11213 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11215 Elf_External_Vernaux
* eaux
;
11216 Elf_Internal_Vernaux aux
;
11218 if (vstart
+ sizeof (*eaux
) > endbuf
)
11220 eaux
= (Elf_External_Vernaux
*) vstart
;
11222 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11223 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11224 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11225 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11226 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11228 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11229 printf (_(" %#06lx: Name: %s"),
11230 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11232 printf (_(" %#06lx: Name index: %lx"),
11233 isum
, aux
.vna_name
);
11235 printf (_(" Flags: %s Version: %d\n"),
11236 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11238 if (aux
.vna_next
< sizeof (*eaux
)
11239 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11241 warn (_("Invalid vna_next field of %lx\n"),
11246 /* Check for overflow. */
11247 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11249 isum
+= aux
.vna_next
;
11250 vstart
+= aux
.vna_next
;
11253 if (j
< ent
.vn_cnt
)
11254 warn (_("Missing Version Needs auxillary information\n"));
11256 if (ent
.vn_next
< sizeof (*entry
)
11257 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11259 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11260 cnt
= section
->sh_info
;
11263 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11265 idx
+= ent
.vn_next
;
11268 if (cnt
< section
->sh_info
)
11269 warn (_("Missing Version Needs information\n"));
11275 case SHT_GNU_versym
:
11277 Elf_Internal_Shdr
* link_section
;
11280 unsigned char * edata
;
11281 unsigned short * data
;
11283 Elf_Internal_Sym
* symbols
;
11284 Elf_Internal_Shdr
* string_sec
;
11285 unsigned long num_syms
;
11288 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11291 link_section
= filedata
->section_headers
+ section
->sh_link
;
11292 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11294 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11299 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11300 if (symbols
== NULL
)
11303 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11305 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11306 string_sec
->sh_size
,
11307 _("version string table"));
11314 printf (ngettext ("\nVersion symbols section '%s' "
11315 "contains %lu entry:\n",
11316 "\nVersion symbols section '%s' "
11317 "contains %lu entries:\n",
11319 printable_section_name (filedata
, section
), (unsigned long) total
);
11321 printf (_(" Addr: 0x"));
11322 printf_vma (section
->sh_addr
);
11323 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11324 (unsigned long) section
->sh_offset
, section
->sh_link
,
11325 printable_section_name (filedata
, link_section
));
11327 off
= offset_from_vma (filedata
,
11328 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11329 total
* sizeof (short));
11330 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11331 sizeof (short), total
,
11332 _("version symbol data"));
11340 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11342 for (cnt
= total
; cnt
--;)
11343 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11348 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11352 char *invalid
= _("*invalid*");
11354 printf (" %03x:", cnt
);
11356 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11357 switch (data
[cnt
+ j
])
11360 fputs (_(" 0 (*local*) "), stdout
);
11364 fputs (_(" 1 (*global*) "), stdout
);
11368 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11369 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11371 /* If this index value is greater than the size of the symbols
11372 array, break to avoid an out-of-bounds read. */
11373 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11375 warn (_("invalid index into symbol array\n"));
11380 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11382 Elf_Internal_Verneed ivn
;
11383 unsigned long offset
;
11385 offset
= offset_from_vma
11387 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11388 sizeof (Elf_External_Verneed
));
11392 Elf_Internal_Vernaux ivna
;
11393 Elf_External_Verneed evn
;
11394 Elf_External_Vernaux evna
;
11395 unsigned long a_off
;
11397 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11398 _("version need")) == NULL
)
11401 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11402 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11404 a_off
= offset
+ ivn
.vn_aux
;
11408 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11409 1, _("version need aux (2)")) == NULL
)
11412 ivna
.vna_other
= 0;
11416 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11417 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11420 a_off
+= ivna
.vna_next
;
11422 while (ivna
.vna_other
!= data
[cnt
+ j
]
11423 && ivna
.vna_next
!= 0);
11425 if (ivna
.vna_other
== data
[cnt
+ j
])
11427 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11429 if (ivna
.vna_name
>= string_sec
->sh_size
)
11432 name
= strtab
+ ivna
.vna_name
;
11436 offset
+= ivn
.vn_next
;
11438 while (ivn
.vn_next
);
11441 if (data
[cnt
+ j
] != 0x8001
11442 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11444 Elf_Internal_Verdef ivd
;
11445 Elf_External_Verdef evd
;
11446 unsigned long offset
;
11448 offset
= offset_from_vma
11450 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11455 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11456 _("version def")) == NULL
)
11459 /* PR 17531: file: 046-1082287-0.004. */
11460 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11465 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11466 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11469 offset
+= ivd
.vd_next
;
11471 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11472 && ivd
.vd_next
!= 0);
11474 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11476 Elf_External_Verdaux evda
;
11477 Elf_Internal_Verdaux ivda
;
11479 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11481 if (get_data (&evda
, filedata
,
11482 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11484 _("version def aux")) == NULL
)
11487 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11489 if (ivda
.vda_name
>= string_sec
->sh_size
)
11491 else if (name
!= NULL
&& name
!= invalid
)
11492 name
= _("*both*");
11494 name
= strtab
+ ivda
.vda_name
;
11498 nn
+= printf ("(%s%-*s",
11500 12 - (int) strlen (name
),
11504 printf ("%*c", 18 - nn
, ' ');
11522 printf (_("\nNo version information found in this file.\n"));
11527 static const char *
11528 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11530 static char buff
[64];
11534 case STB_LOCAL
: return "LOCAL";
11535 case STB_GLOBAL
: return "GLOBAL";
11536 case STB_WEAK
: return "WEAK";
11538 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11539 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11541 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11543 if (binding
== STB_GNU_UNIQUE
11544 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11546 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11549 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11554 static const char *
11555 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11557 static char buff
[64];
11561 case STT_NOTYPE
: return "NOTYPE";
11562 case STT_OBJECT
: return "OBJECT";
11563 case STT_FUNC
: return "FUNC";
11564 case STT_SECTION
: return "SECTION";
11565 case STT_FILE
: return "FILE";
11566 case STT_COMMON
: return "COMMON";
11567 case STT_TLS
: return "TLS";
11568 case STT_RELC
: return "RELC";
11569 case STT_SRELC
: return "SRELC";
11571 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11573 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11574 return "THUMB_FUNC";
11576 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11579 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11580 return "PARISC_MILLI";
11582 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11584 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11586 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11588 if (type
== STT_HP_OPAQUE
)
11589 return "HP_OPAQUE";
11590 if (type
== STT_HP_STUB
)
11594 if (type
== STT_GNU_IFUNC
11595 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11596 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11599 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11602 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11607 static const char *
11608 get_symbol_visibility (unsigned int visibility
)
11610 switch (visibility
)
11612 case STV_DEFAULT
: return "DEFAULT";
11613 case STV_INTERNAL
: return "INTERNAL";
11614 case STV_HIDDEN
: return "HIDDEN";
11615 case STV_PROTECTED
: return "PROTECTED";
11617 error (_("Unrecognized visibility value: %u\n"), visibility
);
11618 return _("<unknown>");
11622 static const char *
11623 get_alpha_symbol_other (unsigned int other
)
11627 case STO_ALPHA_NOPV
: return "NOPV";
11628 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11630 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11631 return _("<unknown>");
11635 static const char *
11636 get_solaris_symbol_visibility (unsigned int visibility
)
11638 switch (visibility
)
11640 case 4: return "EXPORTED";
11641 case 5: return "SINGLETON";
11642 case 6: return "ELIMINATE";
11643 default: return get_symbol_visibility (visibility
);
11647 static const char *
11648 get_aarch64_symbol_other (unsigned int other
)
11650 static char buf
[32];
11652 if (other
& STO_AARCH64_VARIANT_PCS
)
11654 other
&= ~STO_AARCH64_VARIANT_PCS
;
11656 return "VARIANT_PCS";
11657 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11663 static const char *
11664 get_mips_symbol_other (unsigned int other
)
11668 case STO_OPTIONAL
: return "OPTIONAL";
11669 case STO_MIPS_PLT
: return "MIPS PLT";
11670 case STO_MIPS_PIC
: return "MIPS PIC";
11671 case STO_MICROMIPS
: return "MICROMIPS";
11672 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11673 case STO_MIPS16
: return "MIPS16";
11674 default: return NULL
;
11678 static const char *
11679 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11681 if (is_ia64_vms (filedata
))
11683 static char res
[32];
11687 /* Function types is for images and .STB files only. */
11688 switch (filedata
->file_header
.e_type
)
11692 switch (VMS_ST_FUNC_TYPE (other
))
11694 case VMS_SFT_CODE_ADDR
:
11695 strcat (res
, " CA");
11697 case VMS_SFT_SYMV_IDX
:
11698 strcat (res
, " VEC");
11701 strcat (res
, " FD");
11703 case VMS_SFT_RESERVE
:
11704 strcat (res
, " RSV");
11707 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11708 VMS_ST_FUNC_TYPE (other
));
11709 strcat (res
, " <unknown>");
11716 switch (VMS_ST_LINKAGE (other
))
11718 case VMS_STL_IGNORE
:
11719 strcat (res
, " IGN");
11721 case VMS_STL_RESERVE
:
11722 strcat (res
, " RSV");
11725 strcat (res
, " STD");
11728 strcat (res
, " LNK");
11731 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11732 VMS_ST_LINKAGE (other
));
11733 strcat (res
, " <unknown>");
11745 static const char *
11746 get_ppc64_symbol_other (unsigned int other
)
11748 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11751 other
>>= STO_PPC64_LOCAL_BIT
;
11754 static char buf
[64];
11756 other
= ppc64_decode_local_entry (other
);
11757 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11763 static const char *
11764 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11766 const char * result
= NULL
;
11767 static char buff
[64];
11772 switch (filedata
->file_header
.e_machine
)
11775 result
= get_alpha_symbol_other (other
);
11778 result
= get_aarch64_symbol_other (other
);
11781 result
= get_mips_symbol_other (other
);
11784 result
= get_ia64_symbol_other (filedata
, other
);
11787 result
= get_ppc64_symbol_other (other
);
11797 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11801 static const char *
11802 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11804 static char buff
[32];
11808 case SHN_UNDEF
: return "UND";
11809 case SHN_ABS
: return "ABS";
11810 case SHN_COMMON
: return "COM";
11812 if (type
== SHN_IA_64_ANSI_COMMON
11813 && filedata
->file_header
.e_machine
== EM_IA_64
11814 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11816 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11817 || filedata
->file_header
.e_machine
== EM_L1OM
11818 || filedata
->file_header
.e_machine
== EM_K1OM
)
11819 && type
== SHN_X86_64_LCOMMON
)
11820 return "LARGE_COM";
11821 else if ((type
== SHN_MIPS_SCOMMON
11822 && filedata
->file_header
.e_machine
== EM_MIPS
)
11823 || (type
== SHN_TIC6X_SCOMMON
11824 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11826 else if (type
== SHN_MIPS_SUNDEFINED
11827 && filedata
->file_header
.e_machine
== EM_MIPS
)
11829 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11830 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11831 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11832 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11833 else if (type
>= SHN_LORESERVE
)
11834 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11835 else if (filedata
->file_header
.e_shnum
!= 0
11836 && type
>= filedata
->file_header
.e_shnum
)
11837 sprintf (buff
, _("bad section index[%3d]"), type
);
11839 sprintf (buff
, "%3d", type
);
11846 static const char *
11847 get_symbol_version_string (Filedata
* filedata
,
11848 bfd_boolean is_dynsym
,
11849 const char * strtab
,
11850 unsigned long int strtab_size
,
11852 Elf_Internal_Sym
* psym
,
11853 enum versioned_symbol_info
* sym_info
,
11854 unsigned short * vna_other
)
11856 unsigned char data
[2];
11857 unsigned short vers_data
;
11858 unsigned long offset
;
11859 unsigned short max_vd_ndx
;
11862 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11865 offset
= offset_from_vma (filedata
,
11866 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11867 sizeof data
+ si
* sizeof (vers_data
));
11869 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11870 sizeof (data
), 1, _("version data")) == NULL
)
11873 vers_data
= byte_get (data
, 2);
11875 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11878 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11881 /* Usually we'd only see verdef for defined symbols, and verneed for
11882 undefined symbols. However, symbols defined by the linker in
11883 .dynbss for variables copied from a shared library in order to
11884 avoid text relocations are defined yet have verneed. We could
11885 use a heuristic to detect the special case, for example, check
11886 for verneed first on symbols defined in SHT_NOBITS sections, but
11887 it is simpler and more reliable to just look for both verdef and
11888 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11890 if (psym
->st_shndx
!= SHN_UNDEF
11891 && vers_data
!= 0x8001
11892 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11894 Elf_Internal_Verdef ivd
;
11895 Elf_Internal_Verdaux ivda
;
11896 Elf_External_Verdaux evda
;
11899 off
= offset_from_vma (filedata
,
11900 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11901 sizeof (Elf_External_Verdef
));
11905 Elf_External_Verdef evd
;
11907 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11908 _("version def")) == NULL
)
11917 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11918 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11919 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11920 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11923 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11924 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11926 off
+= ivd
.vd_next
;
11928 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11930 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11932 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11935 off
-= ivd
.vd_next
;
11938 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11939 _("version def aux")) != NULL
)
11941 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11943 if (psym
->st_name
!= ivda
.vda_name
)
11944 return (ivda
.vda_name
< strtab_size
11945 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11950 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11952 Elf_External_Verneed evn
;
11953 Elf_Internal_Verneed ivn
;
11954 Elf_Internal_Vernaux ivna
;
11956 offset
= offset_from_vma (filedata
,
11957 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11961 unsigned long vna_off
;
11963 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11964 _("version need")) == NULL
)
11967 ivna
.vna_other
= 0;
11972 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11973 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11975 vna_off
= offset
+ ivn
.vn_aux
;
11979 Elf_External_Vernaux evna
;
11981 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11982 _("version need aux (3)")) == NULL
)
11985 ivna
.vna_other
= 0;
11990 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11991 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11992 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11995 vna_off
+= ivna
.vna_next
;
11997 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11999 if (ivna
.vna_other
== vers_data
)
12002 offset
+= ivn
.vn_next
;
12004 while (ivn
.vn_next
!= 0);
12006 if (ivna
.vna_other
== vers_data
)
12008 *sym_info
= symbol_undefined
;
12009 *vna_other
= ivna
.vna_other
;
12010 return (ivna
.vna_name
< strtab_size
12011 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12013 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12014 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12015 return _("<corrupt>");
12021 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12022 Elf_Internal_Sym
*symtab
,
12023 Elf_Internal_Shdr
*section
,
12024 char *strtab
, size_t strtab_size
)
12026 const char *version_string
;
12027 enum versioned_symbol_info sym_info
;
12028 unsigned short vna_other
;
12029 Elf_Internal_Sym
*psym
= symtab
+ si
;
12031 printf ("%6ld: ", si
);
12032 print_vma (psym
->st_value
, LONG_HEX
);
12034 print_vma (psym
->st_size
, DEC_5
);
12035 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12036 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12037 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12038 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12041 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12043 printf (" %-7s", get_symbol_visibility (vis
));
12044 /* Check to see if any other bits in the st_other field are set.
12045 Note - displaying this information disrupts the layout of the
12046 table being generated, but for the moment this case is very rare. */
12047 if (psym
->st_other
^ vis
)
12048 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12050 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12051 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
12053 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12056 = get_symbol_version_string (filedata
,
12058 || section
->sh_type
== SHT_DYNSYM
),
12059 strtab
, strtab_size
, si
,
12060 psym
, &sym_info
, &vna_other
);
12061 if (version_string
)
12063 if (sym_info
== symbol_undefined
)
12064 printf ("@%s (%d)", version_string
, vna_other
);
12066 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12072 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12074 && si
>= section
->sh_info
12075 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12076 && filedata
->file_header
.e_machine
!= EM_MIPS
12077 /* Solaris binaries have been found to violate this requirement as
12078 well. Not sure if this is a bug or an ABI requirement. */
12079 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12080 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12081 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12084 /* Dump the symbol table. */
12086 process_symbol_table (Filedata
* filedata
)
12088 Elf_Internal_Shdr
* section
;
12090 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12093 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12095 && do_using_dynamic
12096 && filedata
->dynamic_strings
!= NULL
12097 && filedata
->dynamic_symbols
!= NULL
)
12101 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12102 "\nSymbol table for image contains %lu entries:\n",
12103 filedata
->num_dynamic_syms
),
12104 filedata
->num_dynamic_syms
);
12106 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12108 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12110 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12111 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12112 filedata
->dynamic_strings
,
12113 filedata
->dynamic_strings_length
);
12115 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12116 && filedata
->section_headers
!= NULL
)
12120 for (i
= 0, section
= filedata
->section_headers
;
12121 i
< filedata
->file_header
.e_shnum
;
12124 char * strtab
= NULL
;
12125 unsigned long int strtab_size
= 0;
12126 Elf_Internal_Sym
* symtab
;
12127 unsigned long si
, num_syms
;
12129 if ((section
->sh_type
!= SHT_SYMTAB
12130 && section
->sh_type
!= SHT_DYNSYM
)
12132 && section
->sh_type
== SHT_SYMTAB
))
12135 if (section
->sh_entsize
== 0)
12137 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12138 printable_section_name (filedata
, section
));
12142 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12143 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12144 "\nSymbol table '%s' contains %lu entries:\n",
12146 printable_section_name (filedata
, section
),
12150 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12152 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12154 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12155 if (symtab
== NULL
)
12158 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12160 strtab
= filedata
->string_table
;
12161 strtab_size
= filedata
->string_table_length
;
12163 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12165 Elf_Internal_Shdr
* string_sec
;
12167 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12169 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12170 1, string_sec
->sh_size
,
12171 _("string table"));
12172 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12175 for (si
= 0; si
< num_syms
; si
++)
12176 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12177 strtab
, strtab_size
);
12180 if (strtab
!= filedata
->string_table
)
12186 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12188 if (do_histogram
&& filedata
->buckets
!= NULL
)
12190 unsigned long * lengths
;
12191 unsigned long * counts
;
12194 unsigned long maxlength
= 0;
12195 unsigned long nzero_counts
= 0;
12196 unsigned long nsyms
= 0;
12199 printf (ngettext ("\nHistogram for bucket list length "
12200 "(total of %lu bucket):\n",
12201 "\nHistogram for bucket list length "
12202 "(total of %lu buckets):\n",
12203 (unsigned long) filedata
->nbuckets
),
12204 (unsigned long) filedata
->nbuckets
);
12206 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12207 sizeof (*lengths
));
12208 if (lengths
== NULL
)
12210 error (_("Out of memory allocating space for histogram buckets\n"));
12213 visited
= xcmalloc (filedata
->nchains
, 1);
12214 memset (visited
, 0, filedata
->nchains
);
12216 printf (_(" Length Number %% of total Coverage\n"));
12217 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12219 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12222 if (maxlength
< ++lengths
[hn
])
12224 if (si
>= filedata
->nchains
|| visited
[si
])
12226 error (_("histogram chain is corrupt\n"));
12234 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12235 if (counts
== NULL
)
12238 error (_("Out of memory allocating space for histogram counts\n"));
12242 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12243 ++counts
[lengths
[hn
]];
12245 if (filedata
->nbuckets
> 0)
12248 printf (" 0 %-10lu (%5.1f%%)\n",
12249 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12250 for (i
= 1; i
<= maxlength
; ++i
)
12252 nzero_counts
+= counts
[i
] * i
;
12253 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12254 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12255 (nzero_counts
* 100.0) / nsyms
);
12263 free (filedata
->buckets
);
12264 filedata
->buckets
= NULL
;
12265 filedata
->nbuckets
= 0;
12266 free (filedata
->chains
);
12267 filedata
->chains
= NULL
;
12269 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12271 unsigned long * lengths
;
12272 unsigned long * counts
;
12274 unsigned long maxlength
= 0;
12275 unsigned long nzero_counts
= 0;
12276 unsigned long nsyms
= 0;
12278 printf (ngettext ("\nHistogram for `%s' bucket list length "
12279 "(total of %lu bucket):\n",
12280 "\nHistogram for `%s' bucket list length "
12281 "(total of %lu buckets):\n",
12282 (unsigned long) filedata
->ngnubuckets
),
12283 GNU_HASH_SECTION_NAME (filedata
),
12284 (unsigned long) filedata
->ngnubuckets
);
12286 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12287 sizeof (*lengths
));
12288 if (lengths
== NULL
)
12290 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12294 printf (_(" Length Number %% of total Coverage\n"));
12296 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12297 if (filedata
->gnubuckets
[hn
] != 0)
12299 bfd_vma off
, length
= 1;
12301 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12302 /* PR 17531 file: 010-77222-0.004. */
12303 off
< filedata
->ngnuchains
12304 && (filedata
->gnuchains
[off
] & 1) == 0;
12307 lengths
[hn
] = length
;
12308 if (length
> maxlength
)
12309 maxlength
= length
;
12313 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12314 if (counts
== NULL
)
12317 error (_("Out of memory allocating space for gnu histogram counts\n"));
12321 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12322 ++counts
[lengths
[hn
]];
12324 if (filedata
->ngnubuckets
> 0)
12327 printf (" 0 %-10lu (%5.1f%%)\n",
12328 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12329 for (j
= 1; j
<= maxlength
; ++j
)
12331 nzero_counts
+= counts
[j
] * j
;
12332 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12333 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12334 (nzero_counts
* 100.0) / nsyms
);
12341 free (filedata
->gnubuckets
);
12342 filedata
->gnubuckets
= NULL
;
12343 filedata
->ngnubuckets
= 0;
12344 free (filedata
->gnuchains
);
12345 filedata
->gnuchains
= NULL
;
12346 filedata
->ngnuchains
= 0;
12347 free (filedata
->mipsxlat
);
12348 filedata
->mipsxlat
= NULL
;
12352 free (filedata
->gnubuckets
);
12353 filedata
->gnubuckets
= NULL
;
12354 filedata
->ngnubuckets
= 0;
12355 free (filedata
->gnuchains
);
12356 filedata
->gnuchains
= NULL
;
12357 filedata
->ngnuchains
= 0;
12358 free (filedata
->mipsxlat
);
12359 filedata
->mipsxlat
= NULL
;
12360 free (filedata
->buckets
);
12361 filedata
->buckets
= NULL
;
12362 filedata
->nbuckets
= 0;
12363 free (filedata
->chains
);
12364 filedata
->chains
= NULL
;
12369 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12373 if (filedata
->dynamic_syminfo
== NULL
12375 /* No syminfo, this is ok. */
12378 /* There better should be a dynamic symbol section. */
12379 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12382 if (filedata
->dynamic_addr
)
12383 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12384 "contains %d entry:\n",
12385 "\nDynamic info segment at offset 0x%lx "
12386 "contains %d entries:\n",
12387 filedata
->dynamic_syminfo_nent
),
12388 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12390 printf (_(" Num: Name BoundTo Flags\n"));
12391 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12393 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12395 printf ("%4d: ", i
);
12396 if (i
>= filedata
->num_dynamic_syms
)
12397 printf (_("<corrupt index>"));
12398 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12399 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12400 filedata
->dynamic_symbols
[i
].st_name
));
12402 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12405 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12407 case SYMINFO_BT_SELF
:
12408 fputs ("SELF ", stdout
);
12410 case SYMINFO_BT_PARENT
:
12411 fputs ("PARENT ", stdout
);
12414 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12415 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12416 && VALID_DYNAMIC_NAME (filedata
,
12417 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12419 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12420 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12424 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12428 if (flags
& SYMINFO_FLG_DIRECT
)
12429 printf (" DIRECT");
12430 if (flags
& SYMINFO_FLG_PASSTHRU
)
12431 printf (" PASSTHRU");
12432 if (flags
& SYMINFO_FLG_COPY
)
12434 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12435 printf (" LAZYLOAD");
12443 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12444 is contained by the region START .. END. The types of ADDR, START
12445 and END should all be the same. Note both ADDR + NELEM and END
12446 point to just beyond the end of the regions that are being tested. */
12447 #define IN_RANGE(START,END,ADDR,NELEM) \
12448 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12450 /* Check to see if the given reloc needs to be handled in a target specific
12451 manner. If so then process the reloc and return TRUE otherwise return
12454 If called with reloc == NULL, then this is a signal that reloc processing
12455 for the current section has finished, and any saved state should be
12459 target_specific_reloc_handling (Filedata
* filedata
,
12460 Elf_Internal_Rela
* reloc
,
12461 unsigned char * start
,
12462 unsigned char * end
,
12463 Elf_Internal_Sym
* symtab
,
12464 unsigned long num_syms
)
12466 unsigned int reloc_type
= 0;
12467 unsigned long sym_index
= 0;
12471 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12472 sym_index
= get_reloc_symindex (reloc
->r_info
);
12475 switch (filedata
->file_header
.e_machine
)
12478 case EM_MSP430_OLD
:
12480 static Elf_Internal_Sym
* saved_sym
= NULL
;
12488 switch (reloc_type
)
12490 case 10: /* R_MSP430_SYM_DIFF */
12491 if (uses_msp430x_relocs (filedata
))
12493 /* Fall through. */
12494 case 21: /* R_MSP430X_SYM_DIFF */
12496 if (sym_index
>= num_syms
)
12497 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12500 saved_sym
= symtab
+ sym_index
;
12503 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12504 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12505 goto handle_sym_diff
;
12507 case 5: /* R_MSP430_16_BYTE */
12508 case 9: /* R_MSP430_8 */
12509 if (uses_msp430x_relocs (filedata
))
12511 goto handle_sym_diff
;
12513 case 2: /* R_MSP430_ABS16 */
12514 case 15: /* R_MSP430X_ABS16 */
12515 if (! uses_msp430x_relocs (filedata
))
12517 goto handle_sym_diff
;
12520 if (saved_sym
!= NULL
)
12522 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12525 if (sym_index
>= num_syms
)
12526 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12530 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12531 - saved_sym
->st_value
);
12533 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12534 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12537 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12538 (long) reloc
->r_offset
);
12547 if (saved_sym
!= NULL
)
12548 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12555 case EM_CYGNUS_MN10300
:
12557 static Elf_Internal_Sym
* saved_sym
= NULL
;
12565 switch (reloc_type
)
12567 case 34: /* R_MN10300_ALIGN */
12569 case 33: /* R_MN10300_SYM_DIFF */
12570 if (sym_index
>= num_syms
)
12571 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12574 saved_sym
= symtab
+ sym_index
;
12577 case 1: /* R_MN10300_32 */
12578 case 2: /* R_MN10300_16 */
12579 if (saved_sym
!= NULL
)
12581 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12584 if (sym_index
>= num_syms
)
12585 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12589 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12590 - saved_sym
->st_value
);
12592 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12593 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12595 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12596 (long) reloc
->r_offset
);
12604 if (saved_sym
!= NULL
)
12605 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12613 static bfd_vma saved_sym1
= 0;
12614 static bfd_vma saved_sym2
= 0;
12615 static bfd_vma value
;
12619 saved_sym1
= saved_sym2
= 0;
12623 switch (reloc_type
)
12625 case 0x80: /* R_RL78_SYM. */
12626 saved_sym1
= saved_sym2
;
12627 if (sym_index
>= num_syms
)
12628 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12632 saved_sym2
= symtab
[sym_index
].st_value
;
12633 saved_sym2
+= reloc
->r_addend
;
12637 case 0x83: /* R_RL78_OPsub. */
12638 value
= saved_sym1
- saved_sym2
;
12639 saved_sym2
= saved_sym1
= 0;
12643 case 0x41: /* R_RL78_ABS32. */
12644 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12645 byte_put (start
+ reloc
->r_offset
, value
, 4);
12647 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12648 (long) reloc
->r_offset
);
12652 case 0x43: /* R_RL78_ABS16. */
12653 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12654 byte_put (start
+ reloc
->r_offset
, value
, 2);
12656 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12657 (long) reloc
->r_offset
);
12671 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12672 DWARF debug sections. This is a target specific test. Note - we do not
12673 go through the whole including-target-headers-multiple-times route, (as
12674 we have already done with <elf/h8.h>) because this would become very
12675 messy and even then this function would have to contain target specific
12676 information (the names of the relocs instead of their numeric values).
12677 FIXME: This is not the correct way to solve this problem. The proper way
12678 is to have target specific reloc sizing and typing functions created by
12679 the reloc-macros.h header, in the same way that it already creates the
12680 reloc naming functions. */
12683 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12685 /* Please keep this table alpha-sorted for ease of visual lookup. */
12686 switch (filedata
->file_header
.e_machine
)
12690 return reloc_type
== 1; /* R_386_32. */
12692 return reloc_type
== 1; /* R_68K_32. */
12694 return reloc_type
== 1; /* R_860_32. */
12696 return reloc_type
== 2; /* R_960_32. */
12698 return (reloc_type
== 258
12699 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12701 return reloc_type
== 11; /* R_BPF_DATA_32 */
12702 case EM_ADAPTEVA_EPIPHANY
:
12703 return reloc_type
== 3;
12705 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12707 return reloc_type
== 1; /* R_ARC_32. */
12708 case EM_ARC_COMPACT
:
12709 case EM_ARC_COMPACT2
:
12710 return reloc_type
== 4; /* R_ARC_32. */
12712 return reloc_type
== 2; /* R_ARM_ABS32 */
12715 return reloc_type
== 1;
12717 return reloc_type
== 0x12; /* R_byte4_data. */
12719 return reloc_type
== 3; /* R_CRIS_32. */
12721 return reloc_type
== 3; /* R_CR16_NUM32. */
12723 return reloc_type
== 15; /* R_CRX_NUM32. */
12725 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12726 case EM_CYGNUS_FRV
:
12727 return reloc_type
== 1;
12728 case EM_CYGNUS_D10V
:
12730 return reloc_type
== 6; /* R_D10V_32. */
12731 case EM_CYGNUS_D30V
:
12733 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12735 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12736 case EM_CYGNUS_FR30
:
12738 return reloc_type
== 3; /* R_FR30_32. */
12740 return reloc_type
== 1; /* R_FT32_32. */
12744 return reloc_type
== 1; /* R_H8_DIR32. */
12746 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12747 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12748 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12749 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12752 return reloc_type
== 2; /* R_IP2K_32. */
12754 return reloc_type
== 2; /* R_IQ2000_32. */
12755 case EM_LATTICEMICO32
:
12756 return reloc_type
== 3; /* R_LM32_32. */
12759 return reloc_type
== 3; /* R_M32C_32. */
12761 return reloc_type
== 34; /* R_M32R_32_RELA. */
12764 return reloc_type
== 6; /* R_M68HC11_32. */
12766 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12767 reloc_type
== 6; /* R_S12Z_CW32. */
12769 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12770 case EM_CYGNUS_MEP
:
12771 return reloc_type
== 4; /* R_MEP_32. */
12773 return reloc_type
== 2; /* R_METAG_ADDR32. */
12774 case EM_MICROBLAZE
:
12775 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12777 return reloc_type
== 2; /* R_MIPS_32. */
12779 return reloc_type
== 4; /* R_MMIX_32. */
12780 case EM_CYGNUS_MN10200
:
12782 return reloc_type
== 1; /* R_MN10200_32. */
12783 case EM_CYGNUS_MN10300
:
12785 return reloc_type
== 1; /* R_MN10300_32. */
12787 return reloc_type
== 1; /* R_MOXIE_32. */
12788 case EM_MSP430_OLD
:
12790 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12792 return reloc_type
== 2; /* R_MT_32. */
12794 return reloc_type
== 20; /* R_NDS32_RELA. */
12795 case EM_ALTERA_NIOS2
:
12796 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12798 return reloc_type
== 1; /* R_NIOS_32. */
12800 return reloc_type
== 1; /* R_OR1K_32. */
12802 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12803 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12804 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12807 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12809 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12811 return reloc_type
== 1; /* R_PPC_ADDR32. */
12813 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12815 return reloc_type
== 1; /* R_RISCV_32. */
12817 return reloc_type
== 1; /* R_RL78_DIR32. */
12819 return reloc_type
== 1; /* R_RX_DIR32. */
12821 return reloc_type
== 1; /* R_I370_ADDR31. */
12824 return reloc_type
== 4; /* R_S390_32. */
12826 return reloc_type
== 8; /* R_SCORE_ABS32. */
12828 return reloc_type
== 1; /* R_SH_DIR32. */
12829 case EM_SPARC32PLUS
:
12832 return reloc_type
== 3 /* R_SPARC_32. */
12833 || reloc_type
== 23; /* R_SPARC_UA32. */
12835 return reloc_type
== 6; /* R_SPU_ADDR32 */
12837 return reloc_type
== 1; /* R_C6000_ABS32. */
12839 return reloc_type
== 2; /* R_TILEGX_32. */
12841 return reloc_type
== 1; /* R_TILEPRO_32. */
12842 case EM_CYGNUS_V850
:
12844 return reloc_type
== 6; /* R_V850_ABS32. */
12846 return reloc_type
== 0x33; /* R_V810_WORD. */
12848 return reloc_type
== 1; /* R_VAX_32. */
12850 return reloc_type
== 3; /* R_VISIUM_32. */
12851 case EM_WEBASSEMBLY
:
12852 return reloc_type
== 1; /* R_WASM32_32. */
12856 return reloc_type
== 10; /* R_X86_64_32. */
12859 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12861 return reloc_type
== 4; /* R_XGATE_32. */
12863 return reloc_type
== 1; /* R_XSTROMY16_32. */
12864 case EM_XTENSA_OLD
:
12866 return reloc_type
== 1; /* R_XTENSA_32. */
12868 return reloc_type
== 6; /* R_Z80_32. */
12871 static unsigned int prev_warn
= 0;
12873 /* Avoid repeating the same warning multiple times. */
12874 if (prev_warn
!= filedata
->file_header
.e_machine
)
12875 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12876 filedata
->file_header
.e_machine
);
12877 prev_warn
= filedata
->file_header
.e_machine
;
12883 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12884 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12887 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12889 switch (filedata
->file_header
.e_machine
)
12890 /* Please keep this table alpha-sorted for ease of visual lookup. */
12894 return reloc_type
== 2; /* R_386_PC32. */
12896 return reloc_type
== 4; /* R_68K_PC32. */
12898 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12899 case EM_ADAPTEVA_EPIPHANY
:
12900 return reloc_type
== 6;
12902 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12903 case EM_ARC_COMPACT
:
12904 case EM_ARC_COMPACT2
:
12905 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12907 return reloc_type
== 3; /* R_ARM_REL32 */
12910 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12911 case EM_MICROBLAZE
:
12912 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12914 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12916 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12918 return reloc_type
== 26; /* R_PPC_REL32. */
12920 return reloc_type
== 26; /* R_PPC64_REL32. */
12922 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12925 return reloc_type
== 5; /* R_390_PC32. */
12927 return reloc_type
== 2; /* R_SH_REL32. */
12928 case EM_SPARC32PLUS
:
12931 return reloc_type
== 6; /* R_SPARC_DISP32. */
12933 return reloc_type
== 13; /* R_SPU_REL32. */
12935 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12937 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12939 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12943 return reloc_type
== 2; /* R_X86_64_PC32. */
12945 return reloc_type
== 4; /* R_VAX_PCREL32. */
12946 case EM_XTENSA_OLD
:
12948 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12950 /* Do not abort or issue an error message here. Not all targets use
12951 pc-relative 32-bit relocs in their DWARF debug information and we
12952 have already tested for target coverage in is_32bit_abs_reloc. A
12953 more helpful warning message will be generated by apply_relocations
12954 anyway, so just return. */
12959 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12960 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12963 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12965 switch (filedata
->file_header
.e_machine
)
12968 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12970 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12972 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12973 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12975 return reloc_type
== 80; /* R_PARISC_DIR64. */
12977 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12979 return reloc_type
== 2; /* R_RISCV_64. */
12980 case EM_SPARC32PLUS
:
12983 return reloc_type
== 32 /* R_SPARC_64. */
12984 || reloc_type
== 54; /* R_SPARC_UA64. */
12988 return reloc_type
== 1; /* R_X86_64_64. */
12991 return reloc_type
== 22; /* R_S390_64. */
12993 return reloc_type
== 1; /* R_TILEGX_64. */
12995 return reloc_type
== 18; /* R_MIPS_64. */
13001 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13002 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13005 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13007 switch (filedata
->file_header
.e_machine
)
13010 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13012 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13014 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13015 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13017 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13019 return reloc_type
== 44; /* R_PPC64_REL64. */
13020 case EM_SPARC32PLUS
:
13023 return reloc_type
== 46; /* R_SPARC_DISP64. */
13027 return reloc_type
== 24; /* R_X86_64_PC64. */
13030 return reloc_type
== 23; /* R_S390_PC64. */
13032 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13038 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13039 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13042 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13044 switch (filedata
->file_header
.e_machine
)
13046 case EM_CYGNUS_MN10200
:
13048 return reloc_type
== 4; /* R_MN10200_24. */
13050 return reloc_type
== 5; /* R_FT32_20. */
13052 return reloc_type
== 5; /* R_Z80_24. */
13058 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13059 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13062 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13064 /* Please keep this table alpha-sorted for ease of visual lookup. */
13065 switch (filedata
->file_header
.e_machine
)
13068 case EM_ARC_COMPACT
:
13069 case EM_ARC_COMPACT2
:
13070 return reloc_type
== 2; /* R_ARC_16. */
13071 case EM_ADAPTEVA_EPIPHANY
:
13072 return reloc_type
== 5;
13075 return reloc_type
== 4; /* R_AVR_16. */
13076 case EM_CYGNUS_D10V
:
13078 return reloc_type
== 3; /* R_D10V_16. */
13080 return reloc_type
== 2; /* R_FT32_16. */
13084 return reloc_type
== R_H8_DIR16
;
13087 return reloc_type
== 1; /* R_IP2K_16. */
13090 return reloc_type
== 1; /* R_M32C_16 */
13091 case EM_CYGNUS_MN10200
:
13093 return reloc_type
== 2; /* R_MN10200_16. */
13094 case EM_CYGNUS_MN10300
:
13096 return reloc_type
== 2; /* R_MN10300_16. */
13098 if (uses_msp430x_relocs (filedata
))
13099 return reloc_type
== 2; /* R_MSP430_ABS16. */
13100 /* Fall through. */
13101 case EM_MSP430_OLD
:
13102 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13104 return reloc_type
== 19; /* R_NDS32_RELA. */
13105 case EM_ALTERA_NIOS2
:
13106 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13108 return reloc_type
== 9; /* R_NIOS_16. */
13110 return reloc_type
== 2; /* R_OR1K_16. */
13112 return reloc_type
== 55; /* R_RISCV_SET16. */
13114 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13116 return reloc_type
== 2; /* R_C6000_ABS16. */
13118 return reloc_type
== 2; /* R_VISIUM_16. */
13121 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13123 return reloc_type
== 3; /* R_XGATE_16. */
13125 return reloc_type
== 4; /* R_Z80_16. */
13131 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13132 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13135 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13137 switch (filedata
->file_header
.e_machine
)
13140 return reloc_type
== 54; /* R_RISCV_SET8. */
13142 return reloc_type
== 1; /* R_Z80_8. */
13148 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13149 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13152 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13154 switch (filedata
->file_header
.e_machine
)
13157 return reloc_type
== 53; /* R_RISCV_SET6. */
13163 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13164 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13167 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13169 /* Please keep this table alpha-sorted for ease of visual lookup. */
13170 switch (filedata
->file_header
.e_machine
)
13173 return reloc_type
== 35; /* R_RISCV_ADD32. */
13179 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13180 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13183 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13185 /* Please keep this table alpha-sorted for ease of visual lookup. */
13186 switch (filedata
->file_header
.e_machine
)
13189 return reloc_type
== 39; /* R_RISCV_SUB32. */
13195 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13196 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13199 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13201 /* Please keep this table alpha-sorted for ease of visual lookup. */
13202 switch (filedata
->file_header
.e_machine
)
13205 return reloc_type
== 36; /* R_RISCV_ADD64. */
13211 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13212 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13215 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13217 /* Please keep this table alpha-sorted for ease of visual lookup. */
13218 switch (filedata
->file_header
.e_machine
)
13221 return reloc_type
== 40; /* R_RISCV_SUB64. */
13227 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13228 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13231 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13233 /* Please keep this table alpha-sorted for ease of visual lookup. */
13234 switch (filedata
->file_header
.e_machine
)
13237 return reloc_type
== 34; /* R_RISCV_ADD16. */
13243 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13244 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13247 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13249 /* Please keep this table alpha-sorted for ease of visual lookup. */
13250 switch (filedata
->file_header
.e_machine
)
13253 return reloc_type
== 38; /* R_RISCV_SUB16. */
13259 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13260 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13263 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13265 /* Please keep this table alpha-sorted for ease of visual lookup. */
13266 switch (filedata
->file_header
.e_machine
)
13269 return reloc_type
== 33; /* R_RISCV_ADD8. */
13275 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13276 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13279 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13281 /* Please keep this table alpha-sorted for ease of visual lookup. */
13282 switch (filedata
->file_header
.e_machine
)
13285 return reloc_type
== 37; /* R_RISCV_SUB8. */
13291 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13292 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13295 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13297 switch (filedata
->file_header
.e_machine
)
13300 return reloc_type
== 52; /* R_RISCV_SUB6. */
13306 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13307 relocation entries (possibly formerly used for SHT_GROUP sections). */
13310 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13312 switch (filedata
->file_header
.e_machine
)
13314 case EM_386
: /* R_386_NONE. */
13315 case EM_68K
: /* R_68K_NONE. */
13316 case EM_ADAPTEVA_EPIPHANY
:
13317 case EM_ALPHA
: /* R_ALPHA_NONE. */
13318 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13319 case EM_ARC
: /* R_ARC_NONE. */
13320 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13321 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13322 case EM_ARM
: /* R_ARM_NONE. */
13323 case EM_C166
: /* R_XC16X_NONE. */
13324 case EM_CRIS
: /* R_CRIS_NONE. */
13325 case EM_FT32
: /* R_FT32_NONE. */
13326 case EM_IA_64
: /* R_IA64_NONE. */
13327 case EM_K1OM
: /* R_X86_64_NONE. */
13328 case EM_L1OM
: /* R_X86_64_NONE. */
13329 case EM_M32R
: /* R_M32R_NONE. */
13330 case EM_MIPS
: /* R_MIPS_NONE. */
13331 case EM_MN10300
: /* R_MN10300_NONE. */
13332 case EM_MOXIE
: /* R_MOXIE_NONE. */
13333 case EM_NIOS32
: /* R_NIOS_NONE. */
13334 case EM_OR1K
: /* R_OR1K_NONE. */
13335 case EM_PARISC
: /* R_PARISC_NONE. */
13336 case EM_PPC64
: /* R_PPC64_NONE. */
13337 case EM_PPC
: /* R_PPC_NONE. */
13338 case EM_RISCV
: /* R_RISCV_NONE. */
13339 case EM_S390
: /* R_390_NONE. */
13341 case EM_SH
: /* R_SH_NONE. */
13342 case EM_SPARC32PLUS
:
13343 case EM_SPARC
: /* R_SPARC_NONE. */
13345 case EM_TILEGX
: /* R_TILEGX_NONE. */
13346 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13347 case EM_TI_C6000
:/* R_C6000_NONE. */
13348 case EM_X86_64
: /* R_X86_64_NONE. */
13350 case EM_Z80
: /* R_Z80_NONE. */
13351 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13352 return reloc_type
== 0;
13355 return reloc_type
== 0 || reloc_type
== 256;
13358 return (reloc_type
== 0 /* R_AVR_NONE. */
13359 || reloc_type
== 30 /* R_AVR_DIFF8. */
13360 || reloc_type
== 31 /* R_AVR_DIFF16. */
13361 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13363 return reloc_type
== 3; /* R_METAG_NONE. */
13365 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13366 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13367 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13368 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13369 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13371 return (reloc_type
== 0 /* R_PRU_NONE. */
13372 || reloc_type
== 65 /* R_PRU_DIFF8. */
13373 || reloc_type
== 66 /* R_PRU_DIFF16. */
13374 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13375 case EM_XTENSA_OLD
:
13377 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13378 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13379 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13380 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13381 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13382 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13383 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13384 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13385 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13386 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13391 /* Returns TRUE if there is a relocation against
13392 section NAME at OFFSET bytes. */
13395 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13397 Elf_Internal_Rela
* relocs
;
13398 Elf_Internal_Rela
* rp
;
13400 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13403 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13405 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13406 if (rp
->r_offset
== offset
)
13412 /* Apply relocations to a section.
13413 Returns TRUE upon success, FALSE otherwise.
13414 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13415 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13416 will be set to the number of relocs loaded.
13418 Note: So far support has been added only for those relocations
13419 which can be found in debug sections. FIXME: Add support for
13420 more relocations ? */
13423 apply_relocations (Filedata
* filedata
,
13424 const Elf_Internal_Shdr
* section
,
13425 unsigned char * start
,
13426 bfd_size_type size
,
13427 void ** relocs_return
,
13428 unsigned long * num_relocs_return
)
13430 Elf_Internal_Shdr
* relsec
;
13431 unsigned char * end
= start
+ size
;
13433 if (relocs_return
!= NULL
)
13435 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13436 * num_relocs_return
= 0;
13439 if (filedata
->file_header
.e_type
!= ET_REL
)
13440 /* No relocs to apply. */
13443 /* Find the reloc section associated with the section. */
13444 for (relsec
= filedata
->section_headers
;
13445 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13448 bfd_boolean is_rela
;
13449 unsigned long num_relocs
;
13450 Elf_Internal_Rela
* relocs
;
13451 Elf_Internal_Rela
* rp
;
13452 Elf_Internal_Shdr
* symsec
;
13453 Elf_Internal_Sym
* symtab
;
13454 unsigned long num_syms
;
13455 Elf_Internal_Sym
* sym
;
13457 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13458 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13459 || filedata
->section_headers
+ relsec
->sh_info
!= section
13460 || relsec
->sh_size
== 0
13461 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13464 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13465 if (symsec
->sh_type
!= SHT_SYMTAB
13466 && symsec
->sh_type
!= SHT_DYNSYM
)
13469 is_rela
= relsec
->sh_type
== SHT_RELA
;
13473 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13474 relsec
->sh_size
, & relocs
, & num_relocs
))
13479 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13480 relsec
->sh_size
, & relocs
, & num_relocs
))
13484 /* SH uses RELA but uses in place value instead of the addend field. */
13485 if (filedata
->file_header
.e_machine
== EM_SH
)
13488 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13490 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13493 unsigned int reloc_type
;
13494 unsigned int reloc_size
;
13495 bfd_boolean reloc_inplace
= FALSE
;
13496 bfd_boolean reloc_subtract
= FALSE
;
13497 unsigned char * rloc
;
13498 unsigned long sym_index
;
13500 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13502 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13504 else if (is_none_reloc (filedata
, reloc_type
))
13506 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13507 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13509 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13510 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13512 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13514 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13516 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13517 || is_6bit_abs_reloc (filedata
, reloc_type
))
13519 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13521 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13524 reloc_inplace
= TRUE
;
13526 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13528 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13531 reloc_inplace
= TRUE
;
13533 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13535 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13538 reloc_inplace
= TRUE
;
13540 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13542 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13545 reloc_inplace
= TRUE
;
13547 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13551 reloc_inplace
= TRUE
;
13555 static unsigned int prev_reloc
= 0;
13557 if (reloc_type
!= prev_reloc
)
13558 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13559 reloc_type
, printable_section_name (filedata
, section
));
13560 prev_reloc
= reloc_type
;
13564 rloc
= start
+ rp
->r_offset
;
13565 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13567 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13568 (unsigned long) rp
->r_offset
,
13569 printable_section_name (filedata
, section
));
13573 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13574 if (sym_index
>= num_syms
)
13576 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13577 sym_index
, printable_section_name (filedata
, section
));
13580 sym
= symtab
+ sym_index
;
13582 /* If the reloc has a symbol associated with it,
13583 make sure that it is of an appropriate type.
13585 Relocations against symbols without type can happen.
13586 Gcc -feliminate-dwarf2-dups may generate symbols
13587 without type for debug info.
13589 Icc generates relocations against function symbols
13590 instead of local labels.
13592 Relocations against object symbols can happen, eg when
13593 referencing a global array. For an example of this see
13594 the _clz.o binary in libgcc.a. */
13596 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13597 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13599 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13600 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13601 printable_section_name (filedata
, relsec
),
13602 (long int)(rp
- relocs
));
13608 addend
+= rp
->r_addend
;
13609 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13610 partial_inplace. */
13612 || (filedata
->file_header
.e_machine
== EM_XTENSA
13613 && reloc_type
== 1)
13614 || ((filedata
->file_header
.e_machine
== EM_PJ
13615 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13616 && reloc_type
== 1)
13617 || ((filedata
->file_header
.e_machine
== EM_D30V
13618 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13619 && reloc_type
== 12)
13622 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13623 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13625 addend
+= byte_get (rloc
, reloc_size
);
13628 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13629 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13631 /* On HPPA, all pc-relative relocations are biased by 8. */
13632 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13634 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13637 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13638 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13640 if (reloc_subtract
)
13641 addend
-= sym
->st_value
;
13643 addend
+= sym
->st_value
;
13644 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13645 byte_put (rloc
, addend
, reloc_size
);
13647 else if (reloc_subtract
)
13648 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13650 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13654 /* Let the target specific reloc processing code know that
13655 we have finished with these relocs. */
13656 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13660 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13661 * num_relocs_return
= num_relocs
;
13672 #ifdef SUPPORT_DISASSEMBLY
13674 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13676 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13678 /* FIXME: XXX -- to be done --- XXX */
13684 /* Reads in the contents of SECTION from FILE, returning a pointer
13685 to a malloc'ed buffer or NULL if something went wrong. */
13688 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13690 bfd_size_type num_bytes
= section
->sh_size
;
13692 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13694 printf (_("Section '%s' has no data to dump.\n"),
13695 printable_section_name (filedata
, section
));
13699 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13700 _("section contents"));
13703 /* Uncompresses a section that was compressed using zlib, in place. */
13706 uncompress_section_contents (unsigned char ** buffer
,
13707 dwarf_size_type uncompressed_size
,
13708 dwarf_size_type
* size
)
13710 dwarf_size_type compressed_size
= *size
;
13711 unsigned char * compressed_buffer
= *buffer
;
13712 unsigned char * uncompressed_buffer
;
13716 /* It is possible the section consists of several compressed
13717 buffers concatenated together, so we uncompress in a loop. */
13718 /* PR 18313: The state field in the z_stream structure is supposed
13719 to be invisible to the user (ie us), but some compilers will
13720 still complain about it being used without initialisation. So
13721 we first zero the entire z_stream structure and then set the fields
13723 memset (& strm
, 0, sizeof strm
);
13724 strm
.avail_in
= compressed_size
;
13725 strm
.next_in
= (Bytef
*) compressed_buffer
;
13726 strm
.avail_out
= uncompressed_size
;
13727 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13729 rc
= inflateInit (& strm
);
13730 while (strm
.avail_in
> 0)
13734 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13735 + (uncompressed_size
- strm
.avail_out
));
13736 rc
= inflate (&strm
, Z_FINISH
);
13737 if (rc
!= Z_STREAM_END
)
13739 rc
= inflateReset (& strm
);
13741 rc
= inflateEnd (& strm
);
13743 || strm
.avail_out
!= 0)
13746 *buffer
= uncompressed_buffer
;
13747 *size
= uncompressed_size
;
13751 free (uncompressed_buffer
);
13752 /* Indicate decompression failure. */
13758 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13760 Elf_Internal_Shdr
* relsec
;
13761 bfd_size_type num_bytes
;
13762 unsigned char * data
;
13763 unsigned char * end
;
13764 unsigned char * real_start
;
13765 unsigned char * start
;
13766 bfd_boolean some_strings_shown
;
13768 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13770 /* PR 21820: Do not fail if the section was empty. */
13771 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13773 num_bytes
= section
->sh_size
;
13775 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13777 if (decompress_dumps
)
13779 dwarf_size_type new_size
= num_bytes
;
13780 dwarf_size_type uncompressed_size
= 0;
13782 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13784 Elf_Internal_Chdr chdr
;
13785 unsigned int compression_header_size
13786 = get_compression_header (& chdr
, (unsigned char *) start
,
13788 if (compression_header_size
== 0)
13789 /* An error message will have already been generated
13790 by get_compression_header. */
13793 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13795 warn (_("section '%s' has unsupported compress type: %d\n"),
13796 printable_section_name (filedata
, section
), chdr
.ch_type
);
13799 uncompressed_size
= chdr
.ch_size
;
13800 start
+= compression_header_size
;
13801 new_size
-= compression_header_size
;
13803 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13805 /* Read the zlib header. In this case, it should be "ZLIB"
13806 followed by the uncompressed section size, 8 bytes in
13807 big-endian order. */
13808 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13809 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13810 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13811 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13812 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13813 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13814 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13815 uncompressed_size
+= start
[11];
13820 if (uncompressed_size
)
13822 if (uncompress_section_contents (& start
,
13823 uncompressed_size
, & new_size
))
13824 num_bytes
= new_size
;
13827 error (_("Unable to decompress section %s\n"),
13828 printable_section_name (filedata
, section
));
13833 start
= real_start
;
13836 /* If the section being dumped has relocations against it the user might
13837 be expecting these relocations to have been applied. Check for this
13838 case and issue a warning message in order to avoid confusion.
13839 FIXME: Maybe we ought to have an option that dumps a section with
13840 relocs applied ? */
13841 for (relsec
= filedata
->section_headers
;
13842 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13845 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13846 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13847 || filedata
->section_headers
+ relsec
->sh_info
!= section
13848 || relsec
->sh_size
== 0
13849 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13852 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13857 end
= start
+ num_bytes
;
13858 some_strings_shown
= FALSE
;
13860 #ifdef HAVE_MBSTATE_T
13862 /* Initialise the multibyte conversion state. */
13863 memset (& state
, 0, sizeof (state
));
13866 bfd_boolean continuing
= FALSE
;
13870 while (!ISPRINT (* data
))
13871 if (++ data
>= end
)
13876 size_t maxlen
= end
- data
;
13881 continuing
= FALSE
;
13886 /* PR 11128: Use two separate invocations in order to work
13887 around bugs in the Solaris 8 implementation of printf. */
13888 printf (" [%6tx] ", data
- start
);
13890 printf (" [%6Ix] ", (size_t) (data
- start
));
13905 /* PR 25543: Treat new-lines as string-ending characters. */
13914 /* Do not print control characters directly as they can affect terminal
13915 settings. Such characters usually appear in the names generated
13916 by the assembler for local labels. */
13919 printf ("^%c", c
+ 0x40);
13921 else if (ISPRINT (c
))
13928 #ifdef HAVE_MBSTATE_T
13931 /* Let printf do the hard work of displaying multibyte characters. */
13932 printf ("%.1s", data
- 1);
13933 #ifdef HAVE_MBSTATE_T
13934 /* Try to find out how many bytes made up the character that was
13935 just printed. Advance the symbol pointer past the bytes that
13937 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13941 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13951 printf (_("<corrupt>\n"));
13954 some_strings_shown
= TRUE
;
13958 if (! some_strings_shown
)
13959 printf (_(" No strings found in this section."));
13972 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13973 Filedata
* filedata
,
13974 bfd_boolean relocate
)
13976 Elf_Internal_Shdr
* relsec
;
13977 bfd_size_type bytes
;
13978 bfd_size_type section_size
;
13980 unsigned char * data
;
13981 unsigned char * real_start
;
13982 unsigned char * start
;
13984 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13986 /* PR 21820: Do not fail if the section was empty. */
13987 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13989 section_size
= section
->sh_size
;
13991 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13993 if (decompress_dumps
)
13995 dwarf_size_type new_size
= section_size
;
13996 dwarf_size_type uncompressed_size
= 0;
13998 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14000 Elf_Internal_Chdr chdr
;
14001 unsigned int compression_header_size
14002 = get_compression_header (& chdr
, start
, section_size
);
14004 if (compression_header_size
== 0)
14005 /* An error message will have already been generated
14006 by get_compression_header. */
14009 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14011 warn (_("section '%s' has unsupported compress type: %d\n"),
14012 printable_section_name (filedata
, section
), chdr
.ch_type
);
14015 uncompressed_size
= chdr
.ch_size
;
14016 start
+= compression_header_size
;
14017 new_size
-= compression_header_size
;
14019 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14021 /* Read the zlib header. In this case, it should be "ZLIB"
14022 followed by the uncompressed section size, 8 bytes in
14023 big-endian order. */
14024 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14025 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14026 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14027 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14028 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14029 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14030 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14031 uncompressed_size
+= start
[11];
14036 if (uncompressed_size
)
14038 if (uncompress_section_contents (& start
, uncompressed_size
,
14041 section_size
= new_size
;
14045 error (_("Unable to decompress section %s\n"),
14046 printable_section_name (filedata
, section
));
14047 /* FIXME: Print the section anyway ? */
14052 start
= real_start
;
14057 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14062 /* If the section being dumped has relocations against it the user might
14063 be expecting these relocations to have been applied. Check for this
14064 case and issue a warning message in order to avoid confusion.
14065 FIXME: Maybe we ought to have an option that dumps a section with
14066 relocs applied ? */
14067 for (relsec
= filedata
->section_headers
;
14068 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14071 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14072 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14073 || filedata
->section_headers
+ relsec
->sh_info
!= section
14074 || relsec
->sh_size
== 0
14075 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14078 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14083 addr
= section
->sh_addr
;
14084 bytes
= section_size
;
14093 lbytes
= (bytes
> 16 ? 16 : bytes
);
14095 printf (" 0x%8.8lx ", (unsigned long) addr
);
14097 for (j
= 0; j
< 16; j
++)
14100 printf ("%2.2x", data
[j
]);
14108 for (j
= 0; j
< lbytes
; j
++)
14111 if (k
>= ' ' && k
< 0x7f)
14134 static ctf_sect_t
*
14135 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14137 buf
->cts_name
= SECTION_NAME (shdr
);
14138 buf
->cts_size
= shdr
->sh_size
;
14139 buf
->cts_entsize
= shdr
->sh_entsize
;
14144 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14145 it is passed, or a pointer to newly-allocated storage, in which case
14146 dump_ctf() will free it when it no longer needs it. */
14148 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14149 char *s
, void *arg
)
14151 const char *blanks
= arg
;
14154 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14160 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14162 Elf_Internal_Shdr
* parent_sec
= NULL
;
14163 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14164 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14165 void * data
= NULL
;
14166 void * symdata
= NULL
;
14167 void * strdata
= NULL
;
14168 void * parentdata
= NULL
;
14169 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14170 ctf_sect_t
* symsectp
= NULL
;
14171 ctf_sect_t
* strsectp
= NULL
;
14172 ctf_file_t
* ctf
= NULL
;
14173 ctf_file_t
* parent
= NULL
;
14175 const char *things
[] = {"Header", "Labels", "Data objects",
14176 "Function objects", "Variables", "Types", "Strings",
14178 const char **thing
;
14180 bfd_boolean ret
= FALSE
;
14183 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14184 data
= get_section_contents (section
, filedata
);
14185 ctfsect
.cts_data
= data
;
14187 if (!dump_ctf_symtab_name
)
14188 dump_ctf_symtab_name
= strdup (".symtab");
14190 if (!dump_ctf_strtab_name
)
14191 dump_ctf_strtab_name
= strdup (".strtab");
14193 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14195 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14197 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14200 if ((symdata
= (void *) get_data (NULL
, filedata
,
14201 symtab_sec
->sh_offset
, 1,
14202 symtab_sec
->sh_size
,
14203 _("symbols"))) == NULL
)
14205 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14206 symsect
.cts_data
= symdata
;
14208 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14210 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14212 error (_("No string table section named %s\n"),
14213 dump_ctf_strtab_name
);
14216 if ((strdata
= (void *) get_data (NULL
, filedata
,
14217 strtab_sec
->sh_offset
, 1,
14218 strtab_sec
->sh_size
,
14219 _("strings"))) == NULL
)
14221 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14222 strsect
.cts_data
= strdata
;
14224 if (dump_ctf_parent_name
)
14226 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14228 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14231 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14232 parent_sec
->sh_offset
, 1,
14233 parent_sec
->sh_size
,
14234 _("CTF parent"))) == NULL
)
14236 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14237 parentsect
.cts_data
= parentdata
;
14240 /* Load the CTF file and dump it. */
14242 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14244 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14250 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14252 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14256 ctf_import (ctf
, parent
);
14261 printf (_("\nDump of CTF section '%s':\n"),
14262 printable_section_name (filedata
, section
));
14264 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14266 ctf_dump_state_t
*s
= NULL
;
14269 printf ("\n %s:\n", *thing
);
14270 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14271 (void *) " ")) != NULL
)
14273 printf ("%s\n", item
);
14277 if (ctf_errno (ctf
))
14279 error (_("Iteration failed: %s, %s\n"), *thing
,
14280 ctf_errmsg (ctf_errno (ctf
)));
14286 ctf_file_close (ctf
);
14287 ctf_file_close (parent
);
14296 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14297 const Elf_Internal_Shdr
* sec
,
14300 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14302 Filedata
* filedata
= (Filedata
*) data
;
14304 if (section
->start
!= NULL
)
14306 /* If it is already loaded, do nothing. */
14307 if (streq (section
->filename
, filedata
->file_name
))
14309 free (section
->start
);
14312 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14313 section
->address
= sec
->sh_addr
;
14314 section
->user_data
= NULL
;
14315 section
->filename
= filedata
->file_name
;
14316 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14318 sec
->sh_size
, buf
);
14319 if (section
->start
== NULL
)
14323 unsigned char *start
= section
->start
;
14324 dwarf_size_type size
= sec
->sh_size
;
14325 dwarf_size_type uncompressed_size
= 0;
14327 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14329 Elf_Internal_Chdr chdr
;
14330 unsigned int compression_header_size
;
14332 if (size
< (is_32bit_elf
14333 ? sizeof (Elf32_External_Chdr
)
14334 : sizeof (Elf64_External_Chdr
)))
14336 warn (_("compressed section %s is too small to contain a compression header\n"),
14341 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14342 if (compression_header_size
== 0)
14343 /* An error message will have already been generated
14344 by get_compression_header. */
14347 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14349 warn (_("section '%s' has unsupported compress type: %d\n"),
14350 section
->name
, chdr
.ch_type
);
14353 uncompressed_size
= chdr
.ch_size
;
14354 start
+= compression_header_size
;
14355 size
-= compression_header_size
;
14357 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14359 /* Read the zlib header. In this case, it should be "ZLIB"
14360 followed by the uncompressed section size, 8 bytes in
14361 big-endian order. */
14362 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14363 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14364 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14365 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14366 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14367 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14368 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14369 uncompressed_size
+= start
[11];
14374 if (uncompressed_size
)
14376 if (uncompress_section_contents (&start
, uncompressed_size
,
14379 /* Free the compressed buffer, update the section buffer
14380 and the section size if uncompress is successful. */
14381 free (section
->start
);
14382 section
->start
= start
;
14386 error (_("Unable to decompress section %s\n"),
14387 printable_section_name (filedata
, sec
));
14392 section
->size
= size
;
14395 if (section
->start
== NULL
)
14398 if (debug_displays
[debug
].relocate
)
14400 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14401 & section
->reloc_info
, & section
->num_relocs
))
14406 section
->reloc_info
= NULL
;
14407 section
->num_relocs
= 0;
14413 #if HAVE_LIBDEBUGINFOD
14414 /* Return a hex string representation of the build-id. */
14416 get_build_id (void * data
)
14418 Filedata
* filedata
= (Filedata
*)data
;
14419 Elf_Internal_Shdr
* shdr
;
14422 /* Iterate through notes to find note.gnu.build-id.
14423 FIXME: Only the first note in any note section is examined. */
14424 for (i
= 0, shdr
= filedata
->section_headers
;
14425 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14428 if (shdr
->sh_type
!= SHT_NOTE
)
14433 size_t data_remaining
;
14435 Elf_External_Note
* enote
;
14436 Elf_Internal_Note inote
;
14438 bfd_vma offset
= shdr
->sh_offset
;
14439 bfd_vma align
= shdr
->sh_addralign
;
14440 bfd_vma length
= shdr
->sh_size
;
14442 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14448 else if (align
!= 4 && align
!= 8)
14454 end
= (char *) enote
+ length
;
14455 data_remaining
= end
- (char *) enote
;
14457 if (!is_ia64_vms (filedata
))
14459 min_notesz
= offsetof (Elf_External_Note
, name
);
14460 if (data_remaining
< min_notesz
)
14463 malformed note encountered in section %s whilst scanning for build-id note\n"),
14464 printable_section_name (filedata
, shdr
));
14468 data_remaining
-= min_notesz
;
14470 inote
.type
= BYTE_GET (enote
->type
);
14471 inote
.namesz
= BYTE_GET (enote
->namesz
);
14472 inote
.namedata
= enote
->name
;
14473 inote
.descsz
= BYTE_GET (enote
->descsz
);
14474 inote
.descdata
= ((char *) enote
14475 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14476 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14477 next
= ((char *) enote
14478 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14482 Elf64_External_VMS_Note
*vms_enote
;
14484 /* PR binutils/15191
14485 Make sure that there is enough data to read. */
14486 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14487 if (data_remaining
< min_notesz
)
14490 malformed note encountered in section %s whilst scanning for build-id note\n"),
14491 printable_section_name (filedata
, shdr
));
14495 data_remaining
-= min_notesz
;
14497 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14498 inote
.type
= BYTE_GET (vms_enote
->type
);
14499 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14500 inote
.namedata
= vms_enote
->name
;
14501 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14502 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14503 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14504 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14507 /* Skip malformed notes. */
14508 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14509 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14510 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14511 || ((size_t) (next
- inote
.descdata
)
14512 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14515 malformed note encountered in section %s whilst scanning for build-id note\n"),
14516 printable_section_name (filedata
, shdr
));
14521 /* Check if this is the build-id note. If so then convert the build-id
14522 bytes to a hex string. */
14523 if (inote
.namesz
> 0
14524 && const_strneq (inote
.namedata
, "GNU")
14525 && inote
.type
== NT_GNU_BUILD_ID
)
14530 build_id
= malloc (inote
.descsz
* 2 + 1);
14531 if (build_id
== NULL
)
14537 for (j
= 0; j
< inote
.descsz
; ++j
)
14538 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14539 build_id
[inote
.descsz
* 2] = '\0';
14542 return (unsigned char *) build_id
;
14549 #endif /* HAVE_LIBDEBUGINFOD */
14551 /* If this is not NULL, load_debug_section will only look for sections
14552 within the list of sections given here. */
14553 static unsigned int * section_subset
= NULL
;
14556 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14558 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14559 Elf_Internal_Shdr
* sec
;
14560 Filedata
* filedata
= (Filedata
*) data
;
14562 /* Without section headers we cannot find any sections. */
14563 if (filedata
->section_headers
== NULL
)
14566 if (filedata
->string_table
== NULL
14567 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14568 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14570 Elf_Internal_Shdr
* strs
;
14572 /* Read in the string table, so that we have section names to scan. */
14573 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14575 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14577 filedata
->string_table
14578 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14579 1, strs
->sh_size
, _("string table"));
14581 filedata
->string_table_length
14582 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14586 /* Locate the debug section. */
14587 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14589 section
->name
= section
->uncompressed_name
;
14592 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14594 section
->name
= section
->compressed_name
;
14599 /* If we're loading from a subset of sections, and we've loaded
14600 a section matching this name before, it's likely that it's a
14602 if (section_subset
!= NULL
)
14603 free_debug_section (debug
);
14605 return load_specific_debug_section (debug
, sec
, data
);
14609 free_debug_section (enum dwarf_section_display_enum debug
)
14611 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14613 if (section
->start
== NULL
)
14616 free ((char *) section
->start
);
14617 section
->start
= NULL
;
14618 section
->address
= 0;
14621 free (section
->reloc_info
);
14622 section
->reloc_info
= NULL
;
14623 section
->num_relocs
= 0;
14627 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14629 char * name
= SECTION_NAME (section
);
14630 const char * print_name
= printable_section_name (filedata
, section
);
14631 bfd_size_type length
;
14632 bfd_boolean result
= TRUE
;
14635 length
= section
->sh_size
;
14638 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14641 if (section
->sh_type
== SHT_NOBITS
)
14643 /* There is no point in dumping the contents of a debugging section
14644 which has the NOBITS type - the bits in the file will be random.
14645 This can happen when a file containing a .eh_frame section is
14646 stripped with the --only-keep-debug command line option. */
14647 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14652 if (const_strneq (name
, ".gnu.linkonce.wi."))
14653 name
= ".debug_info";
14655 /* See if we know how to display the contents of this section. */
14656 for (i
= 0; i
< max
; i
++)
14658 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14659 struct dwarf_section_display
* display
= debug_displays
+ i
;
14660 struct dwarf_section
* sec
= & display
->section
;
14662 if (streq (sec
->uncompressed_name
, name
)
14663 || (id
== line
&& const_strneq (name
, ".debug_line."))
14664 || streq (sec
->compressed_name
, name
))
14666 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14669 free_debug_section (id
);
14671 if (i
== line
&& const_strneq (name
, ".debug_line."))
14673 else if (streq (sec
->uncompressed_name
, name
))
14674 sec
->name
= sec
->uncompressed_name
;
14676 sec
->name
= sec
->compressed_name
;
14678 if (load_specific_debug_section (id
, section
, filedata
))
14680 /* If this debug section is part of a CU/TU set in a .dwp file,
14681 restrict load_debug_section to the sections in that set. */
14682 section_subset
= find_cu_tu_set (filedata
, shndx
);
14684 result
&= display
->display (sec
, filedata
);
14686 section_subset
= NULL
;
14688 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14689 free_debug_section (id
);
14697 printf (_("Unrecognized debug section: %s\n"), print_name
);
14704 /* Set DUMP_SECTS for all sections where dumps were requested
14705 based on section name. */
14708 initialise_dumps_byname (Filedata
* filedata
)
14710 struct dump_list_entry
* cur
;
14712 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14715 bfd_boolean any
= FALSE
;
14717 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14718 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14720 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14725 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14731 process_section_contents (Filedata
* filedata
)
14733 Elf_Internal_Shdr
* section
;
14735 bfd_boolean res
= TRUE
;
14740 initialise_dumps_byname (filedata
);
14742 for (i
= 0, section
= filedata
->section_headers
;
14743 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14746 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14748 #ifdef SUPPORT_DISASSEMBLY
14749 if (dump
& DISASS_DUMP
)
14751 if (! disassemble_section (section
, filedata
))
14755 if (dump
& HEX_DUMP
)
14757 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14761 if (dump
& RELOC_DUMP
)
14763 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14767 if (dump
& STRING_DUMP
)
14769 if (! dump_section_as_strings (section
, filedata
))
14773 if (dump
& DEBUG_DUMP
)
14775 if (! display_debug_section (i
, section
, filedata
))
14779 if (dump
& CTF_DUMP
)
14781 if (! dump_section_as_ctf (section
, filedata
))
14786 /* Check to see if the user requested a
14787 dump of a section that does not exist. */
14788 while (i
< filedata
->dump
.num_dump_sects
)
14790 if (filedata
->dump
.dump_sects
[i
])
14792 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14802 process_mips_fpe_exception (int mask
)
14806 bfd_boolean first
= TRUE
;
14808 if (mask
& OEX_FPU_INEX
)
14809 fputs ("INEX", stdout
), first
= FALSE
;
14810 if (mask
& OEX_FPU_UFLO
)
14811 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14812 if (mask
& OEX_FPU_OFLO
)
14813 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14814 if (mask
& OEX_FPU_DIV0
)
14815 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14816 if (mask
& OEX_FPU_INVAL
)
14817 printf ("%sINVAL", first
? "" : "|");
14820 fputs ("0", stdout
);
14823 /* Display's the value of TAG at location P. If TAG is
14824 greater than 0 it is assumed to be an unknown tag, and
14825 a message is printed to this effect. Otherwise it is
14826 assumed that a message has already been printed.
14828 If the bottom bit of TAG is set it assumed to have a
14829 string value, otherwise it is assumed to have an integer
14832 Returns an updated P pointing to the first unread byte
14833 beyond the end of TAG's value.
14835 Reads at or beyond END will not be made. */
14837 static unsigned char *
14838 display_tag_value (signed int tag
,
14840 const unsigned char * const end
)
14845 printf (" Tag_unknown_%d: ", tag
);
14849 warn (_("<corrupt tag>\n"));
14853 /* PR 17531 file: 027-19978-0.004. */
14854 size_t maxlen
= (end
- p
) - 1;
14859 print_symbol ((int) maxlen
, (const char *) p
);
14860 p
+= strnlen ((char *) p
, maxlen
) + 1;
14864 printf (_("<corrupt string tag>"));
14865 p
= (unsigned char *) end
;
14871 READ_ULEB (val
, p
, end
);
14872 printf ("%ld (0x%lx)\n", val
, val
);
14879 /* ARC ABI attributes section. */
14881 static unsigned char *
14882 display_arc_attribute (unsigned char * p
,
14883 const unsigned char * const end
)
14888 READ_ULEB (tag
, p
, end
);
14892 case Tag_ARC_PCS_config
:
14893 READ_ULEB (val
, p
, end
);
14894 printf (" Tag_ARC_PCS_config: ");
14898 printf (_("Absent/Non standard\n"));
14901 printf (_("Bare metal/mwdt\n"));
14904 printf (_("Bare metal/newlib\n"));
14907 printf (_("Linux/uclibc\n"));
14910 printf (_("Linux/glibc\n"));
14913 printf (_("Unknown\n"));
14918 case Tag_ARC_CPU_base
:
14919 READ_ULEB (val
, p
, end
);
14920 printf (" Tag_ARC_CPU_base: ");
14925 printf (_("Absent\n"));
14927 case TAG_CPU_ARC6xx
:
14928 printf ("ARC6xx\n");
14930 case TAG_CPU_ARC7xx
:
14931 printf ("ARC7xx\n");
14933 case TAG_CPU_ARCEM
:
14934 printf ("ARCEM\n");
14936 case TAG_CPU_ARCHS
:
14937 printf ("ARCHS\n");
14942 case Tag_ARC_CPU_variation
:
14943 READ_ULEB (val
, p
, end
);
14944 printf (" Tag_ARC_CPU_variation: ");
14948 if (val
> 0 && val
< 16)
14949 printf ("Core%d\n", val
);
14951 printf ("Unknown\n");
14955 printf (_("Absent\n"));
14960 case Tag_ARC_CPU_name
:
14961 printf (" Tag_ARC_CPU_name: ");
14962 p
= display_tag_value (-1, p
, end
);
14965 case Tag_ARC_ABI_rf16
:
14966 READ_ULEB (val
, p
, end
);
14967 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14970 case Tag_ARC_ABI_osver
:
14971 READ_ULEB (val
, p
, end
);
14972 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14975 case Tag_ARC_ABI_pic
:
14976 case Tag_ARC_ABI_sda
:
14977 READ_ULEB (val
, p
, end
);
14978 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14979 : " Tag_ARC_ABI_pic: ");
14983 printf (_("Absent\n"));
14992 printf (_("Unknown\n"));
14997 case Tag_ARC_ABI_tls
:
14998 READ_ULEB (val
, p
, end
);
14999 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15002 case Tag_ARC_ABI_enumsize
:
15003 READ_ULEB (val
, p
, end
);
15004 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15008 case Tag_ARC_ABI_exceptions
:
15009 READ_ULEB (val
, p
, end
);
15010 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15014 case Tag_ARC_ABI_double_size
:
15015 READ_ULEB (val
, p
, end
);
15016 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15019 case Tag_ARC_ISA_config
:
15020 printf (" Tag_ARC_ISA_config: ");
15021 p
= display_tag_value (-1, p
, end
);
15024 case Tag_ARC_ISA_apex
:
15025 printf (" Tag_ARC_ISA_apex: ");
15026 p
= display_tag_value (-1, p
, end
);
15029 case Tag_ARC_ISA_mpy_option
:
15030 READ_ULEB (val
, p
, end
);
15031 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15034 case Tag_ARC_ATR_version
:
15035 READ_ULEB (val
, p
, end
);
15036 printf (" Tag_ARC_ATR_version: %d\n", val
);
15040 return display_tag_value (tag
& 1, p
, end
);
15046 /* ARM EABI attributes section. */
15051 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15053 const char ** table
;
15054 } arm_attr_public_tag
;
15056 static const char * arm_attr_tag_CPU_arch
[] =
15057 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15058 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15059 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15060 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15061 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15062 {"No", "Thumb-1", "Thumb-2", "Yes"};
15063 static const char * arm_attr_tag_FP_arch
[] =
15064 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15065 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15066 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15067 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15068 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15069 "NEON for ARMv8.1"};
15070 static const char * arm_attr_tag_PCS_config
[] =
15071 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15072 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15073 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15074 {"V6", "SB", "TLS", "Unused"};
15075 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15076 {"Absolute", "PC-relative", "SB-relative", "None"};
15077 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15078 {"Absolute", "PC-relative", "None"};
15079 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15080 {"None", "direct", "GOT-indirect"};
15081 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15082 {"None", "??? 1", "2", "??? 3", "4"};
15083 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15084 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15085 {"Unused", "Needed", "Sign only"};
15086 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15087 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15088 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15089 {"Unused", "Finite", "RTABI", "IEEE 754"};
15090 static const char * arm_attr_tag_ABI_enum_size
[] =
15091 {"Unused", "small", "int", "forced to int"};
15092 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15093 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15094 static const char * arm_attr_tag_ABI_VFP_args
[] =
15095 {"AAPCS", "VFP registers", "custom", "compatible"};
15096 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15097 {"AAPCS", "WMMX registers", "custom"};
15098 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15099 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15100 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15101 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15102 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15103 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15104 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15105 static const char * arm_attr_tag_FP_HP_extension
[] =
15106 {"Not Allowed", "Allowed"};
15107 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15108 {"None", "IEEE 754", "Alternative Format"};
15109 static const char * arm_attr_tag_DSP_extension
[] =
15110 {"Follow architecture", "Allowed"};
15111 static const char * arm_attr_tag_MPextension_use
[] =
15112 {"Not Allowed", "Allowed"};
15113 static const char * arm_attr_tag_DIV_use
[] =
15114 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15115 "Allowed in v7-A with integer division extension"};
15116 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15117 static const char * arm_attr_tag_Virtualization_use
[] =
15118 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15119 "TrustZone and Virtualization Extensions"};
15120 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15121 {"Not Allowed", "Allowed"};
15123 static const char * arm_attr_tag_MVE_arch
[] =
15124 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15126 #define LOOKUP(id, name) \
15127 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15128 static arm_attr_public_tag arm_attr_public_tags
[] =
15130 {4, "CPU_raw_name", 1, NULL
},
15131 {5, "CPU_name", 1, NULL
},
15132 LOOKUP(6, CPU_arch
),
15133 {7, "CPU_arch_profile", 0, NULL
},
15134 LOOKUP(8, ARM_ISA_use
),
15135 LOOKUP(9, THUMB_ISA_use
),
15136 LOOKUP(10, FP_arch
),
15137 LOOKUP(11, WMMX_arch
),
15138 LOOKUP(12, Advanced_SIMD_arch
),
15139 LOOKUP(13, PCS_config
),
15140 LOOKUP(14, ABI_PCS_R9_use
),
15141 LOOKUP(15, ABI_PCS_RW_data
),
15142 LOOKUP(16, ABI_PCS_RO_data
),
15143 LOOKUP(17, ABI_PCS_GOT_use
),
15144 LOOKUP(18, ABI_PCS_wchar_t
),
15145 LOOKUP(19, ABI_FP_rounding
),
15146 LOOKUP(20, ABI_FP_denormal
),
15147 LOOKUP(21, ABI_FP_exceptions
),
15148 LOOKUP(22, ABI_FP_user_exceptions
),
15149 LOOKUP(23, ABI_FP_number_model
),
15150 {24, "ABI_align_needed", 0, NULL
},
15151 {25, "ABI_align_preserved", 0, NULL
},
15152 LOOKUP(26, ABI_enum_size
),
15153 LOOKUP(27, ABI_HardFP_use
),
15154 LOOKUP(28, ABI_VFP_args
),
15155 LOOKUP(29, ABI_WMMX_args
),
15156 LOOKUP(30, ABI_optimization_goals
),
15157 LOOKUP(31, ABI_FP_optimization_goals
),
15158 {32, "compatibility", 0, NULL
},
15159 LOOKUP(34, CPU_unaligned_access
),
15160 LOOKUP(36, FP_HP_extension
),
15161 LOOKUP(38, ABI_FP_16bit_format
),
15162 LOOKUP(42, MPextension_use
),
15163 LOOKUP(44, DIV_use
),
15164 LOOKUP(46, DSP_extension
),
15165 LOOKUP(48, MVE_arch
),
15166 {64, "nodefaults", 0, NULL
},
15167 {65, "also_compatible_with", 0, NULL
},
15168 LOOKUP(66, T2EE_use
),
15169 {67, "conformance", 1, NULL
},
15170 LOOKUP(68, Virtualization_use
),
15171 LOOKUP(70, MPextension_use_legacy
)
15175 static unsigned char *
15176 display_arm_attribute (unsigned char * p
,
15177 const unsigned char * const end
)
15181 arm_attr_public_tag
* attr
;
15185 READ_ULEB (tag
, p
, end
);
15187 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15189 if (arm_attr_public_tags
[i
].tag
== tag
)
15191 attr
= &arm_attr_public_tags
[i
];
15198 printf (" Tag_%s: ", attr
->name
);
15199 switch (attr
->type
)
15204 case 7: /* Tag_CPU_arch_profile. */
15205 READ_ULEB (val
, p
, end
);
15208 case 0: printf (_("None\n")); break;
15209 case 'A': printf (_("Application\n")); break;
15210 case 'R': printf (_("Realtime\n")); break;
15211 case 'M': printf (_("Microcontroller\n")); break;
15212 case 'S': printf (_("Application or Realtime\n")); break;
15213 default: printf ("??? (%d)\n", val
); break;
15217 case 24: /* Tag_align_needed. */
15218 READ_ULEB (val
, p
, end
);
15221 case 0: printf (_("None\n")); break;
15222 case 1: printf (_("8-byte\n")); break;
15223 case 2: printf (_("4-byte\n")); break;
15224 case 3: printf ("??? 3\n"); break;
15227 printf (_("8-byte and up to %d-byte extended\n"),
15230 printf ("??? (%d)\n", val
);
15235 case 25: /* Tag_align_preserved. */
15236 READ_ULEB (val
, p
, end
);
15239 case 0: printf (_("None\n")); break;
15240 case 1: printf (_("8-byte, except leaf SP\n")); break;
15241 case 2: printf (_("8-byte\n")); break;
15242 case 3: printf ("??? 3\n"); break;
15245 printf (_("8-byte and up to %d-byte extended\n"),
15248 printf ("??? (%d)\n", val
);
15253 case 32: /* Tag_compatibility. */
15255 READ_ULEB (val
, p
, end
);
15256 printf (_("flag = %d, vendor = "), val
);
15259 size_t maxlen
= (end
- p
) - 1;
15261 print_symbol ((int) maxlen
, (const char *) p
);
15262 p
+= strnlen ((char *) p
, maxlen
) + 1;
15266 printf (_("<corrupt>"));
15267 p
= (unsigned char *) end
;
15273 case 64: /* Tag_nodefaults. */
15274 /* PR 17531: file: 001-505008-0.01. */
15277 printf (_("True\n"));
15280 case 65: /* Tag_also_compatible_with. */
15281 READ_ULEB (val
, p
, end
);
15282 if (val
== 6 /* Tag_CPU_arch. */)
15284 READ_ULEB (val
, p
, end
);
15285 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15286 printf ("??? (%d)\n", val
);
15288 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15292 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15297 printf (_("<unknown: %d>\n"), tag
);
15303 return display_tag_value (-1, p
, end
);
15305 return display_tag_value (0, p
, end
);
15308 assert (attr
->type
& 0x80);
15309 READ_ULEB (val
, p
, end
);
15310 type
= attr
->type
& 0x7f;
15312 printf ("??? (%d)\n", val
);
15314 printf ("%s\n", attr
->table
[val
]);
15319 return display_tag_value (tag
, p
, end
);
15322 static unsigned char *
15323 display_gnu_attribute (unsigned char * p
,
15324 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15325 const unsigned char * const end
)
15330 READ_ULEB (tag
, p
, end
);
15332 /* Tag_compatibility is the only generic GNU attribute defined at
15336 READ_ULEB (val
, p
, end
);
15338 printf (_("flag = %d, vendor = "), val
);
15341 printf (_("<corrupt>\n"));
15342 warn (_("corrupt vendor attribute\n"));
15348 size_t maxlen
= (end
- p
) - 1;
15350 print_symbol ((int) maxlen
, (const char *) p
);
15351 p
+= strnlen ((char *) p
, maxlen
) + 1;
15355 printf (_("<corrupt>"));
15356 p
= (unsigned char *) end
;
15363 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15364 return display_proc_gnu_attribute (p
, tag
, end
);
15366 return display_tag_value (tag
, p
, end
);
15369 static unsigned char *
15370 display_power_gnu_attribute (unsigned char * p
,
15372 const unsigned char * const end
)
15376 if (tag
== Tag_GNU_Power_ABI_FP
)
15378 printf (" Tag_GNU_Power_ABI_FP: ");
15381 printf (_("<corrupt>\n"));
15384 READ_ULEB (val
, p
, end
);
15387 printf ("(%#x), ", val
);
15392 printf (_("unspecified hard/soft float, "));
15395 printf (_("hard float, "));
15398 printf (_("soft float, "));
15401 printf (_("single-precision hard float, "));
15408 printf (_("unspecified long double\n"));
15411 printf (_("128-bit IBM long double\n"));
15414 printf (_("64-bit long double\n"));
15417 printf (_("128-bit IEEE long double\n"));
15423 if (tag
== Tag_GNU_Power_ABI_Vector
)
15425 printf (" Tag_GNU_Power_ABI_Vector: ");
15428 printf (_("<corrupt>\n"));
15431 READ_ULEB (val
, p
, end
);
15434 printf ("(%#x), ", val
);
15439 printf (_("unspecified\n"));
15442 printf (_("generic\n"));
15445 printf ("AltiVec\n");
15454 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15456 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15459 printf (_("<corrupt>\n"));
15462 READ_ULEB (val
, p
, end
);
15465 printf ("(%#x), ", val
);
15470 printf (_("unspecified\n"));
15473 printf ("r3/r4\n");
15476 printf (_("memory\n"));
15485 return display_tag_value (tag
& 1, p
, end
);
15488 static unsigned char *
15489 display_s390_gnu_attribute (unsigned char * p
,
15491 const unsigned char * const end
)
15495 if (tag
== Tag_GNU_S390_ABI_Vector
)
15497 printf (" Tag_GNU_S390_ABI_Vector: ");
15498 READ_ULEB (val
, p
, end
);
15503 printf (_("any\n"));
15506 printf (_("software\n"));
15509 printf (_("hardware\n"));
15512 printf ("??? (%d)\n", val
);
15518 return display_tag_value (tag
& 1, p
, end
);
15522 display_sparc_hwcaps (unsigned int mask
)
15526 bfd_boolean first
= TRUE
;
15528 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15529 fputs ("mul32", stdout
), first
= FALSE
;
15530 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15531 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15532 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15533 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15534 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15535 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15536 if (mask
& ELF_SPARC_HWCAP_POPC
)
15537 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15538 if (mask
& ELF_SPARC_HWCAP_VIS
)
15539 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15540 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15541 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15542 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15543 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15544 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15545 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15546 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15547 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15548 if (mask
& ELF_SPARC_HWCAP_HPC
)
15549 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15550 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15551 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15552 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15553 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15554 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15555 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15556 if (mask
& ELF_SPARC_HWCAP_IMA
)
15557 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15558 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15559 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15562 fputc ('0', stdout
);
15563 fputc ('\n', stdout
);
15567 display_sparc_hwcaps2 (unsigned int mask
)
15571 bfd_boolean first
= TRUE
;
15573 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15574 fputs ("fjathplus", stdout
), first
= FALSE
;
15575 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15576 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15577 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15578 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15579 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15580 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15581 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15582 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15583 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15584 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15585 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15586 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15587 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15588 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15589 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15590 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15591 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15592 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15593 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15594 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15597 fputc ('0', stdout
);
15598 fputc ('\n', stdout
);
15601 static unsigned char *
15602 display_sparc_gnu_attribute (unsigned char * p
,
15604 const unsigned char * const end
)
15608 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15610 READ_ULEB (val
, p
, end
);
15611 printf (" Tag_GNU_Sparc_HWCAPS: ");
15612 display_sparc_hwcaps (val
);
15615 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15617 READ_ULEB (val
, p
, end
);
15618 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15619 display_sparc_hwcaps2 (val
);
15623 return display_tag_value (tag
, p
, end
);
15627 print_mips_fp_abi_value (unsigned int val
)
15631 case Val_GNU_MIPS_ABI_FP_ANY
:
15632 printf (_("Hard or soft float\n"));
15634 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15635 printf (_("Hard float (double precision)\n"));
15637 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15638 printf (_("Hard float (single precision)\n"));
15640 case Val_GNU_MIPS_ABI_FP_SOFT
:
15641 printf (_("Soft float\n"));
15643 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15644 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15646 case Val_GNU_MIPS_ABI_FP_XX
:
15647 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15649 case Val_GNU_MIPS_ABI_FP_64
:
15650 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15652 case Val_GNU_MIPS_ABI_FP_64A
:
15653 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15655 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15656 printf (_("NaN 2008 compatibility\n"));
15659 printf ("??? (%d)\n", val
);
15664 static unsigned char *
15665 display_mips_gnu_attribute (unsigned char * p
,
15667 const unsigned char * const end
)
15669 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15673 printf (" Tag_GNU_MIPS_ABI_FP: ");
15674 READ_ULEB (val
, p
, end
);
15675 print_mips_fp_abi_value (val
);
15679 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15683 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15684 READ_ULEB (val
, p
, end
);
15688 case Val_GNU_MIPS_ABI_MSA_ANY
:
15689 printf (_("Any MSA or not\n"));
15691 case Val_GNU_MIPS_ABI_MSA_128
:
15692 printf (_("128-bit MSA\n"));
15695 printf ("??? (%d)\n", val
);
15701 return display_tag_value (tag
& 1, p
, end
);
15704 static unsigned char *
15705 display_tic6x_attribute (unsigned char * p
,
15706 const unsigned char * const end
)
15711 READ_ULEB (tag
, p
, end
);
15716 printf (" Tag_ISA: ");
15717 READ_ULEB (val
, p
, end
);
15721 case C6XABI_Tag_ISA_none
:
15722 printf (_("None\n"));
15724 case C6XABI_Tag_ISA_C62X
:
15727 case C6XABI_Tag_ISA_C67X
:
15730 case C6XABI_Tag_ISA_C67XP
:
15731 printf ("C67x+\n");
15733 case C6XABI_Tag_ISA_C64X
:
15736 case C6XABI_Tag_ISA_C64XP
:
15737 printf ("C64x+\n");
15739 case C6XABI_Tag_ISA_C674X
:
15740 printf ("C674x\n");
15743 printf ("??? (%d)\n", val
);
15748 case Tag_ABI_wchar_t
:
15749 printf (" Tag_ABI_wchar_t: ");
15750 READ_ULEB (val
, p
, end
);
15754 printf (_("Not used\n"));
15757 printf (_("2 bytes\n"));
15760 printf (_("4 bytes\n"));
15763 printf ("??? (%d)\n", val
);
15768 case Tag_ABI_stack_align_needed
:
15769 printf (" Tag_ABI_stack_align_needed: ");
15770 READ_ULEB (val
, p
, end
);
15774 printf (_("8-byte\n"));
15777 printf (_("16-byte\n"));
15780 printf ("??? (%d)\n", val
);
15785 case Tag_ABI_stack_align_preserved
:
15786 READ_ULEB (val
, p
, end
);
15787 printf (" Tag_ABI_stack_align_preserved: ");
15791 printf (_("8-byte\n"));
15794 printf (_("16-byte\n"));
15797 printf ("??? (%d)\n", val
);
15803 READ_ULEB (val
, p
, end
);
15804 printf (" Tag_ABI_DSBT: ");
15808 printf (_("DSBT addressing not used\n"));
15811 printf (_("DSBT addressing used\n"));
15814 printf ("??? (%d)\n", val
);
15820 READ_ULEB (val
, p
, end
);
15821 printf (" Tag_ABI_PID: ");
15825 printf (_("Data addressing position-dependent\n"));
15828 printf (_("Data addressing position-independent, GOT near DP\n"));
15831 printf (_("Data addressing position-independent, GOT far from DP\n"));
15834 printf ("??? (%d)\n", val
);
15840 READ_ULEB (val
, p
, end
);
15841 printf (" Tag_ABI_PIC: ");
15845 printf (_("Code addressing position-dependent\n"));
15848 printf (_("Code addressing position-independent\n"));
15851 printf ("??? (%d)\n", val
);
15856 case Tag_ABI_array_object_alignment
:
15857 READ_ULEB (val
, p
, end
);
15858 printf (" Tag_ABI_array_object_alignment: ");
15862 printf (_("8-byte\n"));
15865 printf (_("4-byte\n"));
15868 printf (_("16-byte\n"));
15871 printf ("??? (%d)\n", val
);
15876 case Tag_ABI_array_object_align_expected
:
15877 READ_ULEB (val
, p
, end
);
15878 printf (" Tag_ABI_array_object_align_expected: ");
15882 printf (_("8-byte\n"));
15885 printf (_("4-byte\n"));
15888 printf (_("16-byte\n"));
15891 printf ("??? (%d)\n", val
);
15896 case Tag_ABI_compatibility
:
15898 READ_ULEB (val
, p
, end
);
15899 printf (" Tag_ABI_compatibility: ");
15900 printf (_("flag = %d, vendor = "), val
);
15903 size_t maxlen
= (end
- p
) - 1;
15905 print_symbol ((int) maxlen
, (const char *) p
);
15906 p
+= strnlen ((char *) p
, maxlen
) + 1;
15910 printf (_("<corrupt>"));
15911 p
= (unsigned char *) end
;
15917 case Tag_ABI_conformance
:
15919 printf (" Tag_ABI_conformance: \"");
15922 size_t maxlen
= (end
- p
) - 1;
15924 print_symbol ((int) maxlen
, (const char *) p
);
15925 p
+= strnlen ((char *) p
, maxlen
) + 1;
15929 printf (_("<corrupt>"));
15930 p
= (unsigned char *) end
;
15937 return display_tag_value (tag
, p
, end
);
15941 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15943 unsigned long addr
= 0;
15944 size_t bytes
= end
- p
;
15951 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15953 printf (" 0x%8.8lx ", addr
);
15955 for (j
= 0; j
< 16; j
++)
15958 printf ("%2.2x", p
[j
]);
15966 for (j
= 0; j
< lbytes
; j
++)
15969 if (k
>= ' ' && k
< 0x7f)
15985 static unsigned char *
15986 display_msp430x_attribute (unsigned char * p
,
15987 const unsigned char * const end
)
15992 READ_ULEB (tag
, p
, end
);
15996 case OFBA_MSPABI_Tag_ISA
:
15997 printf (" Tag_ISA: ");
15998 READ_ULEB (val
, p
, end
);
16001 case 0: printf (_("None\n")); break;
16002 case 1: printf (_("MSP430\n")); break;
16003 case 2: printf (_("MSP430X\n")); break;
16004 default: printf ("??? (%d)\n", val
); break;
16008 case OFBA_MSPABI_Tag_Code_Model
:
16009 printf (" Tag_Code_Model: ");
16010 READ_ULEB (val
, p
, end
);
16013 case 0: printf (_("None\n")); break;
16014 case 1: printf (_("Small\n")); break;
16015 case 2: printf (_("Large\n")); break;
16016 default: printf ("??? (%d)\n", val
); break;
16020 case OFBA_MSPABI_Tag_Data_Model
:
16021 printf (" Tag_Data_Model: ");
16022 READ_ULEB (val
, p
, end
);
16025 case 0: printf (_("None\n")); break;
16026 case 1: printf (_("Small\n")); break;
16027 case 2: printf (_("Large\n")); break;
16028 case 3: printf (_("Restricted Large\n")); break;
16029 default: printf ("??? (%d)\n", val
); break;
16034 printf (_(" <unknown tag %d>: "), tag
);
16041 size_t maxlen
= (end
- p
) - 1;
16043 print_symbol ((int) maxlen
, (const char *) p
);
16044 p
+= strnlen ((char *) p
, maxlen
) + 1;
16048 printf (_("<corrupt>"));
16049 p
= (unsigned char *) end
;
16055 READ_ULEB (val
, p
, end
);
16056 printf ("%d (0x%x)\n", val
, val
);
16065 static unsigned char *
16066 display_msp430_gnu_attribute (unsigned char * p
,
16068 const unsigned char * const end
)
16070 if (tag
== Tag_GNU_MSP430_Data_Region
)
16074 printf (" Tag_GNU_MSP430_Data_Region: ");
16075 READ_ULEB (val
, p
, end
);
16079 case Val_GNU_MSP430_Data_Region_Any
:
16080 printf (_("Any Region\n"));
16082 case Val_GNU_MSP430_Data_Region_Lower
:
16083 printf (_("Lower Region Only\n"));
16086 printf ("??? (%u)\n", val
);
16090 return display_tag_value (tag
& 1, p
, end
);
16093 struct riscv_attr_tag_t
{
16098 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16100 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16103 T(priv_spec_minor
),
16104 T(priv_spec_revision
),
16105 T(unaligned_access
),
16110 static unsigned char *
16111 display_riscv_attribute (unsigned char *p
,
16112 const unsigned char * const end
)
16116 struct riscv_attr_tag_t
*attr
= NULL
;
16119 READ_ULEB (tag
, p
, end
);
16121 /* Find the name of attribute. */
16122 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16124 if (riscv_attr_tag
[i
].tag
== tag
)
16126 attr
= &riscv_attr_tag
[i
];
16132 printf (" %s: ", attr
->name
);
16134 return display_tag_value (tag
, p
, end
);
16138 case Tag_RISCV_priv_spec
:
16139 case Tag_RISCV_priv_spec_minor
:
16140 case Tag_RISCV_priv_spec_revision
:
16141 READ_ULEB (val
, p
, end
);
16142 printf (_("%u\n"), val
);
16144 case Tag_RISCV_unaligned_access
:
16145 READ_ULEB (val
, p
, end
);
16149 printf (_("No unaligned access\n"));
16152 printf (_("Unaligned access\n"));
16156 case Tag_RISCV_stack_align
:
16157 READ_ULEB (val
, p
, end
);
16158 printf (_("%u-bytes\n"), val
);
16160 case Tag_RISCV_arch
:
16161 p
= display_tag_value (-1, p
, end
);
16164 return display_tag_value (tag
, p
, end
);
16171 process_attributes (Filedata
* filedata
,
16172 const char * public_name
,
16173 unsigned int proc_type
,
16174 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16175 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16177 Elf_Internal_Shdr
* sect
;
16179 bfd_boolean res
= TRUE
;
16181 /* Find the section header so that we get the size. */
16182 for (i
= 0, sect
= filedata
->section_headers
;
16183 i
< filedata
->file_header
.e_shnum
;
16186 unsigned char * contents
;
16189 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16192 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16193 sect
->sh_size
, _("attributes"));
16194 if (contents
== NULL
)
16201 /* The first character is the version of the attributes.
16202 Currently only version 1, (aka 'A') is recognised here. */
16205 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16210 bfd_vma section_len
;
16212 section_len
= sect
->sh_size
- 1;
16215 while (section_len
> 0)
16218 unsigned int namelen
;
16219 bfd_boolean public_section
;
16220 bfd_boolean gnu_section
;
16222 if (section_len
<= 4)
16224 error (_("Tag section ends prematurely\n"));
16228 attr_len
= byte_get (p
, 4);
16231 if (attr_len
> section_len
)
16233 error (_("Bad attribute length (%u > %u)\n"),
16234 (unsigned) attr_len
, (unsigned) section_len
);
16235 attr_len
= section_len
;
16238 /* PR 17531: file: 001-101425-0.004 */
16239 else if (attr_len
< 5)
16241 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16246 section_len
-= attr_len
;
16249 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16250 if (namelen
== 0 || namelen
>= attr_len
)
16252 error (_("Corrupt attribute section name\n"));
16257 printf (_("Attribute Section: "));
16258 print_symbol (INT_MAX
, (const char *) p
);
16261 if (public_name
&& streq ((char *) p
, public_name
))
16262 public_section
= TRUE
;
16264 public_section
= FALSE
;
16266 if (streq ((char *) p
, "gnu"))
16267 gnu_section
= TRUE
;
16269 gnu_section
= FALSE
;
16272 attr_len
-= namelen
;
16274 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16279 unsigned char * end
;
16281 /* PR binutils/17531: Safe handling of corrupt files. */
16284 error (_("Unused bytes at end of section\n"));
16291 size
= byte_get (p
, 4);
16292 if (size
> attr_len
)
16294 error (_("Bad subsection length (%u > %u)\n"),
16295 (unsigned) size
, (unsigned) attr_len
);
16299 /* PR binutils/17531: Safe handling of corrupt files. */
16302 error (_("Bad subsection length (%u < 6)\n"),
16310 end
= p
+ size
- 1;
16311 assert (end
<= contents
+ sect
->sh_size
);
16317 printf (_("File Attributes\n"));
16320 printf (_("Section Attributes:"));
16323 printf (_("Symbol Attributes:"));
16324 /* Fall through. */
16328 READ_ULEB (val
, p
, end
);
16331 printf (" %d", val
);
16336 printf (_("Unknown tag: %d\n"), tag
);
16337 public_section
= FALSE
;
16341 if (public_section
&& display_pub_attribute
!= NULL
)
16344 p
= display_pub_attribute (p
, end
);
16347 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16350 p
= display_gnu_attribute (p
,
16351 display_proc_gnu_attribute
,
16357 printf (_(" Unknown attribute:\n"));
16358 display_raw_attribute (p
, end
);
16373 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16374 Print the Address, Access and Initial fields of an entry at VMA ADDR
16375 and return the VMA of the next entry, or -1 if there was a problem.
16376 Does not read from DATA_END or beyond. */
16379 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16380 unsigned char * data_end
)
16383 print_vma (addr
, LONG_HEX
);
16385 if (addr
< pltgot
+ 0xfff0)
16386 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16388 printf ("%10s", "");
16391 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16395 unsigned char * from
= data
+ addr
- pltgot
;
16397 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16399 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16400 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16401 return (bfd_vma
) -1;
16405 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16406 print_vma (entry
, LONG_HEX
);
16409 return addr
+ (is_32bit_elf
? 4 : 8);
16412 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16413 PLTGOT. Print the Address and Initial fields of an entry at VMA
16414 ADDR and return the VMA of the next entry. */
16417 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16420 print_vma (addr
, LONG_HEX
);
16423 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16428 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16429 print_vma (entry
, LONG_HEX
);
16431 return addr
+ (is_32bit_elf
? 4 : 8);
16435 print_mips_ases (unsigned int mask
)
16437 if (mask
& AFL_ASE_DSP
)
16438 fputs ("\n\tDSP ASE", stdout
);
16439 if (mask
& AFL_ASE_DSPR2
)
16440 fputs ("\n\tDSP R2 ASE", stdout
);
16441 if (mask
& AFL_ASE_DSPR3
)
16442 fputs ("\n\tDSP R3 ASE", stdout
);
16443 if (mask
& AFL_ASE_EVA
)
16444 fputs ("\n\tEnhanced VA Scheme", stdout
);
16445 if (mask
& AFL_ASE_MCU
)
16446 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16447 if (mask
& AFL_ASE_MDMX
)
16448 fputs ("\n\tMDMX ASE", stdout
);
16449 if (mask
& AFL_ASE_MIPS3D
)
16450 fputs ("\n\tMIPS-3D ASE", stdout
);
16451 if (mask
& AFL_ASE_MT
)
16452 fputs ("\n\tMT ASE", stdout
);
16453 if (mask
& AFL_ASE_SMARTMIPS
)
16454 fputs ("\n\tSmartMIPS ASE", stdout
);
16455 if (mask
& AFL_ASE_VIRT
)
16456 fputs ("\n\tVZ ASE", stdout
);
16457 if (mask
& AFL_ASE_MSA
)
16458 fputs ("\n\tMSA ASE", stdout
);
16459 if (mask
& AFL_ASE_MIPS16
)
16460 fputs ("\n\tMIPS16 ASE", stdout
);
16461 if (mask
& AFL_ASE_MICROMIPS
)
16462 fputs ("\n\tMICROMIPS ASE", stdout
);
16463 if (mask
& AFL_ASE_XPA
)
16464 fputs ("\n\tXPA ASE", stdout
);
16465 if (mask
& AFL_ASE_MIPS16E2
)
16466 fputs ("\n\tMIPS16e2 ASE", stdout
);
16467 if (mask
& AFL_ASE_CRC
)
16468 fputs ("\n\tCRC ASE", stdout
);
16469 if (mask
& AFL_ASE_GINV
)
16470 fputs ("\n\tGINV ASE", stdout
);
16471 if (mask
& AFL_ASE_LOONGSON_MMI
)
16472 fputs ("\n\tLoongson MMI ASE", stdout
);
16473 if (mask
& AFL_ASE_LOONGSON_CAM
)
16474 fputs ("\n\tLoongson CAM ASE", stdout
);
16475 if (mask
& AFL_ASE_LOONGSON_EXT
)
16476 fputs ("\n\tLoongson EXT ASE", stdout
);
16477 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16478 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16480 fprintf (stdout
, "\n\t%s", _("None"));
16481 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16482 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16486 print_mips_isa_ext (unsigned int isa_ext
)
16491 fputs (_("None"), stdout
);
16494 fputs ("RMI XLR", stdout
);
16496 case AFL_EXT_OCTEON3
:
16497 fputs ("Cavium Networks Octeon3", stdout
);
16499 case AFL_EXT_OCTEON2
:
16500 fputs ("Cavium Networks Octeon2", stdout
);
16502 case AFL_EXT_OCTEONP
:
16503 fputs ("Cavium Networks OcteonP", stdout
);
16505 case AFL_EXT_OCTEON
:
16506 fputs ("Cavium Networks Octeon", stdout
);
16509 fputs ("Toshiba R5900", stdout
);
16512 fputs ("MIPS R4650", stdout
);
16515 fputs ("LSI R4010", stdout
);
16518 fputs ("NEC VR4100", stdout
);
16521 fputs ("Toshiba R3900", stdout
);
16523 case AFL_EXT_10000
:
16524 fputs ("MIPS R10000", stdout
);
16527 fputs ("Broadcom SB-1", stdout
);
16530 fputs ("NEC VR4111/VR4181", stdout
);
16533 fputs ("NEC VR4120", stdout
);
16536 fputs ("NEC VR5400", stdout
);
16539 fputs ("NEC VR5500", stdout
);
16541 case AFL_EXT_LOONGSON_2E
:
16542 fputs ("ST Microelectronics Loongson 2E", stdout
);
16544 case AFL_EXT_LOONGSON_2F
:
16545 fputs ("ST Microelectronics Loongson 2F", stdout
);
16547 case AFL_EXT_INTERAPTIV_MR2
:
16548 fputs ("Imagination interAptiv MR2", stdout
);
16551 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16556 get_mips_reg_size (int reg_size
)
16558 return (reg_size
== AFL_REG_NONE
) ? 0
16559 : (reg_size
== AFL_REG_32
) ? 32
16560 : (reg_size
== AFL_REG_64
) ? 64
16561 : (reg_size
== AFL_REG_128
) ? 128
16566 process_mips_specific (Filedata
* filedata
)
16568 Elf_Internal_Dyn
* entry
;
16569 Elf_Internal_Shdr
*sect
= NULL
;
16570 size_t liblist_offset
= 0;
16571 size_t liblistno
= 0;
16572 size_t conflictsno
= 0;
16573 size_t options_offset
= 0;
16574 size_t conflicts_offset
= 0;
16575 size_t pltrelsz
= 0;
16577 bfd_vma pltgot
= 0;
16578 bfd_vma mips_pltgot
= 0;
16579 bfd_vma jmprel
= 0;
16580 bfd_vma local_gotno
= 0;
16581 bfd_vma gotsym
= 0;
16582 bfd_vma symtabno
= 0;
16583 bfd_boolean res
= TRUE
;
16585 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16586 display_mips_gnu_attribute
))
16589 sect
= find_section (filedata
, ".MIPS.abiflags");
16593 Elf_External_ABIFlags_v0
*abiflags_ext
;
16594 Elf_Internal_ABIFlags_v0 abiflags_in
;
16596 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16598 error (_("Corrupt MIPS ABI Flags section.\n"));
16603 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16604 sect
->sh_size
, _("MIPS ABI Flags section"));
16607 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16608 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16609 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16610 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16611 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16612 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16613 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16614 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16615 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16616 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16617 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16619 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16620 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16621 if (abiflags_in
.isa_rev
> 1)
16622 printf ("r%d", abiflags_in
.isa_rev
);
16623 printf ("\nGPR size: %d",
16624 get_mips_reg_size (abiflags_in
.gpr_size
));
16625 printf ("\nCPR1 size: %d",
16626 get_mips_reg_size (abiflags_in
.cpr1_size
));
16627 printf ("\nCPR2 size: %d",
16628 get_mips_reg_size (abiflags_in
.cpr2_size
));
16629 fputs ("\nFP ABI: ", stdout
);
16630 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16631 fputs ("ISA Extension: ", stdout
);
16632 print_mips_isa_ext (abiflags_in
.isa_ext
);
16633 fputs ("\nASEs:", stdout
);
16634 print_mips_ases (abiflags_in
.ases
);
16635 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16636 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16637 fputc ('\n', stdout
);
16638 free (abiflags_ext
);
16643 /* We have a lot of special sections. Thanks SGI! */
16644 if (filedata
->dynamic_section
== NULL
)
16646 /* No dynamic information available. See if there is static GOT. */
16647 sect
= find_section (filedata
, ".got");
16650 unsigned char *data_end
;
16651 unsigned char *data
;
16655 pltgot
= sect
->sh_addr
;
16658 addr_size
= (is_32bit_elf
? 4 : 8);
16659 end
= pltgot
+ sect
->sh_size
;
16661 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16663 _("Global Offset Table data"));
16664 /* PR 12855: Null data is handled gracefully throughout. */
16665 data_end
= data
+ (end
- pltgot
);
16667 printf (_("\nStatic GOT:\n"));
16668 printf (_(" Canonical gp value: "));
16669 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16672 /* In a dynamic binary GOT[0] is reserved for the dynamic
16673 loader to store the lazy resolver pointer, however in
16674 a static binary it may well have been omitted and GOT
16675 reduced to a table of addresses.
16676 PR 21344: Check for the entry being fully available
16677 before fetching it. */
16679 && data
+ ent
- pltgot
+ addr_size
<= data_end
16680 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16682 printf (_(" Reserved entries:\n"));
16683 printf (_(" %*s %10s %*s\n"),
16684 addr_size
* 2, _("Address"), _("Access"),
16685 addr_size
* 2, _("Value"));
16686 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16688 if (ent
== (bfd_vma
) -1)
16689 goto sgot_print_fail
;
16691 /* Check for the MSB of GOT[1] being set, identifying a
16692 GNU object. This entry will be used by some runtime
16693 loaders, to store the module pointer. Otherwise this
16694 is an ordinary local entry.
16695 PR 21344: Check for the entry being fully available
16696 before fetching it. */
16698 && data
+ ent
- pltgot
+ addr_size
<= data_end
16699 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16700 >> (addr_size
* 8 - 1)) != 0)
16702 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16704 if (ent
== (bfd_vma
) -1)
16705 goto sgot_print_fail
;
16710 if (data
!= NULL
&& ent
< end
)
16712 printf (_(" Local entries:\n"));
16713 printf (" %*s %10s %*s\n",
16714 addr_size
* 2, _("Address"), _("Access"),
16715 addr_size
* 2, _("Value"));
16718 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16720 if (ent
== (bfd_vma
) -1)
16721 goto sgot_print_fail
;
16732 for (entry
= filedata
->dynamic_section
;
16733 /* PR 17531 file: 012-50589-0.004. */
16734 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16735 && entry
->d_tag
!= DT_NULL
);
16737 switch (entry
->d_tag
)
16739 case DT_MIPS_LIBLIST
:
16741 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16742 liblistno
* sizeof (Elf32_External_Lib
));
16744 case DT_MIPS_LIBLISTNO
:
16745 liblistno
= entry
->d_un
.d_val
;
16747 case DT_MIPS_OPTIONS
:
16748 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16750 case DT_MIPS_CONFLICT
:
16752 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16753 conflictsno
* sizeof (Elf32_External_Conflict
));
16755 case DT_MIPS_CONFLICTNO
:
16756 conflictsno
= entry
->d_un
.d_val
;
16759 pltgot
= entry
->d_un
.d_ptr
;
16761 case DT_MIPS_LOCAL_GOTNO
:
16762 local_gotno
= entry
->d_un
.d_val
;
16764 case DT_MIPS_GOTSYM
:
16765 gotsym
= entry
->d_un
.d_val
;
16767 case DT_MIPS_SYMTABNO
:
16768 symtabno
= entry
->d_un
.d_val
;
16770 case DT_MIPS_PLTGOT
:
16771 mips_pltgot
= entry
->d_un
.d_ptr
;
16774 pltrel
= entry
->d_un
.d_val
;
16777 pltrelsz
= entry
->d_un
.d_val
;
16780 jmprel
= entry
->d_un
.d_ptr
;
16786 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16788 Elf32_External_Lib
* elib
;
16791 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16792 sizeof (Elf32_External_Lib
),
16794 _("liblist section data"));
16797 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16798 "\nSection '.liblist' contains %lu entries:\n",
16799 (unsigned long) liblistno
),
16800 (unsigned long) liblistno
);
16801 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16804 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16811 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16812 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16813 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16814 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16815 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16817 tmp
= gmtime (&atime
);
16818 snprintf (timebuf
, sizeof (timebuf
),
16819 "%04u-%02u-%02uT%02u:%02u:%02u",
16820 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16821 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16823 printf ("%3lu: ", (unsigned long) cnt
);
16824 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
16825 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
16827 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16828 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16829 liblist
.l_version
);
16831 if (liblist
.l_flags
== 0)
16835 static const struct
16842 { " EXACT_MATCH", LL_EXACT_MATCH
},
16843 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16844 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16845 { " EXPORTS", LL_EXPORTS
},
16846 { " DELAY_LOAD", LL_DELAY_LOAD
},
16847 { " DELTA", LL_DELTA
}
16849 int flags
= liblist
.l_flags
;
16852 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16853 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16855 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16856 flags
^= l_flags_vals
[fcnt
].bit
;
16859 printf (" %#x", (unsigned int) flags
);
16871 if (options_offset
!= 0)
16873 Elf_External_Options
* eopt
;
16876 sect
= filedata
->section_headers
;
16878 /* Find the section header so that we get the size. */
16879 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16880 /* PR 17533 file: 012-277276-0.004. */
16883 error (_("No MIPS_OPTIONS header found\n"));
16887 if (sect
->sh_size
< sizeof (* eopt
))
16889 error (_("The MIPS options section is too small.\n"));
16893 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16894 sect
->sh_size
, _("options"));
16897 Elf_Internal_Options option
;
16900 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16902 Elf_External_Options
* eoption
;
16903 unsigned int optsize
;
16905 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16907 optsize
= BYTE_GET (eoption
->size
);
16909 /* PR 17531: file: ffa0fa3b. */
16910 if (optsize
< sizeof (* eopt
)
16911 || optsize
> sect
->sh_size
- offset
)
16913 error (_("Invalid size (%u) for MIPS option\n"),
16922 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16923 "\nSection '%s' contains %d entries:\n",
16925 printable_section_name (filedata
, sect
), cnt
);
16931 Elf_External_Options
* eoption
;
16933 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16935 option
.kind
= BYTE_GET (eoption
->kind
);
16936 option
.size
= BYTE_GET (eoption
->size
);
16937 option
.section
= BYTE_GET (eoption
->section
);
16938 option
.info
= BYTE_GET (eoption
->info
);
16940 switch (option
.kind
)
16943 /* This shouldn't happen. */
16944 printf (" NULL %" PRId16
" %" PRIx32
,
16945 option
.section
, option
.info
);
16949 printf (" REGINFO ");
16950 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16952 Elf32_External_RegInfo
* ereg
;
16953 Elf32_RegInfo reginfo
;
16956 if (option
.size
< (sizeof (Elf_External_Options
)
16957 + sizeof (Elf32_External_RegInfo
)))
16959 printf (_("<corrupt>\n"));
16960 error (_("Truncated MIPS REGINFO option\n"));
16965 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
16967 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16968 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16969 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16970 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16971 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16972 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16974 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
16975 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
16977 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
16978 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
16979 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16980 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16985 Elf64_External_RegInfo
* ereg
;
16986 Elf64_Internal_RegInfo reginfo
;
16988 if (option
.size
< (sizeof (Elf_External_Options
)
16989 + sizeof (Elf64_External_RegInfo
)))
16991 printf (_("<corrupt>\n"));
16992 error (_("Truncated MIPS REGINFO option\n"));
16997 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
16998 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16999 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17000 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17001 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17002 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17003 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17005 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
17006 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17008 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17009 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17010 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17011 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17013 offset
+= option
.size
;
17016 case ODK_EXCEPTIONS
:
17017 fputs (" EXCEPTIONS fpe_min(", stdout
);
17018 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
17019 fputs (") fpe_max(", stdout
);
17020 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
17021 fputs (")", stdout
);
17023 if (option
.info
& OEX_PAGE0
)
17024 fputs (" PAGE0", stdout
);
17025 if (option
.info
& OEX_SMM
)
17026 fputs (" SMM", stdout
);
17027 if (option
.info
& OEX_FPDBUG
)
17028 fputs (" FPDBUG", stdout
);
17029 if (option
.info
& OEX_DISMISS
)
17030 fputs (" DISMISS", stdout
);
17034 fputs (" PAD ", stdout
);
17035 if (option
.info
& OPAD_PREFIX
)
17036 fputs (" PREFIX", stdout
);
17037 if (option
.info
& OPAD_POSTFIX
)
17038 fputs (" POSTFIX", stdout
);
17039 if (option
.info
& OPAD_SYMBOL
)
17040 fputs (" SYMBOL", stdout
);
17044 fputs (" HWPATCH ", stdout
);
17045 if (option
.info
& OHW_R4KEOP
)
17046 fputs (" R4KEOP", stdout
);
17047 if (option
.info
& OHW_R8KPFETCH
)
17048 fputs (" R8KPFETCH", stdout
);
17049 if (option
.info
& OHW_R5KEOP
)
17050 fputs (" R5KEOP", stdout
);
17051 if (option
.info
& OHW_R5KCVTL
)
17052 fputs (" R5KCVTL", stdout
);
17056 fputs (" FILL ", stdout
);
17057 /* XXX Print content of info word? */
17061 fputs (" TAGS ", stdout
);
17062 /* XXX Print content of info word? */
17066 fputs (" HWAND ", stdout
);
17067 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17068 fputs (" R4KEOP_CHECKED", stdout
);
17069 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17070 fputs (" R4KEOP_CLEAN", stdout
);
17074 fputs (" HWOR ", stdout
);
17075 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17076 fputs (" R4KEOP_CHECKED", stdout
);
17077 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17078 fputs (" R4KEOP_CLEAN", stdout
);
17082 printf (" GP_GROUP %#06x self-contained %#06x",
17083 option
.info
& OGP_GROUP
,
17084 (option
.info
& OGP_SELF
) >> 16);
17088 printf (" IDENT %#06x self-contained %#06x",
17089 option
.info
& OGP_GROUP
,
17090 (option
.info
& OGP_SELF
) >> 16);
17094 /* This shouldn't happen. */
17095 printf (" %3d ??? %" PRId16
" %" PRIx32
,
17096 option
.kind
, option
.section
, option
.info
);
17100 len
= sizeof (* eopt
);
17101 while (len
< option
.size
)
17103 unsigned char datum
= *((unsigned char *) eoption
+ len
);
17105 if (ISPRINT (datum
))
17106 printf ("%c", datum
);
17108 printf ("\\%03o", datum
);
17111 fputs ("\n", stdout
);
17113 offset
+= option
.size
;
17121 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17123 Elf32_Conflict
* iconf
;
17126 if (filedata
->dynamic_symbols
== NULL
)
17128 error (_("conflict list found without a dynamic symbol table\n"));
17132 /* PR 21345 - print a slightly more helpful error message
17133 if we are sure that the cmalloc will fail. */
17134 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17136 error (_("Overlarge number of conflicts detected: %lx\n"),
17137 (long) conflictsno
);
17141 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17144 error (_("Out of memory allocating space for dynamic conflicts\n"));
17150 Elf32_External_Conflict
* econf32
;
17152 econf32
= (Elf32_External_Conflict
*)
17153 get_data (NULL
, filedata
, conflicts_offset
,
17154 sizeof (*econf32
), conflictsno
, _("conflict"));
17161 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17162 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17168 Elf64_External_Conflict
* econf64
;
17170 econf64
= (Elf64_External_Conflict
*)
17171 get_data (NULL
, filedata
, conflicts_offset
,
17172 sizeof (*econf64
), conflictsno
, _("conflict"));
17179 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17180 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17185 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17186 "\nSection '.conflict' contains %lu entries:\n",
17187 (unsigned long) conflictsno
),
17188 (unsigned long) conflictsno
);
17189 puts (_(" Num: Index Value Name"));
17191 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17193 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17195 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17196 printf (_("<corrupt symbol index>"));
17199 Elf_Internal_Sym
* psym
;
17201 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17202 print_vma (psym
->st_value
, FULL_HEX
);
17204 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17205 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17207 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17215 if (pltgot
!= 0 && local_gotno
!= 0)
17217 bfd_vma ent
, local_end
, global_end
;
17219 unsigned char * data
;
17220 unsigned char * data_end
;
17224 addr_size
= (is_32bit_elf
? 4 : 8);
17225 local_end
= pltgot
+ local_gotno
* addr_size
;
17227 /* PR binutils/17533 file: 012-111227-0.004 */
17228 if (symtabno
< gotsym
)
17230 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17231 (unsigned long) gotsym
, (unsigned long) symtabno
);
17235 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17236 /* PR 17531: file: 54c91a34. */
17237 if (global_end
< local_end
)
17239 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17243 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17244 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17245 global_end
- pltgot
, 1,
17246 _("Global Offset Table data"));
17247 /* PR 12855: Null data is handled gracefully throughout. */
17248 data_end
= data
+ (global_end
- pltgot
);
17250 printf (_("\nPrimary GOT:\n"));
17251 printf (_(" Canonical gp value: "));
17252 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17255 printf (_(" Reserved entries:\n"));
17256 printf (_(" %*s %10s %*s Purpose\n"),
17257 addr_size
* 2, _("Address"), _("Access"),
17258 addr_size
* 2, _("Initial"));
17259 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17260 printf (_(" Lazy resolver\n"));
17261 if (ent
== (bfd_vma
) -1)
17262 goto got_print_fail
;
17264 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17265 This entry will be used by some runtime loaders, to store the
17266 module pointer. Otherwise this is an ordinary local entry.
17267 PR 21344: Check for the entry being fully available before
17270 && data
+ ent
- pltgot
+ addr_size
<= data_end
17271 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17272 >> (addr_size
* 8 - 1)) != 0)
17274 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17275 printf (_(" Module pointer (GNU extension)\n"));
17276 if (ent
== (bfd_vma
) -1)
17277 goto got_print_fail
;
17281 if (data
!= NULL
&& ent
< local_end
)
17283 printf (_(" Local entries:\n"));
17284 printf (" %*s %10s %*s\n",
17285 addr_size
* 2, _("Address"), _("Access"),
17286 addr_size
* 2, _("Initial"));
17287 while (ent
< local_end
)
17289 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17291 if (ent
== (bfd_vma
) -1)
17292 goto got_print_fail
;
17297 if (data
!= NULL
&& gotsym
< symtabno
)
17301 printf (_(" Global entries:\n"));
17302 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17303 addr_size
* 2, _("Address"),
17305 addr_size
* 2, _("Initial"),
17306 addr_size
* 2, _("Sym.Val."),
17308 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17309 _("Ndx"), _("Name"));
17311 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17313 for (i
= gotsym
; i
< symtabno
; i
++)
17315 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17318 if (filedata
->dynamic_symbols
== NULL
)
17319 printf (_("<no dynamic symbols>"));
17320 else if (i
< filedata
->num_dynamic_syms
)
17322 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17324 print_vma (psym
->st_value
, LONG_HEX
);
17325 printf (" %-7s %3s ",
17326 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17327 get_symbol_index_type (filedata
, psym
->st_shndx
));
17329 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17330 print_symbol (sym_width
,
17331 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17333 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17336 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17337 (unsigned long) i
);
17340 if (ent
== (bfd_vma
) -1)
17350 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17353 size_t offset
, rel_offset
;
17354 unsigned long count
, i
;
17355 unsigned char * data
;
17356 int addr_size
, sym_width
;
17357 Elf_Internal_Rela
* rels
;
17359 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17360 if (pltrel
== DT_RELA
)
17362 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17367 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17372 addr_size
= (is_32bit_elf
? 4 : 8);
17373 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17375 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17376 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17377 1, _("Procedure Linkage Table data"));
17381 printf ("\nPLT GOT:\n\n");
17382 printf (_(" Reserved entries:\n"));
17383 printf (_(" %*s %*s Purpose\n"),
17384 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17385 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17386 printf (_(" PLT lazy resolver\n"));
17387 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17388 printf (_(" Module pointer\n"));
17391 printf (_(" Entries:\n"));
17392 printf (" %*s %*s %*s %-7s %3s %s\n",
17393 addr_size
* 2, _("Address"),
17394 addr_size
* 2, _("Initial"),
17395 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17396 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17397 for (i
= 0; i
< count
; i
++)
17399 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17401 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17404 if (idx
>= filedata
->num_dynamic_syms
)
17405 printf (_("<corrupt symbol index: %lu>"), idx
);
17408 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17410 print_vma (psym
->st_value
, LONG_HEX
);
17411 printf (" %-7s %3s ",
17412 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17413 get_symbol_index_type (filedata
, psym
->st_shndx
));
17414 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17415 print_symbol (sym_width
,
17416 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17418 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17432 process_nds32_specific (Filedata
* filedata
)
17434 Elf_Internal_Shdr
*sect
= NULL
;
17436 sect
= find_section (filedata
, ".nds32_e_flags");
17437 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17439 unsigned char *buf
;
17442 printf ("\nNDS32 elf flags section:\n");
17443 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17444 _("NDS32 elf flags section"));
17449 flag
= byte_get (buf
, 4);
17451 switch (flag
& 0x3)
17454 printf ("(VEC_SIZE):\tNo entry.\n");
17457 printf ("(VEC_SIZE):\t4 bytes\n");
17460 printf ("(VEC_SIZE):\t16 bytes\n");
17463 printf ("(VEC_SIZE):\treserved\n");
17472 process_gnu_liblist (Filedata
* filedata
)
17474 Elf_Internal_Shdr
* section
;
17475 Elf_Internal_Shdr
* string_sec
;
17476 Elf32_External_Lib
* elib
;
17478 size_t strtab_size
;
17480 unsigned long num_liblist
;
17482 bfd_boolean res
= TRUE
;
17487 for (i
= 0, section
= filedata
->section_headers
;
17488 i
< filedata
->file_header
.e_shnum
;
17491 switch (section
->sh_type
)
17493 case SHT_GNU_LIBLIST
:
17494 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17497 elib
= (Elf32_External_Lib
*)
17498 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17499 _("liblist section data"));
17507 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17508 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17509 string_sec
->sh_size
,
17510 _("liblist string table"));
17512 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17519 strtab_size
= string_sec
->sh_size
;
17521 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17522 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17523 "\nLibrary list section '%s' contains %lu entries:\n",
17525 printable_section_name (filedata
, section
),
17528 puts (_(" Library Time Stamp Checksum Version Flags"));
17530 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17538 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17539 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17540 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17541 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17542 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17544 tmp
= gmtime (&atime
);
17545 snprintf (timebuf
, sizeof (timebuf
),
17546 "%04u-%02u-%02uT%02u:%02u:%02u",
17547 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17548 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17550 printf ("%3lu: ", (unsigned long) cnt
);
17552 printf ("%-20s", liblist
.l_name
< strtab_size
17553 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17555 printf ("%-20.20s", liblist
.l_name
< strtab_size
17556 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17557 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17558 liblist
.l_version
, liblist
.l_flags
);
17569 static const char *
17570 get_note_type (Filedata
* filedata
, unsigned e_type
)
17572 static char buff
[64];
17574 if (filedata
->file_header
.e_type
== ET_CORE
)
17578 return _("NT_AUXV (auxiliary vector)");
17580 return _("NT_PRSTATUS (prstatus structure)");
17582 return _("NT_FPREGSET (floating point registers)");
17584 return _("NT_PRPSINFO (prpsinfo structure)");
17585 case NT_TASKSTRUCT
:
17586 return _("NT_TASKSTRUCT (task structure)");
17588 return _("NT_PRXFPREG (user_xfpregs structure)");
17590 return _("NT_PPC_VMX (ppc Altivec registers)");
17592 return _("NT_PPC_VSX (ppc VSX registers)");
17594 return _("NT_PPC_TAR (ppc TAR register)");
17596 return _("NT_PPC_PPR (ppc PPR register)");
17598 return _("NT_PPC_DSCR (ppc DSCR register)");
17600 return _("NT_PPC_EBB (ppc EBB registers)");
17602 return _("NT_PPC_PMU (ppc PMU registers)");
17603 case NT_PPC_TM_CGPR
:
17604 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17605 case NT_PPC_TM_CFPR
:
17606 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17607 case NT_PPC_TM_CVMX
:
17608 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17609 case NT_PPC_TM_CVSX
:
17610 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17611 case NT_PPC_TM_SPR
:
17612 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17613 case NT_PPC_TM_CTAR
:
17614 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17615 case NT_PPC_TM_CPPR
:
17616 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17617 case NT_PPC_TM_CDSCR
:
17618 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17620 return _("NT_386_TLS (x86 TLS information)");
17621 case NT_386_IOPERM
:
17622 return _("NT_386_IOPERM (x86 I/O permissions)");
17623 case NT_X86_XSTATE
:
17624 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17625 case NT_S390_HIGH_GPRS
:
17626 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17627 case NT_S390_TIMER
:
17628 return _("NT_S390_TIMER (s390 timer register)");
17629 case NT_S390_TODCMP
:
17630 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17631 case NT_S390_TODPREG
:
17632 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17634 return _("NT_S390_CTRS (s390 control registers)");
17635 case NT_S390_PREFIX
:
17636 return _("NT_S390_PREFIX (s390 prefix register)");
17637 case NT_S390_LAST_BREAK
:
17638 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17639 case NT_S390_SYSTEM_CALL
:
17640 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17642 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17643 case NT_S390_VXRS_LOW
:
17644 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17645 case NT_S390_VXRS_HIGH
:
17646 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17647 case NT_S390_GS_CB
:
17648 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17649 case NT_S390_GS_BC
:
17650 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17652 return _("NT_ARM_VFP (arm VFP registers)");
17654 return _("NT_ARM_TLS (AArch TLS registers)");
17655 case NT_ARM_HW_BREAK
:
17656 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17657 case NT_ARM_HW_WATCH
:
17658 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17660 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17662 return _("NT_PSTATUS (pstatus structure)");
17664 return _("NT_FPREGS (floating point registers)");
17666 return _("NT_PSINFO (psinfo structure)");
17668 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17670 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17671 case NT_WIN32PSTATUS
:
17672 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17674 return _("NT_SIGINFO (siginfo_t data)");
17676 return _("NT_FILE (mapped files)");
17684 return _("NT_VERSION (version)");
17686 return _("NT_ARCH (architecture)");
17687 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17689 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17695 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17700 print_core_note (Elf_Internal_Note
*pnote
)
17702 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17703 bfd_vma count
, page_size
;
17704 unsigned char *descdata
, *filenames
, *descend
;
17706 if (pnote
->type
!= NT_FILE
)
17716 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17717 /* Still "successful". */
17722 if (pnote
->descsz
< 2 * addr_size
)
17724 error (_(" Malformed note - too short for header\n"));
17728 descdata
= (unsigned char *) pnote
->descdata
;
17729 descend
= descdata
+ pnote
->descsz
;
17731 if (descdata
[pnote
->descsz
- 1] != '\0')
17733 error (_(" Malformed note - does not end with \\0\n"));
17737 count
= byte_get (descdata
, addr_size
);
17738 descdata
+= addr_size
;
17740 page_size
= byte_get (descdata
, addr_size
);
17741 descdata
+= addr_size
;
17743 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17744 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17746 error (_(" Malformed note - too short for supplied file count\n"));
17750 printf (_(" Page size: "));
17751 print_vma (page_size
, DEC
);
17754 printf (_(" %*s%*s%*s\n"),
17755 (int) (2 + 2 * addr_size
), _("Start"),
17756 (int) (4 + 2 * addr_size
), _("End"),
17757 (int) (4 + 2 * addr_size
), _("Page Offset"));
17758 filenames
= descdata
+ count
* 3 * addr_size
;
17759 while (count
-- > 0)
17761 bfd_vma start
, end
, file_ofs
;
17763 if (filenames
== descend
)
17765 error (_(" Malformed note - filenames end too early\n"));
17769 start
= byte_get (descdata
, addr_size
);
17770 descdata
+= addr_size
;
17771 end
= byte_get (descdata
, addr_size
);
17772 descdata
+= addr_size
;
17773 file_ofs
= byte_get (descdata
, addr_size
);
17774 descdata
+= addr_size
;
17777 print_vma (start
, FULL_HEX
);
17779 print_vma (end
, FULL_HEX
);
17781 print_vma (file_ofs
, FULL_HEX
);
17782 printf ("\n %s\n", filenames
);
17784 filenames
+= 1 + strlen ((char *) filenames
);
17790 static const char *
17791 get_gnu_elf_note_type (unsigned e_type
)
17793 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17796 case NT_GNU_ABI_TAG
:
17797 return _("NT_GNU_ABI_TAG (ABI version tag)");
17799 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17800 case NT_GNU_BUILD_ID
:
17801 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17802 case NT_GNU_GOLD_VERSION
:
17803 return _("NT_GNU_GOLD_VERSION (gold version)");
17804 case NT_GNU_PROPERTY_TYPE_0
:
17805 return _("NT_GNU_PROPERTY_TYPE_0");
17806 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17807 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17808 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17809 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17812 static char buff
[64];
17814 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17821 decode_x86_compat_isa (unsigned int bitmask
)
17825 unsigned int bit
= bitmask
& (- bitmask
);
17830 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17833 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17836 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17839 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17842 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17845 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17848 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17851 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17854 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17857 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17860 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17863 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17864 printf ("AVX512F");
17866 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17867 printf ("AVX512CD");
17869 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17870 printf ("AVX512ER");
17872 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17873 printf ("AVX512PF");
17875 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17876 printf ("AVX512VL");
17878 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17879 printf ("AVX512DQ");
17881 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17882 printf ("AVX512BW");
17885 printf (_("<unknown: %x>"), bit
);
17894 decode_x86_isa (unsigned int bitmask
)
17898 printf (_("<None>"));
17904 unsigned int bit
= bitmask
& (- bitmask
);
17909 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17912 case GNU_PROPERTY_X86_ISA_1_SSE
:
17915 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17918 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17921 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17924 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17927 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17930 case GNU_PROPERTY_X86_ISA_1_AVX
:
17933 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17936 case GNU_PROPERTY_X86_ISA_1_FMA
:
17939 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17940 printf ("AVX512F");
17942 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17943 printf ("AVX512CD");
17945 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17946 printf ("AVX512ER");
17948 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17949 printf ("AVX512PF");
17951 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17952 printf ("AVX512VL");
17954 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17955 printf ("AVX512DQ");
17957 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17958 printf ("AVX512BW");
17960 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17961 printf ("AVX512_4FMAPS");
17963 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17964 printf ("AVX512_4VNNIW");
17966 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17967 printf ("AVX512_BITALG");
17969 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17970 printf ("AVX512_IFMA");
17972 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17973 printf ("AVX512_VBMI");
17975 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17976 printf ("AVX512_VBMI2");
17978 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17979 printf ("AVX512_VNNI");
17981 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17982 printf ("AVX512_BF16");
17985 printf (_("<unknown: %x>"), bit
);
17994 decode_x86_feature_1 (unsigned int bitmask
)
17998 printf (_("<None>"));
18004 unsigned int bit
= bitmask
& (- bitmask
);
18009 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18012 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18016 printf (_("<unknown: %x>"), bit
);
18025 decode_x86_feature_2 (unsigned int bitmask
)
18029 printf (_("<None>"));
18035 unsigned int bit
= bitmask
& (- bitmask
);
18040 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18043 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18046 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18049 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18052 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18055 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18058 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18061 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18064 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18065 printf ("XSAVEOPT");
18067 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18071 printf (_("<unknown: %x>"), bit
);
18080 decode_aarch64_feature_1_and (unsigned int bitmask
)
18084 unsigned int bit
= bitmask
& (- bitmask
);
18089 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18093 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18098 printf (_("<unknown: %x>"), bit
);
18107 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18109 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18110 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18111 unsigned int size
= is_32bit_elf
? 4 : 8;
18113 printf (_(" Properties: "));
18115 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18117 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18121 while (ptr
< ptr_end
)
18125 unsigned int datasz
;
18127 if ((size_t) (ptr_end
- ptr
) < 8)
18129 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18133 type
= byte_get (ptr
, 4);
18134 datasz
= byte_get (ptr
+ 4, 4);
18138 if (datasz
> (size_t) (ptr_end
- ptr
))
18140 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18145 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18147 if (filedata
->file_header
.e_machine
== EM_X86_64
18148 || filedata
->file_header
.e_machine
== EM_IAMCU
18149 || filedata
->file_header
.e_machine
== EM_386
)
18151 unsigned int bitmask
;
18154 bitmask
= byte_get (ptr
, 4);
18160 case GNU_PROPERTY_X86_ISA_1_USED
:
18162 printf (_("x86 ISA used: <corrupt length: %#x> "),
18166 printf ("x86 ISA used: ");
18167 decode_x86_isa (bitmask
);
18171 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18173 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18177 printf ("x86 ISA needed: ");
18178 decode_x86_isa (bitmask
);
18182 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18184 printf (_("x86 feature: <corrupt length: %#x> "),
18188 printf ("x86 feature: ");
18189 decode_x86_feature_1 (bitmask
);
18193 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18195 printf (_("x86 feature used: <corrupt length: %#x> "),
18199 printf ("x86 feature used: ");
18200 decode_x86_feature_2 (bitmask
);
18204 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18206 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18209 printf ("x86 feature needed: ");
18210 decode_x86_feature_2 (bitmask
);
18214 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18216 printf (_("x86 ISA used: <corrupt length: %#x> "),
18220 printf ("x86 ISA used: ");
18221 decode_x86_compat_isa (bitmask
);
18225 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18227 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18231 printf ("x86 ISA needed: ");
18232 decode_x86_compat_isa (bitmask
);
18240 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18242 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18244 printf ("AArch64 feature: ");
18246 printf (_("<corrupt length: %#x> "), datasz
);
18248 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18257 case GNU_PROPERTY_STACK_SIZE
:
18258 printf (_("stack size: "));
18259 if (datasz
!= size
)
18260 printf (_("<corrupt length: %#x> "), datasz
);
18262 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18265 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18266 printf ("no copy on protected ");
18268 printf (_("<corrupt length: %#x> "), datasz
);
18276 if (type
< GNU_PROPERTY_LOPROC
)
18277 printf (_("<unknown type %#x data: "), type
);
18278 else if (type
< GNU_PROPERTY_LOUSER
)
18279 printf (_("<procesor-specific type %#x data: "), type
);
18281 printf (_("<application-specific type %#x data: "), type
);
18282 for (j
= 0; j
< datasz
; ++j
)
18283 printf ("%02x ", ptr
[j
] & 0xff);
18287 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18288 if (ptr
== ptr_end
)
18301 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18303 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18304 switch (pnote
->type
)
18306 case NT_GNU_BUILD_ID
:
18310 printf (_(" Build ID: "));
18311 for (i
= 0; i
< pnote
->descsz
; ++i
)
18312 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18317 case NT_GNU_ABI_TAG
:
18319 unsigned long os
, major
, minor
, subminor
;
18320 const char *osname
;
18322 /* PR 17531: file: 030-599401-0.004. */
18323 if (pnote
->descsz
< 16)
18325 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18329 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18330 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18331 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18332 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18336 case GNU_ABI_TAG_LINUX
:
18339 case GNU_ABI_TAG_HURD
:
18342 case GNU_ABI_TAG_SOLARIS
:
18343 osname
= "Solaris";
18345 case GNU_ABI_TAG_FREEBSD
:
18346 osname
= "FreeBSD";
18348 case GNU_ABI_TAG_NETBSD
:
18351 case GNU_ABI_TAG_SYLLABLE
:
18352 osname
= "Syllable";
18354 case GNU_ABI_TAG_NACL
:
18358 osname
= "Unknown";
18362 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18363 major
, minor
, subminor
);
18367 case NT_GNU_GOLD_VERSION
:
18371 printf (_(" Version: "));
18372 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18373 printf ("%c", pnote
->descdata
[i
]);
18380 unsigned long num_entries
, mask
;
18382 /* Hardware capabilities information. Word 0 is the number of entries.
18383 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18384 is a series of entries, where each entry is a single byte followed
18385 by a nul terminated string. The byte gives the bit number to test
18386 if enabled in the bitmask. */
18387 printf (_(" Hardware Capabilities: "));
18388 if (pnote
->descsz
< 8)
18390 error (_("<corrupt GNU_HWCAP>\n"));
18393 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18394 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18395 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18396 /* FIXME: Add code to display the entries... */
18400 case NT_GNU_PROPERTY_TYPE_0
:
18401 print_gnu_property_note (filedata
, pnote
);
18405 /* Handle unrecognised types. An error message should have already been
18406 created by get_gnu_elf_note_type(), so all that we need to do is to
18407 display the data. */
18411 printf (_(" Description data: "));
18412 for (i
= 0; i
< pnote
->descsz
; ++i
)
18413 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18422 static const char *
18423 get_v850_elf_note_type (enum v850_notes n_type
)
18425 static char buff
[64];
18429 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18430 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18431 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18432 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18433 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18434 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18436 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18442 print_v850_note (Elf_Internal_Note
* pnote
)
18446 if (pnote
->descsz
!= 4)
18449 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18453 printf (_("not set\n"));
18457 switch (pnote
->type
)
18459 case V850_NOTE_ALIGNMENT
:
18462 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18463 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18467 case V850_NOTE_DATA_SIZE
:
18470 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18471 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18475 case V850_NOTE_FPU_INFO
:
18478 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18479 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18483 case V850_NOTE_MMU_INFO
:
18484 case V850_NOTE_CACHE_INFO
:
18485 case V850_NOTE_SIMD_INFO
:
18486 if (val
== EF_RH850_SIMD
)
18488 printf (_("yes\n"));
18494 /* An 'unknown note type' message will already have been displayed. */
18498 printf (_("unknown value: %x\n"), val
);
18503 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18505 unsigned int version
;
18507 switch (pnote
->type
)
18509 case NT_NETBSD_IDENT
:
18510 if (pnote
->descsz
< 1)
18512 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18513 if ((version
/ 10000) % 100)
18514 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18515 version
, version
/ 100000000, (version
/ 1000000) % 100,
18516 (version
/ 10000) % 100 > 26 ? "Z" : "",
18517 'A' + (version
/ 10000) % 26);
18519 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18520 version
, version
/ 100000000, (version
/ 1000000) % 100,
18521 (version
/ 100) % 100);
18524 case NT_NETBSD_MARCH
:
18525 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18529 #ifdef NT_NETBSD_PAX
18530 case NT_NETBSD_PAX
:
18531 if (pnote
->descsz
< 1)
18533 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18534 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18535 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18536 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18537 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18538 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18539 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18540 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18545 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18546 pnote
->descsz
, pnote
->type
);
18550 static const char *
18551 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18555 case NT_FREEBSD_THRMISC
:
18556 return _("NT_THRMISC (thrmisc structure)");
18557 case NT_FREEBSD_PROCSTAT_PROC
:
18558 return _("NT_PROCSTAT_PROC (proc data)");
18559 case NT_FREEBSD_PROCSTAT_FILES
:
18560 return _("NT_PROCSTAT_FILES (files data)");
18561 case NT_FREEBSD_PROCSTAT_VMMAP
:
18562 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18563 case NT_FREEBSD_PROCSTAT_GROUPS
:
18564 return _("NT_PROCSTAT_GROUPS (groups data)");
18565 case NT_FREEBSD_PROCSTAT_UMASK
:
18566 return _("NT_PROCSTAT_UMASK (umask data)");
18567 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18568 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18569 case NT_FREEBSD_PROCSTAT_OSREL
:
18570 return _("NT_PROCSTAT_OSREL (osreldate data)");
18571 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18572 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18573 case NT_FREEBSD_PROCSTAT_AUXV
:
18574 return _("NT_PROCSTAT_AUXV (auxv data)");
18575 case NT_FREEBSD_PTLWPINFO
:
18576 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18578 return get_note_type (filedata
, e_type
);
18581 static const char *
18582 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18584 static char buff
[64];
18588 case NT_NETBSDCORE_PROCINFO
:
18589 /* NetBSD core "procinfo" structure. */
18590 return _("NetBSD procinfo structure");
18592 #ifdef NT_NETBSDCORE_AUXV
18593 case NT_NETBSDCORE_AUXV
:
18594 return _("NetBSD ELF auxiliary vector data");
18597 #ifdef NT_NETBSDCORE_LWPSTATUS
18598 case NT_NETBSDCORE_LWPSTATUS
:
18599 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18603 /* As of Jan 2020 there are no other machine-independent notes
18604 defined for NetBSD core files. If the note type is less
18605 than the start of the machine-dependent note types, we don't
18608 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18610 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18616 switch (filedata
->file_header
.e_machine
)
18618 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18619 and PT_GETFPREGS == mach+2. */
18624 case EM_SPARC32PLUS
:
18628 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18629 return _("PT_GETREGS (reg structure)");
18630 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18631 return _("PT_GETFPREGS (fpreg structure)");
18637 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18638 There's also old PT___GETREGS40 == mach + 1 for old reg
18639 structure which lacks GBR. */
18643 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18644 return _("PT___GETREGS40 (old reg structure)");
18645 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18646 return _("PT_GETREGS (reg structure)");
18647 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18648 return _("PT_GETFPREGS (fpreg structure)");
18654 /* On all other arch's, PT_GETREGS == mach+1 and
18655 PT_GETFPREGS == mach+3. */
18659 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18660 return _("PT_GETREGS (reg structure)");
18661 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18662 return _("PT_GETFPREGS (fpreg structure)");
18668 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18669 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18673 static const char *
18674 get_stapsdt_note_type (unsigned e_type
)
18676 static char buff
[64];
18681 return _("NT_STAPSDT (SystemTap probe descriptors)");
18687 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18692 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18694 size_t len
, maxlen
;
18695 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18696 char *data
= pnote
->descdata
;
18697 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18698 bfd_vma pc
, base_addr
, semaphore
;
18699 char *provider
, *probe
, *arg_fmt
;
18701 if (pnote
->descsz
< (addr_size
* 3))
18702 goto stapdt_note_too_small
;
18704 pc
= byte_get ((unsigned char *) data
, addr_size
);
18707 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18710 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18713 if (data
>= data_end
)
18714 goto stapdt_note_too_small
;
18715 maxlen
= data_end
- data
;
18716 len
= strnlen (data
, maxlen
);
18723 goto stapdt_note_too_small
;
18725 if (data
>= data_end
)
18726 goto stapdt_note_too_small
;
18727 maxlen
= data_end
- data
;
18728 len
= strnlen (data
, maxlen
);
18735 goto stapdt_note_too_small
;
18737 if (data
>= data_end
)
18738 goto stapdt_note_too_small
;
18739 maxlen
= data_end
- data
;
18740 len
= strnlen (data
, maxlen
);
18747 goto stapdt_note_too_small
;
18749 printf (_(" Provider: %s\n"), provider
);
18750 printf (_(" Name: %s\n"), probe
);
18751 printf (_(" Location: "));
18752 print_vma (pc
, FULL_HEX
);
18753 printf (_(", Base: "));
18754 print_vma (base_addr
, FULL_HEX
);
18755 printf (_(", Semaphore: "));
18756 print_vma (semaphore
, FULL_HEX
);
18758 printf (_(" Arguments: %s\n"), arg_fmt
);
18760 return data
== data_end
;
18762 stapdt_note_too_small
:
18763 printf (_(" <corrupt - note is too small>\n"));
18764 error (_("corrupt stapdt note - the data size is too small\n"));
18768 static const char *
18769 get_ia64_vms_note_type (unsigned e_type
)
18771 static char buff
[64];
18776 return _("NT_VMS_MHD (module header)");
18778 return _("NT_VMS_LNM (language name)");
18780 return _("NT_VMS_SRC (source files)");
18782 return "NT_VMS_TITLE";
18784 return _("NT_VMS_EIDC (consistency check)");
18785 case NT_VMS_FPMODE
:
18786 return _("NT_VMS_FPMODE (FP mode)");
18787 case NT_VMS_LINKTIME
:
18788 return "NT_VMS_LINKTIME";
18789 case NT_VMS_IMGNAM
:
18790 return _("NT_VMS_IMGNAM (image name)");
18792 return _("NT_VMS_IMGID (image id)");
18793 case NT_VMS_LINKID
:
18794 return _("NT_VMS_LINKID (link id)");
18795 case NT_VMS_IMGBID
:
18796 return _("NT_VMS_IMGBID (build id)");
18797 case NT_VMS_GSTNAM
:
18798 return _("NT_VMS_GSTNAM (sym table name)");
18799 case NT_VMS_ORIG_DYN
:
18800 return "NT_VMS_ORIG_DYN";
18801 case NT_VMS_PATCHTIME
:
18802 return "NT_VMS_PATCHTIME";
18804 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18810 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18812 int maxlen
= pnote
->descsz
;
18814 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18815 goto desc_size_fail
;
18817 switch (pnote
->type
)
18821 goto desc_size_fail
;
18823 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18825 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18826 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18827 if (l
+ 34 < maxlen
)
18829 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18830 if (l
+ 35 < maxlen
)
18831 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18833 printf (_(" Module version : <missing>\n"));
18837 printf (_(" Module name : <missing>\n"));
18838 printf (_(" Module version : <missing>\n"));
18843 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18847 case NT_VMS_FPMODE
:
18848 printf (_(" Floating Point mode: "));
18850 goto desc_size_fail
;
18851 /* FIXME: Generate an error if descsz > 8 ? */
18853 printf ("0x%016" BFD_VMA_FMT
"x\n",
18854 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18857 case NT_VMS_LINKTIME
:
18858 printf (_(" Link time: "));
18860 goto desc_size_fail
;
18861 /* FIXME: Generate an error if descsz > 8 ? */
18864 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18868 case NT_VMS_PATCHTIME
:
18869 printf (_(" Patch time: "));
18871 goto desc_size_fail
;
18872 /* FIXME: Generate an error if descsz > 8 ? */
18875 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18879 case NT_VMS_ORIG_DYN
:
18881 goto desc_size_fail
;
18883 printf (_(" Major id: %u, minor id: %u\n"),
18884 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18885 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18886 printf (_(" Last modified : "));
18888 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18889 printf (_("\n Link flags : "));
18890 printf ("0x%016" BFD_VMA_FMT
"x\n",
18891 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18892 printf (_(" Header flags: 0x%08x\n"),
18893 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18894 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18898 case NT_VMS_IMGNAM
:
18899 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18902 case NT_VMS_GSTNAM
:
18903 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18907 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18910 case NT_VMS_LINKID
:
18911 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18921 printf (_(" <corrupt - data size is too small>\n"));
18922 error (_("corrupt IA64 note: data size is too small\n"));
18926 struct build_attr_cache
{
18927 Filedata
*filedata
;
18929 unsigned long strtablen
;
18930 Elf_Internal_Sym
*symtab
;
18931 unsigned long nsyms
;
18934 /* Find the symbol associated with a build attribute that is attached
18935 to address OFFSET. If PNAME is non-NULL then store the name of
18936 the symbol (if found) in the provided pointer, Returns NULL if a
18937 symbol could not be found. */
18939 static Elf_Internal_Sym
*
18940 get_symbol_for_build_attribute (Filedata
* filedata
,
18941 unsigned long offset
,
18942 bfd_boolean is_open_attr
,
18943 const char ** pname
)
18945 Elf_Internal_Sym
*saved_sym
= NULL
;
18946 Elf_Internal_Sym
*sym
;
18948 if (filedata
->section_headers
!= NULL
18949 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18951 Elf_Internal_Shdr
* symsec
;
18953 free (ba_cache
.strtab
);
18954 ba_cache
.strtab
= NULL
;
18955 free (ba_cache
.symtab
);
18956 ba_cache
.symtab
= NULL
;
18958 /* Load the symbol and string sections. */
18959 for (symsec
= filedata
->section_headers
;
18960 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18963 if (symsec
->sh_type
== SHT_SYMTAB
18964 && get_symtab (filedata
, symsec
,
18965 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18966 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18969 ba_cache
.filedata
= filedata
;
18972 if (ba_cache
.symtab
== NULL
)
18975 /* Find a symbol whose value matches offset. */
18976 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18977 if (sym
->st_value
== offset
)
18979 if (sym
->st_name
>= ba_cache
.strtablen
)
18980 /* Huh ? This should not happen. */
18983 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18986 /* The AArch64 and ARM architectures define mapping symbols
18987 (eg $d, $x, $t) which we want to ignore. */
18988 if (ba_cache
.strtab
[sym
->st_name
] == '$'
18989 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
18990 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
18995 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18996 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18997 FUNC symbols entirely. */
18998 switch (ELF_ST_TYPE (sym
->st_info
))
19005 /* If the symbol has a size associated
19006 with it then we can stop searching. */
19007 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19012 /* Ignore function symbols. */
19019 switch (ELF_ST_BIND (sym
->st_info
))
19022 if (saved_sym
== NULL
19023 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19028 if (saved_sym
== NULL
)
19038 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19046 if (saved_sym
&& pname
)
19047 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19052 /* Returns true iff addr1 and addr2 are in the same section. */
19055 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19057 Elf_Internal_Shdr
* a1
;
19058 Elf_Internal_Shdr
* a2
;
19060 a1
= find_section_by_address (filedata
, addr1
);
19061 a2
= find_section_by_address (filedata
, addr2
);
19063 return a1
== a2
&& a1
!= NULL
;
19067 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19068 Filedata
* filedata
)
19070 static unsigned long global_offset
= 0;
19071 static unsigned long global_end
= 0;
19072 static unsigned long func_offset
= 0;
19073 static unsigned long func_end
= 0;
19075 Elf_Internal_Sym
* sym
;
19077 unsigned long start
;
19079 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19081 switch (pnote
->descsz
)
19084 /* A zero-length description means that the range of
19085 the previous note of the same type should be used. */
19088 if (global_end
> global_offset
)
19089 printf (_(" Applies to region from %#lx to %#lx\n"),
19090 global_offset
, global_end
);
19092 printf (_(" Applies to region from %#lx\n"), global_offset
);
19096 if (func_end
> func_offset
)
19097 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19099 printf (_(" Applies to region from %#lx\n"), func_offset
);
19104 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19111 /* FIXME: We should check that version 3+ notes are being used here... */
19112 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19113 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19117 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19123 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19124 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19128 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19129 printf (_(" <invalid descsz>"));
19134 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19135 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19136 in order to avoid them being confused with the start address of the
19137 first function in the file... */
19138 if (sym
== NULL
&& is_open_attr
)
19139 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19142 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19143 end
= start
+ sym
->st_size
;
19147 /* FIXME: Need to properly allow for section alignment.
19148 16 is just the alignment used on x86_64. */
19150 && start
> BFD_ALIGN (global_end
, 16)
19151 /* Build notes are not guaranteed to be organised in order of
19152 increasing address, but we should find the all of the notes
19153 for one section in the same place. */
19154 && same_section (filedata
, start
, global_end
))
19155 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19156 global_end
+ 1, start
- 1);
19158 printf (_(" Applies to region from %#lx"), start
);
19159 global_offset
= start
;
19163 printf (_(" to %#lx"), end
);
19169 printf (_(" Applies to region from %#lx"), start
);
19170 func_offset
= start
;
19174 printf (_(" to %#lx"), end
);
19180 printf (_(" (%s)"), name
);
19187 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19189 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19190 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19191 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19193 char name_attribute
;
19194 const char * expected_types
;
19195 const char * name
= pnote
->namedata
;
19199 if (name
== NULL
|| pnote
->namesz
< 2)
19201 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19202 print_symbol (-20, _(" <corrupt name>"));
19211 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19212 if (name
[0] == 'G' && name
[1] == 'A')
19214 if (pnote
->namesz
< 4)
19216 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19217 print_symbol (-20, _(" <corrupt name>"));
19226 switch ((name_type
= * name
))
19228 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19229 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19230 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19231 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19232 printf ("%c", * name
);
19236 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19237 print_symbol (-20, _("<unknown name type>"));
19244 switch ((name_attribute
= * name
))
19246 case GNU_BUILD_ATTRIBUTE_VERSION
:
19247 text
= _("<version>");
19248 expected_types
= string_expected
;
19251 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19252 text
= _("<stack prot>");
19253 expected_types
= "!+*";
19256 case GNU_BUILD_ATTRIBUTE_RELRO
:
19257 text
= _("<relro>");
19258 expected_types
= bool_expected
;
19261 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19262 text
= _("<stack size>");
19263 expected_types
= number_expected
;
19266 case GNU_BUILD_ATTRIBUTE_TOOL
:
19267 text
= _("<tool>");
19268 expected_types
= string_expected
;
19271 case GNU_BUILD_ATTRIBUTE_ABI
:
19273 expected_types
= "$*";
19276 case GNU_BUILD_ATTRIBUTE_PIC
:
19278 expected_types
= number_expected
;
19281 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19282 text
= _("<short enum>");
19283 expected_types
= bool_expected
;
19287 if (ISPRINT (* name
))
19289 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19291 if (len
> left
&& ! do_wide
)
19293 printf ("%.*s:", len
, name
);
19299 static char tmpbuf
[128];
19301 error (_("unrecognised byte in name field: %d\n"), * name
);
19302 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19306 expected_types
= "*$!+";
19311 left
-= printf ("%s", text
);
19313 if (strchr (expected_types
, name_type
) == NULL
)
19314 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19316 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19318 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19319 (unsigned long) pnote
->namesz
,
19320 (long) (name
- pnote
->namedata
));
19324 if (left
< 1 && ! do_wide
)
19329 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19331 unsigned int bytes
;
19332 unsigned long long val
= 0;
19333 unsigned int shift
= 0;
19334 char * decoded
= NULL
;
19336 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19338 /* The -1 is because the name field is always 0 terminated, and we
19339 want to be able to ensure that the shift in the while loop below
19340 will not overflow. */
19343 if (bytes
> sizeof (val
))
19345 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19347 bytes
= sizeof (val
);
19349 /* We do not bother to warn if bytes == 0 as this can
19350 happen with some early versions of the gcc plugin. */
19354 unsigned long byte
= (* name
++) & 0xff;
19356 val
|= byte
<< shift
;
19360 switch (name_attribute
)
19362 case GNU_BUILD_ATTRIBUTE_PIC
:
19365 case 0: decoded
= "static"; break;
19366 case 1: decoded
= "pic"; break;
19367 case 2: decoded
= "PIC"; break;
19368 case 3: decoded
= "pie"; break;
19369 case 4: decoded
= "PIE"; break;
19373 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19376 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19377 case 0: decoded
= "off"; break;
19378 case 1: decoded
= "on"; break;
19379 case 2: decoded
= "all"; break;
19380 case 3: decoded
= "strong"; break;
19381 case 4: decoded
= "explicit"; break;
19389 if (decoded
!= NULL
)
19391 print_symbol (-left
, decoded
);
19402 left
-= printf ("0x%llx", val
);
19404 left
-= printf ("0x%-.*llx", left
, val
);
19408 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19409 left
-= print_symbol (- left
, name
);
19411 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19412 left
-= print_symbol (- left
, "true");
19414 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19415 left
-= print_symbol (- left
, "false");
19419 if (do_wide
&& left
> 0)
19420 printf ("%-*s", left
, " ");
19425 /* Note that by the ELF standard, the name field is already null byte
19426 terminated, and namesz includes the terminating null byte.
19427 I.E. the value of namesz for the name "FSF" is 4.
19429 If the value of namesz is zero, there is no name present. */
19432 process_note (Elf_Internal_Note
* pnote
,
19433 Filedata
* filedata
)
19435 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19438 if (pnote
->namesz
== 0)
19439 /* If there is no note name, then use the default set of
19440 note type strings. */
19441 nt
= get_note_type (filedata
, pnote
->type
);
19443 else if (const_strneq (pnote
->namedata
, "GNU"))
19444 /* GNU-specific object file notes. */
19445 nt
= get_gnu_elf_note_type (pnote
->type
);
19447 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19448 /* FreeBSD-specific core file notes. */
19449 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19451 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19452 /* NetBSD-specific core file notes. */
19453 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19455 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19456 /* NetBSD-specific core file notes. */
19457 return process_netbsd_elf_note (pnote
);
19459 else if (const_strneq (pnote
->namedata
, "PaX"))
19460 /* NetBSD-specific core file notes. */
19461 return process_netbsd_elf_note (pnote
);
19463 else if (strneq (pnote
->namedata
, "SPU/", 4))
19465 /* SPU-specific core file notes. */
19466 nt
= pnote
->namedata
+ 4;
19470 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19471 /* VMS/ia64-specific file notes. */
19472 nt
= get_ia64_vms_note_type (pnote
->type
);
19474 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19475 nt
= get_stapsdt_note_type (pnote
->type
);
19478 /* Don't recognize this note name; just use the default set of
19479 note type strings. */
19480 nt
= get_note_type (filedata
, pnote
->type
);
19484 if (((const_strneq (pnote
->namedata
, "GA")
19485 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19486 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19487 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19488 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19489 print_gnu_build_attribute_name (pnote
);
19491 print_symbol (-20, name
);
19494 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19496 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19498 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19499 return print_ia64_vms_note (pnote
);
19500 else if (const_strneq (pnote
->namedata
, "GNU"))
19501 return print_gnu_note (filedata
, pnote
);
19502 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19503 return print_stapsdt_note (pnote
);
19504 else if (const_strneq (pnote
->namedata
, "CORE"))
19505 return print_core_note (pnote
);
19506 else if (((const_strneq (pnote
->namedata
, "GA")
19507 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19508 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19509 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19510 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19511 return print_gnu_build_attribute_description (pnote
, filedata
);
19517 printf (_(" description data: "));
19518 for (i
= 0; i
< pnote
->descsz
; i
++)
19519 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19531 process_notes_at (Filedata
* filedata
,
19532 Elf_Internal_Shdr
* section
,
19537 Elf_External_Note
* pnotes
;
19538 Elf_External_Note
* external
;
19540 bfd_boolean res
= TRUE
;
19547 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19550 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19558 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19561 if (pnotes
== NULL
)
19567 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19569 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19570 (unsigned long) offset
, (unsigned long) length
);
19572 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19573 specifies that notes should be aligned to 4 bytes in 32-bit
19574 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19575 we also support 4 byte alignment in 64-bit objects. If section
19576 alignment is less than 4, we treate alignment as 4 bytes. */
19579 else if (align
!= 4 && align
!= 8)
19581 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19587 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19589 end
= (char *) pnotes
+ length
;
19590 while ((char *) external
< end
)
19592 Elf_Internal_Note inote
;
19595 char * temp
= NULL
;
19596 size_t data_remaining
= end
- (char *) external
;
19598 if (!is_ia64_vms (filedata
))
19600 /* PR binutils/15191
19601 Make sure that there is enough data to read. */
19602 min_notesz
= offsetof (Elf_External_Note
, name
);
19603 if (data_remaining
< min_notesz
)
19605 warn (ngettext ("Corrupt note: only %ld byte remains, "
19606 "not enough for a full note\n",
19607 "Corrupt note: only %ld bytes remain, "
19608 "not enough for a full note\n",
19610 (long) data_remaining
);
19613 data_remaining
-= min_notesz
;
19615 inote
.type
= BYTE_GET (external
->type
);
19616 inote
.namesz
= BYTE_GET (external
->namesz
);
19617 inote
.namedata
= external
->name
;
19618 inote
.descsz
= BYTE_GET (external
->descsz
);
19619 inote
.descdata
= ((char *) external
19620 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19621 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19622 next
= ((char *) external
19623 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19627 Elf64_External_VMS_Note
*vms_external
;
19629 /* PR binutils/15191
19630 Make sure that there is enough data to read. */
19631 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19632 if (data_remaining
< min_notesz
)
19634 warn (ngettext ("Corrupt note: only %ld byte remains, "
19635 "not enough for a full note\n",
19636 "Corrupt note: only %ld bytes remain, "
19637 "not enough for a full note\n",
19639 (long) data_remaining
);
19642 data_remaining
-= min_notesz
;
19644 vms_external
= (Elf64_External_VMS_Note
*) external
;
19645 inote
.type
= BYTE_GET (vms_external
->type
);
19646 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19647 inote
.namedata
= vms_external
->name
;
19648 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19649 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19650 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19651 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19654 /* PR 17531: file: 3443835e. */
19655 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19656 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19657 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19658 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19659 || ((size_t) (next
- inote
.descdata
)
19660 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19662 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19663 (unsigned long) ((char *) external
- (char *) pnotes
));
19664 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19665 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19669 external
= (Elf_External_Note
*) next
;
19671 /* Verify that name is null terminated. It appears that at least
19672 one version of Linux (RedHat 6.0) generates corefiles that don't
19673 comply with the ELF spec by failing to include the null byte in
19675 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19677 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19679 temp
= (char *) malloc (inote
.namesz
+ 1);
19682 error (_("Out of memory allocating space for inote name\n"));
19687 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19688 inote
.namedata
= temp
;
19690 inote
.namedata
[inote
.namesz
] = 0;
19693 if (! process_note (& inote
, filedata
))
19706 process_corefile_note_segments (Filedata
* filedata
)
19708 Elf_Internal_Phdr
* segment
;
19710 bfd_boolean res
= TRUE
;
19712 if (! get_program_headers (filedata
))
19715 for (i
= 0, segment
= filedata
->program_headers
;
19716 i
< filedata
->file_header
.e_phnum
;
19719 if (segment
->p_type
== PT_NOTE
)
19720 if (! process_notes_at (filedata
, NULL
,
19721 (bfd_vma
) segment
->p_offset
,
19722 (bfd_vma
) segment
->p_filesz
,
19723 (bfd_vma
) segment
->p_align
))
19731 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19733 Elf_External_Note
* pnotes
;
19734 Elf_External_Note
* external
;
19736 bfd_boolean res
= TRUE
;
19741 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19743 if (pnotes
== NULL
)
19747 end
= (char*) pnotes
+ length
;
19749 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19750 (unsigned long) offset
, (unsigned long) length
);
19752 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19754 Elf_External_Note
* next
;
19755 Elf_Internal_Note inote
;
19757 inote
.type
= BYTE_GET (external
->type
);
19758 inote
.namesz
= BYTE_GET (external
->namesz
);
19759 inote
.namedata
= external
->name
;
19760 inote
.descsz
= BYTE_GET (external
->descsz
);
19761 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19762 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19764 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19766 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19767 inote
.descdata
= inote
.namedata
;
19771 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19773 if ( ((char *) next
> end
)
19774 || ((char *) next
< (char *) pnotes
))
19776 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19777 (unsigned long) ((char *) external
- (char *) pnotes
));
19778 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19779 inote
.type
, inote
.namesz
, inote
.descsz
);
19785 /* Prevent out-of-bounds indexing. */
19786 if ( inote
.namedata
+ inote
.namesz
> end
19787 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19789 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19790 (unsigned long) ((char *) external
- (char *) pnotes
));
19791 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19792 inote
.type
, inote
.namesz
, inote
.descsz
);
19796 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19798 if (! print_v850_note (& inote
))
19801 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19802 inote
.namesz
, inote
.descsz
);
19812 process_note_sections (Filedata
* filedata
)
19814 Elf_Internal_Shdr
* section
;
19816 unsigned int n
= 0;
19817 bfd_boolean res
= TRUE
;
19819 for (i
= 0, section
= filedata
->section_headers
;
19820 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19823 if (section
->sh_type
== SHT_NOTE
)
19825 if (! process_notes_at (filedata
, section
,
19826 (bfd_vma
) section
->sh_offset
,
19827 (bfd_vma
) section
->sh_size
,
19828 (bfd_vma
) section
->sh_addralign
))
19833 if (( filedata
->file_header
.e_machine
== EM_V800
19834 || filedata
->file_header
.e_machine
== EM_V850
19835 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19836 && section
->sh_type
== SHT_RENESAS_INFO
)
19838 if (! process_v850_notes (filedata
,
19839 (bfd_vma
) section
->sh_offset
,
19840 (bfd_vma
) section
->sh_size
))
19847 /* Try processing NOTE segments instead. */
19848 return process_corefile_note_segments (filedata
);
19854 process_notes (Filedata
* filedata
)
19856 /* If we have not been asked to display the notes then do nothing. */
19860 if (filedata
->file_header
.e_type
!= ET_CORE
)
19861 return process_note_sections (filedata
);
19863 /* No program headers means no NOTE segment. */
19864 if (filedata
->file_header
.e_phnum
> 0)
19865 return process_corefile_note_segments (filedata
);
19867 printf (_("No note segments present in the core file.\n"));
19871 static unsigned char *
19872 display_public_gnu_attributes (unsigned char * start
,
19873 const unsigned char * const end
)
19875 printf (_(" Unknown GNU attribute: %s\n"), start
);
19877 start
+= strnlen ((char *) start
, end
- start
);
19878 display_raw_attribute (start
, end
);
19880 return (unsigned char *) end
;
19883 static unsigned char *
19884 display_generic_attribute (unsigned char * start
,
19886 const unsigned char * const end
)
19889 return (unsigned char *) end
;
19891 return display_tag_value (tag
, start
, end
);
19895 process_arch_specific (Filedata
* filedata
)
19900 switch (filedata
->file_header
.e_machine
)
19903 case EM_ARC_COMPACT
:
19904 case EM_ARC_COMPACT2
:
19905 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19906 display_arc_attribute
,
19907 display_generic_attribute
);
19909 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19910 display_arm_attribute
,
19911 display_generic_attribute
);
19914 case EM_MIPS_RS3_LE
:
19915 return process_mips_specific (filedata
);
19918 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19919 display_msp430x_attribute
,
19920 display_msp430_gnu_attribute
);
19923 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19924 display_riscv_attribute
,
19925 display_generic_attribute
);
19928 return process_nds32_specific (filedata
);
19932 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19933 display_power_gnu_attribute
);
19937 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19938 display_s390_gnu_attribute
);
19941 case EM_SPARC32PLUS
:
19943 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19944 display_sparc_gnu_attribute
);
19947 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19948 display_tic6x_attribute
,
19949 display_generic_attribute
);
19952 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19953 display_public_gnu_attributes
,
19954 display_generic_attribute
);
19959 get_file_header (Filedata
* filedata
)
19961 /* Read in the identity array. */
19962 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19965 /* Determine how to read the rest of the header. */
19966 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19971 byte_get
= byte_get_little_endian
;
19972 byte_put
= byte_put_little_endian
;
19975 byte_get
= byte_get_big_endian
;
19976 byte_put
= byte_put_big_endian
;
19980 /* For now we only support 32 bit and 64 bit ELF files. */
19981 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19983 /* Read in the rest of the header. */
19986 Elf32_External_Ehdr ehdr32
;
19988 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19991 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19992 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19993 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19994 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19995 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19996 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19997 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19998 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19999 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20000 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20001 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20002 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20003 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20007 Elf64_External_Ehdr ehdr64
;
20009 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20010 we will not be able to cope with the 64bit data found in
20011 64 ELF files. Detect this now and abort before we start
20012 overwriting things. */
20013 if (sizeof (bfd_vma
) < 8)
20015 error (_("This instance of readelf has been built without support for a\n\
20016 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20020 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20023 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20024 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20025 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20026 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20027 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20028 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20029 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20030 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20031 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20032 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20033 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20034 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20035 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20038 if (filedata
->file_header
.e_shoff
)
20040 /* There may be some extensions in the first section header. Don't
20041 bomb if we can't read it. */
20043 get_32bit_section_headers (filedata
, TRUE
);
20045 get_64bit_section_headers (filedata
, TRUE
);
20052 close_file (Filedata
* filedata
)
20056 if (filedata
->handle
)
20057 fclose (filedata
->handle
);
20063 close_debug_file (void * data
)
20065 close_file ((Filedata
*) data
);
20069 open_file (const char * pathname
)
20071 struct stat statbuf
;
20072 Filedata
* filedata
= NULL
;
20074 if (stat (pathname
, & statbuf
) < 0
20075 || ! S_ISREG (statbuf
.st_mode
))
20078 filedata
= calloc (1, sizeof * filedata
);
20079 if (filedata
== NULL
)
20082 filedata
->handle
= fopen (pathname
, "rb");
20083 if (filedata
->handle
== NULL
)
20086 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20087 filedata
->file_name
= pathname
;
20089 if (! get_file_header (filedata
))
20092 if (filedata
->file_header
.e_shoff
)
20096 /* Read the section headers again, this time for real. */
20098 res
= get_32bit_section_headers (filedata
, FALSE
);
20100 res
= get_64bit_section_headers (filedata
, FALSE
);
20111 if (filedata
->handle
)
20112 fclose (filedata
->handle
);
20119 open_debug_file (const char * pathname
)
20121 return open_file (pathname
);
20124 /* Process one ELF object file according to the command line options.
20125 This file may actually be stored in an archive. The file is
20126 positioned at the start of the ELF object. Returns TRUE if no
20127 problems were encountered, FALSE otherwise. */
20130 process_object (Filedata
* filedata
)
20132 bfd_boolean have_separate_files
;
20136 if (! get_file_header (filedata
))
20138 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20142 /* Initialise per file variables. */
20143 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20144 filedata
->version_info
[i
] = 0;
20146 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20147 filedata
->dynamic_info
[i
] = 0;
20148 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20149 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20151 /* Process the file. */
20153 printf (_("\nFile: %s\n"), filedata
->file_name
);
20155 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20156 Note we do this even if cmdline_dump_sects is empty because we
20157 must make sure that the dump_sets array is zeroed out before each
20158 object file is processed. */
20159 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20160 memset (filedata
->dump
.dump_sects
, 0,
20161 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20163 if (cmdline
.num_dump_sects
> 0)
20165 if (filedata
->dump
.num_dump_sects
== 0)
20166 /* A sneaky way of allocating the dump_sects array. */
20167 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20169 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20170 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20171 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20174 if (! process_file_header (filedata
))
20177 if (! process_section_headers (filedata
))
20179 /* Without loaded section headers we cannot process lots of things. */
20180 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20182 if (! do_using_dynamic
)
20183 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20186 if (! process_section_groups (filedata
))
20187 /* Without loaded section groups we cannot process unwind. */
20190 res
= process_program_headers (filedata
);
20192 res
= process_dynamic_section (filedata
);
20194 if (! process_relocs (filedata
))
20197 if (! process_unwind (filedata
))
20200 if (! process_symbol_table (filedata
))
20203 if (! process_syminfo (filedata
))
20206 if (! process_version_sections (filedata
))
20209 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20210 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20212 have_separate_files
= FALSE
;
20214 if (! process_section_contents (filedata
))
20217 if (have_separate_files
)
20221 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20223 if (! process_section_headers (d
->handle
))
20225 else if (! process_section_contents (d
->handle
))
20229 /* The file handles are closed by the call to free_debug_memory() below. */
20232 if (! process_notes (filedata
))
20235 if (! process_gnu_liblist (filedata
))
20238 if (! process_arch_specific (filedata
))
20241 free (filedata
->program_headers
);
20242 filedata
->program_headers
= NULL
;
20244 free (filedata
->section_headers
);
20245 filedata
->section_headers
= NULL
;
20247 free (filedata
->string_table
);
20248 filedata
->string_table
= NULL
;
20249 filedata
->string_table_length
= 0;
20251 free (filedata
->dump
.dump_sects
);
20252 filedata
->dump
.dump_sects
= NULL
;
20253 filedata
->dump
.num_dump_sects
= 0;
20255 free (filedata
->dynamic_strings
);
20256 filedata
->dynamic_strings
= NULL
;
20257 filedata
->dynamic_strings_length
= 0;
20259 free (filedata
->dynamic_symbols
);
20260 filedata
->dynamic_symbols
= NULL
;
20261 filedata
->num_dynamic_syms
= 0;
20263 free (filedata
->dynamic_syminfo
);
20264 filedata
->dynamic_syminfo
= NULL
;
20266 free (filedata
->dynamic_section
);
20267 filedata
->dynamic_section
= NULL
;
20269 while (filedata
->symtab_shndx_list
!= NULL
)
20271 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20272 free (filedata
->symtab_shndx_list
);
20273 filedata
->symtab_shndx_list
= next
;
20276 free (filedata
->section_headers_groups
);
20277 filedata
->section_headers_groups
= NULL
;
20279 if (filedata
->section_groups
)
20281 struct group_list
* g
;
20282 struct group_list
* next
;
20284 for (i
= 0; i
< filedata
->group_count
; i
++)
20286 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20293 free (filedata
->section_groups
);
20294 filedata
->section_groups
= NULL
;
20297 free_debug_memory ();
20302 /* Process an ELF archive.
20303 On entry the file is positioned just after the ARMAG string.
20304 Returns TRUE upon success, FALSE otherwise. */
20307 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20309 struct archive_info arch
;
20310 struct archive_info nested_arch
;
20312 bfd_boolean ret
= TRUE
;
20316 /* The ARCH structure is used to hold information about this archive. */
20317 arch
.file_name
= NULL
;
20319 arch
.index_array
= NULL
;
20320 arch
.sym_table
= NULL
;
20321 arch
.longnames
= NULL
;
20323 /* The NESTED_ARCH structure is used as a single-item cache of information
20324 about a nested archive (when members of a thin archive reside within
20325 another regular archive file). */
20326 nested_arch
.file_name
= NULL
;
20327 nested_arch
.file
= NULL
;
20328 nested_arch
.index_array
= NULL
;
20329 nested_arch
.sym_table
= NULL
;
20330 nested_arch
.longnames
= NULL
;
20332 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20333 filedata
->file_size
, is_thin_archive
,
20334 do_archive_index
) != 0)
20340 if (do_archive_index
)
20342 if (arch
.sym_table
== NULL
)
20343 error (_("%s: unable to dump the index as none was found\n"),
20344 filedata
->file_name
);
20347 unsigned long i
, l
;
20348 unsigned long current_pos
;
20350 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20351 "in the symbol table)\n"),
20352 filedata
->file_name
, (unsigned long) arch
.index_num
,
20355 current_pos
= ftell (filedata
->handle
);
20357 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20360 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20363 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20366 if (member_name
!= NULL
)
20368 char * qualified_name
20369 = make_qualified_name (&arch
, &nested_arch
,
20372 if (qualified_name
!= NULL
)
20374 printf (_("Contents of binary %s at offset "),
20376 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20378 free (qualified_name
);
20380 free (member_name
);
20384 if (l
>= arch
.sym_size
)
20386 error (_("%s: end of the symbol table reached "
20387 "before the end of the index\n"),
20388 filedata
->file_name
);
20392 /* PR 17531: file: 0b6630b2. */
20393 printf ("\t%.*s\n",
20394 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20395 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20398 if (arch
.uses_64bit_indices
)
20403 if (l
< arch
.sym_size
)
20405 error (ngettext ("%s: %ld byte remains in the symbol table, "
20406 "but without corresponding entries in "
20407 "the index table\n",
20408 "%s: %ld bytes remain in the symbol table, "
20409 "but without corresponding entries in "
20410 "the index table\n",
20411 arch
.sym_size
- l
),
20412 filedata
->file_name
, arch
.sym_size
- l
);
20416 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20418 error (_("%s: failed to seek back to start of object files "
20419 "in the archive\n"),
20420 filedata
->file_name
);
20426 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20427 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20428 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20429 && !do_section_groups
&& !do_dyn_syms
)
20431 ret
= TRUE
; /* Archive index only. */
20440 char * qualified_name
;
20442 /* Read the next archive header. */
20443 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20445 error (_("%s: failed to seek to next archive header\n"),
20450 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20451 if (got
!= sizeof arch
.arhdr
)
20455 /* PR 24049 - we cannot use filedata->file_name as this will
20456 have already been freed. */
20457 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20462 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20464 error (_("%s: did not find a valid archive header\n"),
20470 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20472 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20473 if (filedata
->archive_file_size
& 01)
20474 ++filedata
->archive_file_size
;
20476 name
= get_archive_member_name (&arch
, &nested_arch
);
20479 error (_("%s: bad archive file name\n"), arch
.file_name
);
20483 namelen
= strlen (name
);
20485 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20486 if (qualified_name
== NULL
)
20488 error (_("%s: bad archive file name\n"), arch
.file_name
);
20494 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20496 /* This is a proxy for an external member of a thin archive. */
20497 Filedata
* member_filedata
;
20498 char * member_file_name
= adjust_relative_path
20499 (filedata
->file_name
, name
, namelen
);
20502 if (member_file_name
== NULL
)
20504 free (qualified_name
);
20509 member_filedata
= open_file (member_file_name
);
20510 if (member_filedata
== NULL
)
20512 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20513 free (member_file_name
);
20514 free (qualified_name
);
20519 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20520 member_filedata
->file_name
= qualified_name
;
20522 if (! process_object (member_filedata
))
20525 close_file (member_filedata
);
20526 free (member_file_name
);
20528 else if (is_thin_archive
)
20530 Filedata thin_filedata
;
20532 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20534 /* PR 15140: Allow for corrupt thin archives. */
20535 if (nested_arch
.file
== NULL
)
20537 error (_("%s: contains corrupt thin archive: %s\n"),
20538 qualified_name
, name
);
20539 free (qualified_name
);
20546 /* This is a proxy for a member of a nested archive. */
20547 filedata
->archive_file_offset
20548 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20550 /* The nested archive file will have been opened and setup by
20551 get_archive_member_name. */
20552 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20555 error (_("%s: failed to seek to archive member.\n"),
20556 nested_arch
.file_name
);
20557 free (qualified_name
);
20562 thin_filedata
.handle
= nested_arch
.file
;
20563 thin_filedata
.file_name
= qualified_name
;
20565 if (! process_object (& thin_filedata
))
20571 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20572 filedata
->file_name
= qualified_name
;
20573 if (! process_object (filedata
))
20575 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20576 /* Stop looping with "negative" archive_file_size. */
20577 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20578 arch
.next_arhdr_offset
= -1ul;
20581 free (qualified_name
);
20585 if (nested_arch
.file
!= NULL
)
20586 fclose (nested_arch
.file
);
20587 release_archive (&nested_arch
);
20588 release_archive (&arch
);
20594 process_file (char * file_name
)
20596 Filedata
* filedata
= NULL
;
20597 struct stat statbuf
;
20598 char armag
[SARMAG
];
20599 bfd_boolean ret
= TRUE
;
20601 if (stat (file_name
, &statbuf
) < 0)
20603 if (errno
== ENOENT
)
20604 error (_("'%s': No such file\n"), file_name
);
20606 error (_("Could not locate '%s'. System error message: %s\n"),
20607 file_name
, strerror (errno
));
20611 if (! S_ISREG (statbuf
.st_mode
))
20613 error (_("'%s' is not an ordinary file\n"), file_name
);
20617 filedata
= calloc (1, sizeof * filedata
);
20618 if (filedata
== NULL
)
20620 error (_("Out of memory allocating file data structure\n"));
20624 filedata
->file_name
= file_name
;
20625 filedata
->handle
= fopen (file_name
, "rb");
20626 if (filedata
->handle
== NULL
)
20628 error (_("Input file '%s' is not readable.\n"), file_name
);
20633 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20635 error (_("%s: Failed to read file's magic number\n"), file_name
);
20636 fclose (filedata
->handle
);
20641 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20643 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20645 if (! process_archive (filedata
, FALSE
))
20648 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20650 if ( ! process_archive (filedata
, TRUE
))
20655 if (do_archive_index
&& !check_all
)
20656 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20659 rewind (filedata
->handle
);
20660 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20662 if (! process_object (filedata
))
20666 fclose (filedata
->handle
);
20667 free (filedata
->section_headers
);
20668 free (filedata
->program_headers
);
20669 free (filedata
->string_table
);
20670 free (filedata
->dump
.dump_sects
);
20673 free (ba_cache
.strtab
);
20674 ba_cache
.strtab
= NULL
;
20675 free (ba_cache
.symtab
);
20676 ba_cache
.symtab
= NULL
;
20677 ba_cache
.filedata
= NULL
;
20682 #ifdef SUPPORT_DISASSEMBLY
20683 /* Needed by the i386 disassembler. For extra credit, someone could
20684 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20688 print_address (unsigned int addr
, FILE * outfile
)
20690 fprintf (outfile
,"0x%8.8x", addr
);
20693 /* Needed by the i386 disassembler. */
20696 db_task_printsym (unsigned int addr
)
20698 print_address (addr
, stderr
);
20703 main (int argc
, char ** argv
)
20707 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20708 setlocale (LC_MESSAGES
, "");
20710 #if defined (HAVE_SETLOCALE)
20711 setlocale (LC_CTYPE
, "");
20713 bindtextdomain (PACKAGE
, LOCALEDIR
);
20714 textdomain (PACKAGE
);
20716 expandargv (&argc
, &argv
);
20718 parse_args (& cmdline
, argc
, argv
);
20720 if (optind
< (argc
- 1))
20721 /* When displaying information for more than one file,
20722 prefix the information with the file name. */
20724 else if (optind
>= argc
)
20726 /* Ensure that the warning is always displayed. */
20729 warn (_("Nothing to do.\n"));
20734 while (optind
< argc
)
20735 if (! process_file (argv
[optind
++]))
20738 free (cmdline
.dump_sects
);
20740 free (dump_ctf_symtab_name
);
20741 free (dump_ctf_strtab_name
);
20742 free (dump_ctf_parent_name
);
20744 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;