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. */
203 dump_type
* dump_sects
;
204 unsigned int num_dump_sects
;
207 static struct dump_data cmdline
;
209 static struct dump_list_entry
* dump_sects_byname
;
211 char * program_name
= "readelf";
213 static bfd_boolean show_name
= FALSE
;
214 static bfd_boolean do_dynamic
= FALSE
;
215 static bfd_boolean do_syms
= FALSE
;
216 static bfd_boolean do_dyn_syms
= FALSE
;
217 static bfd_boolean do_reloc
= FALSE
;
218 static bfd_boolean do_sections
= FALSE
;
219 static bfd_boolean do_section_groups
= FALSE
;
220 static bfd_boolean do_section_details
= FALSE
;
221 static bfd_boolean do_segments
= FALSE
;
222 static bfd_boolean do_unwind
= FALSE
;
223 static bfd_boolean do_using_dynamic
= FALSE
;
224 static bfd_boolean do_header
= FALSE
;
225 static bfd_boolean do_dump
= FALSE
;
226 static bfd_boolean do_version
= FALSE
;
227 static bfd_boolean do_histogram
= FALSE
;
228 static bfd_boolean do_debugging
= FALSE
;
229 static bfd_boolean do_ctf
= FALSE
;
230 static bfd_boolean do_arch
= FALSE
;
231 static bfd_boolean do_notes
= FALSE
;
232 static bfd_boolean do_archive_index
= FALSE
;
233 static bfd_boolean is_32bit_elf
= FALSE
;
234 static bfd_boolean decompress_dumps
= FALSE
;
236 static char *dump_ctf_parent_name
;
237 static char *dump_ctf_symtab_name
;
238 static char *dump_ctf_strtab_name
;
242 struct group_list
* next
;
243 unsigned int section_index
;
248 struct group_list
* root
;
249 unsigned int group_index
;
252 typedef struct filedata
254 const char * file_name
;
256 bfd_size_type file_size
;
257 Elf_Internal_Ehdr file_header
;
258 Elf_Internal_Shdr
* section_headers
;
259 Elf_Internal_Phdr
* program_headers
;
261 unsigned long string_table_length
;
262 unsigned long archive_file_offset
;
263 unsigned long archive_file_size
;
264 unsigned long dynamic_addr
;
265 bfd_size_type dynamic_size
;
267 Elf_Internal_Dyn
* dynamic_section
;
268 char * dynamic_strings
;
269 unsigned long dynamic_strings_length
;
270 unsigned long num_dynamic_syms
;
271 Elf_Internal_Sym
* dynamic_symbols
;
272 bfd_vma version_info
[16];
273 unsigned int dynamic_syminfo_nent
;
274 Elf_Internal_Syminfo
* dynamic_syminfo
;
275 unsigned long dynamic_syminfo_offset
;
276 bfd_size_type nbuckets
;
277 bfd_size_type nchains
;
280 bfd_size_type ngnubuckets
;
281 bfd_size_type ngnuchains
;
282 bfd_vma
* gnubuckets
;
286 char program_interpreter
[PATH_MAX
];
287 bfd_vma dynamic_info
[DT_ENCODING
];
288 bfd_vma dynamic_info_DT_GNU_HASH
;
289 bfd_vma dynamic_info_DT_MIPS_XHASH
;
290 elf_section_list
* symtab_shndx_list
;
292 struct group
* section_groups
;
293 struct group
** section_headers_groups
;
294 /* A dynamic array of flags indicating for which sections a dump of
295 some kind has been requested. It is reset on a per-object file
296 basis and then initialised from the cmdline_dump_sects array,
297 the results of interpreting the -w switch, and the
298 dump_sects_byname list. */
299 struct dump_data dump
;
302 /* How to print a vma value. */
303 typedef enum print_mode
315 /* Versioned symbol info. */
316 enum versioned_symbol_info
323 static const char * get_symbol_version_string
324 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
325 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
329 #define SECTION_NAME(X) \
330 ((X) == NULL ? _("<none>") \
331 : filedata->string_table == NULL ? _("<no-strings>") \
332 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
333 : filedata->string_table + (X)->sh_name))
335 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
337 #define GET_ELF_SYMBOLS(file, section, sym_count) \
338 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
339 : get_64bit_elf_symbols (file, section, sym_count))
341 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
342 (strtab != NULL && offset < strtab_size)
343 #define VALID_DYNAMIC_NAME(filedata, offset) \
344 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
345 filedata->dynamic_strings_length, offset)
346 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
347 already been called and verified that the string exists. */
348 #define GET_DYNAMIC_NAME(filedata, offset) \
349 (filedata->dynamic_strings + offset)
351 #define REMOVE_ARCH_BITS(ADDR) \
354 if (filedata->file_header.e_machine == EM_ARM) \
359 /* Get the correct GNU hash section name. */
360 #define GNU_HASH_SECTION_NAME(filedata) \
361 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
363 /* Print a BFD_VMA to an internal buffer, for use in error messages.
364 BFD_FMA_FMT can't be used in translated strings. */
367 bfd_vmatoa (char *fmtch
, bfd_vma value
)
369 /* bfd_vmatoa is used more then once in a printf call for output.
370 Cycle through an array of buffers. */
371 static int buf_pos
= 0;
372 static struct bfd_vmatoa_buf
379 ret
= buf
[buf_pos
++].place
;
380 buf_pos
%= ARRAY_SIZE (buf
);
382 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
383 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
387 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
388 OFFSET + the offset of the current archive member, if we are examining an
389 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
390 allocate a buffer using malloc and fill that. In either case return the
391 pointer to the start of the retrieved data or NULL if something went wrong.
392 If something does go wrong and REASON is not NULL then emit an error
393 message using REASON as part of the context. */
396 get_data (void * var
,
398 unsigned long offset
,
404 bfd_size_type amt
= size
* nmemb
;
406 if (size
== 0 || nmemb
== 0)
409 /* If the size_t type is smaller than the bfd_size_type, eg because
410 you are building a 32-bit tool on a 64-bit host, then make sure
411 that when the sizes are cast to (size_t) no information is lost. */
412 if ((size_t) size
!= size
413 || (size_t) nmemb
!= nmemb
414 || (size_t) amt
!= amt
)
417 error (_("Size truncation prevents reading %s"
418 " elements of size %s for %s\n"),
419 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
423 /* Check for size overflow. */
424 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
427 error (_("Size overflow prevents reading %s"
428 " elements of size %s for %s\n"),
429 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
433 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
434 attempting to allocate memory when the read is bound to fail. */
435 if (filedata
->archive_file_offset
> filedata
->file_size
436 || offset
> filedata
->file_size
- filedata
->archive_file_offset
437 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
440 error (_("Reading %s bytes extends past end of file for %s\n"),
441 bfd_vmatoa ("u", amt
), reason
);
445 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
449 error (_("Unable to seek to 0x%lx for %s\n"),
450 filedata
->archive_file_offset
+ offset
, reason
);
457 /* + 1 so that we can '\0' terminate invalid string table sections. */
458 mvar
= malloc ((size_t) amt
+ 1);
463 error (_("Out of memory allocating %s bytes for %s\n"),
464 bfd_vmatoa ("u", amt
), reason
);
468 ((char *) mvar
)[amt
] = '\0';
471 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
474 error (_("Unable to read in %s bytes of %s\n"),
475 bfd_vmatoa ("u", amt
), reason
);
484 /* Print a VMA value in the MODE specified.
485 Returns the number of characters displayed. */
488 print_vma (bfd_vma vma
, print_mode mode
)
500 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
507 return printf ("%5" BFD_VMA_FMT
"d", vma
);
513 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
516 return printf ("%" BFD_VMA_FMT
"d", vma
);
519 return printf ("%" BFD_VMA_FMT
"u", vma
);
522 /* FIXME: Report unrecognised mode ? */
527 /* Display a symbol on stdout. Handles the display of control characters and
528 multibye characters (assuming the host environment supports them).
530 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
532 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
533 padding as necessary.
535 Returns the number of emitted characters. */
538 print_symbol (signed int width
, const char *symbol
)
540 bfd_boolean extra_padding
= FALSE
;
541 signed int num_printed
= 0;
542 #ifdef HAVE_MBSTATE_T
545 unsigned int width_remaining
;
549 /* Keep the width positive. This helps the code below. */
551 extra_padding
= TRUE
;
557 /* Set the remaining width to a very large value.
558 This simplifies the code below. */
559 width_remaining
= INT_MAX
;
561 width_remaining
= width
;
563 #ifdef HAVE_MBSTATE_T
564 /* Initialise the multibyte conversion state. */
565 memset (& state
, 0, sizeof (state
));
568 while (width_remaining
)
571 const char c
= *symbol
++;
576 /* Do not print control characters directly as they can affect terminal
577 settings. Such characters usually appear in the names generated
578 by the assembler for local labels. */
581 if (width_remaining
< 2)
584 printf ("^%c", c
+ 0x40);
585 width_remaining
-= 2;
588 else if (ISPRINT (c
))
596 #ifdef HAVE_MBSTATE_T
599 /* Let printf do the hard work of displaying multibyte characters. */
600 printf ("%.1s", symbol
- 1);
604 #ifdef HAVE_MBSTATE_T
605 /* Try to find out how many bytes made up the character that was
606 just printed. Advance the symbol pointer past the bytes that
608 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
612 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
617 if (extra_padding
&& num_printed
< width
)
619 /* Fill in the remaining spaces. */
620 printf ("%-*s", width
- num_printed
, " ");
627 /* Returns a pointer to a static buffer containing a printable version of
628 the given section's name. Like print_symbol, except that it does not try
629 to print multibyte characters, it just interprets them as hex values. */
632 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
634 #define MAX_PRINT_SEC_NAME_LEN 128
635 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
636 const char * name
= SECTION_NAME (sec
);
637 char * buf
= sec_name_buf
;
639 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
641 while ((c
= * name
++) != 0)
652 else if (ISPRINT (c
))
659 static char hex
[17] = "0123456789ABCDEF";
664 * buf
++ = hex
[(c
& 0xf0) >> 4];
665 * buf
++ = hex
[c
& 0x0f];
679 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
681 if (ndx
>= filedata
->file_header
.e_shnum
)
682 return _("<corrupt>");
684 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
687 /* Return a pointer to section NAME, or NULL if no such section exists. */
689 static Elf_Internal_Shdr
*
690 find_section (Filedata
* filedata
, const char * name
)
694 if (filedata
->section_headers
== NULL
)
697 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
698 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
699 return filedata
->section_headers
+ i
;
704 /* Return a pointer to a section containing ADDR, or NULL if no such
707 static Elf_Internal_Shdr
*
708 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
712 if (filedata
->section_headers
== NULL
)
715 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
717 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
719 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
726 static Elf_Internal_Shdr
*
727 find_section_by_type (Filedata
* filedata
, unsigned int type
)
731 if (filedata
->section_headers
== NULL
)
734 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
736 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
738 if (sec
->sh_type
== type
)
745 /* Return a pointer to section NAME, or NULL if no such section exists,
746 restricted to the list of sections given in SET. */
748 static Elf_Internal_Shdr
*
749 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
753 if (filedata
->section_headers
== NULL
)
758 while ((i
= *set
++) > 0)
760 /* See PR 21156 for a reproducer. */
761 if (i
>= filedata
->file_header
.e_shnum
)
762 continue; /* FIXME: Should we issue an error message ? */
764 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
765 return filedata
->section_headers
+ i
;
769 return find_section (filedata
, name
);
772 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
773 This OS has so many departures from the ELF standard that we test it at
776 static inline bfd_boolean
777 is_ia64_vms (Filedata
* filedata
)
779 return filedata
->file_header
.e_machine
== EM_IA_64
780 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
783 /* Guess the relocation size commonly used by the specific machines. */
786 guess_is_rela (unsigned int e_machine
)
790 /* Targets that use REL relocations. */
807 /* Targets that use RELA relocations. */
811 case EM_ADAPTEVA_EPIPHANY
:
813 case EM_ALTERA_NIOS2
:
816 case EM_ARC_COMPACT2
:
837 case EM_LATTICEMICO32
:
846 case EM_CYGNUS_MN10200
:
848 case EM_CYGNUS_MN10300
:
884 case EM_MICROBLAZE_OLD
:
906 warn (_("Don't know about relocations on this machine architecture\n"));
911 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
912 Returns TRUE upon success, FALSE otherwise. If successful then a
913 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
914 and the number of relocs loaded is placed in *NRELASP. It is the caller's
915 responsibility to free the allocated buffer. */
918 slurp_rela_relocs (Filedata
* filedata
,
919 unsigned long rel_offset
,
920 unsigned long rel_size
,
921 Elf_Internal_Rela
** relasp
,
922 unsigned long * nrelasp
)
924 Elf_Internal_Rela
* relas
;
930 Elf32_External_Rela
* erelas
;
932 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
933 rel_size
, _("32-bit relocation data"));
937 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
939 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
940 sizeof (Elf_Internal_Rela
));
945 error (_("out of memory parsing relocs\n"));
949 for (i
= 0; i
< nrelas
; i
++)
951 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
952 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
953 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
960 Elf64_External_Rela
* erelas
;
962 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
963 rel_size
, _("64-bit relocation data"));
967 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
969 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
970 sizeof (Elf_Internal_Rela
));
975 error (_("out of memory parsing relocs\n"));
979 for (i
= 0; i
< nrelas
; i
++)
981 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
982 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
983 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
985 /* The #ifdef BFD64 below is to prevent a compile time
986 warning. We know that if we do not have a 64 bit data
987 type that we will never execute this code anyway. */
989 if (filedata
->file_header
.e_machine
== EM_MIPS
990 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
992 /* In little-endian objects, r_info isn't really a
993 64-bit little-endian value: it has a 32-bit
994 little-endian symbol index followed by four
995 individual byte fields. Reorder INFO
997 bfd_vma inf
= relas
[i
].r_info
;
998 inf
= (((inf
& 0xffffffff) << 32)
999 | ((inf
>> 56) & 0xff)
1000 | ((inf
>> 40) & 0xff00)
1001 | ((inf
>> 24) & 0xff0000)
1002 | ((inf
>> 8) & 0xff000000));
1003 relas
[i
].r_info
= inf
;
1016 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1017 Returns TRUE upon success, FALSE otherwise. If successful then a
1018 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1019 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1020 responsibility to free the allocated buffer. */
1023 slurp_rel_relocs (Filedata
* filedata
,
1024 unsigned long rel_offset
,
1025 unsigned long rel_size
,
1026 Elf_Internal_Rela
** relsp
,
1027 unsigned long * nrelsp
)
1029 Elf_Internal_Rela
* rels
;
1035 Elf32_External_Rel
* erels
;
1037 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1038 rel_size
, _("32-bit relocation data"));
1042 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1044 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1049 error (_("out of memory parsing relocs\n"));
1053 for (i
= 0; i
< nrels
; i
++)
1055 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1056 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1057 rels
[i
].r_addend
= 0;
1064 Elf64_External_Rel
* erels
;
1066 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1067 rel_size
, _("64-bit relocation data"));
1071 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1073 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1078 error (_("out of memory parsing relocs\n"));
1082 for (i
= 0; i
< nrels
; i
++)
1084 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1085 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1086 rels
[i
].r_addend
= 0;
1088 /* The #ifdef BFD64 below is to prevent a compile time
1089 warning. We know that if we do not have a 64 bit data
1090 type that we will never execute this code anyway. */
1092 if (filedata
->file_header
.e_machine
== EM_MIPS
1093 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1095 /* In little-endian objects, r_info isn't really a
1096 64-bit little-endian value: it has a 32-bit
1097 little-endian symbol index followed by four
1098 individual byte fields. Reorder INFO
1100 bfd_vma inf
= rels
[i
].r_info
;
1101 inf
= (((inf
& 0xffffffff) << 32)
1102 | ((inf
>> 56) & 0xff)
1103 | ((inf
>> 40) & 0xff00)
1104 | ((inf
>> 24) & 0xff0000)
1105 | ((inf
>> 8) & 0xff000000));
1106 rels
[i
].r_info
= inf
;
1119 /* Returns the reloc type extracted from the reloc info field. */
1122 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1125 return ELF32_R_TYPE (reloc_info
);
1127 switch (filedata
->file_header
.e_machine
)
1130 /* Note: We assume that reloc_info has already been adjusted for us. */
1131 return ELF64_MIPS_R_TYPE (reloc_info
);
1134 return ELF64_R_TYPE_ID (reloc_info
);
1137 return ELF64_R_TYPE (reloc_info
);
1141 /* Return the symbol index extracted from the reloc info field. */
1144 get_reloc_symindex (bfd_vma reloc_info
)
1146 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1149 static inline bfd_boolean
1150 uses_msp430x_relocs (Filedata
* filedata
)
1153 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1154 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1155 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1156 /* TI compiler uses ELFOSABI_NONE. */
1157 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1160 /* Display the contents of the relocation data found at the specified
1164 dump_relocations (Filedata
* filedata
,
1165 unsigned long rel_offset
,
1166 unsigned long rel_size
,
1167 Elf_Internal_Sym
* symtab
,
1168 unsigned long nsyms
,
1170 unsigned long strtablen
,
1172 bfd_boolean is_dynsym
)
1175 Elf_Internal_Rela
* rels
;
1176 bfd_boolean res
= TRUE
;
1178 if (is_rela
== UNKNOWN
)
1179 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1183 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1188 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1197 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1199 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1204 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1206 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1214 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1216 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1221 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1223 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1227 for (i
= 0; i
< rel_size
; i
++)
1232 bfd_vma symtab_index
;
1235 offset
= rels
[i
].r_offset
;
1236 inf
= rels
[i
].r_info
;
1238 type
= get_reloc_type (filedata
, inf
);
1239 symtab_index
= get_reloc_symindex (inf
);
1243 printf ("%8.8lx %8.8lx ",
1244 (unsigned long) offset
& 0xffffffff,
1245 (unsigned long) inf
& 0xffffffff);
1249 #if BFD_HOST_64BIT_LONG
1251 ? "%16.16lx %16.16lx "
1252 : "%12.12lx %12.12lx ",
1254 #elif BFD_HOST_64BIT_LONG_LONG
1257 ? "%16.16llx %16.16llx "
1258 : "%12.12llx %12.12llx ",
1262 ? "%16.16I64x %16.16I64x "
1263 : "%12.12I64x %12.12I64x ",
1268 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1269 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1270 _bfd_int64_high (offset
),
1271 _bfd_int64_low (offset
),
1272 _bfd_int64_high (inf
),
1273 _bfd_int64_low (inf
));
1277 switch (filedata
->file_header
.e_machine
)
1284 rtype
= elf_aarch64_reloc_type (type
);
1288 case EM_CYGNUS_M32R
:
1289 rtype
= elf_m32r_reloc_type (type
);
1294 rtype
= elf_i386_reloc_type (type
);
1299 rtype
= elf_m68hc11_reloc_type (type
);
1303 rtype
= elf_s12z_reloc_type (type
);
1307 rtype
= elf_m68k_reloc_type (type
);
1311 rtype
= elf_i960_reloc_type (type
);
1316 rtype
= elf_avr_reloc_type (type
);
1319 case EM_OLD_SPARCV9
:
1320 case EM_SPARC32PLUS
:
1323 rtype
= elf_sparc_reloc_type (type
);
1327 rtype
= elf_spu_reloc_type (type
);
1331 rtype
= v800_reloc_type (type
);
1334 case EM_CYGNUS_V850
:
1335 rtype
= v850_reloc_type (type
);
1339 case EM_CYGNUS_D10V
:
1340 rtype
= elf_d10v_reloc_type (type
);
1344 case EM_CYGNUS_D30V
:
1345 rtype
= elf_d30v_reloc_type (type
);
1349 rtype
= elf_dlx_reloc_type (type
);
1353 rtype
= elf_sh_reloc_type (type
);
1357 case EM_CYGNUS_MN10300
:
1358 rtype
= elf_mn10300_reloc_type (type
);
1362 case EM_CYGNUS_MN10200
:
1363 rtype
= elf_mn10200_reloc_type (type
);
1367 case EM_CYGNUS_FR30
:
1368 rtype
= elf_fr30_reloc_type (type
);
1372 rtype
= elf_frv_reloc_type (type
);
1376 rtype
= elf_csky_reloc_type (type
);
1380 rtype
= elf_ft32_reloc_type (type
);
1384 rtype
= elf_mcore_reloc_type (type
);
1388 rtype
= elf_mmix_reloc_type (type
);
1392 rtype
= elf_moxie_reloc_type (type
);
1396 if (uses_msp430x_relocs (filedata
))
1398 rtype
= elf_msp430x_reloc_type (type
);
1403 rtype
= elf_msp430_reloc_type (type
);
1407 rtype
= elf_nds32_reloc_type (type
);
1411 rtype
= elf_ppc_reloc_type (type
);
1415 rtype
= elf_ppc64_reloc_type (type
);
1419 case EM_MIPS_RS3_LE
:
1420 rtype
= elf_mips_reloc_type (type
);
1424 rtype
= elf_riscv_reloc_type (type
);
1428 rtype
= elf_alpha_reloc_type (type
);
1432 rtype
= elf_arm_reloc_type (type
);
1436 case EM_ARC_COMPACT
:
1437 case EM_ARC_COMPACT2
:
1438 rtype
= elf_arc_reloc_type (type
);
1442 rtype
= elf_hppa_reloc_type (type
);
1448 rtype
= elf_h8_reloc_type (type
);
1452 rtype
= elf_or1k_reloc_type (type
);
1457 rtype
= elf_pj_reloc_type (type
);
1460 rtype
= elf_ia64_reloc_type (type
);
1464 rtype
= elf_cris_reloc_type (type
);
1468 rtype
= elf_i860_reloc_type (type
);
1474 rtype
= elf_x86_64_reloc_type (type
);
1478 rtype
= i370_reloc_type (type
);
1483 rtype
= elf_s390_reloc_type (type
);
1487 rtype
= elf_score_reloc_type (type
);
1491 rtype
= elf_xstormy16_reloc_type (type
);
1495 rtype
= elf_crx_reloc_type (type
);
1499 rtype
= elf_vax_reloc_type (type
);
1503 rtype
= elf_visium_reloc_type (type
);
1507 rtype
= elf_bpf_reloc_type (type
);
1510 case EM_ADAPTEVA_EPIPHANY
:
1511 rtype
= elf_epiphany_reloc_type (type
);
1516 rtype
= elf_ip2k_reloc_type (type
);
1520 rtype
= elf_iq2000_reloc_type (type
);
1525 rtype
= elf_xtensa_reloc_type (type
);
1528 case EM_LATTICEMICO32
:
1529 rtype
= elf_lm32_reloc_type (type
);
1534 rtype
= elf_m32c_reloc_type (type
);
1538 rtype
= elf_mt_reloc_type (type
);
1542 rtype
= elf_bfin_reloc_type (type
);
1546 rtype
= elf_mep_reloc_type (type
);
1550 rtype
= elf_cr16_reloc_type (type
);
1554 case EM_MICROBLAZE_OLD
:
1555 rtype
= elf_microblaze_reloc_type (type
);
1559 rtype
= elf_rl78_reloc_type (type
);
1563 rtype
= elf_rx_reloc_type (type
);
1567 rtype
= elf_metag_reloc_type (type
);
1572 rtype
= elf_xc16x_reloc_type (type
);
1576 rtype
= elf_tic6x_reloc_type (type
);
1580 rtype
= elf_tilegx_reloc_type (type
);
1584 rtype
= elf_tilepro_reloc_type (type
);
1587 case EM_WEBASSEMBLY
:
1588 rtype
= elf_wasm32_reloc_type (type
);
1592 rtype
= elf_xgate_reloc_type (type
);
1595 case EM_ALTERA_NIOS2
:
1596 rtype
= elf_nios2_reloc_type (type
);
1600 rtype
= elf_pru_reloc_type (type
);
1604 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1605 rtype
= elf_nfp3200_reloc_type (type
);
1607 rtype
= elf_nfp_reloc_type (type
);
1611 rtype
= elf_z80_reloc_type (type
);
1616 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1618 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1620 if (filedata
->file_header
.e_machine
== EM_ALPHA
1622 && streq (rtype
, "R_ALPHA_LITUSE")
1625 switch (rels
[i
].r_addend
)
1627 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1628 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1629 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1630 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1631 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1632 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1633 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1634 default: rtype
= NULL
;
1638 printf (" (%s)", rtype
);
1642 printf (_("<unknown addend: %lx>"),
1643 (unsigned long) rels
[i
].r_addend
);
1647 else if (symtab_index
)
1649 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1651 error (_(" bad symbol index: %08lx in reloc\n"),
1652 (unsigned long) symtab_index
);
1657 Elf_Internal_Sym
* psym
;
1658 const char * version_string
;
1659 enum versioned_symbol_info sym_info
;
1660 unsigned short vna_other
;
1662 psym
= symtab
+ symtab_index
;
1665 = get_symbol_version_string (filedata
, is_dynsym
,
1674 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1678 unsigned int width
= is_32bit_elf
? 8 : 14;
1680 /* Relocations against GNU_IFUNC symbols do not use the value
1681 of the symbol as the address to relocate against. Instead
1682 they invoke the function named by the symbol and use its
1683 result as the address for relocation.
1685 To indicate this to the user, do not display the value of
1686 the symbol in the "Symbols's Value" field. Instead show
1687 its name followed by () as a hint that the symbol is
1691 || psym
->st_name
== 0
1692 || psym
->st_name
>= strtablen
)
1695 name
= strtab
+ psym
->st_name
;
1697 len
= print_symbol (width
, name
);
1699 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1701 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1705 print_vma (psym
->st_value
, LONG_HEX
);
1707 printf (is_32bit_elf
? " " : " ");
1710 if (psym
->st_name
== 0)
1712 const char * sec_name
= "<null>";
1715 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1717 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1718 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1719 else if (psym
->st_shndx
== SHN_ABS
)
1721 else if (psym
->st_shndx
== SHN_COMMON
)
1722 sec_name
= "COMMON";
1723 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1724 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1725 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1726 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1727 sec_name
= "SCOMMON";
1728 else if (filedata
->file_header
.e_machine
== EM_MIPS
1729 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1730 sec_name
= "SUNDEF";
1731 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1732 || filedata
->file_header
.e_machine
== EM_L1OM
1733 || filedata
->file_header
.e_machine
== EM_K1OM
)
1734 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1735 sec_name
= "LARGE_COMMON";
1736 else if (filedata
->file_header
.e_machine
== EM_IA_64
1737 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1738 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1739 sec_name
= "ANSI_COM";
1740 else if (is_ia64_vms (filedata
)
1741 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1742 sec_name
= "VMS_SYMVEC";
1745 sprintf (name_buf
, "<section 0x%x>",
1746 (unsigned int) psym
->st_shndx
);
1747 sec_name
= name_buf
;
1750 print_symbol (22, sec_name
);
1752 else if (strtab
== NULL
)
1753 printf (_("<string table index: %3ld>"), psym
->st_name
);
1754 else if (psym
->st_name
>= strtablen
)
1756 error (_("<corrupt string table index: %3ld>\n"),
1762 print_symbol (22, strtab
+ psym
->st_name
);
1764 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1770 bfd_vma off
= rels
[i
].r_addend
;
1772 if ((bfd_signed_vma
) off
< 0)
1773 printf (" - %" BFD_VMA_FMT
"x", - off
);
1775 printf (" + %" BFD_VMA_FMT
"x", off
);
1781 bfd_vma off
= rels
[i
].r_addend
;
1783 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1784 if ((bfd_signed_vma
) off
< 0)
1785 printf ("-%" BFD_VMA_FMT
"x", - off
);
1787 printf ("%" BFD_VMA_FMT
"x", off
);
1790 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1792 && streq (rtype
, "R_SPARC_OLO10"))
1793 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1798 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1800 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1801 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1802 const char * rtype2
= elf_mips_reloc_type (type2
);
1803 const char * rtype3
= elf_mips_reloc_type (type3
);
1805 printf (" Type2: ");
1808 printf (_("unrecognized: %-7lx"),
1809 (unsigned long) type2
& 0xffffffff);
1811 printf ("%-17.17s", rtype2
);
1813 printf ("\n Type3: ");
1816 printf (_("unrecognized: %-7lx"),
1817 (unsigned long) type3
& 0xffffffff);
1819 printf ("%-17.17s", rtype3
);
1832 get_aarch64_dynamic_type (unsigned long type
)
1836 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1837 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1838 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1845 get_mips_dynamic_type (unsigned long type
)
1849 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1850 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1851 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1852 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1853 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1854 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1855 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1856 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1857 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1858 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1859 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1860 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1861 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1862 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1863 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1864 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1865 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1866 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1867 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1868 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1869 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1870 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1871 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1872 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1873 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1874 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1875 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1876 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1877 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1878 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1879 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1880 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1881 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1882 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1883 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1884 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1885 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1886 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1887 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1888 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1889 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1890 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1891 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1892 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1893 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1894 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1895 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1902 get_sparc64_dynamic_type (unsigned long type
)
1906 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1913 get_ppc_dynamic_type (unsigned long type
)
1917 case DT_PPC_GOT
: return "PPC_GOT";
1918 case DT_PPC_OPT
: return "PPC_OPT";
1925 get_ppc64_dynamic_type (unsigned long type
)
1929 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1930 case DT_PPC64_OPD
: return "PPC64_OPD";
1931 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1932 case DT_PPC64_OPT
: return "PPC64_OPT";
1939 get_parisc_dynamic_type (unsigned long type
)
1943 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1944 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1945 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1946 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1947 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1948 case DT_HP_PREINIT
: return "HP_PREINIT";
1949 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1950 case DT_HP_NEEDED
: return "HP_NEEDED";
1951 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1952 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1953 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1954 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1955 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1956 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1957 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1958 case DT_HP_FILTERED
: return "HP_FILTERED";
1959 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1960 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1961 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1962 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1963 case DT_PLT
: return "PLT";
1964 case DT_PLT_SIZE
: return "PLT_SIZE";
1965 case DT_DLT
: return "DLT";
1966 case DT_DLT_SIZE
: return "DLT_SIZE";
1973 get_ia64_dynamic_type (unsigned long type
)
1977 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1978 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1979 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1980 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1981 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1982 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1983 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1984 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1985 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1986 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1987 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1988 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1989 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1990 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1991 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1992 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1993 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1994 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1995 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1996 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1997 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1998 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1999 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2000 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2001 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2002 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2003 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2004 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2005 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2006 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2007 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2014 get_solaris_section_type (unsigned long type
)
2018 case 0x6fffffee: return "SUNW_ancillary";
2019 case 0x6fffffef: return "SUNW_capchain";
2020 case 0x6ffffff0: return "SUNW_capinfo";
2021 case 0x6ffffff1: return "SUNW_symsort";
2022 case 0x6ffffff2: return "SUNW_tlssort";
2023 case 0x6ffffff3: return "SUNW_LDYNSYM";
2024 case 0x6ffffff4: return "SUNW_dof";
2025 case 0x6ffffff5: return "SUNW_cap";
2026 case 0x6ffffff6: return "SUNW_SIGNATURE";
2027 case 0x6ffffff7: return "SUNW_ANNOTATE";
2028 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2029 case 0x6ffffff9: return "SUNW_DEBUG";
2030 case 0x6ffffffa: return "SUNW_move";
2031 case 0x6ffffffb: return "SUNW_COMDAT";
2032 case 0x6ffffffc: return "SUNW_syminfo";
2033 case 0x6ffffffd: return "SUNW_verdef";
2034 case 0x6ffffffe: return "SUNW_verneed";
2035 case 0x6fffffff: return "SUNW_versym";
2036 case 0x70000000: return "SPARC_GOTDATA";
2037 default: return NULL
;
2042 get_alpha_dynamic_type (unsigned long type
)
2046 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2047 default: return NULL
;
2052 get_score_dynamic_type (unsigned long type
)
2056 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2057 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2058 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2059 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2060 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2061 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2062 default: return NULL
;
2067 get_tic6x_dynamic_type (unsigned long type
)
2071 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2072 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2073 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2074 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2075 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2076 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2077 default: return NULL
;
2082 get_nios2_dynamic_type (unsigned long type
)
2086 case DT_NIOS2_GP
: return "NIOS2_GP";
2087 default: return NULL
;
2092 get_solaris_dynamic_type (unsigned long type
)
2096 case 0x6000000d: return "SUNW_AUXILIARY";
2097 case 0x6000000e: return "SUNW_RTLDINF";
2098 case 0x6000000f: return "SUNW_FILTER";
2099 case 0x60000010: return "SUNW_CAP";
2100 case 0x60000011: return "SUNW_SYMTAB";
2101 case 0x60000012: return "SUNW_SYMSZ";
2102 case 0x60000013: return "SUNW_SORTENT";
2103 case 0x60000014: return "SUNW_SYMSORT";
2104 case 0x60000015: return "SUNW_SYMSORTSZ";
2105 case 0x60000016: return "SUNW_TLSSORT";
2106 case 0x60000017: return "SUNW_TLSSORTSZ";
2107 case 0x60000018: return "SUNW_CAPINFO";
2108 case 0x60000019: return "SUNW_STRPAD";
2109 case 0x6000001a: return "SUNW_CAPCHAIN";
2110 case 0x6000001b: return "SUNW_LDMACH";
2111 case 0x6000001d: return "SUNW_CAPCHAINENT";
2112 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2113 case 0x60000021: return "SUNW_PARENT";
2114 case 0x60000023: return "SUNW_ASLR";
2115 case 0x60000025: return "SUNW_RELAX";
2116 case 0x60000029: return "SUNW_NXHEAP";
2117 case 0x6000002b: return "SUNW_NXSTACK";
2119 case 0x70000001: return "SPARC_REGISTER";
2120 case 0x7ffffffd: return "AUXILIARY";
2121 case 0x7ffffffe: return "USED";
2122 case 0x7fffffff: return "FILTER";
2124 default: return NULL
;
2129 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2131 static char buff
[64];
2135 case DT_NULL
: return "NULL";
2136 case DT_NEEDED
: return "NEEDED";
2137 case DT_PLTRELSZ
: return "PLTRELSZ";
2138 case DT_PLTGOT
: return "PLTGOT";
2139 case DT_HASH
: return "HASH";
2140 case DT_STRTAB
: return "STRTAB";
2141 case DT_SYMTAB
: return "SYMTAB";
2142 case DT_RELA
: return "RELA";
2143 case DT_RELASZ
: return "RELASZ";
2144 case DT_RELAENT
: return "RELAENT";
2145 case DT_STRSZ
: return "STRSZ";
2146 case DT_SYMENT
: return "SYMENT";
2147 case DT_INIT
: return "INIT";
2148 case DT_FINI
: return "FINI";
2149 case DT_SONAME
: return "SONAME";
2150 case DT_RPATH
: return "RPATH";
2151 case DT_SYMBOLIC
: return "SYMBOLIC";
2152 case DT_REL
: return "REL";
2153 case DT_RELSZ
: return "RELSZ";
2154 case DT_RELENT
: return "RELENT";
2155 case DT_PLTREL
: return "PLTREL";
2156 case DT_DEBUG
: return "DEBUG";
2157 case DT_TEXTREL
: return "TEXTREL";
2158 case DT_JMPREL
: return "JMPREL";
2159 case DT_BIND_NOW
: return "BIND_NOW";
2160 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2161 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2162 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2163 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2164 case DT_RUNPATH
: return "RUNPATH";
2165 case DT_FLAGS
: return "FLAGS";
2167 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2168 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2169 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2171 case DT_CHECKSUM
: return "CHECKSUM";
2172 case DT_PLTPADSZ
: return "PLTPADSZ";
2173 case DT_MOVEENT
: return "MOVEENT";
2174 case DT_MOVESZ
: return "MOVESZ";
2175 case DT_FEATURE
: return "FEATURE";
2176 case DT_POSFLAG_1
: return "POSFLAG_1";
2177 case DT_SYMINSZ
: return "SYMINSZ";
2178 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2180 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2181 case DT_CONFIG
: return "CONFIG";
2182 case DT_DEPAUDIT
: return "DEPAUDIT";
2183 case DT_AUDIT
: return "AUDIT";
2184 case DT_PLTPAD
: return "PLTPAD";
2185 case DT_MOVETAB
: return "MOVETAB";
2186 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2188 case DT_VERSYM
: return "VERSYM";
2190 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2191 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2192 case DT_RELACOUNT
: return "RELACOUNT";
2193 case DT_RELCOUNT
: return "RELCOUNT";
2194 case DT_FLAGS_1
: return "FLAGS_1";
2195 case DT_VERDEF
: return "VERDEF";
2196 case DT_VERDEFNUM
: return "VERDEFNUM";
2197 case DT_VERNEED
: return "VERNEED";
2198 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2200 case DT_AUXILIARY
: return "AUXILIARY";
2201 case DT_USED
: return "USED";
2202 case DT_FILTER
: return "FILTER";
2204 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2205 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2206 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2207 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2208 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2209 case DT_GNU_HASH
: return "GNU_HASH";
2212 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2214 const char * result
;
2216 switch (filedata
->file_header
.e_machine
)
2219 result
= get_aarch64_dynamic_type (type
);
2222 case EM_MIPS_RS3_LE
:
2223 result
= get_mips_dynamic_type (type
);
2226 result
= get_sparc64_dynamic_type (type
);
2229 result
= get_ppc_dynamic_type (type
);
2232 result
= get_ppc64_dynamic_type (type
);
2235 result
= get_ia64_dynamic_type (type
);
2238 result
= get_alpha_dynamic_type (type
);
2241 result
= get_score_dynamic_type (type
);
2244 result
= get_tic6x_dynamic_type (type
);
2246 case EM_ALTERA_NIOS2
:
2247 result
= get_nios2_dynamic_type (type
);
2250 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2251 result
= get_solaris_dynamic_type (type
);
2260 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2262 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2263 || (filedata
->file_header
.e_machine
== EM_PARISC
2264 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2266 const char * result
;
2268 switch (filedata
->file_header
.e_machine
)
2271 result
= get_parisc_dynamic_type (type
);
2274 result
= get_ia64_dynamic_type (type
);
2277 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2278 result
= get_solaris_dynamic_type (type
);
2287 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2291 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2298 get_file_type (unsigned e_type
)
2300 static char buff
[64];
2304 case ET_NONE
: return _("NONE (None)");
2305 case ET_REL
: return _("REL (Relocatable file)");
2306 case ET_EXEC
: return _("EXEC (Executable file)");
2307 case ET_DYN
: return _("DYN (Shared object file)");
2308 case ET_CORE
: return _("CORE (Core file)");
2311 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2312 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2313 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2314 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2316 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2322 get_machine_name (unsigned e_machine
)
2324 static char buff
[64]; /* XXX */
2328 /* Please keep this switch table sorted by increasing EM_ value. */
2330 case EM_NONE
: return _("None");
2331 case EM_M32
: return "WE32100";
2332 case EM_SPARC
: return "Sparc";
2333 case EM_386
: return "Intel 80386";
2334 case EM_68K
: return "MC68000";
2335 case EM_88K
: return "MC88000";
2336 case EM_IAMCU
: return "Intel MCU";
2337 case EM_860
: return "Intel 80860";
2338 case EM_MIPS
: return "MIPS R3000";
2339 case EM_S370
: return "IBM System/370";
2341 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2342 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2343 case EM_PARISC
: return "HPPA";
2344 case EM_VPP550
: return "Fujitsu VPP500";
2345 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2346 case EM_960
: return "Intel 80960";
2347 case EM_PPC
: return "PowerPC";
2349 case EM_PPC64
: return "PowerPC64";
2351 case EM_S390
: return "IBM S/390";
2352 case EM_SPU
: return "SPU";
2354 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2355 case EM_FR20
: return "Fujitsu FR20";
2356 case EM_RH32
: return "TRW RH32";
2357 case EM_MCORE
: return "MCORE";
2359 case EM_ARM
: return "ARM";
2360 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2361 case EM_SH
: return "Renesas / SuperH SH";
2362 case EM_SPARCV9
: return "Sparc v9";
2363 case EM_TRICORE
: return "Siemens Tricore";
2364 case EM_ARC
: return "ARC";
2365 case EM_H8_300
: return "Renesas H8/300";
2366 case EM_H8_300H
: return "Renesas H8/300H";
2367 case EM_H8S
: return "Renesas H8S";
2368 case EM_H8_500
: return "Renesas H8/500";
2370 case EM_IA_64
: return "Intel IA-64";
2371 case EM_MIPS_X
: return "Stanford MIPS-X";
2372 case EM_COLDFIRE
: return "Motorola Coldfire";
2373 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2374 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2375 case EM_PCP
: return "Siemens PCP";
2376 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2377 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2378 case EM_STARCORE
: return "Motorola Star*Core processor";
2379 case EM_ME16
: return "Toyota ME16 processor";
2381 case EM_ST100
: return "STMicroelectronics ST100 processor";
2382 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2383 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2384 case EM_PDSP
: return "Sony DSP processor";
2385 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2386 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2387 case EM_FX66
: return "Siemens FX66 microcontroller";
2388 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2389 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2390 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2392 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2393 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2394 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2395 case EM_SVX
: return "Silicon Graphics SVx";
2396 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2397 case EM_VAX
: return "Digital VAX";
2398 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2399 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2400 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2401 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2403 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2404 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2405 case EM_PRISM
: return "Vitesse Prism";
2407 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2408 case EM_CYGNUS_FR30
:
2409 case EM_FR30
: return "Fujitsu FR30";
2410 case EM_CYGNUS_D10V
:
2411 case EM_D10V
: return "d10v";
2412 case EM_CYGNUS_D30V
:
2413 case EM_D30V
: return "d30v";
2414 case EM_CYGNUS_V850
:
2415 case EM_V850
: return "Renesas V850";
2416 case EM_CYGNUS_M32R
:
2417 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2418 case EM_CYGNUS_MN10300
:
2419 case EM_MN10300
: return "mn10300";
2421 case EM_CYGNUS_MN10200
:
2422 case EM_MN10200
: return "mn10200";
2423 case EM_PJ
: return "picoJava";
2424 case EM_OR1K
: return "OpenRISC 1000";
2425 case EM_ARC_COMPACT
: return "ARCompact";
2427 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2428 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2429 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2430 case EM_NS32K
: return "National Semiconductor 32000 series";
2431 case EM_TPC
: return "Tenor Network TPC processor";
2432 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2434 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2436 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2437 case EM_MAX
: return "MAX Processor";
2438 case EM_CR
: return "National Semiconductor CompactRISC";
2439 case EM_F2MC16
: return "Fujitsu F2MC16";
2440 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2441 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2442 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2443 case EM_SEP
: return "Sharp embedded microprocessor";
2444 case EM_ARCA
: return "Arca RISC microprocessor";
2446 case EM_UNICORE
: return "Unicore";
2447 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2448 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2449 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2450 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2451 case EM_XGATE
: return "Motorola XGATE embedded processor";
2453 case EM_XC16X
: return "Infineon Technologies xc16x";
2454 case EM_M16C
: return "Renesas M16C series microprocessors";
2455 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2456 case EM_CE
: return "Freescale Communication Engine RISC core";
2458 case EM_M32C
: return "Renesas M32c";
2460 case EM_TSK3000
: return "Altium TSK3000 core";
2461 case EM_RS08
: return "Freescale RS08 embedded processor";
2462 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2463 case EM_SCORE
: return "SUNPLUS S+Core";
2464 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2465 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2466 case EM_LATTICEMICO32
: return "Lattice Mico32";
2467 case EM_SE_C17
: return "Seiko Epson C17 family";
2469 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2470 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2471 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2472 case EM_TI_PRU
: return "TI PRU I/O processor";
2474 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2475 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2476 case EM_R32C
: return "Renesas R32C series microprocessors";
2477 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2478 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2479 case EM_8051
: return "Intel 8051 and variants";
2480 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2481 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2482 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2483 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2485 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2486 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2487 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2488 case EM_RX
: return "Renesas RX";
2489 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2490 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2491 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2494 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2495 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2496 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2498 case EM_L1OM
: return "Intel L1OM";
2499 case EM_K1OM
: return "Intel K1OM";
2500 case EM_INTEL182
: return "Intel (reserved)";
2501 case EM_AARCH64
: return "AArch64";
2502 case EM_ARM184
: return "ARM (reserved)";
2503 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2504 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2505 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2506 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2508 case EM_CUDA
: return "NVIDIA CUDA architecture";
2509 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2510 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2511 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2512 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2513 case EM_ARC_COMPACT2
: return "ARCv2";
2514 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2515 case EM_RL78
: return "Renesas RL78";
2516 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2517 case EM_78K0R
: return "Renesas 78K0R";
2519 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2520 case EM_BA1
: return "Beyond BA1 CPU architecture";
2521 case EM_BA2
: return "Beyond BA2 CPU architecture";
2522 case EM_XCORE
: return "XMOS xCORE processor family";
2523 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2525 case EM_KM32
: return "KM211 KM32 32-bit processor";
2526 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2527 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2528 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2529 case EM_KVARC
: return "KM211 KVARC processor";
2530 case EM_CDP
: return "Paneve CDP architecture family";
2531 case EM_COGE
: return "Cognitive Smart Memory Processor";
2532 case EM_COOL
: return "Bluechip Systems CoolEngine";
2533 case EM_NORC
: return "Nanoradio Optimized RISC";
2534 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2536 case EM_Z80
: return "Zilog Z80";
2537 case EM_VISIUM
: return "CDS VISIUMcore processor";
2538 case EM_FT32
: return "FTDI Chip FT32";
2539 case EM_MOXIE
: return "Moxie";
2540 case EM_AMDGPU
: return "AMD GPU";
2541 case EM_RISCV
: return "RISC-V";
2542 case EM_LANAI
: return "Lanai 32-bit processor";
2543 case EM_BPF
: return "Linux BPF";
2544 case EM_NFP
: return "Netronome Flow Processor";
2546 /* Large numbers... */
2547 case EM_MT
: return "Morpho Techologies MT processor";
2548 case EM_ALPHA
: return "Alpha";
2549 case EM_WEBASSEMBLY
: return "Web Assembly";
2550 case EM_DLX
: return "OpenDLX";
2551 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2552 case EM_IQ2000
: return "Vitesse IQ2000";
2554 case EM_NIOS32
: return "Altera Nios";
2555 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2556 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2557 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2558 case EM_S12Z
: return "Freescale S12Z";
2559 case EM_CSKY
: return "C-SKY";
2562 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2568 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2570 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2571 other compilers don't a specific architecture type in the e_flags, and
2572 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2573 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2576 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2577 but also sets a specific architecture type in the e_flags field.
2579 However, when decoding the flags we don't worry if we see an
2580 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2581 ARCEM architecture type. */
2583 switch (e_flags
& EF_ARC_MACH_MSK
)
2585 /* We only expect these to occur for EM_ARC_COMPACT2. */
2586 case EF_ARC_CPU_ARCV2EM
:
2587 strcat (buf
, ", ARC EM");
2589 case EF_ARC_CPU_ARCV2HS
:
2590 strcat (buf
, ", ARC HS");
2593 /* We only expect these to occur for EM_ARC_COMPACT. */
2594 case E_ARC_MACH_ARC600
:
2595 strcat (buf
, ", ARC600");
2597 case E_ARC_MACH_ARC601
:
2598 strcat (buf
, ", ARC601");
2600 case E_ARC_MACH_ARC700
:
2601 strcat (buf
, ", ARC700");
2604 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2605 new ELF with new architecture being read by an old version of
2606 readelf, or (c) An ELF built with non-GNU compiler that does not
2607 set the architecture in the e_flags. */
2609 if (e_machine
== EM_ARC_COMPACT
)
2610 strcat (buf
, ", Unknown ARCompact");
2612 strcat (buf
, ", Unknown ARC");
2616 switch (e_flags
& EF_ARC_OSABI_MSK
)
2618 case E_ARC_OSABI_ORIG
:
2619 strcat (buf
, ", (ABI:legacy)");
2621 case E_ARC_OSABI_V2
:
2622 strcat (buf
, ", (ABI:v2)");
2624 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2625 case E_ARC_OSABI_V3
:
2626 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2628 case E_ARC_OSABI_V4
:
2629 strcat (buf
, ", v4 ABI");
2632 strcat (buf
, ", unrecognised ARC OSABI flag");
2638 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2641 bfd_boolean unknown
= FALSE
;
2643 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2644 e_flags
&= ~ EF_ARM_EABIMASK
;
2646 /* Handle "generic" ARM flags. */
2647 if (e_flags
& EF_ARM_RELEXEC
)
2649 strcat (buf
, ", relocatable executable");
2650 e_flags
&= ~ EF_ARM_RELEXEC
;
2653 if (e_flags
& EF_ARM_PIC
)
2655 strcat (buf
, ", position independent");
2656 e_flags
&= ~ EF_ARM_PIC
;
2659 /* Now handle EABI specific flags. */
2663 strcat (buf
, ", <unrecognized EABI>");
2668 case EF_ARM_EABI_VER1
:
2669 strcat (buf
, ", Version1 EABI");
2674 /* Process flags one bit at a time. */
2675 flag
= e_flags
& - e_flags
;
2680 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2681 strcat (buf
, ", sorted symbol tables");
2691 case EF_ARM_EABI_VER2
:
2692 strcat (buf
, ", Version2 EABI");
2697 /* Process flags one bit at a time. */
2698 flag
= e_flags
& - e_flags
;
2703 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2704 strcat (buf
, ", sorted symbol tables");
2707 case EF_ARM_DYNSYMSUSESEGIDX
:
2708 strcat (buf
, ", dynamic symbols use segment index");
2711 case EF_ARM_MAPSYMSFIRST
:
2712 strcat (buf
, ", mapping symbols precede others");
2722 case EF_ARM_EABI_VER3
:
2723 strcat (buf
, ", Version3 EABI");
2726 case EF_ARM_EABI_VER4
:
2727 strcat (buf
, ", Version4 EABI");
2732 /* Process flags one bit at a time. */
2733 flag
= e_flags
& - e_flags
;
2739 strcat (buf
, ", BE8");
2743 strcat (buf
, ", LE8");
2753 case EF_ARM_EABI_VER5
:
2754 strcat (buf
, ", Version5 EABI");
2759 /* Process flags one bit at a time. */
2760 flag
= e_flags
& - e_flags
;
2766 strcat (buf
, ", BE8");
2770 strcat (buf
, ", LE8");
2773 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2774 strcat (buf
, ", soft-float ABI");
2777 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2778 strcat (buf
, ", hard-float ABI");
2788 case EF_ARM_EABI_UNKNOWN
:
2789 strcat (buf
, ", GNU EABI");
2794 /* Process flags one bit at a time. */
2795 flag
= e_flags
& - e_flags
;
2800 case EF_ARM_INTERWORK
:
2801 strcat (buf
, ", interworking enabled");
2804 case EF_ARM_APCS_26
:
2805 strcat (buf
, ", uses APCS/26");
2808 case EF_ARM_APCS_FLOAT
:
2809 strcat (buf
, ", uses APCS/float");
2813 strcat (buf
, ", position independent");
2817 strcat (buf
, ", 8 bit structure alignment");
2820 case EF_ARM_NEW_ABI
:
2821 strcat (buf
, ", uses new ABI");
2824 case EF_ARM_OLD_ABI
:
2825 strcat (buf
, ", uses old ABI");
2828 case EF_ARM_SOFT_FLOAT
:
2829 strcat (buf
, ", software FP");
2832 case EF_ARM_VFP_FLOAT
:
2833 strcat (buf
, ", VFP");
2836 case EF_ARM_MAVERICK_FLOAT
:
2837 strcat (buf
, ", Maverick FP");
2848 strcat (buf
,_(", <unknown>"));
2852 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2854 --size
; /* Leave space for null terminator. */
2856 switch (e_flags
& EF_AVR_MACH
)
2858 case E_AVR_MACH_AVR1
:
2859 strncat (buf
, ", avr:1", size
);
2861 case E_AVR_MACH_AVR2
:
2862 strncat (buf
, ", avr:2", size
);
2864 case E_AVR_MACH_AVR25
:
2865 strncat (buf
, ", avr:25", size
);
2867 case E_AVR_MACH_AVR3
:
2868 strncat (buf
, ", avr:3", size
);
2870 case E_AVR_MACH_AVR31
:
2871 strncat (buf
, ", avr:31", size
);
2873 case E_AVR_MACH_AVR35
:
2874 strncat (buf
, ", avr:35", size
);
2876 case E_AVR_MACH_AVR4
:
2877 strncat (buf
, ", avr:4", size
);
2879 case E_AVR_MACH_AVR5
:
2880 strncat (buf
, ", avr:5", size
);
2882 case E_AVR_MACH_AVR51
:
2883 strncat (buf
, ", avr:51", size
);
2885 case E_AVR_MACH_AVR6
:
2886 strncat (buf
, ", avr:6", size
);
2888 case E_AVR_MACH_AVRTINY
:
2889 strncat (buf
, ", avr:100", size
);
2891 case E_AVR_MACH_XMEGA1
:
2892 strncat (buf
, ", avr:101", size
);
2894 case E_AVR_MACH_XMEGA2
:
2895 strncat (buf
, ", avr:102", size
);
2897 case E_AVR_MACH_XMEGA3
:
2898 strncat (buf
, ", avr:103", size
);
2900 case E_AVR_MACH_XMEGA4
:
2901 strncat (buf
, ", avr:104", size
);
2903 case E_AVR_MACH_XMEGA5
:
2904 strncat (buf
, ", avr:105", size
);
2906 case E_AVR_MACH_XMEGA6
:
2907 strncat (buf
, ", avr:106", size
);
2909 case E_AVR_MACH_XMEGA7
:
2910 strncat (buf
, ", avr:107", size
);
2913 strncat (buf
, ", avr:<unknown>", size
);
2917 size
-= strlen (buf
);
2918 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2919 strncat (buf
, ", link-relax", size
);
2923 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2929 bfd_boolean has_fpu
= FALSE
;
2932 static const char *ABI_STRINGS
[] =
2934 "ABI v0", /* use r5 as return register; only used in N1213HC */
2935 "ABI v1", /* use r0 as return register */
2936 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2937 "ABI v2fp", /* for FPU */
2941 static const char *VER_STRINGS
[] =
2943 "Andes ELF V1.3 or older",
2947 static const char *ARCH_STRINGS
[] =
2956 abi
= EF_NDS_ABI
& e_flags
;
2957 arch
= EF_NDS_ARCH
& e_flags
;
2958 config
= EF_NDS_INST
& e_flags
;
2959 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2961 memset (buf
, 0, size
);
2968 case E_NDS_ABI_V2FP
:
2969 case E_NDS_ABI_AABI
:
2970 case E_NDS_ABI_V2FP_PLUS
:
2971 /* In case there are holes in the array. */
2972 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2976 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2982 case E_NDS32_ELF_VER_1_2
:
2983 case E_NDS32_ELF_VER_1_3
:
2984 case E_NDS32_ELF_VER_1_4
:
2985 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2989 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2993 if (E_NDS_ABI_V0
== abi
)
2995 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2996 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2997 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2998 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3004 case E_NDS_ARCH_STAR_V1_0
:
3005 case E_NDS_ARCH_STAR_V2_0
:
3006 case E_NDS_ARCH_STAR_V3_0
:
3007 case E_NDS_ARCH_STAR_V3_M
:
3008 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3012 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3013 /* ARCH version determines how the e_flags are interpreted.
3014 If it is unknown, we cannot proceed. */
3018 /* Newer ABI; Now handle architecture specific flags. */
3019 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3021 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3022 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3024 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3025 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3027 if (config
& E_NDS32_HAS_DIV_INST
)
3028 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3030 if (config
& E_NDS32_HAS_16BIT_INST
)
3031 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3035 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3037 if (version
<= E_NDS32_ELF_VER_1_3
)
3038 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3040 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3043 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3044 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3046 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3047 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3049 if (config
& E_NDS32_HAS_16BIT_INST
)
3051 if (version
<= E_NDS32_ELF_VER_1_3
)
3052 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3054 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3058 if (config
& E_NDS32_HAS_EXT_INST
)
3059 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3061 if (config
& E_NDS32_HAS_EXT2_INST
)
3062 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3064 if (config
& E_NDS32_HAS_FPU_INST
)
3067 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3070 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3073 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3076 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3079 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3084 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3086 case E_NDS32_FPU_REG_8SP_4DP
:
3087 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3089 case E_NDS32_FPU_REG_16SP_8DP
:
3090 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3092 case E_NDS32_FPU_REG_32SP_16DP
:
3093 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3095 case E_NDS32_FPU_REG_32SP_32DP
:
3096 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3101 if (config
& E_NDS32_HAS_AUDIO_INST
)
3102 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3104 if (config
& E_NDS32_HAS_STRING_INST
)
3105 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3107 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3108 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3110 if (config
& E_NDS32_HAS_VIDEO_INST
)
3112 if (version
<= E_NDS32_ELF_VER_1_3
)
3113 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3115 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3118 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3119 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3121 if (config
& E_NDS32_HAS_L2C_INST
)
3122 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3126 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3128 static char buf
[1024];
3139 case EM_ARC_COMPACT2
:
3140 case EM_ARC_COMPACT
:
3141 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3145 decode_ARM_machine_flags (e_flags
, buf
);
3149 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3153 if (e_flags
& EF_BFIN_PIC
)
3154 strcat (buf
, ", PIC");
3156 if (e_flags
& EF_BFIN_FDPIC
)
3157 strcat (buf
, ", FDPIC");
3159 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3160 strcat (buf
, ", code in L1");
3162 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3163 strcat (buf
, ", data in L1");
3168 switch (e_flags
& EF_FRV_CPU_MASK
)
3170 case EF_FRV_CPU_GENERIC
:
3174 strcat (buf
, ", fr???");
3177 case EF_FRV_CPU_FR300
:
3178 strcat (buf
, ", fr300");
3181 case EF_FRV_CPU_FR400
:
3182 strcat (buf
, ", fr400");
3184 case EF_FRV_CPU_FR405
:
3185 strcat (buf
, ", fr405");
3188 case EF_FRV_CPU_FR450
:
3189 strcat (buf
, ", fr450");
3192 case EF_FRV_CPU_FR500
:
3193 strcat (buf
, ", fr500");
3195 case EF_FRV_CPU_FR550
:
3196 strcat (buf
, ", fr550");
3199 case EF_FRV_CPU_SIMPLE
:
3200 strcat (buf
, ", simple");
3202 case EF_FRV_CPU_TOMCAT
:
3203 strcat (buf
, ", tomcat");
3209 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3210 strcat (buf
, ", m68000");
3211 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3212 strcat (buf
, ", cpu32");
3213 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3214 strcat (buf
, ", fido_a");
3217 char const * isa
= _("unknown");
3218 char const * mac
= _("unknown mac");
3219 char const * additional
= NULL
;
3221 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3223 case EF_M68K_CF_ISA_A_NODIV
:
3225 additional
= ", nodiv";
3227 case EF_M68K_CF_ISA_A
:
3230 case EF_M68K_CF_ISA_A_PLUS
:
3233 case EF_M68K_CF_ISA_B_NOUSP
:
3235 additional
= ", nousp";
3237 case EF_M68K_CF_ISA_B
:
3240 case EF_M68K_CF_ISA_C
:
3243 case EF_M68K_CF_ISA_C_NODIV
:
3245 additional
= ", nodiv";
3248 strcat (buf
, ", cf, isa ");
3251 strcat (buf
, additional
);
3252 if (e_flags
& EF_M68K_CF_FLOAT
)
3253 strcat (buf
, ", float");
3254 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3259 case EF_M68K_CF_MAC
:
3262 case EF_M68K_CF_EMAC
:
3265 case EF_M68K_CF_EMAC_B
:
3278 switch (e_flags
& EF_MEP_CPU_MASK
)
3280 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3281 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3282 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3283 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3284 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3285 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3286 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3289 switch (e_flags
& EF_MEP_COP_MASK
)
3291 case EF_MEP_COP_NONE
: break;
3292 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3293 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3294 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3295 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3296 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3299 if (e_flags
& EF_MEP_LIBRARY
)
3300 strcat (buf
, ", Built for Library");
3302 if (e_flags
& EF_MEP_INDEX_MASK
)
3303 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3304 e_flags
& EF_MEP_INDEX_MASK
);
3306 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3307 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3308 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3312 if (e_flags
& EF_PPC_EMB
)
3313 strcat (buf
, ", emb");
3315 if (e_flags
& EF_PPC_RELOCATABLE
)
3316 strcat (buf
, _(", relocatable"));
3318 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3319 strcat (buf
, _(", relocatable-lib"));
3323 if (e_flags
& EF_PPC64_ABI
)
3325 char abi
[] = ", abiv0";
3327 abi
[6] += e_flags
& EF_PPC64_ABI
;
3333 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3334 strcat (buf
, ", RH850 ABI");
3336 if (e_flags
& EF_V800_850E3
)
3337 strcat (buf
, ", V3 architecture");
3339 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3340 strcat (buf
, ", FPU not used");
3342 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3343 strcat (buf
, ", regmode: COMMON");
3345 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3346 strcat (buf
, ", r4 not used");
3348 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3349 strcat (buf
, ", r30 not used");
3351 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3352 strcat (buf
, ", r5 not used");
3354 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3355 strcat (buf
, ", r2 not used");
3357 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3359 switch (e_flags
& - e_flags
)
3361 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3362 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3363 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3364 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3365 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3366 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3367 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3368 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3369 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3370 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3371 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3372 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3379 case EM_CYGNUS_V850
:
3380 switch (e_flags
& EF_V850_ARCH
)
3382 case E_V850E3V5_ARCH
:
3383 strcat (buf
, ", v850e3v5");
3385 case E_V850E2V3_ARCH
:
3386 strcat (buf
, ", v850e2v3");
3389 strcat (buf
, ", v850e2");
3392 strcat (buf
, ", v850e1");
3395 strcat (buf
, ", v850e");
3398 strcat (buf
, ", v850");
3401 strcat (buf
, _(", unknown v850 architecture variant"));
3407 case EM_CYGNUS_M32R
:
3408 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3409 strcat (buf
, ", m32r");
3413 case EM_MIPS_RS3_LE
:
3414 if (e_flags
& EF_MIPS_NOREORDER
)
3415 strcat (buf
, ", noreorder");
3417 if (e_flags
& EF_MIPS_PIC
)
3418 strcat (buf
, ", pic");
3420 if (e_flags
& EF_MIPS_CPIC
)
3421 strcat (buf
, ", cpic");
3423 if (e_flags
& EF_MIPS_UCODE
)
3424 strcat (buf
, ", ugen_reserved");
3426 if (e_flags
& EF_MIPS_ABI2
)
3427 strcat (buf
, ", abi2");
3429 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3430 strcat (buf
, ", odk first");
3432 if (e_flags
& EF_MIPS_32BITMODE
)
3433 strcat (buf
, ", 32bitmode");
3435 if (e_flags
& EF_MIPS_NAN2008
)
3436 strcat (buf
, ", nan2008");
3438 if (e_flags
& EF_MIPS_FP64
)
3439 strcat (buf
, ", fp64");
3441 switch ((e_flags
& EF_MIPS_MACH
))
3443 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3444 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3445 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3446 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3447 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3448 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3449 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3450 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3451 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3452 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3453 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3454 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3455 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3456 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3457 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3458 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3459 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3460 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3461 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3462 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3463 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3465 /* We simply ignore the field in this case to avoid confusion:
3466 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3469 default: strcat (buf
, _(", unknown CPU")); break;
3472 switch ((e_flags
& EF_MIPS_ABI
))
3474 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3475 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3476 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3477 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3479 /* We simply ignore the field in this case to avoid confusion:
3480 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3481 This means it is likely to be an o32 file, but not for
3484 default: strcat (buf
, _(", unknown ABI")); break;
3487 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3488 strcat (buf
, ", mdmx");
3490 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3491 strcat (buf
, ", mips16");
3493 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3494 strcat (buf
, ", micromips");
3496 switch ((e_flags
& EF_MIPS_ARCH
))
3498 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3499 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3500 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3501 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3502 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3503 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3504 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3505 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3506 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3507 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3508 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3509 default: strcat (buf
, _(", unknown ISA")); break;
3514 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3518 switch (EF_NFP_MACH (e_flags
))
3520 case E_NFP_MACH_3200
:
3521 strcat (buf
, ", NFP-32xx");
3523 case E_NFP_MACH_6000
:
3524 strcat (buf
, ", NFP-6xxx");
3530 if (e_flags
& EF_RISCV_RVC
)
3531 strcat (buf
, ", RVC");
3533 if (e_flags
& EF_RISCV_RVE
)
3534 strcat (buf
, ", RVE");
3536 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3538 case EF_RISCV_FLOAT_ABI_SOFT
:
3539 strcat (buf
, ", soft-float ABI");
3542 case EF_RISCV_FLOAT_ABI_SINGLE
:
3543 strcat (buf
, ", single-float ABI");
3546 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3547 strcat (buf
, ", double-float ABI");
3550 case EF_RISCV_FLOAT_ABI_QUAD
:
3551 strcat (buf
, ", quad-float ABI");
3557 switch ((e_flags
& EF_SH_MACH_MASK
))
3559 case EF_SH1
: strcat (buf
, ", sh1"); break;
3560 case EF_SH2
: strcat (buf
, ", sh2"); break;
3561 case EF_SH3
: strcat (buf
, ", sh3"); break;
3562 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3563 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3564 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3565 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3566 case EF_SH4
: strcat (buf
, ", sh4"); break;
3567 case EF_SH5
: strcat (buf
, ", sh5"); break;
3568 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3569 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3570 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3571 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3572 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3573 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3574 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3575 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3576 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3577 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3578 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3579 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3580 default: strcat (buf
, _(", unknown ISA")); break;
3583 if (e_flags
& EF_SH_PIC
)
3584 strcat (buf
, ", pic");
3586 if (e_flags
& EF_SH_FDPIC
)
3587 strcat (buf
, ", fdpic");
3591 if (e_flags
& EF_OR1K_NODELAY
)
3592 strcat (buf
, ", no delay");
3596 if (e_flags
& EF_SPARC_32PLUS
)
3597 strcat (buf
, ", v8+");
3599 if (e_flags
& EF_SPARC_SUN_US1
)
3600 strcat (buf
, ", ultrasparcI");
3602 if (e_flags
& EF_SPARC_SUN_US3
)
3603 strcat (buf
, ", ultrasparcIII");
3605 if (e_flags
& EF_SPARC_HAL_R1
)
3606 strcat (buf
, ", halr1");
3608 if (e_flags
& EF_SPARC_LEDATA
)
3609 strcat (buf
, ", ledata");
3611 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3612 strcat (buf
, ", tso");
3614 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3615 strcat (buf
, ", pso");
3617 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3618 strcat (buf
, ", rmo");
3622 switch (e_flags
& EF_PARISC_ARCH
)
3624 case EFA_PARISC_1_0
:
3625 strcpy (buf
, ", PA-RISC 1.0");
3627 case EFA_PARISC_1_1
:
3628 strcpy (buf
, ", PA-RISC 1.1");
3630 case EFA_PARISC_2_0
:
3631 strcpy (buf
, ", PA-RISC 2.0");
3636 if (e_flags
& EF_PARISC_TRAPNIL
)
3637 strcat (buf
, ", trapnil");
3638 if (e_flags
& EF_PARISC_EXT
)
3639 strcat (buf
, ", ext");
3640 if (e_flags
& EF_PARISC_LSB
)
3641 strcat (buf
, ", lsb");
3642 if (e_flags
& EF_PARISC_WIDE
)
3643 strcat (buf
, ", wide");
3644 if (e_flags
& EF_PARISC_NO_KABP
)
3645 strcat (buf
, ", no kabp");
3646 if (e_flags
& EF_PARISC_LAZYSWAP
)
3647 strcat (buf
, ", lazyswap");
3652 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3653 strcat (buf
, ", new calling convention");
3655 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3656 strcat (buf
, ", gnu calling convention");
3660 if ((e_flags
& EF_IA_64_ABI64
))
3661 strcat (buf
, ", 64-bit");
3663 strcat (buf
, ", 32-bit");
3664 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3665 strcat (buf
, ", reduced fp model");
3666 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3667 strcat (buf
, ", no function descriptors, constant gp");
3668 else if ((e_flags
& EF_IA_64_CONS_GP
))
3669 strcat (buf
, ", constant gp");
3670 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3671 strcat (buf
, ", absolute");
3672 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3674 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3675 strcat (buf
, ", vms_linkages");
3676 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3678 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3680 case EF_IA_64_VMS_COMCOD_WARNING
:
3681 strcat (buf
, ", warning");
3683 case EF_IA_64_VMS_COMCOD_ERROR
:
3684 strcat (buf
, ", error");
3686 case EF_IA_64_VMS_COMCOD_ABORT
:
3687 strcat (buf
, ", abort");
3690 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3691 e_flags
& EF_IA_64_VMS_COMCOD
);
3692 strcat (buf
, ", <unknown>");
3698 if ((e_flags
& EF_VAX_NONPIC
))
3699 strcat (buf
, ", non-PIC");
3700 if ((e_flags
& EF_VAX_DFLOAT
))
3701 strcat (buf
, ", D-Float");
3702 if ((e_flags
& EF_VAX_GFLOAT
))
3703 strcat (buf
, ", G-Float");
3707 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3708 strcat (buf
, ", mcm");
3709 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3710 strcat (buf
, ", mcm24");
3711 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3712 strcat (buf
, ", gr6");
3716 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3718 case E_FLAG_RL78_ANY_CPU
: break;
3719 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3720 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3721 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3723 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3724 strcat (buf
, ", 64-bit doubles");
3728 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3729 strcat (buf
, ", 64-bit doubles");
3730 if (e_flags
& E_FLAG_RX_DSP
)
3731 strcat (buf
, ", dsp");
3732 if (e_flags
& E_FLAG_RX_PID
)
3733 strcat (buf
, ", pid");
3734 if (e_flags
& E_FLAG_RX_ABI
)
3735 strcat (buf
, ", RX ABI");
3736 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3737 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3738 ? ", uses String instructions" : ", bans String instructions");
3739 if (e_flags
& E_FLAG_RX_V2
)
3740 strcat (buf
, ", V2");
3741 if (e_flags
& E_FLAG_RX_V3
)
3742 strcat (buf
, ", V3");
3746 if (e_flags
& EF_S390_HIGH_GPRS
)
3747 strcat (buf
, ", highgprs");
3751 if ((e_flags
& EF_C6000_REL
))
3752 strcat (buf
, ", relocatable module");
3756 strcat (buf
, _(": architecture variant: "));
3757 switch (e_flags
& EF_MSP430_MACH
)
3759 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3760 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3761 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3762 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3763 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3764 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3765 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3766 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3767 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3768 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3769 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3770 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3771 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3772 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3773 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3775 strcat (buf
, _(": unknown")); break;
3778 if (e_flags
& ~ EF_MSP430_MACH
)
3779 strcat (buf
, _(": unknown extra flag bits also present"));
3783 switch (e_flags
& EF_Z80_MACH_MSK
)
3785 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3786 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3787 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3788 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3789 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3790 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3791 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3793 strcat (buf
, _(", unknown")); break;
3803 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3805 static char buff
[32];
3809 case ELFOSABI_NONE
: return "UNIX - System V";
3810 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3811 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3812 case ELFOSABI_GNU
: return "UNIX - GNU";
3813 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3814 case ELFOSABI_AIX
: return "UNIX - AIX";
3815 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3816 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3817 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3818 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3819 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3820 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3821 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3822 case ELFOSABI_AROS
: return "AROS";
3823 case ELFOSABI_FENIXOS
: return "FenixOS";
3824 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3825 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3828 switch (filedata
->file_header
.e_machine
)
3833 case ELFOSABI_ARM
: return "ARM";
3834 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3845 case ELFOSABI_STANDALONE
: return _("Standalone App");
3854 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3855 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3864 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3870 get_aarch64_segment_type (unsigned long type
)
3874 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3875 default: return NULL
;
3880 get_arm_segment_type (unsigned long type
)
3884 case PT_ARM_EXIDX
: return "EXIDX";
3885 default: return NULL
;
3890 get_s390_segment_type (unsigned long type
)
3894 case PT_S390_PGSTE
: return "S390_PGSTE";
3895 default: return NULL
;
3900 get_mips_segment_type (unsigned long type
)
3904 case PT_MIPS_REGINFO
: return "REGINFO";
3905 case PT_MIPS_RTPROC
: return "RTPROC";
3906 case PT_MIPS_OPTIONS
: return "OPTIONS";
3907 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3908 default: return NULL
;
3913 get_parisc_segment_type (unsigned long type
)
3917 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3918 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3919 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3920 default: return NULL
;
3925 get_ia64_segment_type (unsigned long type
)
3929 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3930 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3931 default: return NULL
;
3936 get_tic6x_segment_type (unsigned long type
)
3940 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3941 default: return NULL
;
3946 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3948 if (e_machine
== EM_PARISC
)
3951 case PT_HP_TLS
: return "HP_TLS";
3952 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3953 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3954 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3955 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3956 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3957 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3958 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3959 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3960 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3961 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3962 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3963 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3964 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3965 case PT_HP_STACK
: return "HP_STACK";
3966 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3967 default: return NULL
;
3970 if (e_machine
== EM_IA_64
)
3973 case PT_HP_TLS
: return "HP_TLS";
3974 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3975 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3976 case PT_IA_64_HP_STACK
: return "HP_STACK";
3977 default: return NULL
;
3984 get_solaris_segment_type (unsigned long type
)
3988 case 0x6464e550: return "PT_SUNW_UNWIND";
3989 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3990 case 0x6ffffff7: return "PT_LOSUNW";
3991 case 0x6ffffffa: return "PT_SUNWBSS";
3992 case 0x6ffffffb: return "PT_SUNWSTACK";
3993 case 0x6ffffffc: return "PT_SUNWDTRACE";
3994 case 0x6ffffffd: return "PT_SUNWCAP";
3995 case 0x6fffffff: return "PT_HISUNW";
3996 default: return NULL
;
4001 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4003 static char buff
[32];
4007 case PT_NULL
: return "NULL";
4008 case PT_LOAD
: return "LOAD";
4009 case PT_DYNAMIC
: return "DYNAMIC";
4010 case PT_INTERP
: return "INTERP";
4011 case PT_NOTE
: return "NOTE";
4012 case PT_SHLIB
: return "SHLIB";
4013 case PT_PHDR
: return "PHDR";
4014 case PT_TLS
: return "TLS";
4015 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4016 case PT_GNU_STACK
: return "GNU_STACK";
4017 case PT_GNU_RELRO
: return "GNU_RELRO";
4018 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4021 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4023 const char * result
;
4025 switch (filedata
->file_header
.e_machine
)
4028 result
= get_aarch64_segment_type (p_type
);
4031 result
= get_arm_segment_type (p_type
);
4034 case EM_MIPS_RS3_LE
:
4035 result
= get_mips_segment_type (p_type
);
4038 result
= get_parisc_segment_type (p_type
);
4041 result
= get_ia64_segment_type (p_type
);
4044 result
= get_tic6x_segment_type (p_type
);
4048 result
= get_s390_segment_type (p_type
);
4058 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4060 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4062 const char * result
= NULL
;
4064 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4067 case ELFOSABI_FREEBSD
:
4068 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4070 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4075 result
= get_hpux_segment_type (p_type
,
4076 filedata
->file_header
.e_machine
);
4078 case ELFOSABI_SOLARIS
:
4079 result
= get_solaris_segment_type (p_type
);
4087 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4090 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4097 get_arc_section_type_name (unsigned int sh_type
)
4101 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4109 get_mips_section_type_name (unsigned int sh_type
)
4113 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4114 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4115 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4116 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4117 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4118 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4119 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4120 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4121 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4122 case SHT_MIPS_RELD
: return "MIPS_RELD";
4123 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4124 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4125 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4126 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4127 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4128 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4129 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4130 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4131 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4132 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4133 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4134 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4135 case SHT_MIPS_LINE
: return "MIPS_LINE";
4136 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4137 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4138 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4139 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4140 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4141 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4142 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4143 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4144 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4145 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4146 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4147 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4148 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4149 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4150 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4151 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4152 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4153 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4161 get_parisc_section_type_name (unsigned int sh_type
)
4165 case SHT_PARISC_EXT
: return "PARISC_EXT";
4166 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4167 case SHT_PARISC_DOC
: return "PARISC_DOC";
4168 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4169 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4170 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4171 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4172 default: return NULL
;
4177 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4179 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4180 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4181 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4185 case SHT_IA_64_EXT
: return "IA_64_EXT";
4186 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4187 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4188 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4189 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4190 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4191 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4192 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4193 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4194 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4202 get_x86_64_section_type_name (unsigned int sh_type
)
4206 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4207 default: return NULL
;
4212 get_aarch64_section_type_name (unsigned int sh_type
)
4216 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4217 default: return NULL
;
4222 get_arm_section_type_name (unsigned int sh_type
)
4226 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4227 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4228 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4229 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4230 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4231 default: return NULL
;
4236 get_tic6x_section_type_name (unsigned int sh_type
)
4240 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4241 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4242 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4243 case SHT_TI_ICODE
: return "TI_ICODE";
4244 case SHT_TI_XREF
: return "TI_XREF";
4245 case SHT_TI_HANDLER
: return "TI_HANDLER";
4246 case SHT_TI_INITINFO
: return "TI_INITINFO";
4247 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4248 default: return NULL
;
4253 get_msp430x_section_type_name (unsigned int sh_type
)
4257 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4258 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4259 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4260 default: return NULL
;
4265 get_nfp_section_type_name (unsigned int sh_type
)
4269 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4270 case SHT_NFP_INITREG
: return "NFP_INITREG";
4271 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4272 default: return NULL
;
4277 get_v850_section_type_name (unsigned int sh_type
)
4281 case SHT_V850_SCOMMON
: return "V850 Small Common";
4282 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4283 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4284 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4285 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4286 default: return NULL
;
4291 get_riscv_section_type_name (unsigned int sh_type
)
4295 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4296 default: return NULL
;
4301 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4303 static char buff
[32];
4304 const char * result
;
4308 case SHT_NULL
: return "NULL";
4309 case SHT_PROGBITS
: return "PROGBITS";
4310 case SHT_SYMTAB
: return "SYMTAB";
4311 case SHT_STRTAB
: return "STRTAB";
4312 case SHT_RELA
: return "RELA";
4313 case SHT_HASH
: return "HASH";
4314 case SHT_DYNAMIC
: return "DYNAMIC";
4315 case SHT_NOTE
: return "NOTE";
4316 case SHT_NOBITS
: return "NOBITS";
4317 case SHT_REL
: return "REL";
4318 case SHT_SHLIB
: return "SHLIB";
4319 case SHT_DYNSYM
: return "DYNSYM";
4320 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4321 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4322 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4323 case SHT_GNU_HASH
: return "GNU_HASH";
4324 case SHT_GROUP
: return "GROUP";
4325 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4326 case SHT_GNU_verdef
: return "VERDEF";
4327 case SHT_GNU_verneed
: return "VERNEED";
4328 case SHT_GNU_versym
: return "VERSYM";
4329 case 0x6ffffff0: return "VERSYM";
4330 case 0x6ffffffc: return "VERDEF";
4331 case 0x7ffffffd: return "AUXILIARY";
4332 case 0x7fffffff: return "FILTER";
4333 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4336 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4338 switch (filedata
->file_header
.e_machine
)
4341 case EM_ARC_COMPACT
:
4342 case EM_ARC_COMPACT2
:
4343 result
= get_arc_section_type_name (sh_type
);
4346 case EM_MIPS_RS3_LE
:
4347 result
= get_mips_section_type_name (sh_type
);
4350 result
= get_parisc_section_type_name (sh_type
);
4353 result
= get_ia64_section_type_name (filedata
, sh_type
);
4358 result
= get_x86_64_section_type_name (sh_type
);
4361 result
= get_aarch64_section_type_name (sh_type
);
4364 result
= get_arm_section_type_name (sh_type
);
4367 result
= get_tic6x_section_type_name (sh_type
);
4370 result
= get_msp430x_section_type_name (sh_type
);
4373 result
= get_nfp_section_type_name (sh_type
);
4377 case EM_CYGNUS_V850
:
4378 result
= get_v850_section_type_name (sh_type
);
4381 result
= get_riscv_section_type_name (sh_type
);
4391 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4393 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4395 switch (filedata
->file_header
.e_machine
)
4398 result
= get_ia64_section_type_name (filedata
, sh_type
);
4401 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4402 result
= get_solaris_section_type (sh_type
);
4407 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4408 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4409 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4410 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4422 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4424 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4426 switch (filedata
->file_header
.e_machine
)
4430 case EM_CYGNUS_V850
:
4431 result
= get_v850_section_type_name (sh_type
);
4441 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4444 /* This message is probably going to be displayed in a 15
4445 character wide field, so put the hex value first. */
4446 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4452 #define OPTION_DEBUG_DUMP 512
4453 #define OPTION_DYN_SYMS 513
4454 #define OPTION_DWARF_DEPTH 514
4455 #define OPTION_DWARF_START 515
4456 #define OPTION_DWARF_CHECK 516
4457 #define OPTION_CTF_DUMP 517
4458 #define OPTION_CTF_PARENT 518
4459 #define OPTION_CTF_SYMBOLS 519
4460 #define OPTION_CTF_STRINGS 520
4462 static struct option options
[] =
4464 {"all", no_argument
, 0, 'a'},
4465 {"file-header", no_argument
, 0, 'h'},
4466 {"program-headers", no_argument
, 0, 'l'},
4467 {"headers", no_argument
, 0, 'e'},
4468 {"histogram", no_argument
, 0, 'I'},
4469 {"segments", no_argument
, 0, 'l'},
4470 {"sections", no_argument
, 0, 'S'},
4471 {"section-headers", no_argument
, 0, 'S'},
4472 {"section-groups", no_argument
, 0, 'g'},
4473 {"section-details", no_argument
, 0, 't'},
4474 {"full-section-name",no_argument
, 0, 'N'},
4475 {"symbols", no_argument
, 0, 's'},
4476 {"syms", no_argument
, 0, 's'},
4477 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4478 {"relocs", no_argument
, 0, 'r'},
4479 {"notes", no_argument
, 0, 'n'},
4480 {"dynamic", no_argument
, 0, 'd'},
4481 {"arch-specific", no_argument
, 0, 'A'},
4482 {"version-info", no_argument
, 0, 'V'},
4483 {"use-dynamic", no_argument
, 0, 'D'},
4484 {"unwind", no_argument
, 0, 'u'},
4485 {"archive-index", no_argument
, 0, 'c'},
4486 {"hex-dump", required_argument
, 0, 'x'},
4487 {"relocated-dump", required_argument
, 0, 'R'},
4488 {"string-dump", required_argument
, 0, 'p'},
4489 {"decompress", no_argument
, 0, 'z'},
4490 #ifdef SUPPORT_DISASSEMBLY
4491 {"instruction-dump", required_argument
, 0, 'i'},
4493 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4495 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4496 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4497 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4499 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4501 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4502 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4503 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4505 {"version", no_argument
, 0, 'v'},
4506 {"wide", no_argument
, 0, 'W'},
4507 {"help", no_argument
, 0, 'H'},
4508 {0, no_argument
, 0, 0}
4512 usage (FILE * stream
)
4514 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4515 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4516 fprintf (stream
, _(" Options are:\n\
4517 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4518 -h --file-header Display the ELF file header\n\
4519 -l --program-headers Display the program headers\n\
4520 --segments An alias for --program-headers\n\
4521 -S --section-headers Display the sections' header\n\
4522 --sections An alias for --section-headers\n\
4523 -g --section-groups Display the section groups\n\
4524 -t --section-details Display the section details\n\
4525 -e --headers Equivalent to: -h -l -S\n\
4526 -s --syms Display the symbol table\n\
4527 --symbols An alias for --syms\n\
4528 --dyn-syms Display the dynamic symbol table\n\
4529 -n --notes Display the core notes (if present)\n\
4530 -r --relocs Display the relocations (if present)\n\
4531 -u --unwind Display the unwind info (if present)\n\
4532 -d --dynamic Display the dynamic section (if present)\n\
4533 -V --version-info Display the version sections (if present)\n\
4534 -A --arch-specific Display architecture specific information (if any)\n\
4535 -c --archive-index Display the symbol/file index in an archive\n\
4536 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4537 -x --hex-dump=<number|name>\n\
4538 Dump the contents of section <number|name> as bytes\n\
4539 -p --string-dump=<number|name>\n\
4540 Dump the contents of section <number|name> as strings\n\
4541 -R --relocated-dump=<number|name>\n\
4542 Dump the contents of section <number|name> as relocated bytes\n\
4543 -z --decompress Decompress section before dumping it\n\
4544 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4545 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4546 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4547 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4548 =addr,=cu_index,=links,=follow-links]\n\
4549 Display the contents of DWARF debug sections\n"));
4550 fprintf (stream
, _("\
4551 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4552 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4554 fprintf (stream
, _("\
4555 --ctf=<number|name> Display CTF info from section <number|name>\n\
4556 --ctf-parent=<number|name>\n\
4557 Use section <number|name> as the CTF parent\n\n\
4558 --ctf-symbols=<number|name>\n\
4559 Use section <number|name> as the CTF external symtab\n\n\
4560 --ctf-strings=<number|name>\n\
4561 Use section <number|name> as the CTF external strtab\n\n"));
4563 #ifdef SUPPORT_DISASSEMBLY
4564 fprintf (stream
, _("\
4565 -i --instruction-dump=<number|name>\n\
4566 Disassemble the contents of section <number|name>\n"));
4568 fprintf (stream
, _("\
4569 -I --histogram Display histogram of bucket list lengths\n\
4570 -W --wide Allow output width to exceed 80 characters\n\
4571 @<file> Read options from <file>\n\
4572 -H --help Display this information\n\
4573 -v --version Display the version number of readelf\n"));
4575 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4576 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4578 exit (stream
== stdout
? 0 : 1);
4581 /* Record the fact that the user wants the contents of section number
4582 SECTION to be displayed using the method(s) encoded as flags bits
4583 in TYPE. Note, TYPE can be zero if we are creating the array for
4587 request_dump_bynumber (struct dump_data
*dumpdata
,
4588 unsigned int section
, dump_type type
)
4590 if (section
>= dumpdata
->num_dump_sects
)
4592 dump_type
* new_dump_sects
;
4594 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4595 sizeof (* new_dump_sects
));
4597 if (new_dump_sects
== NULL
)
4598 error (_("Out of memory allocating dump request table.\n"));
4601 if (dumpdata
->dump_sects
)
4603 /* Copy current flag settings. */
4604 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4605 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4607 free (dumpdata
->dump_sects
);
4610 dumpdata
->dump_sects
= new_dump_sects
;
4611 dumpdata
->num_dump_sects
= section
+ 1;
4615 if (dumpdata
->dump_sects
)
4616 dumpdata
->dump_sects
[section
] |= type
;
4619 /* Request a dump by section name. */
4622 request_dump_byname (const char * section
, dump_type type
)
4624 struct dump_list_entry
* new_request
;
4626 new_request
= (struct dump_list_entry
*)
4627 malloc (sizeof (struct dump_list_entry
));
4629 error (_("Out of memory allocating dump request table.\n"));
4631 new_request
->name
= strdup (section
);
4632 if (!new_request
->name
)
4633 error (_("Out of memory allocating dump request table.\n"));
4635 new_request
->type
= type
;
4637 new_request
->next
= dump_sects_byname
;
4638 dump_sects_byname
= new_request
;
4642 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4648 section
= strtoul (optarg
, & cp
, 0);
4650 if (! *cp
&& section
>= 0)
4651 request_dump_bynumber (dumpdata
, section
, type
);
4653 request_dump_byname (optarg
, type
);
4657 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4664 while ((c
= getopt_long
4665 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4683 do_section_groups
= TRUE
;
4686 do_histogram
= TRUE
;
4691 do_section_groups
= TRUE
;
4696 do_section_details
= TRUE
;
4707 do_using_dynamic
= TRUE
;
4731 do_histogram
= TRUE
;
4737 do_archive_index
= TRUE
;
4740 request_dump (dumpdata
, HEX_DUMP
);
4743 request_dump (dumpdata
, STRING_DUMP
);
4746 request_dump (dumpdata
, RELOC_DUMP
);
4749 decompress_dumps
= TRUE
;
4755 do_debugging
= TRUE
;
4756 dwarf_select_sections_all ();
4760 do_debugging
= FALSE
;
4761 dwarf_select_sections_by_letters (optarg
);
4764 case OPTION_DEBUG_DUMP
:
4767 do_debugging
= TRUE
;
4770 do_debugging
= FALSE
;
4771 dwarf_select_sections_by_names (optarg
);
4774 case OPTION_DWARF_DEPTH
:
4778 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4781 case OPTION_DWARF_START
:
4785 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4788 case OPTION_DWARF_CHECK
:
4791 case OPTION_CTF_DUMP
:
4793 request_dump (dumpdata
, CTF_DUMP
);
4795 case OPTION_CTF_SYMBOLS
:
4796 dump_ctf_symtab_name
= strdup (optarg
);
4798 case OPTION_CTF_STRINGS
:
4799 dump_ctf_strtab_name
= strdup (optarg
);
4801 case OPTION_CTF_PARENT
:
4802 dump_ctf_parent_name
= strdup (optarg
);
4804 case OPTION_DYN_SYMS
:
4807 #ifdef SUPPORT_DISASSEMBLY
4809 request_dump (dumpdata
, DISASS_DUMP
);
4813 print_version (program_name
);
4822 /* xgettext:c-format */
4823 error (_("Invalid option '-%c'\n"), c
);
4830 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4831 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4832 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4833 && !do_section_groups
&& !do_archive_index
4839 get_elf_class (unsigned int elf_class
)
4841 static char buff
[32];
4845 case ELFCLASSNONE
: return _("none");
4846 case ELFCLASS32
: return "ELF32";
4847 case ELFCLASS64
: return "ELF64";
4849 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4855 get_data_encoding (unsigned int encoding
)
4857 static char buff
[32];
4861 case ELFDATANONE
: return _("none");
4862 case ELFDATA2LSB
: return _("2's complement, little endian");
4863 case ELFDATA2MSB
: return _("2's complement, big endian");
4865 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4870 /* Decode the data held in 'filedata->file_header'. */
4873 process_file_header (Filedata
* filedata
)
4875 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4877 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4878 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4879 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4880 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4883 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4887 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4893 printf (_("ELF Header:\n"));
4894 printf (_(" Magic: "));
4895 for (i
= 0; i
< EI_NIDENT
; i
++)
4896 printf ("%2.2x ", header
->e_ident
[i
]);
4898 printf (_(" Class: %s\n"),
4899 get_elf_class (header
->e_ident
[EI_CLASS
]));
4900 printf (_(" Data: %s\n"),
4901 get_data_encoding (header
->e_ident
[EI_DATA
]));
4902 printf (_(" Version: %d%s\n"),
4903 header
->e_ident
[EI_VERSION
],
4904 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4906 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4909 printf (_(" OS/ABI: %s\n"),
4910 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4911 printf (_(" ABI Version: %d\n"),
4912 header
->e_ident
[EI_ABIVERSION
]);
4913 printf (_(" Type: %s\n"),
4914 get_file_type (header
->e_type
));
4915 printf (_(" Machine: %s\n"),
4916 get_machine_name (header
->e_machine
));
4917 printf (_(" Version: 0x%lx\n"),
4920 printf (_(" Entry point address: "));
4921 print_vma (header
->e_entry
, PREFIX_HEX
);
4922 printf (_("\n Start of program headers: "));
4923 print_vma (header
->e_phoff
, DEC
);
4924 printf (_(" (bytes into file)\n Start of section headers: "));
4925 print_vma (header
->e_shoff
, DEC
);
4926 printf (_(" (bytes into file)\n"));
4928 printf (_(" Flags: 0x%lx%s\n"),
4930 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4931 printf (_(" Size of this header: %u (bytes)\n"),
4933 printf (_(" Size of program headers: %u (bytes)\n"),
4934 header
->e_phentsize
);
4935 printf (_(" Number of program headers: %u"),
4937 if (filedata
->section_headers
!= NULL
4938 && header
->e_phnum
== PN_XNUM
4939 && filedata
->section_headers
[0].sh_info
!= 0)
4941 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4942 printf (" (%u)", header
->e_phnum
);
4944 putc ('\n', stdout
);
4945 printf (_(" Size of section headers: %u (bytes)\n"),
4946 header
->e_shentsize
);
4947 printf (_(" Number of section headers: %u"),
4949 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4951 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4952 printf (" (%u)", header
->e_shnum
);
4954 putc ('\n', stdout
);
4955 printf (_(" Section header string table index: %u"),
4956 header
->e_shstrndx
);
4957 if (filedata
->section_headers
!= NULL
4958 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4960 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4961 printf (" (%u)", header
->e_shstrndx
);
4963 if (header
->e_shstrndx
!= SHN_UNDEF
4964 && header
->e_shstrndx
>= header
->e_shnum
)
4966 header
->e_shstrndx
= SHN_UNDEF
;
4967 printf (_(" <corrupt: out of range>"));
4969 putc ('\n', stdout
);
4972 if (filedata
->section_headers
!= NULL
)
4974 if (header
->e_phnum
== PN_XNUM
4975 && filedata
->section_headers
[0].sh_info
!= 0)
4976 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4977 if (header
->e_shnum
== SHN_UNDEF
)
4978 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4979 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4980 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4981 if (header
->e_shstrndx
>= header
->e_shnum
)
4982 header
->e_shstrndx
= SHN_UNDEF
;
4983 free (filedata
->section_headers
);
4984 filedata
->section_headers
= NULL
;
4990 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4991 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4994 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4996 Elf32_External_Phdr
* phdrs
;
4997 Elf32_External_Phdr
* external
;
4998 Elf_Internal_Phdr
* internal
;
5000 unsigned int size
= filedata
->file_header
.e_phentsize
;
5001 unsigned int num
= filedata
->file_header
.e_phnum
;
5003 /* PR binutils/17531: Cope with unexpected section header sizes. */
5004 if (size
== 0 || num
== 0)
5006 if (size
< sizeof * phdrs
)
5008 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5011 if (size
> sizeof * phdrs
)
5012 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5014 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5015 size
, num
, _("program headers"));
5019 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5020 i
< filedata
->file_header
.e_phnum
;
5021 i
++, internal
++, external
++)
5023 internal
->p_type
= BYTE_GET (external
->p_type
);
5024 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5025 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5026 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5027 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5028 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5029 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5030 internal
->p_align
= BYTE_GET (external
->p_align
);
5037 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5038 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5041 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5043 Elf64_External_Phdr
* phdrs
;
5044 Elf64_External_Phdr
* external
;
5045 Elf_Internal_Phdr
* internal
;
5047 unsigned int size
= filedata
->file_header
.e_phentsize
;
5048 unsigned int num
= filedata
->file_header
.e_phnum
;
5050 /* PR binutils/17531: Cope with unexpected section header sizes. */
5051 if (size
== 0 || num
== 0)
5053 if (size
< sizeof * phdrs
)
5055 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5058 if (size
> sizeof * phdrs
)
5059 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5061 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5062 size
, num
, _("program headers"));
5066 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5067 i
< filedata
->file_header
.e_phnum
;
5068 i
++, internal
++, external
++)
5070 internal
->p_type
= BYTE_GET (external
->p_type
);
5071 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5072 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5073 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5074 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5075 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5076 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5077 internal
->p_align
= BYTE_GET (external
->p_align
);
5084 /* Returns TRUE if the program headers were read into `program_headers'. */
5087 get_program_headers (Filedata
* filedata
)
5089 Elf_Internal_Phdr
* phdrs
;
5091 /* Check cache of prior read. */
5092 if (filedata
->program_headers
!= NULL
)
5095 /* Be kind to memory checkers by looking for
5096 e_phnum values which we know must be invalid. */
5097 if (filedata
->file_header
.e_phnum
5098 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5099 >= filedata
->file_size
)
5101 error (_("Too many program headers - %#x - the file is not that big\n"),
5102 filedata
->file_header
.e_phnum
);
5106 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5107 sizeof (Elf_Internal_Phdr
));
5110 error (_("Out of memory reading %u program headers\n"),
5111 filedata
->file_header
.e_phnum
);
5116 ? get_32bit_program_headers (filedata
, phdrs
)
5117 : get_64bit_program_headers (filedata
, phdrs
))
5119 filedata
->program_headers
= phdrs
;
5127 /* Returns TRUE if the program headers were loaded. */
5130 process_program_headers (Filedata
* filedata
)
5132 Elf_Internal_Phdr
* segment
;
5134 Elf_Internal_Phdr
* previous_load
= NULL
;
5136 filedata
->dynamic_addr
= 0;
5137 filedata
->dynamic_size
= 0;
5139 if (filedata
->file_header
.e_phnum
== 0)
5141 /* PR binutils/12467. */
5142 if (filedata
->file_header
.e_phoff
!= 0)
5144 warn (_("possibly corrupt ELF header - it has a non-zero program"
5145 " header offset, but no program headers\n"));
5148 else if (do_segments
)
5149 printf (_("\nThere are no program headers in this file.\n"));
5153 if (do_segments
&& !do_header
)
5155 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5156 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5157 printf (ngettext ("There is %d program header, starting at offset %s\n",
5158 "There are %d program headers, starting at offset %s\n",
5159 filedata
->file_header
.e_phnum
),
5160 filedata
->file_header
.e_phnum
,
5161 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5164 if (! get_program_headers (filedata
))
5169 if (filedata
->file_header
.e_phnum
> 1)
5170 printf (_("\nProgram Headers:\n"));
5172 printf (_("\nProgram Headers:\n"));
5176 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5179 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5183 (_(" Type Offset VirtAddr PhysAddr\n"));
5185 (_(" FileSiz MemSiz Flags Align\n"));
5189 for (i
= 0, segment
= filedata
->program_headers
;
5190 i
< filedata
->file_header
.e_phnum
;
5195 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5199 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5200 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5201 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5202 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5203 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5205 (segment
->p_flags
& PF_R
? 'R' : ' '),
5206 (segment
->p_flags
& PF_W
? 'W' : ' '),
5207 (segment
->p_flags
& PF_X
? 'E' : ' '));
5208 printf ("%#lx", (unsigned long) segment
->p_align
);
5212 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5213 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5216 print_vma (segment
->p_offset
, FULL_HEX
);
5220 print_vma (segment
->p_vaddr
, FULL_HEX
);
5222 print_vma (segment
->p_paddr
, FULL_HEX
);
5225 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5226 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5229 print_vma (segment
->p_filesz
, FULL_HEX
);
5233 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5234 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5237 print_vma (segment
->p_memsz
, FULL_HEX
);
5241 (segment
->p_flags
& PF_R
? 'R' : ' '),
5242 (segment
->p_flags
& PF_W
? 'W' : ' '),
5243 (segment
->p_flags
& PF_X
? 'E' : ' '));
5245 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5246 printf ("%#lx", (unsigned long) segment
->p_align
);
5249 print_vma (segment
->p_align
, PREFIX_HEX
);
5254 print_vma (segment
->p_offset
, FULL_HEX
);
5256 print_vma (segment
->p_vaddr
, FULL_HEX
);
5258 print_vma (segment
->p_paddr
, FULL_HEX
);
5260 print_vma (segment
->p_filesz
, FULL_HEX
);
5262 print_vma (segment
->p_memsz
, FULL_HEX
);
5264 (segment
->p_flags
& PF_R
? 'R' : ' '),
5265 (segment
->p_flags
& PF_W
? 'W' : ' '),
5266 (segment
->p_flags
& PF_X
? 'E' : ' '));
5267 print_vma (segment
->p_align
, PREFIX_HEX
);
5270 putc ('\n', stdout
);
5273 switch (segment
->p_type
)
5276 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5277 required by the ELF standard, several programs, including the Linux
5278 kernel, make use of non-ordered segments. */
5280 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5281 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5283 if (segment
->p_memsz
< segment
->p_filesz
)
5284 error (_("the segment's file size is larger than its memory size\n"));
5285 previous_load
= segment
;
5289 /* PR 20815 - Verify that the program header is loaded into memory. */
5290 if (i
> 0 && previous_load
!= NULL
)
5291 error (_("the PHDR segment must occur before any LOAD segment\n"));
5292 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5296 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5298 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5299 if (load
->p_type
== PT_LOAD
5300 && load
->p_offset
<= segment
->p_offset
5301 && (load
->p_offset
+ load
->p_filesz
5302 >= segment
->p_offset
+ segment
->p_filesz
)
5303 && load
->p_vaddr
<= segment
->p_vaddr
5304 && (load
->p_vaddr
+ load
->p_filesz
5305 >= segment
->p_vaddr
+ segment
->p_filesz
))
5308 if (j
== filedata
->file_header
.e_phnum
)
5309 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5314 if (filedata
->dynamic_addr
)
5315 error (_("more than one dynamic segment\n"));
5317 /* By default, assume that the .dynamic section is the first
5318 section in the DYNAMIC segment. */
5319 filedata
->dynamic_addr
= segment
->p_offset
;
5320 filedata
->dynamic_size
= segment
->p_filesz
;
5322 /* Try to locate the .dynamic section. If there is
5323 a section header table, we can easily locate it. */
5324 if (filedata
->section_headers
!= NULL
)
5326 Elf_Internal_Shdr
* sec
;
5328 sec
= find_section (filedata
, ".dynamic");
5329 if (sec
== NULL
|| sec
->sh_size
== 0)
5331 /* A corresponding .dynamic section is expected, but on
5332 IA-64/OpenVMS it is OK for it to be missing. */
5333 if (!is_ia64_vms (filedata
))
5334 error (_("no .dynamic section in the dynamic segment\n"));
5338 if (sec
->sh_type
== SHT_NOBITS
)
5340 filedata
->dynamic_size
= 0;
5344 filedata
->dynamic_addr
= sec
->sh_offset
;
5345 filedata
->dynamic_size
= sec
->sh_size
;
5347 if (filedata
->dynamic_addr
< segment
->p_offset
5348 || filedata
->dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5349 warn (_("the .dynamic section is not contained"
5350 " within the dynamic segment\n"));
5351 else if (filedata
->dynamic_addr
> segment
->p_offset
)
5352 warn (_("the .dynamic section is not the first section"
5353 " in the dynamic segment.\n"));
5356 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5357 segment. Check this after matching against the section headers
5358 so we don't warn on debuginfo file (which have NOBITS .dynamic
5360 if (filedata
->dynamic_addr
> filedata
->file_size
5361 || (filedata
->dynamic_size
5362 > filedata
->file_size
- filedata
->dynamic_addr
))
5364 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5365 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5370 if (fseek (filedata
->handle
,
5371 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5373 error (_("Unable to find program interpreter name\n"));
5377 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5379 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5380 error (_("Internal error: failed to create format string to display program interpreter\n"));
5382 filedata
->program_interpreter
[0] = 0;
5383 if (fscanf (filedata
->handle
, fmt
,
5384 filedata
->program_interpreter
) <= 0)
5385 error (_("Unable to read program interpreter name\n"));
5388 printf (_(" [Requesting program interpreter: %s]\n"),
5389 filedata
->program_interpreter
);
5396 && filedata
->section_headers
!= NULL
5397 && filedata
->string_table
!= NULL
)
5399 printf (_("\n Section to Segment mapping:\n"));
5400 printf (_(" Segment Sections...\n"));
5402 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5405 Elf_Internal_Shdr
* section
;
5407 segment
= filedata
->program_headers
+ i
;
5408 section
= filedata
->section_headers
+ 1;
5410 printf (" %2.2d ", i
);
5412 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5414 if (!ELF_TBSS_SPECIAL (section
, segment
)
5415 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5416 printf ("%s ", printable_section_name (filedata
, section
));
5427 /* Find the file offset corresponding to VMA by using the program headers. */
5430 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5432 Elf_Internal_Phdr
* seg
;
5434 if (! get_program_headers (filedata
))
5436 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5440 for (seg
= filedata
->program_headers
;
5441 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5444 if (seg
->p_type
!= PT_LOAD
)
5447 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5448 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5449 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5452 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5453 (unsigned long) vma
);
5458 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5459 If PROBE is true, this is just a probe and we do not generate any error
5460 messages if the load fails. */
5463 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5465 Elf32_External_Shdr
* shdrs
;
5466 Elf_Internal_Shdr
* internal
;
5468 unsigned int size
= filedata
->file_header
.e_shentsize
;
5469 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5471 /* PR binutils/17531: Cope with unexpected section header sizes. */
5472 if (size
== 0 || num
== 0)
5474 if (size
< sizeof * shdrs
)
5477 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5480 if (!probe
&& size
> sizeof * shdrs
)
5481 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5483 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5485 probe
? NULL
: _("section headers"));
5489 free (filedata
->section_headers
);
5490 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5491 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5492 if (filedata
->section_headers
== NULL
)
5495 error (_("Out of memory reading %u section headers\n"), num
);
5500 for (i
= 0, internal
= filedata
->section_headers
;
5504 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5505 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5506 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5507 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5508 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5509 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5510 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5511 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5512 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5513 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5514 if (!probe
&& internal
->sh_link
> num
)
5515 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5516 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5517 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5524 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5527 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5529 Elf64_External_Shdr
* shdrs
;
5530 Elf_Internal_Shdr
* internal
;
5532 unsigned int size
= filedata
->file_header
.e_shentsize
;
5533 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5535 /* PR binutils/17531: Cope with unexpected section header sizes. */
5536 if (size
== 0 || num
== 0)
5539 if (size
< sizeof * shdrs
)
5542 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5546 if (! probe
&& size
> sizeof * shdrs
)
5547 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5549 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5550 filedata
->file_header
.e_shoff
,
5552 probe
? NULL
: _("section headers"));
5556 free (filedata
->section_headers
);
5557 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5558 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5559 if (filedata
->section_headers
== NULL
)
5562 error (_("Out of memory reading %u section headers\n"), num
);
5567 for (i
= 0, internal
= filedata
->section_headers
;
5571 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5572 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5573 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5574 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5575 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5576 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5577 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5578 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5579 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5580 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5581 if (!probe
&& internal
->sh_link
> num
)
5582 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5583 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5584 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5591 static Elf_Internal_Sym
*
5592 get_32bit_elf_symbols (Filedata
* filedata
,
5593 Elf_Internal_Shdr
* section
,
5594 unsigned long * num_syms_return
)
5596 unsigned long number
= 0;
5597 Elf32_External_Sym
* esyms
= NULL
;
5598 Elf_External_Sym_Shndx
* shndx
= NULL
;
5599 Elf_Internal_Sym
* isyms
= NULL
;
5600 Elf_Internal_Sym
* psym
;
5602 elf_section_list
* entry
;
5604 if (section
->sh_size
== 0)
5606 if (num_syms_return
!= NULL
)
5607 * num_syms_return
= 0;
5611 /* Run some sanity checks first. */
5612 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5614 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5615 printable_section_name (filedata
, section
),
5616 (unsigned long) section
->sh_entsize
);
5620 if (section
->sh_size
> filedata
->file_size
)
5622 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5623 printable_section_name (filedata
, section
),
5624 (unsigned long) section
->sh_size
);
5628 number
= section
->sh_size
/ section
->sh_entsize
;
5630 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5632 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5633 (unsigned long) section
->sh_size
,
5634 printable_section_name (filedata
, section
),
5635 (unsigned long) section
->sh_entsize
);
5639 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5640 section
->sh_size
, _("symbols"));
5645 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5647 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5652 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5656 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5657 entry
->hdr
->sh_offset
,
5658 1, entry
->hdr
->sh_size
,
5659 _("symbol table section indices"));
5663 /* PR17531: file: heap-buffer-overflow */
5664 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5666 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5667 printable_section_name (filedata
, entry
->hdr
),
5668 (unsigned long) entry
->hdr
->sh_size
,
5669 (unsigned long) section
->sh_size
);
5674 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5678 error (_("Out of memory reading %lu symbols\n"),
5679 (unsigned long) number
);
5683 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5685 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5686 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5687 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5688 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5689 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5691 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5692 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5693 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5694 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5695 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5702 if (num_syms_return
!= NULL
)
5703 * num_syms_return
= isyms
== NULL
? 0 : number
;
5708 static Elf_Internal_Sym
*
5709 get_64bit_elf_symbols (Filedata
* filedata
,
5710 Elf_Internal_Shdr
* section
,
5711 unsigned long * num_syms_return
)
5713 unsigned long number
= 0;
5714 Elf64_External_Sym
* esyms
= NULL
;
5715 Elf_External_Sym_Shndx
* shndx
= NULL
;
5716 Elf_Internal_Sym
* isyms
= NULL
;
5717 Elf_Internal_Sym
* psym
;
5719 elf_section_list
* entry
;
5721 if (section
->sh_size
== 0)
5723 if (num_syms_return
!= NULL
)
5724 * num_syms_return
= 0;
5728 /* Run some sanity checks first. */
5729 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5731 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5732 printable_section_name (filedata
, section
),
5733 (unsigned long) section
->sh_entsize
);
5737 if (section
->sh_size
> filedata
->file_size
)
5739 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5740 printable_section_name (filedata
, section
),
5741 (unsigned long) section
->sh_size
);
5745 number
= section
->sh_size
/ section
->sh_entsize
;
5747 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5749 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5750 (unsigned long) section
->sh_size
,
5751 printable_section_name (filedata
, section
),
5752 (unsigned long) section
->sh_entsize
);
5756 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5757 section
->sh_size
, _("symbols"));
5762 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5764 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5769 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5773 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5774 entry
->hdr
->sh_offset
,
5775 1, entry
->hdr
->sh_size
,
5776 _("symbol table section indices"));
5780 /* PR17531: file: heap-buffer-overflow */
5781 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5783 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5784 printable_section_name (filedata
, entry
->hdr
),
5785 (unsigned long) entry
->hdr
->sh_size
,
5786 (unsigned long) section
->sh_size
);
5791 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5795 error (_("Out of memory reading %lu symbols\n"),
5796 (unsigned long) number
);
5800 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5802 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5803 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5804 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5805 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5807 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5809 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5810 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5811 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5813 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5814 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5821 if (num_syms_return
!= NULL
)
5822 * num_syms_return
= isyms
== NULL
? 0 : number
;
5828 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5830 static char buff
[1024];
5832 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5834 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5835 bfd_vma os_flags
= 0;
5836 bfd_vma proc_flags
= 0;
5837 bfd_vma unknown_flags
= 0;
5845 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5846 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5847 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5848 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5849 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5850 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5851 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5852 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5853 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5854 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5855 /* IA-64 specific. */
5856 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5857 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5858 /* IA-64 OpenVMS specific. */
5859 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5860 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5861 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5862 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5863 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5864 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5866 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5867 /* SPARC specific. */
5868 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5869 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5871 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5872 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5873 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5875 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5877 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5880 if (do_section_details
)
5882 sprintf (buff
, "[%*.*lx]: ",
5883 field_size
, field_size
, (unsigned long) sh_flags
);
5884 p
+= field_size
+ 4;
5891 flag
= sh_flags
& - sh_flags
;
5894 if (do_section_details
)
5898 case SHF_WRITE
: sindex
= 0; break;
5899 case SHF_ALLOC
: sindex
= 1; break;
5900 case SHF_EXECINSTR
: sindex
= 2; break;
5901 case SHF_MERGE
: sindex
= 3; break;
5902 case SHF_STRINGS
: sindex
= 4; break;
5903 case SHF_INFO_LINK
: sindex
= 5; break;
5904 case SHF_LINK_ORDER
: sindex
= 6; break;
5905 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5906 case SHF_GROUP
: sindex
= 8; break;
5907 case SHF_TLS
: sindex
= 9; break;
5908 case SHF_EXCLUDE
: sindex
= 18; break;
5909 case SHF_COMPRESSED
: sindex
= 20; break;
5910 case SHF_GNU_MBIND
: sindex
= 24; break;
5914 switch (filedata
->file_header
.e_machine
)
5917 if (flag
== SHF_IA_64_SHORT
)
5919 else if (flag
== SHF_IA_64_NORECOV
)
5922 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5925 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5926 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5927 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5928 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5929 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5930 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5941 case EM_OLD_SPARCV9
:
5942 case EM_SPARC32PLUS
:
5945 if (flag
== SHF_ORDERED
)
5952 case SHF_ENTRYSECT
: sindex
= 21; break;
5953 case SHF_ARM_PURECODE
: sindex
= 22; break;
5954 case SHF_COMDEF
: sindex
= 23; break;
5959 if (flag
== SHF_PPC_VLE
)
5970 if (p
!= buff
+ field_size
+ 4)
5972 if (size
< (10 + 2))
5974 warn (_("Internal error: not enough buffer room for section flag info"));
5975 return _("<unknown>");
5982 size
-= flags
[sindex
].len
;
5983 p
= stpcpy (p
, flags
[sindex
].str
);
5985 else if (flag
& SHF_MASKOS
)
5987 else if (flag
& SHF_MASKPROC
)
5990 unknown_flags
|= flag
;
5996 case SHF_WRITE
: *p
= 'W'; break;
5997 case SHF_ALLOC
: *p
= 'A'; break;
5998 case SHF_EXECINSTR
: *p
= 'X'; break;
5999 case SHF_MERGE
: *p
= 'M'; break;
6000 case SHF_STRINGS
: *p
= 'S'; break;
6001 case SHF_INFO_LINK
: *p
= 'I'; break;
6002 case SHF_LINK_ORDER
: *p
= 'L'; break;
6003 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6004 case SHF_GROUP
: *p
= 'G'; break;
6005 case SHF_TLS
: *p
= 'T'; break;
6006 case SHF_EXCLUDE
: *p
= 'E'; break;
6007 case SHF_COMPRESSED
: *p
= 'C'; break;
6008 case SHF_GNU_MBIND
: *p
= 'D'; break;
6011 if ((filedata
->file_header
.e_machine
== EM_X86_64
6012 || filedata
->file_header
.e_machine
== EM_L1OM
6013 || filedata
->file_header
.e_machine
== EM_K1OM
)
6014 && flag
== SHF_X86_64_LARGE
)
6016 else if (filedata
->file_header
.e_machine
== EM_ARM
6017 && flag
== SHF_ARM_PURECODE
)
6019 else if (filedata
->file_header
.e_machine
== EM_PPC
6020 && flag
== SHF_PPC_VLE
)
6022 else if (flag
& SHF_MASKOS
)
6025 sh_flags
&= ~ SHF_MASKOS
;
6027 else if (flag
& SHF_MASKPROC
)
6030 sh_flags
&= ~ SHF_MASKPROC
;
6040 if (do_section_details
)
6044 size
-= 5 + field_size
;
6045 if (p
!= buff
+ field_size
+ 4)
6049 warn (_("Internal error: not enough buffer room for section flag info"));
6050 return _("<unknown>");
6056 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6057 (unsigned long) os_flags
);
6058 p
+= 5 + field_size
;
6062 size
-= 7 + field_size
;
6063 if (p
!= buff
+ field_size
+ 4)
6067 warn (_("Internal error: not enough buffer room for section flag info"));
6068 return _("<unknown>");
6074 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6075 (unsigned long) proc_flags
);
6076 p
+= 7 + field_size
;
6080 size
-= 10 + field_size
;
6081 if (p
!= buff
+ field_size
+ 4)
6085 warn (_("Internal error: not enough buffer room for section flag info"));
6086 return _("<unknown>");
6092 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6093 (unsigned long) unknown_flags
);
6094 p
+= 10 + field_size
;
6102 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6103 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6107 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6109 if (size
< sizeof (* echdr
))
6111 error (_("Compressed section is too small even for a compression header\n"));
6115 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6116 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6117 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6118 return sizeof (*echdr
);
6122 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6124 if (size
< sizeof (* echdr
))
6126 error (_("Compressed section is too small even for a compression header\n"));
6130 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6131 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6132 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6133 return sizeof (*echdr
);
6138 process_section_headers (Filedata
* filedata
)
6140 Elf_Internal_Shdr
* section
;
6143 free (filedata
->section_headers
);
6144 filedata
->section_headers
= NULL
;
6145 free (filedata
->dynamic_symbols
);
6146 filedata
->dynamic_symbols
= NULL
;
6147 filedata
->num_dynamic_syms
= 0;
6148 free (filedata
->dynamic_strings
);
6149 filedata
->dynamic_strings
= NULL
;
6150 filedata
->dynamic_strings_length
= 0;
6151 free (filedata
->dynamic_syminfo
);
6152 filedata
->dynamic_syminfo
= NULL
;
6153 while (filedata
->symtab_shndx_list
!= NULL
)
6155 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6156 free (filedata
->symtab_shndx_list
);
6157 filedata
->symtab_shndx_list
= next
;
6160 if (filedata
->file_header
.e_shnum
== 0)
6162 /* PR binutils/12467. */
6163 if (filedata
->file_header
.e_shoff
!= 0)
6165 warn (_("possibly corrupt ELF file header - it has a non-zero"
6166 " section header offset, but no section headers\n"));
6169 else if (do_sections
)
6170 printf (_("\nThere are no sections in this file.\n"));
6175 if (do_sections
&& !do_header
)
6176 printf (ngettext ("There is %d section header, "
6177 "starting at offset 0x%lx:\n",
6178 "There are %d section headers, "
6179 "starting at offset 0x%lx:\n",
6180 filedata
->file_header
.e_shnum
),
6181 filedata
->file_header
.e_shnum
,
6182 (unsigned long) filedata
->file_header
.e_shoff
);
6186 if (! get_32bit_section_headers (filedata
, FALSE
))
6191 if (! get_64bit_section_headers (filedata
, FALSE
))
6195 /* Read in the string table, so that we have names to display. */
6196 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6197 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6199 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6201 if (section
->sh_size
!= 0)
6203 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6204 1, section
->sh_size
,
6207 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6211 /* Scan the sections for the dynamic symbol table
6212 and dynamic string table and debug sections. */
6213 eh_addr_size
= is_32bit_elf
? 4 : 8;
6214 switch (filedata
->file_header
.e_machine
)
6217 case EM_MIPS_RS3_LE
:
6218 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6219 FDE addresses. However, the ABI also has a semi-official ILP32
6220 variant for which the normal FDE address size rules apply.
6222 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6223 section, where XX is the size of longs in bits. Unfortunately,
6224 earlier compilers provided no way of distinguishing ILP32 objects
6225 from LP64 objects, so if there's any doubt, we should assume that
6226 the official LP64 form is being used. */
6227 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6228 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6234 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6236 case E_H8_MACH_H8300
:
6237 case E_H8_MACH_H8300HN
:
6238 case E_H8_MACH_H8300SN
:
6239 case E_H8_MACH_H8300SXN
:
6242 case E_H8_MACH_H8300H
:
6243 case E_H8_MACH_H8300S
:
6244 case E_H8_MACH_H8300SX
:
6252 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6254 case EF_M32C_CPU_M16C
:
6261 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6264 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6265 if (section->sh_entsize != expected_entsize) \
6268 sprintf_vma (buf, section->sh_entsize); \
6269 /* Note: coded this way so that there is a single string for \
6271 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6272 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6273 (unsigned) expected_entsize); \
6274 section->sh_entsize = expected_entsize; \
6279 #define CHECK_ENTSIZE(section, i, type) \
6280 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6281 sizeof (Elf64_External_##type))
6283 for (i
= 0, section
= filedata
->section_headers
;
6284 i
< filedata
->file_header
.e_shnum
;
6287 char * name
= SECTION_NAME (section
);
6289 if (section
->sh_type
== SHT_DYNSYM
)
6291 if (filedata
->dynamic_symbols
!= NULL
)
6293 error (_("File contains multiple dynamic symbol tables\n"));
6297 CHECK_ENTSIZE (section
, i
, Sym
);
6298 filedata
->dynamic_symbols
6299 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6301 else if (section
->sh_type
== SHT_STRTAB
6302 && streq (name
, ".dynstr"))
6304 if (filedata
->dynamic_strings
!= NULL
)
6306 error (_("File contains multiple dynamic string tables\n"));
6310 filedata
->dynamic_strings
6311 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6312 1, section
->sh_size
, _("dynamic strings"));
6313 filedata
->dynamic_strings_length
6314 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6316 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6318 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6320 entry
->hdr
= section
;
6321 entry
->next
= filedata
->symtab_shndx_list
;
6322 filedata
->symtab_shndx_list
= entry
;
6324 else if (section
->sh_type
== SHT_SYMTAB
)
6325 CHECK_ENTSIZE (section
, i
, Sym
);
6326 else if (section
->sh_type
== SHT_GROUP
)
6327 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6328 else if (section
->sh_type
== SHT_REL
)
6329 CHECK_ENTSIZE (section
, i
, Rel
);
6330 else if (section
->sh_type
== SHT_RELA
)
6331 CHECK_ENTSIZE (section
, i
, Rela
);
6332 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6333 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6334 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6335 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6336 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6337 && (const_strneq (name
, ".debug_")
6338 || const_strneq (name
, ".zdebug_")))
6341 name
+= sizeof (".zdebug_") - 1;
6343 name
+= sizeof (".debug_") - 1;
6346 || (do_debug_info
&& const_strneq (name
, "info"))
6347 || (do_debug_info
&& const_strneq (name
, "types"))
6348 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6349 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6350 || (do_debug_lines
&& const_strneq (name
, "line."))
6351 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6352 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6353 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6354 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6355 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6356 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6357 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6358 || (do_debug_frames
&& const_strneq (name
, "frame"))
6359 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6360 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6361 || (do_debug_str
&& const_strneq (name
, "str"))
6362 || (do_debug_loc
&& const_strneq (name
, "loc"))
6363 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6364 || (do_debug_addr
&& const_strneq (name
, "addr"))
6365 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6366 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6368 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6370 /* Linkonce section to be combined with .debug_info at link time. */
6371 else if ((do_debugging
|| do_debug_info
)
6372 && const_strneq (name
, ".gnu.linkonce.wi."))
6373 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6374 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6375 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6376 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6377 || streq (name
, ".debug_names")))
6378 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6379 /* Trace sections for Itanium VMS. */
6380 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6381 || do_trace_aranges
)
6382 && const_strneq (name
, ".trace_"))
6384 name
+= sizeof (".trace_") - 1;
6387 || (do_trace_info
&& streq (name
, "info"))
6388 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6389 || (do_trace_aranges
&& streq (name
, "aranges"))
6391 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6393 else if ((do_debugging
|| do_debug_links
)
6394 && (const_strneq (name
, ".gnu_debuglink")
6395 || const_strneq (name
, ".gnu_debugaltlink")))
6396 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6402 if (filedata
->file_header
.e_shnum
> 1)
6403 printf (_("\nSection Headers:\n"));
6405 printf (_("\nSection Header:\n"));
6409 if (do_section_details
)
6411 printf (_(" [Nr] Name\n"));
6412 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6416 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6420 if (do_section_details
)
6422 printf (_(" [Nr] Name\n"));
6423 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6427 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6431 if (do_section_details
)
6433 printf (_(" [Nr] Name\n"));
6434 printf (_(" Type Address Offset Link\n"));
6435 printf (_(" Size EntSize Info Align\n"));
6439 printf (_(" [Nr] Name Type Address Offset\n"));
6440 printf (_(" Size EntSize Flags Link Info Align\n"));
6444 if (do_section_details
)
6445 printf (_(" Flags\n"));
6447 for (i
= 0, section
= filedata
->section_headers
;
6448 i
< filedata
->file_header
.e_shnum
;
6451 /* Run some sanity checks on the section header. */
6453 /* Check the sh_link field. */
6454 switch (section
->sh_type
)
6458 if (section
->sh_link
== 0
6459 && (filedata
->file_header
.e_type
== ET_EXEC
6460 || filedata
->file_header
.e_type
== ET_DYN
))
6461 /* A dynamic relocation section where all entries use a
6462 zero symbol index need not specify a symtab section. */
6465 case SHT_SYMTAB_SHNDX
:
6469 case SHT_GNU_versym
:
6470 if (section
->sh_link
== 0
6471 || section
->sh_link
>= filedata
->file_header
.e_shnum
6472 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6473 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6474 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6475 i
, section
->sh_link
);
6481 case SHT_GNU_verneed
:
6482 case SHT_GNU_verdef
:
6483 case SHT_GNU_LIBLIST
:
6484 if (section
->sh_link
== 0
6485 || section
->sh_link
>= filedata
->file_header
.e_shnum
6486 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6487 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6488 i
, section
->sh_link
);
6491 case SHT_INIT_ARRAY
:
6492 case SHT_FINI_ARRAY
:
6493 case SHT_PREINIT_ARRAY
:
6494 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6495 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6496 i
, section
->sh_link
);
6500 /* FIXME: Add support for target specific section types. */
6501 #if 0 /* Currently we do not check other section types as there are too
6502 many special cases. Stab sections for example have a type
6503 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6505 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6506 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6507 i
, section
->sh_link
);
6512 /* Check the sh_info field. */
6513 switch (section
->sh_type
)
6517 if (section
->sh_info
== 0
6518 && (filedata
->file_header
.e_type
== ET_EXEC
6519 || filedata
->file_header
.e_type
== ET_DYN
))
6520 /* Dynamic relocations apply to segments, so they do not
6521 need to specify the section they relocate. */
6523 if (section
->sh_info
== 0
6524 || section
->sh_info
>= filedata
->file_header
.e_shnum
6525 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6526 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6527 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6528 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6529 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6530 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6531 /* FIXME: Are other section types valid ? */
6532 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6533 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6534 i
, section
->sh_info
);
6539 case SHT_SYMTAB_SHNDX
:
6540 case SHT_INIT_ARRAY
:
6541 case SHT_FINI_ARRAY
:
6542 case SHT_PREINIT_ARRAY
:
6543 if (section
->sh_info
!= 0)
6544 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6545 i
, section
->sh_info
);
6551 /* A symbol index - we assume that it is valid. */
6555 /* FIXME: Add support for target specific section types. */
6556 if (section
->sh_type
== SHT_NOBITS
)
6557 /* NOBITS section headers with non-zero sh_info fields can be
6558 created when a binary is stripped of everything but its debug
6559 information. The stripped sections have their headers
6560 preserved but their types set to SHT_NOBITS. So do not check
6561 this type of section. */
6563 else if (section
->sh_flags
& SHF_INFO_LINK
)
6565 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6566 warn (_("[%2u]: Expected link to another section in info field"), i
);
6568 else if (section
->sh_type
< SHT_LOOS
6569 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6570 && section
->sh_info
!= 0)
6571 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6572 i
, section
->sh_info
);
6576 /* Check the sh_size field. */
6577 if (section
->sh_size
> filedata
->file_size
6578 && section
->sh_type
!= SHT_NOBITS
6579 && section
->sh_type
!= SHT_NULL
6580 && section
->sh_type
< SHT_LOOS
)
6581 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6583 printf (" [%2u] ", i
);
6584 if (do_section_details
)
6585 printf ("%s\n ", printable_section_name (filedata
, section
));
6587 print_symbol (-17, SECTION_NAME (section
));
6589 printf (do_wide
? " %-15s " : " %-15.15s ",
6590 get_section_type_name (filedata
, section
->sh_type
));
6594 const char * link_too_big
= NULL
;
6596 print_vma (section
->sh_addr
, LONG_HEX
);
6598 printf ( " %6.6lx %6.6lx %2.2lx",
6599 (unsigned long) section
->sh_offset
,
6600 (unsigned long) section
->sh_size
,
6601 (unsigned long) section
->sh_entsize
);
6603 if (do_section_details
)
6604 fputs (" ", stdout
);
6606 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6608 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6611 /* The sh_link value is out of range. Normally this indicates
6612 an error but it can have special values in Solaris binaries. */
6613 switch (filedata
->file_header
.e_machine
)
6620 case EM_OLD_SPARCV9
:
6621 case EM_SPARC32PLUS
:
6624 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6625 link_too_big
= "BEFORE";
6626 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6627 link_too_big
= "AFTER";
6634 if (do_section_details
)
6636 if (link_too_big
!= NULL
&& * link_too_big
)
6637 printf ("<%s> ", link_too_big
);
6639 printf ("%2u ", section
->sh_link
);
6640 printf ("%3u %2lu\n", section
->sh_info
,
6641 (unsigned long) section
->sh_addralign
);
6644 printf ("%2u %3u %2lu\n",
6647 (unsigned long) section
->sh_addralign
);
6649 if (link_too_big
&& ! * link_too_big
)
6650 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6651 i
, section
->sh_link
);
6655 print_vma (section
->sh_addr
, LONG_HEX
);
6657 if ((long) section
->sh_offset
== section
->sh_offset
)
6658 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6662 print_vma (section
->sh_offset
, LONG_HEX
);
6665 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6666 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6670 print_vma (section
->sh_size
, LONG_HEX
);
6673 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6674 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6678 print_vma (section
->sh_entsize
, LONG_HEX
);
6681 if (do_section_details
)
6682 fputs (" ", stdout
);
6684 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6686 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6688 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6689 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6692 print_vma (section
->sh_addralign
, DEC
);
6696 else if (do_section_details
)
6699 print_vma (section
->sh_addr
, LONG_HEX
);
6700 if ((long) section
->sh_offset
== section
->sh_offset
)
6701 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6705 print_vma (section
->sh_offset
, LONG_HEX
);
6707 printf (" %u\n ", section
->sh_link
);
6708 print_vma (section
->sh_size
, LONG_HEX
);
6710 print_vma (section
->sh_entsize
, LONG_HEX
);
6712 printf (" %-16u %lu\n",
6714 (unsigned long) section
->sh_addralign
);
6719 print_vma (section
->sh_addr
, LONG_HEX
);
6720 if ((long) section
->sh_offset
== section
->sh_offset
)
6721 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6725 print_vma (section
->sh_offset
, LONG_HEX
);
6728 print_vma (section
->sh_size
, LONG_HEX
);
6730 print_vma (section
->sh_entsize
, LONG_HEX
);
6732 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6734 printf (" %2u %3u %lu\n",
6737 (unsigned long) section
->sh_addralign
);
6740 if (do_section_details
)
6742 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6743 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6745 /* Minimum section size is 12 bytes for 32-bit compression
6746 header + 12 bytes for compressed data header. */
6747 unsigned char buf
[24];
6749 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6750 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6751 sizeof (buf
), _("compression header")))
6753 Elf_Internal_Chdr chdr
;
6755 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6756 printf (_(" [<corrupt>]\n"));
6759 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6762 printf (_(" [<unknown>: 0x%x], "),
6764 print_vma (chdr
.ch_size
, LONG_HEX
);
6765 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6772 if (!do_section_details
)
6774 /* The ordering of the letters shown here matches the ordering of the
6775 corresponding SHF_xxx values, and hence the order in which these
6776 letters will be displayed to the user. */
6777 printf (_("Key to Flags:\n\
6778 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6779 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6780 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6781 if (filedata
->file_header
.e_machine
== EM_X86_64
6782 || filedata
->file_header
.e_machine
== EM_L1OM
6783 || filedata
->file_header
.e_machine
== EM_K1OM
)
6784 printf (_("l (large), "));
6785 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6786 printf (_("y (purecode), "));
6787 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6788 printf (_("v (VLE), "));
6789 printf ("p (processor specific)\n");
6796 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6797 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6798 char **strtab
, unsigned long *strtablen
)
6802 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6804 if (*symtab
== NULL
)
6807 if (symsec
->sh_link
!= 0)
6809 Elf_Internal_Shdr
*strsec
;
6811 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6813 error (_("Bad sh_link in symbol table section\n"));
6820 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6822 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6823 1, strsec
->sh_size
, _("string table"));
6824 if (*strtab
== NULL
)
6831 *strtablen
= strsec
->sh_size
;
6837 get_group_flags (unsigned int flags
)
6839 static char buff
[128];
6843 else if (flags
== GRP_COMDAT
)
6846 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6848 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6849 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6850 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6851 ? _("<unknown>") : ""));
6857 process_section_groups (Filedata
* filedata
)
6859 Elf_Internal_Shdr
* section
;
6861 struct group
* group
;
6862 Elf_Internal_Shdr
* symtab_sec
;
6863 Elf_Internal_Shdr
* strtab_sec
;
6864 Elf_Internal_Sym
* symtab
;
6865 unsigned long num_syms
;
6869 /* Don't process section groups unless needed. */
6870 if (!do_unwind
&& !do_section_groups
)
6873 if (filedata
->file_header
.e_shnum
== 0)
6875 if (do_section_groups
)
6876 printf (_("\nThere are no sections to group in this file.\n"));
6881 if (filedata
->section_headers
== NULL
)
6883 error (_("Section headers are not available!\n"));
6884 /* PR 13622: This can happen with a corrupt ELF header. */
6888 filedata
->section_headers_groups
6889 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6890 sizeof (struct group
*));
6892 if (filedata
->section_headers_groups
== NULL
)
6894 error (_("Out of memory reading %u section group headers\n"),
6895 filedata
->file_header
.e_shnum
);
6899 /* Scan the sections for the group section. */
6900 filedata
->group_count
= 0;
6901 for (i
= 0, section
= filedata
->section_headers
;
6902 i
< filedata
->file_header
.e_shnum
;
6904 if (section
->sh_type
== SHT_GROUP
)
6905 filedata
->group_count
++;
6907 if (filedata
->group_count
== 0)
6909 if (do_section_groups
)
6910 printf (_("\nThere are no section groups in this file.\n"));
6915 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
6916 sizeof (struct group
));
6918 if (filedata
->section_groups
== NULL
)
6920 error (_("Out of memory reading %lu groups\n"),
6921 (unsigned long) filedata
->group_count
);
6931 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
6932 i
< filedata
->file_header
.e_shnum
;
6935 if (section
->sh_type
== SHT_GROUP
)
6937 const char * name
= printable_section_name (filedata
, section
);
6938 const char * group_name
;
6939 unsigned char * start
;
6940 unsigned char * indices
;
6941 unsigned int entry
, j
, size
;
6942 Elf_Internal_Shdr
* sec
;
6943 Elf_Internal_Sym
* sym
;
6945 /* Get the symbol table. */
6946 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6947 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6950 error (_("Bad sh_link in group section `%s'\n"), name
);
6954 if (symtab_sec
!= sec
)
6959 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6964 error (_("Corrupt header in group section `%s'\n"), name
);
6968 if (section
->sh_info
>= num_syms
)
6970 error (_("Bad sh_info in group section `%s'\n"), name
);
6974 sym
= symtab
+ section
->sh_info
;
6976 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6978 if (sym
->st_shndx
== 0
6979 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6981 error (_("Bad sh_info in group section `%s'\n"), name
);
6985 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6994 /* Get the string table. */
6995 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7004 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7010 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7011 1, strtab_sec
->sh_size
,
7013 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7015 group_name
= sym
->st_name
< strtab_size
7016 ? strtab
+ sym
->st_name
: _("<corrupt>");
7019 /* PR 17531: file: loop. */
7020 if (section
->sh_entsize
> section
->sh_size
)
7022 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7023 printable_section_name (filedata
, section
),
7024 (unsigned long) section
->sh_entsize
,
7025 (unsigned long) section
->sh_size
);
7029 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7030 1, section
->sh_size
,
7036 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7037 entry
= byte_get (indices
, 4);
7040 if (do_section_groups
)
7042 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7043 get_group_flags (entry
), i
, name
, group_name
, size
);
7045 printf (_(" [Index] Name\n"));
7048 group
->group_index
= i
;
7050 for (j
= 0; j
< size
; j
++)
7052 struct group_list
* g
;
7054 entry
= byte_get (indices
, 4);
7057 if (entry
>= filedata
->file_header
.e_shnum
)
7059 static unsigned num_group_errors
= 0;
7061 if (num_group_errors
++ < 10)
7063 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7064 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7065 if (num_group_errors
== 10)
7066 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7071 if (filedata
->section_headers_groups
[entry
] != NULL
)
7075 static unsigned num_errs
= 0;
7077 if (num_errs
++ < 10)
7079 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7081 filedata
->section_headers_groups
[entry
]->group_index
);
7083 warn (_("Further error messages about already contained group sections suppressed\n"));
7089 /* Intel C/C++ compiler may put section 0 in a
7090 section group. We just warn it the first time
7091 and ignore it afterwards. */
7092 static bfd_boolean warned
= FALSE
;
7095 error (_("section 0 in group section [%5u]\n"),
7096 filedata
->section_headers_groups
[entry
]->group_index
);
7102 filedata
->section_headers_groups
[entry
] = group
;
7104 if (do_section_groups
)
7106 sec
= filedata
->section_headers
+ entry
;
7107 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7110 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7111 g
->section_index
= entry
;
7112 g
->next
= group
->root
;
7130 /* Data used to display dynamic fixups. */
7132 struct ia64_vms_dynfixup
7134 bfd_vma needed_ident
; /* Library ident number. */
7135 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7136 bfd_vma fixup_needed
; /* Index of the library. */
7137 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7138 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7141 /* Data used to display dynamic relocations. */
7143 struct ia64_vms_dynimgrela
7145 bfd_vma img_rela_cnt
; /* Number of relocations. */
7146 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7149 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7153 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7154 struct ia64_vms_dynfixup
* fixup
,
7155 const char * strtab
,
7156 unsigned int strtab_sz
)
7158 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7160 const char * lib_name
;
7162 imfs
= get_data (NULL
, filedata
,
7163 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7164 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7165 _("dynamic section image fixups"));
7169 if (fixup
->needed
< strtab_sz
)
7170 lib_name
= strtab
+ fixup
->needed
;
7173 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7174 (unsigned long) fixup
->needed
);
7178 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7179 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7181 (_("Seg Offset Type SymVec DataType\n"));
7183 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7188 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7189 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7190 type
= BYTE_GET (imfs
[i
].type
);
7191 rtype
= elf_ia64_reloc_type (type
);
7193 printf (" 0x%08x ", type
);
7195 printf (" %-32s ", rtype
);
7196 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7197 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7204 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7207 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7209 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7212 imrs
= get_data (NULL
, filedata
,
7213 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7214 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7215 _("dynamic section image relocations"));
7219 printf (_("\nImage relocs\n"));
7221 (_("Seg Offset Type Addend Seg Sym Off\n"));
7223 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7228 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7229 printf ("%08" BFD_VMA_FMT
"x ",
7230 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7231 type
= BYTE_GET (imrs
[i
].type
);
7232 rtype
= elf_ia64_reloc_type (type
);
7234 printf ("0x%08x ", type
);
7236 printf ("%-31s ", rtype
);
7237 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7238 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7239 printf ("%08" BFD_VMA_FMT
"x\n",
7240 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7247 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7250 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7252 struct ia64_vms_dynfixup fixup
;
7253 struct ia64_vms_dynimgrela imgrela
;
7254 Elf_Internal_Dyn
*entry
;
7255 bfd_vma strtab_off
= 0;
7256 bfd_vma strtab_sz
= 0;
7257 char *strtab
= NULL
;
7258 bfd_boolean res
= TRUE
;
7260 memset (&fixup
, 0, sizeof (fixup
));
7261 memset (&imgrela
, 0, sizeof (imgrela
));
7263 /* Note: the order of the entries is specified by the OpenVMS specs. */
7264 for (entry
= filedata
->dynamic_section
;
7265 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7268 switch (entry
->d_tag
)
7270 case DT_IA_64_VMS_STRTAB_OFFSET
:
7271 strtab_off
= entry
->d_un
.d_val
;
7274 strtab_sz
= entry
->d_un
.d_val
;
7276 strtab
= get_data (NULL
, filedata
,
7277 filedata
->dynamic_addr
+ strtab_off
,
7278 1, strtab_sz
, _("dynamic string section"));
7283 case DT_IA_64_VMS_NEEDED_IDENT
:
7284 fixup
.needed_ident
= entry
->d_un
.d_val
;
7287 fixup
.needed
= entry
->d_un
.d_val
;
7289 case DT_IA_64_VMS_FIXUP_NEEDED
:
7290 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7292 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7293 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7295 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7296 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7297 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7300 case DT_IA_64_VMS_IMG_RELA_CNT
:
7301 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7303 case DT_IA_64_VMS_IMG_RELA_OFF
:
7304 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7305 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7327 dynamic_relocations
[] =
7329 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7330 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7331 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7334 /* Process the reloc section. */
7337 process_relocs (Filedata
* filedata
)
7339 unsigned long rel_size
;
7340 unsigned long rel_offset
;
7345 if (do_using_dynamic
)
7349 bfd_boolean has_dynamic_reloc
;
7352 has_dynamic_reloc
= FALSE
;
7354 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7356 is_rela
= dynamic_relocations
[i
].rela
;
7357 name
= dynamic_relocations
[i
].name
;
7358 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7359 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7362 has_dynamic_reloc
= TRUE
;
7364 if (is_rela
== UNKNOWN
)
7366 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7367 switch (filedata
->dynamic_info
[DT_PLTREL
])
7381 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7382 name
, rel_offset
, rel_size
);
7384 dump_relocations (filedata
,
7385 offset_from_vma (filedata
, rel_offset
, rel_size
),
7387 filedata
->dynamic_symbols
,
7388 filedata
->num_dynamic_syms
,
7389 filedata
->dynamic_strings
,
7390 filedata
->dynamic_strings_length
,
7391 is_rela
, TRUE
/* is_dynamic */);
7395 if (is_ia64_vms (filedata
))
7396 if (process_ia64_vms_dynamic_relocs (filedata
))
7397 has_dynamic_reloc
= TRUE
;
7399 if (! has_dynamic_reloc
)
7400 printf (_("\nThere are no dynamic relocations in this file.\n"));
7404 Elf_Internal_Shdr
* section
;
7406 bfd_boolean found
= FALSE
;
7408 for (i
= 0, section
= filedata
->section_headers
;
7409 i
< filedata
->file_header
.e_shnum
;
7412 if ( section
->sh_type
!= SHT_RELA
7413 && section
->sh_type
!= SHT_REL
)
7416 rel_offset
= section
->sh_offset
;
7417 rel_size
= section
->sh_size
;
7422 unsigned long num_rela
;
7424 printf (_("\nRelocation section "));
7426 if (filedata
->string_table
== NULL
)
7427 printf ("%d", section
->sh_name
);
7429 printf ("'%s'", printable_section_name (filedata
, section
));
7431 num_rela
= rel_size
/ section
->sh_entsize
;
7432 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7433 " at offset 0x%lx contains %lu entries:\n",
7435 rel_offset
, num_rela
);
7437 is_rela
= section
->sh_type
== SHT_RELA
;
7439 if (section
->sh_link
!= 0
7440 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7442 Elf_Internal_Shdr
* symsec
;
7443 Elf_Internal_Sym
* symtab
;
7444 unsigned long nsyms
;
7445 unsigned long strtablen
= 0;
7446 char * strtab
= NULL
;
7448 symsec
= filedata
->section_headers
+ section
->sh_link
;
7449 if (symsec
->sh_type
!= SHT_SYMTAB
7450 && symsec
->sh_type
!= SHT_DYNSYM
)
7453 if (!get_symtab (filedata
, symsec
,
7454 &symtab
, &nsyms
, &strtab
, &strtablen
))
7457 dump_relocations (filedata
, rel_offset
, rel_size
,
7458 symtab
, nsyms
, strtab
, strtablen
,
7460 symsec
->sh_type
== SHT_DYNSYM
);
7466 dump_relocations (filedata
, rel_offset
, rel_size
,
7467 NULL
, 0, NULL
, 0, is_rela
,
7468 FALSE
/* is_dynamic */);
7476 /* Users sometimes forget the -D option, so try to be helpful. */
7477 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7479 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7481 printf (_("\nThere are no static relocations in this file."));
7482 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7487 if (i
== ARRAY_SIZE (dynamic_relocations
))
7488 printf (_("\nThere are no relocations in this file.\n"));
7495 /* An absolute address consists of a section and an offset. If the
7496 section is NULL, the offset itself is the address, otherwise, the
7497 address equals to LOAD_ADDRESS(section) + offset. */
7501 unsigned short section
;
7505 /* Find the nearest symbol at or below ADDR. Returns the symbol
7506 name, if found, and the offset from the symbol to ADDR. */
7509 find_symbol_for_address (Filedata
* filedata
,
7510 Elf_Internal_Sym
* symtab
,
7511 unsigned long nsyms
,
7512 const char * strtab
,
7513 unsigned long strtab_size
,
7514 struct absaddr addr
,
7515 const char ** symname
,
7518 bfd_vma dist
= 0x100000;
7519 Elf_Internal_Sym
* sym
;
7520 Elf_Internal_Sym
* beg
;
7521 Elf_Internal_Sym
* end
;
7522 Elf_Internal_Sym
* best
= NULL
;
7524 REMOVE_ARCH_BITS (addr
.offset
);
7526 end
= symtab
+ nsyms
;
7532 sym
= beg
+ (end
- beg
) / 2;
7534 value
= sym
->st_value
;
7535 REMOVE_ARCH_BITS (value
);
7537 if (sym
->st_name
!= 0
7538 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7539 && addr
.offset
>= value
7540 && addr
.offset
- value
< dist
)
7543 dist
= addr
.offset
- value
;
7548 if (addr
.offset
< value
)
7556 *symname
= (best
->st_name
>= strtab_size
7557 ? _("<corrupt>") : strtab
+ best
->st_name
);
7563 *offset
= addr
.offset
;
7566 static /* signed */ int
7567 symcmp (const void *p
, const void *q
)
7569 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7570 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7572 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7575 /* Process the unwind section. */
7577 #include "unwind-ia64.h"
7579 struct ia64_unw_table_entry
7581 struct absaddr start
;
7583 struct absaddr info
;
7586 struct ia64_unw_aux_info
7588 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7589 unsigned long table_len
; /* Length of unwind table. */
7590 unsigned char * info
; /* Unwind info. */
7591 unsigned long info_size
; /* Size of unwind info. */
7592 bfd_vma info_addr
; /* Starting address of unwind info. */
7593 bfd_vma seg_base
; /* Starting address of segment. */
7594 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7595 unsigned long nsyms
; /* Number of symbols. */
7596 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7597 unsigned long nfuns
; /* Number of entries in funtab. */
7598 char * strtab
; /* The string table. */
7599 unsigned long strtab_size
; /* Size of string table. */
7603 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7605 struct ia64_unw_table_entry
* tp
;
7606 unsigned long j
, nfuns
;
7608 bfd_boolean res
= TRUE
;
7610 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7611 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7612 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7613 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7615 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7617 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7621 const unsigned char * dp
;
7622 const unsigned char * head
;
7623 const unsigned char * end
;
7624 const char * procname
;
7626 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7627 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7629 fputs ("\n<", stdout
);
7633 fputs (procname
, stdout
);
7636 printf ("+%lx", (unsigned long) offset
);
7639 fputs (">: [", stdout
);
7640 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7641 fputc ('-', stdout
);
7642 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7643 printf ("], info at +0x%lx\n",
7644 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7646 /* PR 17531: file: 86232b32. */
7647 if (aux
->info
== NULL
)
7650 offset
= tp
->info
.offset
;
7651 if (tp
->info
.section
)
7653 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7655 warn (_("Invalid section %u in table entry %ld\n"),
7656 tp
->info
.section
, (long) (tp
- aux
->table
));
7660 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7662 offset
-= aux
->info_addr
;
7663 /* PR 17531: file: 0997b4d1. */
7664 if (offset
>= aux
->info_size
7665 || aux
->info_size
- offset
< 8)
7667 warn (_("Invalid offset %lx in table entry %ld\n"),
7668 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7673 head
= aux
->info
+ offset
;
7674 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7676 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7677 (unsigned) UNW_VER (stamp
),
7678 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7679 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7680 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7681 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7683 if (UNW_VER (stamp
) != 1)
7685 printf (_("\tUnknown version.\n"));
7690 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7691 /* PR 17531: file: 16ceda89. */
7692 if (end
> aux
->info
+ aux
->info_size
)
7693 end
= aux
->info
+ aux
->info_size
;
7694 for (dp
= head
+ 8; dp
< end
;)
7695 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7704 slurp_ia64_unwind_table (Filedata
* filedata
,
7705 struct ia64_unw_aux_info
* aux
,
7706 Elf_Internal_Shdr
* sec
)
7708 unsigned long size
, nrelas
, i
;
7709 Elf_Internal_Phdr
* seg
;
7710 struct ia64_unw_table_entry
* tep
;
7711 Elf_Internal_Shdr
* relsec
;
7712 Elf_Internal_Rela
* rela
;
7713 Elf_Internal_Rela
* rp
;
7714 unsigned char * table
;
7716 Elf_Internal_Sym
* sym
;
7717 const char * relname
;
7721 /* First, find the starting address of the segment that includes
7724 if (filedata
->file_header
.e_phnum
)
7726 if (! get_program_headers (filedata
))
7729 for (seg
= filedata
->program_headers
;
7730 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7733 if (seg
->p_type
!= PT_LOAD
)
7736 if (sec
->sh_addr
>= seg
->p_vaddr
7737 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7739 aux
->seg_base
= seg
->p_vaddr
;
7745 /* Second, build the unwind table from the contents of the unwind section: */
7746 size
= sec
->sh_size
;
7747 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7752 aux
->table_len
= size
/ (3 * eh_addr_size
);
7753 aux
->table
= (struct ia64_unw_table_entry
*)
7754 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7757 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7759 tep
->start
.section
= SHN_UNDEF
;
7760 tep
->end
.section
= SHN_UNDEF
;
7761 tep
->info
.section
= SHN_UNDEF
;
7762 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7763 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7764 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7765 tep
->start
.offset
+= aux
->seg_base
;
7766 tep
->end
.offset
+= aux
->seg_base
;
7767 tep
->info
.offset
+= aux
->seg_base
;
7771 /* Third, apply any relocations to the unwind table: */
7772 for (relsec
= filedata
->section_headers
;
7773 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7776 if (relsec
->sh_type
!= SHT_RELA
7777 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7778 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7781 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7790 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7792 unsigned int sym_ndx
;
7793 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7794 relname
= elf_ia64_reloc_type (r_type
);
7796 /* PR 17531: file: 9fa67536. */
7797 if (relname
== NULL
)
7799 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7803 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7805 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7809 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7811 /* PR 17531: file: 5bc8d9bf. */
7812 if (i
>= aux
->table_len
)
7814 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7818 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7819 if (sym_ndx
>= aux
->nsyms
)
7821 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7825 sym
= aux
->symtab
+ sym_ndx
;
7827 switch (rp
->r_offset
/ eh_addr_size
% 3)
7830 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7831 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7834 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7835 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7838 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7839 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7853 ia64_process_unwind (Filedata
* filedata
)
7855 Elf_Internal_Shdr
* sec
;
7856 Elf_Internal_Shdr
* unwsec
= NULL
;
7857 unsigned long i
, unwcount
= 0, unwstart
= 0;
7858 struct ia64_unw_aux_info aux
;
7859 bfd_boolean res
= TRUE
;
7861 memset (& aux
, 0, sizeof (aux
));
7863 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7865 if (sec
->sh_type
== SHT_SYMTAB
)
7869 error (_("Multiple symbol tables encountered\n"));
7875 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7876 &aux
.strtab
, &aux
.strtab_size
))
7879 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7884 printf (_("\nThere are no unwind sections in this file.\n"));
7886 while (unwcount
-- > 0)
7891 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7892 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7893 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7898 /* We have already counted the number of SHT_IA64_UNWIND
7899 sections so the loop above should never fail. */
7900 assert (unwsec
!= NULL
);
7903 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7905 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7907 /* We need to find which section group it is in. */
7908 struct group_list
* g
;
7910 if (filedata
->section_headers_groups
== NULL
7911 || filedata
->section_headers_groups
[i
] == NULL
)
7912 i
= filedata
->file_header
.e_shnum
;
7915 g
= filedata
->section_headers_groups
[i
]->root
;
7917 for (; g
!= NULL
; g
= g
->next
)
7919 sec
= filedata
->section_headers
+ g
->section_index
;
7921 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7926 i
= filedata
->file_header
.e_shnum
;
7929 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7931 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7932 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7933 suffix
= SECTION_NAME (unwsec
) + len
;
7934 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7936 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7937 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7942 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7943 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7944 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7945 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7947 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7948 suffix
= SECTION_NAME (unwsec
) + len
;
7949 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7951 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7952 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7956 if (i
== filedata
->file_header
.e_shnum
)
7958 printf (_("\nCould not find unwind info section for "));
7960 if (filedata
->string_table
== NULL
)
7961 printf ("%d", unwsec
->sh_name
);
7963 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7967 aux
.info_addr
= sec
->sh_addr
;
7968 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7971 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7973 printf (_("\nUnwind section "));
7975 if (filedata
->string_table
== NULL
)
7976 printf ("%d", unwsec
->sh_name
);
7978 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7980 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7981 (unsigned long) unwsec
->sh_offset
,
7982 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7984 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7985 && aux
.table_len
> 0)
7986 dump_ia64_unwind (filedata
, & aux
);
7989 free ((char *) aux
.table
);
7991 free ((char *) aux
.info
);
8000 free ((char *) aux
.strtab
);
8005 struct hppa_unw_table_entry
8007 struct absaddr start
;
8009 unsigned int Cannot_unwind
:1; /* 0 */
8010 unsigned int Millicode
:1; /* 1 */
8011 unsigned int Millicode_save_sr0
:1; /* 2 */
8012 unsigned int Region_description
:2; /* 3..4 */
8013 unsigned int reserved1
:1; /* 5 */
8014 unsigned int Entry_SR
:1; /* 6 */
8015 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8016 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8017 unsigned int Args_stored
:1; /* 16 */
8018 unsigned int Variable_Frame
:1; /* 17 */
8019 unsigned int Separate_Package_Body
:1; /* 18 */
8020 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8021 unsigned int Stack_Overflow_Check
:1; /* 20 */
8022 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8023 unsigned int Ada_Region
:1; /* 22 */
8024 unsigned int cxx_info
:1; /* 23 */
8025 unsigned int cxx_try_catch
:1; /* 24 */
8026 unsigned int sched_entry_seq
:1; /* 25 */
8027 unsigned int reserved2
:1; /* 26 */
8028 unsigned int Save_SP
:1; /* 27 */
8029 unsigned int Save_RP
:1; /* 28 */
8030 unsigned int Save_MRP_in_frame
:1; /* 29 */
8031 unsigned int extn_ptr_defined
:1; /* 30 */
8032 unsigned int Cleanup_defined
:1; /* 31 */
8034 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8035 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8036 unsigned int Large_frame
:1; /* 2 */
8037 unsigned int Pseudo_SP_Set
:1; /* 3 */
8038 unsigned int reserved4
:1; /* 4 */
8039 unsigned int Total_frame_size
:27; /* 5..31 */
8042 struct hppa_unw_aux_info
8044 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8045 unsigned long table_len
; /* Length of unwind table. */
8046 bfd_vma seg_base
; /* Starting address of segment. */
8047 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8048 unsigned long nsyms
; /* Number of symbols. */
8049 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8050 unsigned long nfuns
; /* Number of entries in funtab. */
8051 char * strtab
; /* The string table. */
8052 unsigned long strtab_size
; /* Size of string table. */
8056 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8058 struct hppa_unw_table_entry
* tp
;
8059 unsigned long j
, nfuns
;
8060 bfd_boolean res
= TRUE
;
8062 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8063 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8064 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8065 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8067 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8069 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8072 const char * procname
;
8074 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8075 aux
->strtab_size
, tp
->start
, &procname
,
8078 fputs ("\n<", stdout
);
8082 fputs (procname
, stdout
);
8085 printf ("+%lx", (unsigned long) offset
);
8088 fputs (">: [", stdout
);
8089 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8090 fputc ('-', stdout
);
8091 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8094 #define PF(_m) if (tp->_m) printf (#_m " ");
8095 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8098 PF(Millicode_save_sr0
);
8099 /* PV(Region_description); */
8105 PF(Separate_Package_Body
);
8106 PF(Frame_Extension_Millicode
);
8107 PF(Stack_Overflow_Check
);
8108 PF(Two_Instruction_SP_Increment
);
8112 PF(sched_entry_seq
);
8115 PF(Save_MRP_in_frame
);
8116 PF(extn_ptr_defined
);
8117 PF(Cleanup_defined
);
8118 PF(MPE_XL_interrupt_marker
);
8119 PF(HP_UX_interrupt_marker
);
8122 PV(Total_frame_size
);
8135 slurp_hppa_unwind_table (Filedata
* filedata
,
8136 struct hppa_unw_aux_info
* aux
,
8137 Elf_Internal_Shdr
* sec
)
8139 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8140 Elf_Internal_Phdr
* seg
;
8141 struct hppa_unw_table_entry
* tep
;
8142 Elf_Internal_Shdr
* relsec
;
8143 Elf_Internal_Rela
* rela
;
8144 Elf_Internal_Rela
* rp
;
8145 unsigned char * table
;
8147 Elf_Internal_Sym
* sym
;
8148 const char * relname
;
8150 /* First, find the starting address of the segment that includes
8152 if (filedata
->file_header
.e_phnum
)
8154 if (! get_program_headers (filedata
))
8157 for (seg
= filedata
->program_headers
;
8158 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8161 if (seg
->p_type
!= PT_LOAD
)
8164 if (sec
->sh_addr
>= seg
->p_vaddr
8165 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8167 aux
->seg_base
= seg
->p_vaddr
;
8173 /* Second, build the unwind table from the contents of the unwind
8175 size
= sec
->sh_size
;
8176 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8182 nentries
= size
/ unw_ent_size
;
8183 size
= unw_ent_size
* nentries
;
8185 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8186 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8188 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8190 unsigned int tmp1
, tmp2
;
8192 tep
->start
.section
= SHN_UNDEF
;
8193 tep
->end
.section
= SHN_UNDEF
;
8195 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8196 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8197 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8198 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8200 tep
->start
.offset
+= aux
->seg_base
;
8201 tep
->end
.offset
+= aux
->seg_base
;
8203 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8204 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8205 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8206 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8207 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8208 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8209 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8210 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8211 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8212 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8213 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8214 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8215 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8216 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8217 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8218 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8219 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8220 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8221 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8222 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8223 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8224 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8225 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8226 tep
->Cleanup_defined
= tmp1
& 0x1;
8228 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8229 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8230 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8231 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8232 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8233 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8237 /* Third, apply any relocations to the unwind table. */
8238 for (relsec
= filedata
->section_headers
;
8239 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8242 if (relsec
->sh_type
!= SHT_RELA
8243 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8244 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8247 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8251 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8253 unsigned int sym_ndx
;
8254 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8255 relname
= elf_hppa_reloc_type (r_type
);
8257 if (relname
== NULL
)
8259 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8263 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8264 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8266 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8270 i
= rp
->r_offset
/ unw_ent_size
;
8271 if (i
>= aux
->table_len
)
8273 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8277 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8278 if (sym_ndx
>= aux
->nsyms
)
8280 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8284 sym
= aux
->symtab
+ sym_ndx
;
8286 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8289 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8290 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8293 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8294 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8304 aux
->table_len
= nentries
;
8310 hppa_process_unwind (Filedata
* filedata
)
8312 struct hppa_unw_aux_info aux
;
8313 Elf_Internal_Shdr
* unwsec
= NULL
;
8314 Elf_Internal_Shdr
* sec
;
8316 bfd_boolean res
= TRUE
;
8318 if (filedata
->string_table
== NULL
)
8321 memset (& aux
, 0, sizeof (aux
));
8323 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8325 if (sec
->sh_type
== SHT_SYMTAB
)
8329 error (_("Multiple symbol tables encountered\n"));
8335 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8336 &aux
.strtab
, &aux
.strtab_size
))
8339 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8344 printf (_("\nThere are no unwind sections in this file.\n"));
8346 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8348 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8350 unsigned long num_unwind
= sec
->sh_size
/ 16;
8352 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8353 "contains %lu entry:\n",
8354 "\nUnwind section '%s' at offset 0x%lx "
8355 "contains %lu entries:\n",
8357 printable_section_name (filedata
, sec
),
8358 (unsigned long) sec
->sh_offset
,
8361 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8364 if (res
&& aux
.table_len
> 0)
8366 if (! dump_hppa_unwind (filedata
, &aux
))
8371 free ((char *) aux
.table
);
8379 free ((char *) aux
.strtab
);
8386 unsigned char * data
; /* The unwind data. */
8387 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8388 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8389 unsigned long nrelas
; /* The number of relocations. */
8390 unsigned int rel_type
; /* REL or RELA ? */
8391 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8394 struct arm_unw_aux_info
8396 Filedata
* filedata
; /* The file containing the unwind sections. */
8397 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8398 unsigned long nsyms
; /* Number of symbols. */
8399 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8400 unsigned long nfuns
; /* Number of these symbols. */
8401 char * strtab
; /* The file's string table. */
8402 unsigned long strtab_size
; /* Size of string table. */
8406 arm_print_vma_and_name (Filedata
* filedata
,
8407 struct arm_unw_aux_info
* aux
,
8409 struct absaddr addr
)
8411 const char *procname
;
8414 if (addr
.section
== SHN_UNDEF
)
8417 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8418 aux
->strtab_size
, addr
, &procname
,
8421 print_vma (fn
, PREFIX_HEX
);
8425 fputs (" <", stdout
);
8426 fputs (procname
, stdout
);
8429 printf ("+0x%lx", (unsigned long) sym_offset
);
8430 fputc ('>', stdout
);
8437 arm_free_section (struct arm_section
*arm_sec
)
8439 if (arm_sec
->data
!= NULL
)
8440 free (arm_sec
->data
);
8442 if (arm_sec
->rela
!= NULL
)
8443 free (arm_sec
->rela
);
8446 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8447 cached section and install SEC instead.
8448 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8449 and return its valued in * WORDP, relocating if necessary.
8450 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8451 relocation's offset in ADDR.
8452 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8453 into the string table of the symbol associated with the reloc. If no
8454 reloc was applied store -1 there.
8455 5) Return TRUE upon success, FALSE otherwise. */
8458 get_unwind_section_word (Filedata
* filedata
,
8459 struct arm_unw_aux_info
* aux
,
8460 struct arm_section
* arm_sec
,
8461 Elf_Internal_Shdr
* sec
,
8462 bfd_vma word_offset
,
8463 unsigned int * wordp
,
8464 struct absaddr
* addr
,
8467 Elf_Internal_Rela
*rp
;
8468 Elf_Internal_Sym
*sym
;
8469 const char * relname
;
8471 bfd_boolean wrapped
;
8473 if (sec
== NULL
|| arm_sec
== NULL
)
8476 addr
->section
= SHN_UNDEF
;
8479 if (sym_name
!= NULL
)
8480 *sym_name
= (bfd_vma
) -1;
8482 /* If necessary, update the section cache. */
8483 if (sec
!= arm_sec
->sec
)
8485 Elf_Internal_Shdr
*relsec
;
8487 arm_free_section (arm_sec
);
8490 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8491 sec
->sh_size
, _("unwind data"));
8492 arm_sec
->rela
= NULL
;
8493 arm_sec
->nrelas
= 0;
8495 for (relsec
= filedata
->section_headers
;
8496 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8499 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8500 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8501 /* PR 15745: Check the section type as well. */
8502 || (relsec
->sh_type
!= SHT_REL
8503 && relsec
->sh_type
!= SHT_RELA
))
8506 arm_sec
->rel_type
= relsec
->sh_type
;
8507 if (relsec
->sh_type
== SHT_REL
)
8509 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8511 & arm_sec
->rela
, & arm_sec
->nrelas
))
8514 else /* relsec->sh_type == SHT_RELA */
8516 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8518 & arm_sec
->rela
, & arm_sec
->nrelas
))
8524 arm_sec
->next_rela
= arm_sec
->rela
;
8527 /* If there is no unwind data we can do nothing. */
8528 if (arm_sec
->data
== NULL
)
8531 /* If the offset is invalid then fail. */
8532 if (/* PR 21343 *//* PR 18879 */
8534 || word_offset
> (sec
->sh_size
- 4)
8535 || ((bfd_signed_vma
) word_offset
) < 0)
8538 /* Get the word at the required offset. */
8539 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8541 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8542 if (arm_sec
->rela
== NULL
)
8548 /* Look through the relocs to find the one that applies to the provided offset. */
8550 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8552 bfd_vma prelval
, offset
;
8554 if (rp
->r_offset
> word_offset
&& !wrapped
)
8559 if (rp
->r_offset
> word_offset
)
8562 if (rp
->r_offset
& 3)
8564 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8565 (unsigned long) rp
->r_offset
);
8569 if (rp
->r_offset
< word_offset
)
8572 /* PR 17531: file: 027-161405-0.004 */
8573 if (aux
->symtab
== NULL
)
8576 if (arm_sec
->rel_type
== SHT_REL
)
8578 offset
= word
& 0x7fffffff;
8579 if (offset
& 0x40000000)
8580 offset
|= ~ (bfd_vma
) 0x7fffffff;
8582 else if (arm_sec
->rel_type
== SHT_RELA
)
8583 offset
= rp
->r_addend
;
8586 error (_("Unknown section relocation type %d encountered\n"),
8591 /* PR 17531 file: 027-1241568-0.004. */
8592 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8594 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8595 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8599 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8600 offset
+= sym
->st_value
;
8601 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8603 /* Check that we are processing the expected reloc type. */
8604 if (filedata
->file_header
.e_machine
== EM_ARM
)
8606 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8607 if (relname
== NULL
)
8609 warn (_("Skipping unknown ARM relocation type: %d\n"),
8610 (int) ELF32_R_TYPE (rp
->r_info
));
8614 if (streq (relname
, "R_ARM_NONE"))
8617 if (! streq (relname
, "R_ARM_PREL31"))
8619 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8623 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8625 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8626 if (relname
== NULL
)
8628 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8629 (int) ELF32_R_TYPE (rp
->r_info
));
8633 if (streq (relname
, "R_C6000_NONE"))
8636 if (! streq (relname
, "R_C6000_PREL31"))
8638 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8646 /* This function currently only supports ARM and TI unwinders. */
8647 warn (_("Only TI and ARM unwinders are currently supported\n"));
8651 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8652 addr
->section
= sym
->st_shndx
;
8653 addr
->offset
= offset
;
8656 * sym_name
= sym
->st_name
;
8661 arm_sec
->next_rela
= rp
;
8666 static const char *tic6x_unwind_regnames
[16] =
8668 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8669 "A14", "A13", "A12", "A11", "A10",
8670 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8674 decode_tic6x_unwind_regmask (unsigned int mask
)
8678 for (i
= 12; mask
; mask
>>= 1, i
--)
8682 fputs (tic6x_unwind_regnames
[i
], stdout
);
8684 fputs (", ", stdout
);
8690 if (remaining == 0 && more_words) \
8693 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8694 data_offset, & word, & addr, NULL)) \
8700 #define GET_OP(OP) \
8705 (OP) = word >> 24; \
8710 printf (_("[Truncated opcode]\n")); \
8713 printf ("0x%02x ", OP)
8716 decode_arm_unwind_bytecode (Filedata
* filedata
,
8717 struct arm_unw_aux_info
* aux
,
8719 unsigned int remaining
,
8720 unsigned int more_words
,
8721 bfd_vma data_offset
,
8722 Elf_Internal_Shdr
* data_sec
,
8723 struct arm_section
* data_arm_sec
)
8725 struct absaddr addr
;
8726 bfd_boolean res
= TRUE
;
8728 /* Decode the unwinding instructions. */
8731 unsigned int op
, op2
;
8740 printf (" 0x%02x ", op
);
8742 if ((op
& 0xc0) == 0x00)
8744 int offset
= ((op
& 0x3f) << 2) + 4;
8746 printf (" vsp = vsp + %d", offset
);
8748 else if ((op
& 0xc0) == 0x40)
8750 int offset
= ((op
& 0x3f) << 2) + 4;
8752 printf (" vsp = vsp - %d", offset
);
8754 else if ((op
& 0xf0) == 0x80)
8757 if (op
== 0x80 && op2
== 0)
8758 printf (_("Refuse to unwind"));
8761 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8762 bfd_boolean first
= TRUE
;
8766 for (i
= 0; i
< 12; i
++)
8767 if (mask
& (1 << i
))
8773 printf ("r%d", 4 + i
);
8778 else if ((op
& 0xf0) == 0x90)
8780 if (op
== 0x9d || op
== 0x9f)
8781 printf (_(" [Reserved]"));
8783 printf (" vsp = r%d", op
& 0x0f);
8785 else if ((op
& 0xf0) == 0xa0)
8787 int end
= 4 + (op
& 0x07);
8788 bfd_boolean first
= TRUE
;
8792 for (i
= 4; i
<= end
; i
++)
8808 else if (op
== 0xb0)
8809 printf (_(" finish"));
8810 else if (op
== 0xb1)
8813 if (op2
== 0 || (op2
& 0xf0) != 0)
8814 printf (_("[Spare]"));
8817 unsigned int mask
= op2
& 0x0f;
8818 bfd_boolean first
= TRUE
;
8822 for (i
= 0; i
< 12; i
++)
8823 if (mask
& (1 << i
))
8834 else if (op
== 0xb2)
8836 unsigned char buf
[9];
8837 unsigned int i
, len
;
8838 unsigned long offset
;
8840 for (i
= 0; i
< sizeof (buf
); i
++)
8843 if ((buf
[i
] & 0x80) == 0)
8846 if (i
== sizeof (buf
))
8848 error (_("corrupt change to vsp\n"));
8853 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8854 assert (len
== i
+ 1);
8855 offset
= offset
* 4 + 0x204;
8856 printf ("vsp = vsp + %ld", offset
);
8859 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8861 unsigned int first
, last
;
8868 printf ("pop {D%d", first
);
8870 printf ("-D%d", first
+ last
);
8873 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8875 unsigned int count
= op
& 0x07;
8879 printf ("-D%d", 8 + count
);
8882 else if (op
>= 0xc0 && op
<= 0xc5)
8884 unsigned int count
= op
& 0x07;
8886 printf (" pop {wR10");
8888 printf ("-wR%d", 10 + count
);
8891 else if (op
== 0xc6)
8893 unsigned int first
, last
;
8898 printf ("pop {wR%d", first
);
8900 printf ("-wR%d", first
+ last
);
8903 else if (op
== 0xc7)
8906 if (op2
== 0 || (op2
& 0xf0) != 0)
8907 printf (_("[Spare]"));
8910 unsigned int mask
= op2
& 0x0f;
8911 bfd_boolean first
= TRUE
;
8915 for (i
= 0; i
< 4; i
++)
8916 if (mask
& (1 << i
))
8922 printf ("wCGR%d", i
);
8929 printf (_(" [unsupported opcode]"));
8940 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8941 struct arm_unw_aux_info
* aux
,
8943 unsigned int remaining
,
8944 unsigned int more_words
,
8945 bfd_vma data_offset
,
8946 Elf_Internal_Shdr
* data_sec
,
8947 struct arm_section
* data_arm_sec
)
8949 struct absaddr addr
;
8951 /* Decode the unwinding instructions. */
8954 unsigned int op
, op2
;
8963 printf (" 0x%02x ", op
);
8965 if ((op
& 0xc0) == 0x00)
8967 int offset
= ((op
& 0x3f) << 3) + 8;
8968 printf (" sp = sp + %d", offset
);
8970 else if ((op
& 0xc0) == 0x80)
8973 if (op
== 0x80 && op2
== 0)
8974 printf (_("Refuse to unwind"));
8977 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8979 printf ("pop compact {");
8983 decode_tic6x_unwind_regmask (mask
);
8987 else if ((op
& 0xf0) == 0xc0)
8995 unsigned int offset
;
8999 /* Scan entire instruction first so that GET_OP output is not
9000 interleaved with disassembly. */
9002 for (i
= 0; nregs
< (op
& 0xf); i
++)
9008 regpos
[nregs
].offset
= i
* 2;
9009 regpos
[nregs
].reg
= reg
;
9016 regpos
[nregs
].offset
= i
* 2 + 1;
9017 regpos
[nregs
].reg
= reg
;
9022 printf (_("pop frame {"));
9025 printf (_("*corrupt* - no registers specified"));
9030 for (i
= i
* 2; i
> 0; i
--)
9032 if (regpos
[reg
].offset
== i
- 1)
9034 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9041 fputs (name
, stdout
);
9049 else if (op
== 0xd0)
9050 printf (" MOV FP, SP");
9051 else if (op
== 0xd1)
9052 printf (" __c6xabi_pop_rts");
9053 else if (op
== 0xd2)
9055 unsigned char buf
[9];
9056 unsigned int i
, len
;
9057 unsigned long offset
;
9059 for (i
= 0; i
< sizeof (buf
); i
++)
9062 if ((buf
[i
] & 0x80) == 0)
9065 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9066 if (i
== sizeof (buf
))
9068 warn (_("Corrupt stack pointer adjustment detected\n"));
9072 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9073 assert (len
== i
+ 1);
9074 offset
= offset
* 8 + 0x408;
9075 printf (_("sp = sp + %ld"), offset
);
9077 else if ((op
& 0xf0) == 0xe0)
9079 if ((op
& 0x0f) == 7)
9082 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9086 printf (_(" [unsupported opcode]"));
9095 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9099 offset
= word
& 0x7fffffff;
9100 if (offset
& 0x40000000)
9101 offset
|= ~ (bfd_vma
) 0x7fffffff;
9103 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9106 return offset
+ where
;
9110 decode_arm_unwind (Filedata
* filedata
,
9111 struct arm_unw_aux_info
* aux
,
9113 unsigned int remaining
,
9114 bfd_vma data_offset
,
9115 Elf_Internal_Shdr
* data_sec
,
9116 struct arm_section
* data_arm_sec
)
9119 unsigned int more_words
= 0;
9120 struct absaddr addr
;
9121 bfd_vma sym_name
= (bfd_vma
) -1;
9122 bfd_boolean res
= TRUE
;
9126 /* Fetch the first word.
9127 Note - when decoding an object file the address extracted
9128 here will always be 0. So we also pass in the sym_name
9129 parameter so that we can find the symbol associated with
9130 the personality routine. */
9131 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9132 & word
, & addr
, & sym_name
))
9139 addr
.section
= SHN_UNDEF
;
9143 if ((word
& 0x80000000) == 0)
9145 /* Expand prel31 for personality routine. */
9147 const char *procname
;
9149 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9150 printf (_(" Personality routine: "));
9152 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9153 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9155 procname
= aux
->strtab
+ sym_name
;
9156 print_vma (fn
, PREFIX_HEX
);
9159 fputs (" <", stdout
);
9160 fputs (procname
, stdout
);
9161 fputc ('>', stdout
);
9165 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9166 fputc ('\n', stdout
);
9168 /* The GCC personality routines use the standard compact
9169 encoding, starting with one byte giving the number of
9171 if (procname
!= NULL
9172 && (const_strneq (procname
, "__gcc_personality_v0")
9173 || const_strneq (procname
, "__gxx_personality_v0")
9174 || const_strneq (procname
, "__gcj_personality_v0")
9175 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9182 printf (_(" [Truncated data]\n"));
9185 more_words
= word
>> 24;
9195 /* ARM EHABI Section 6.3:
9197 An exception-handling table entry for the compact model looks like:
9201 1 0 index Data for personalityRoutine[index] */
9203 if (filedata
->file_header
.e_machine
== EM_ARM
9204 && (word
& 0x70000000))
9206 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9210 per_index
= (word
>> 24) & 0x7f;
9211 printf (_(" Compact model index: %d\n"), per_index
);
9218 else if (per_index
< 3)
9220 more_words
= (word
>> 16) & 0xff;
9226 switch (filedata
->file_header
.e_machine
)
9231 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9232 data_offset
, data_sec
, data_arm_sec
))
9237 warn (_("Unknown ARM compact model index encountered\n"));
9238 printf (_(" [reserved]\n"));
9246 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9247 data_offset
, data_sec
, data_arm_sec
))
9250 else if (per_index
< 5)
9252 if (((word
>> 17) & 0x7f) == 0x7f)
9253 printf (_(" Restore stack from frame pointer\n"));
9255 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9256 printf (_(" Registers restored: "));
9258 printf (" (compact) ");
9259 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9261 printf (_(" Return register: %s\n"),
9262 tic6x_unwind_regnames
[word
& 0xf]);
9265 printf (_(" [reserved (%d)]\n"), per_index
);
9269 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9270 filedata
->file_header
.e_machine
);
9274 /* Decode the descriptors. Not implemented. */
9280 dump_arm_unwind (Filedata
* filedata
,
9281 struct arm_unw_aux_info
* aux
,
9282 Elf_Internal_Shdr
* exidx_sec
)
9284 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9285 unsigned int i
, exidx_len
;
9286 unsigned long j
, nfuns
;
9287 bfd_boolean res
= TRUE
;
9289 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9290 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9291 exidx_len
= exidx_sec
->sh_size
/ 8;
9293 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9294 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9295 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9296 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9298 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9300 for (i
= 0; i
< exidx_len
; i
++)
9302 unsigned int exidx_fn
, exidx_entry
;
9303 struct absaddr fn_addr
, entry_addr
;
9306 fputc ('\n', stdout
);
9308 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9309 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9310 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9311 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9314 arm_free_section (& exidx_arm_sec
);
9315 arm_free_section (& extab_arm_sec
);
9319 /* ARM EHABI, Section 5:
9320 An index table entry consists of 2 words.
9321 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9322 if (exidx_fn
& 0x80000000)
9324 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9328 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9330 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9331 fputs (": ", stdout
);
9333 if (exidx_entry
== 1)
9335 print_vma (exidx_entry
, PREFIX_HEX
);
9336 fputs (" [cantunwind]\n", stdout
);
9338 else if (exidx_entry
& 0x80000000)
9340 print_vma (exidx_entry
, PREFIX_HEX
);
9341 fputc ('\n', stdout
);
9342 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9346 bfd_vma table
, table_offset
= 0;
9347 Elf_Internal_Shdr
*table_sec
;
9349 fputs ("@", stdout
);
9350 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9351 print_vma (table
, PREFIX_HEX
);
9354 /* Locate the matching .ARM.extab. */
9355 if (entry_addr
.section
!= SHN_UNDEF
9356 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9358 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9359 table_offset
= entry_addr
.offset
;
9361 if (table_offset
> table_sec
->sh_size
9362 || ((bfd_signed_vma
) table_offset
) < 0)
9364 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9365 (unsigned long) table_offset
,
9366 printable_section_name (filedata
, table_sec
));
9373 table_sec
= find_section_by_address (filedata
, table
);
9374 if (table_sec
!= NULL
)
9375 table_offset
= table
- table_sec
->sh_addr
;
9378 if (table_sec
== NULL
)
9380 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9381 (unsigned long) table
);
9386 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9395 arm_free_section (&exidx_arm_sec
);
9396 arm_free_section (&extab_arm_sec
);
9401 /* Used for both ARM and C6X unwinding tables. */
9404 arm_process_unwind (Filedata
* filedata
)
9406 struct arm_unw_aux_info aux
;
9407 Elf_Internal_Shdr
*unwsec
= NULL
;
9408 Elf_Internal_Shdr
*sec
;
9410 unsigned int sec_type
;
9411 bfd_boolean res
= TRUE
;
9413 switch (filedata
->file_header
.e_machine
)
9416 sec_type
= SHT_ARM_EXIDX
;
9420 sec_type
= SHT_C6000_UNWIND
;
9424 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9425 filedata
->file_header
.e_machine
);
9429 if (filedata
->string_table
== NULL
)
9432 memset (& aux
, 0, sizeof (aux
));
9433 aux
.filedata
= filedata
;
9435 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9437 if (sec
->sh_type
== SHT_SYMTAB
)
9441 error (_("Multiple symbol tables encountered\n"));
9447 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9448 &aux
.strtab
, &aux
.strtab_size
))
9451 else if (sec
->sh_type
== sec_type
)
9456 printf (_("\nThere are no unwind sections in this file.\n"));
9458 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9460 if (sec
->sh_type
== sec_type
)
9462 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9463 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9464 "contains %lu entry:\n",
9465 "\nUnwind section '%s' at offset 0x%lx "
9466 "contains %lu entries:\n",
9468 printable_section_name (filedata
, sec
),
9469 (unsigned long) sec
->sh_offset
,
9472 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9480 free ((char *) aux
.strtab
);
9486 process_unwind (Filedata
* filedata
)
9488 struct unwind_handler
9490 unsigned int machtype
;
9491 bfd_boolean (* handler
)(Filedata
*);
9494 { EM_ARM
, arm_process_unwind
},
9495 { EM_IA_64
, ia64_process_unwind
},
9496 { EM_PARISC
, hppa_process_unwind
},
9497 { EM_TI_C6000
, arm_process_unwind
},
9505 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9506 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9507 return handlers
[i
].handler (filedata
);
9509 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9510 get_machine_name (filedata
->file_header
.e_machine
));
9515 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9517 switch (entry
->d_tag
)
9519 case DT_AARCH64_BTI_PLT
:
9520 case DT_AARCH64_PAC_PLT
:
9523 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9530 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9532 switch (entry
->d_tag
)
9535 if (entry
->d_un
.d_val
== 0)
9539 static const char * opts
[] =
9541 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9542 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9543 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9544 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9548 bfd_boolean first
= TRUE
;
9550 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9551 if (entry
->d_un
.d_val
& (1 << cnt
))
9553 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9559 case DT_MIPS_IVERSION
:
9560 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9561 printf (_("Interface Version: %s"),
9562 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9566 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9567 /* Note: coded this way so that there is a single string for translation. */
9568 printf (_("<corrupt: %s>"), buf
);
9572 case DT_MIPS_TIME_STAMP
:
9576 time_t atime
= entry
->d_un
.d_val
;
9578 tmp
= gmtime (&atime
);
9579 /* PR 17531: file: 6accc532. */
9581 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9583 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9584 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9585 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9586 printf (_("Time Stamp: %s"), timebuf
);
9590 case DT_MIPS_RLD_VERSION
:
9591 case DT_MIPS_LOCAL_GOTNO
:
9592 case DT_MIPS_CONFLICTNO
:
9593 case DT_MIPS_LIBLISTNO
:
9594 case DT_MIPS_SYMTABNO
:
9595 case DT_MIPS_UNREFEXTNO
:
9596 case DT_MIPS_HIPAGENO
:
9597 case DT_MIPS_DELTA_CLASS_NO
:
9598 case DT_MIPS_DELTA_INSTANCE_NO
:
9599 case DT_MIPS_DELTA_RELOC_NO
:
9600 case DT_MIPS_DELTA_SYM_NO
:
9601 case DT_MIPS_DELTA_CLASSSYM_NO
:
9602 case DT_MIPS_COMPACT_SIZE
:
9603 print_vma (entry
->d_un
.d_val
, DEC
);
9607 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9608 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9609 /* Falls through. */
9612 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9618 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9620 switch (entry
->d_tag
)
9622 case DT_HP_DLD_FLAGS
:
9631 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9632 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9633 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9634 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9635 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9636 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9637 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9638 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9639 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9640 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9641 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9642 { DT_HP_GST
, "HP_GST" },
9643 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9644 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9645 { DT_HP_NODELETE
, "HP_NODELETE" },
9646 { DT_HP_GROUP
, "HP_GROUP" },
9647 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9649 bfd_boolean first
= TRUE
;
9651 bfd_vma val
= entry
->d_un
.d_val
;
9653 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9654 if (val
& flags
[cnt
].bit
)
9658 fputs (flags
[cnt
].str
, stdout
);
9660 val
^= flags
[cnt
].bit
;
9663 if (val
!= 0 || first
)
9667 print_vma (val
, HEX
);
9673 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9681 /* VMS vs Unix time offset and factor. */
9683 #define VMS_EPOCH_OFFSET 35067168000000000LL
9684 #define VMS_GRANULARITY_FACTOR 10000000
9686 /* Display a VMS time in a human readable format. */
9689 print_vms_time (bfd_int64_t vmstime
)
9694 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9695 tm
= gmtime (&unxtime
);
9696 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9697 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9698 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9703 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9705 switch (entry
->d_tag
)
9707 case DT_IA_64_PLT_RESERVE
:
9708 /* First 3 slots reserved. */
9709 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9711 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9714 case DT_IA_64_VMS_LINKTIME
:
9716 print_vms_time (entry
->d_un
.d_val
);
9720 case DT_IA_64_VMS_LNKFLAGS
:
9721 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9722 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9723 printf (" CALL_DEBUG");
9724 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9725 printf (" NOP0BUFS");
9726 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9727 printf (" P0IMAGE");
9728 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9729 printf (" MKTHREADS");
9730 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9731 printf (" UPCALLS");
9732 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9734 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9735 printf (" INITIALIZE");
9736 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9738 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9739 printf (" EXE_INIT");
9740 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9741 printf (" TBK_IN_IMG");
9742 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9743 printf (" DBG_IN_IMG");
9744 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9745 printf (" TBK_IN_DSF");
9746 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9747 printf (" DBG_IN_DSF");
9748 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9749 printf (" SIGNATURES");
9750 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9751 printf (" REL_SEG_OFF");
9755 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9762 get_32bit_dynamic_section (Filedata
* filedata
)
9764 Elf32_External_Dyn
* edyn
;
9765 Elf32_External_Dyn
* ext
;
9766 Elf_Internal_Dyn
* entry
;
9768 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9769 filedata
->dynamic_addr
, 1,
9770 filedata
->dynamic_size
,
9771 _("dynamic section"));
9775 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9776 might not have the luxury of section headers. Look for the DT_NULL
9777 terminator to determine the number of entries. */
9778 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9779 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9782 filedata
->dynamic_nent
++;
9783 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9787 filedata
->dynamic_section
9788 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9789 if (filedata
->dynamic_section
== NULL
)
9791 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9792 (unsigned long) filedata
->dynamic_nent
);
9797 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9798 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9801 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9802 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9811 get_64bit_dynamic_section (Filedata
* filedata
)
9813 Elf64_External_Dyn
* edyn
;
9814 Elf64_External_Dyn
* ext
;
9815 Elf_Internal_Dyn
* entry
;
9817 /* Read in the data. */
9818 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9819 filedata
->dynamic_addr
, 1,
9820 filedata
->dynamic_size
,
9821 _("dynamic section"));
9825 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9826 might not have the luxury of section headers. Look for the DT_NULL
9827 terminator to determine the number of entries. */
9828 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9829 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9830 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9833 filedata
->dynamic_nent
++;
9834 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9838 filedata
->dynamic_section
9839 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9840 if (filedata
->dynamic_section
== NULL
)
9842 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9843 (unsigned long) filedata
->dynamic_nent
);
9848 /* Convert from external to internal formats. */
9849 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9850 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9853 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9854 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9863 print_dynamic_flags (bfd_vma flags
)
9865 bfd_boolean first
= TRUE
;
9871 flag
= flags
& - flags
;
9881 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9882 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9883 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9884 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9885 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9886 default: fputs (_("unknown"), stdout
); break;
9893 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9895 unsigned char * e_data
;
9898 /* If the size_t type is smaller than the bfd_size_type, eg because
9899 you are building a 32-bit tool on a 64-bit host, then make sure
9900 that when (number) is cast to (size_t) no information is lost. */
9901 if (sizeof (size_t) < sizeof (bfd_size_type
)
9902 && (bfd_size_type
) ((size_t) number
) != number
)
9904 error (_("Size truncation prevents reading %s elements of size %u\n"),
9905 bfd_vmatoa ("u", number
), ent_size
);
9909 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9910 attempting to allocate memory when the read is bound to fail. */
9911 if (ent_size
* number
> filedata
->file_size
)
9913 error (_("Invalid number of dynamic entries: %s\n"),
9914 bfd_vmatoa ("u", number
));
9918 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9921 error (_("Out of memory reading %s dynamic entries\n"),
9922 bfd_vmatoa ("u", number
));
9926 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9928 error (_("Unable to read in %s bytes of dynamic data\n"),
9929 bfd_vmatoa ("u", number
* ent_size
));
9934 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
9937 error (_("Out of memory allocating space for %s dynamic entries\n"),
9938 bfd_vmatoa ("u", number
));
9944 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9951 static unsigned long
9952 get_num_dynamic_syms (Filedata
* filedata
)
9954 unsigned long num_of_syms
= 0;
9956 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
9959 if (filedata
->dynamic_info
[DT_HASH
])
9961 unsigned char nb
[8];
9962 unsigned char nc
[8];
9963 unsigned int hash_ent_size
= 4;
9965 if ((filedata
->file_header
.e_machine
== EM_ALPHA
9966 || filedata
->file_header
.e_machine
== EM_S390
9967 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
9968 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9971 if (fseek (filedata
->handle
,
9972 (filedata
->archive_file_offset
9973 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
9974 sizeof nb
+ sizeof nc
)),
9977 error (_("Unable to seek to start of dynamic information\n"));
9981 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
9983 error (_("Failed to read in number of buckets\n"));
9987 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
9989 error (_("Failed to read in number of chains\n"));
9993 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
9994 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
9996 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
9998 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10001 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10002 num_of_syms
= filedata
->nchains
;
10005 if (num_of_syms
== 0)
10007 if (filedata
->buckets
)
10009 free (filedata
->buckets
);
10010 filedata
->buckets
= NULL
;
10012 if (filedata
->chains
)
10014 free (filedata
->chains
);
10015 filedata
->chains
= NULL
;
10017 filedata
->nbuckets
= 0;
10021 if (filedata
->dynamic_info_DT_GNU_HASH
)
10023 unsigned char nb
[16];
10024 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10025 bfd_vma buckets_vma
;
10027 bfd_boolean gnu_hash_error
= FALSE
;
10029 if (fseek (filedata
->handle
,
10030 (filedata
->archive_file_offset
10031 + offset_from_vma (filedata
,
10032 filedata
->dynamic_info_DT_GNU_HASH
,
10036 error (_("Unable to seek to start of dynamic information\n"));
10037 gnu_hash_error
= TRUE
;
10041 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10043 error (_("Failed to read in number of buckets\n"));
10044 gnu_hash_error
= TRUE
;
10048 filedata
->ngnubuckets
= byte_get (nb
, 4);
10049 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10050 bitmaskwords
= byte_get (nb
+ 8, 4);
10051 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10053 buckets_vma
+= bitmaskwords
* 4;
10055 buckets_vma
+= bitmaskwords
* 8;
10057 if (fseek (filedata
->handle
,
10058 (filedata
->archive_file_offset
10059 + offset_from_vma (filedata
, buckets_vma
, 4)),
10062 error (_("Unable to seek to start of dynamic information\n"));
10063 gnu_hash_error
= TRUE
;
10067 filedata
->gnubuckets
10068 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10070 if (filedata
->gnubuckets
== NULL
)
10072 gnu_hash_error
= TRUE
;
10076 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10077 if (filedata
->gnubuckets
[i
] != 0)
10079 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10081 gnu_hash_error
= TRUE
;
10085 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10086 maxchain
= filedata
->gnubuckets
[i
];
10089 if (maxchain
== 0xffffffff)
10091 gnu_hash_error
= TRUE
;
10095 maxchain
-= filedata
->gnusymidx
;
10097 if (fseek (filedata
->handle
,
10098 (filedata
->archive_file_offset
10099 + offset_from_vma (filedata
,
10100 buckets_vma
+ 4 * (filedata
->ngnubuckets
10105 error (_("Unable to seek to start of dynamic information\n"));
10106 gnu_hash_error
= TRUE
;
10112 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10114 error (_("Failed to determine last chain length\n"));
10115 gnu_hash_error
= TRUE
;
10119 if (maxchain
+ 1 == 0)
10121 gnu_hash_error
= TRUE
;
10127 while ((byte_get (nb
, 4) & 1) == 0);
10129 if (fseek (filedata
->handle
,
10130 (filedata
->archive_file_offset
10131 + offset_from_vma (filedata
, (buckets_vma
10132 + 4 * filedata
->ngnubuckets
),
10136 error (_("Unable to seek to start of dynamic information\n"));
10137 gnu_hash_error
= TRUE
;
10141 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10142 filedata
->ngnuchains
= maxchain
;
10144 if (filedata
->gnuchains
== NULL
)
10146 gnu_hash_error
= TRUE
;
10150 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10152 if (fseek (filedata
->handle
,
10153 (filedata
->archive_file_offset
10154 + offset_from_vma (filedata
, (buckets_vma
10155 + 4 * (filedata
->ngnubuckets
10159 error (_("Unable to seek to start of dynamic information\n"));
10160 gnu_hash_error
= TRUE
;
10164 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10167 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10168 if (filedata
->gnubuckets
[hn
] != 0)
10170 bfd_vma si
= filedata
->gnubuckets
[hn
];
10171 bfd_vma off
= si
- filedata
->gnusymidx
;
10175 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10177 if (filedata
->mipsxlat
[off
] >= num_of_syms
)
10178 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10182 if (si
>= num_of_syms
)
10183 num_of_syms
= si
+ 1;
10187 while (off
< filedata
->ngnuchains
10188 && (filedata
->gnuchains
[off
++] & 1) == 0);
10192 if (gnu_hash_error
)
10194 if (filedata
->mipsxlat
)
10196 free (filedata
->mipsxlat
);
10197 filedata
->mipsxlat
= NULL
;
10199 if (filedata
->gnuchains
)
10201 free (filedata
->gnuchains
);
10202 filedata
->gnuchains
= NULL
;
10204 if (filedata
->gnubuckets
)
10206 free (filedata
->gnubuckets
);
10207 filedata
->gnubuckets
= NULL
;
10209 filedata
->ngnubuckets
= 0;
10210 filedata
->ngnuchains
= 0;
10214 return num_of_syms
;
10217 /* Parse and display the contents of the dynamic section. */
10220 process_dynamic_section (Filedata
* filedata
)
10222 Elf_Internal_Dyn
* entry
;
10224 if (filedata
->dynamic_size
== 0)
10227 printf (_("\nThere is no dynamic section in this file.\n"));
10234 if (! get_32bit_dynamic_section (filedata
))
10239 if (! get_64bit_dynamic_section (filedata
))
10243 /* Find the appropriate symbol table. */
10244 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10246 for (entry
= filedata
->dynamic_section
;
10247 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10249 if (entry
->d_tag
== DT_SYMTAB
)
10250 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10251 else if (entry
->d_tag
== DT_SYMENT
)
10252 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10253 else if (entry
->d_tag
== DT_HASH
)
10254 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10255 else if (entry
->d_tag
== DT_GNU_HASH
)
10256 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10257 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10258 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10259 && entry
->d_tag
== DT_MIPS_XHASH
)
10261 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10262 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10265 if (filedata
->dynamic_info
[DT_SYMTAB
]
10266 && filedata
->dynamic_info
[DT_SYMENT
])
10268 Elf_Internal_Phdr
*seg
;
10269 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10271 if (! get_program_headers (filedata
))
10273 error (_("Cannot interpret virtual addresses without program headers.\n"));
10277 for (seg
= filedata
->program_headers
;
10278 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10281 unsigned long num_of_syms
;
10283 if (seg
->p_type
!= PT_LOAD
)
10286 if ((seg
->p_offset
+ seg
->p_filesz
)
10287 > filedata
->file_size
)
10289 /* See PR 21379 for a reproducer. */
10290 error (_("Invalid PT_LOAD entry\n"));
10294 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10295 && vma
<= seg
->p_vaddr
+ seg
->p_filesz
10296 && (num_of_syms
= get_num_dynamic_syms (filedata
)) != 0
10297 && filedata
->dynamic_symbols
== NULL
)
10299 /* Since we do not know how big the symbol table is,
10300 we default to reading in up to the end of PT_LOAD
10301 segment and processing that. This is overkill, I
10302 know, but it should work. */
10303 Elf_Internal_Shdr section
;
10304 section
.sh_offset
= (vma
- seg
->p_vaddr
10306 section
.sh_size
= (num_of_syms
10307 * filedata
->dynamic_info
[DT_SYMENT
]);
10308 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10309 section
.sh_name
= filedata
->string_table_length
;
10310 filedata
->dynamic_symbols
10311 = GET_ELF_SYMBOLS (filedata
, §ion
,
10312 &filedata
->num_dynamic_syms
);
10313 if (filedata
->dynamic_symbols
== NULL
10314 || filedata
->num_dynamic_syms
!= num_of_syms
)
10316 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10324 /* Similarly find a string table. */
10325 if (filedata
->dynamic_strings
== NULL
)
10326 for (entry
= filedata
->dynamic_section
;
10327 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10330 if (entry
->d_tag
== DT_STRTAB
)
10331 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10333 if (entry
->d_tag
== DT_STRSZ
)
10334 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10336 if (filedata
->dynamic_info
[DT_STRTAB
]
10337 && filedata
->dynamic_info
[DT_STRSZ
])
10339 unsigned long offset
;
10340 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10342 offset
= offset_from_vma (filedata
,
10343 filedata
->dynamic_info
[DT_STRTAB
],
10345 filedata
->dynamic_strings
10346 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10347 _("dynamic string table"));
10348 if (filedata
->dynamic_strings
== NULL
)
10350 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10354 filedata
->dynamic_strings_length
= str_tab_len
;
10359 /* And find the syminfo section if available. */
10360 if (filedata
->dynamic_syminfo
== NULL
)
10362 unsigned long syminsz
= 0;
10364 for (entry
= filedata
->dynamic_section
;
10365 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10368 if (entry
->d_tag
== DT_SYMINENT
)
10370 /* Note: these braces are necessary to avoid a syntax
10371 error from the SunOS4 C compiler. */
10372 /* PR binutils/17531: A corrupt file can trigger this test.
10373 So do not use an assert, instead generate an error message. */
10374 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10375 error (_("Bad value (%d) for SYMINENT entry\n"),
10376 (int) entry
->d_un
.d_val
);
10378 else if (entry
->d_tag
== DT_SYMINSZ
)
10379 syminsz
= entry
->d_un
.d_val
;
10380 else if (entry
->d_tag
== DT_SYMINFO
)
10381 filedata
->dynamic_syminfo_offset
10382 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10385 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10387 Elf_External_Syminfo
* extsyminfo
;
10388 Elf_External_Syminfo
* extsym
;
10389 Elf_Internal_Syminfo
* syminfo
;
10391 /* There is a syminfo section. Read the data. */
10392 extsyminfo
= (Elf_External_Syminfo
*)
10393 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10394 1, syminsz
, _("symbol information"));
10398 if (filedata
->dynamic_syminfo
!= NULL
)
10400 error (_("Multiple dynamic symbol information sections found\n"));
10401 free (filedata
->dynamic_syminfo
);
10403 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10404 if (filedata
->dynamic_syminfo
== NULL
)
10406 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10407 (unsigned long) syminsz
);
10411 filedata
->dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10412 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10413 syminfo
< filedata
->dynamic_syminfo
+ filedata
->dynamic_syminfo_nent
;
10414 ++syminfo
, ++extsym
)
10416 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10417 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10424 if (do_dynamic
&& filedata
->dynamic_addr
)
10425 printf (ngettext ("\nDynamic section at offset 0x%lx "
10426 "contains %lu entry:\n",
10427 "\nDynamic section at offset 0x%lx "
10428 "contains %lu entries:\n",
10429 filedata
->dynamic_nent
),
10430 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10432 printf (_(" Tag Type Name/Value\n"));
10434 for (entry
= filedata
->dynamic_section
;
10435 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10440 const char * dtype
;
10443 print_vma (entry
->d_tag
, FULL_HEX
);
10444 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10445 printf (" (%s)%*s", dtype
,
10446 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10449 switch (entry
->d_tag
)
10453 print_dynamic_flags (entry
->d_un
.d_val
);
10463 switch (entry
->d_tag
)
10466 printf (_("Auxiliary library"));
10470 printf (_("Filter library"));
10474 printf (_("Configuration file"));
10478 printf (_("Dependency audit library"));
10482 printf (_("Audit library"));
10486 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10487 printf (": [%s]\n",
10488 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10492 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10501 printf (_("Flags:"));
10503 if (entry
->d_un
.d_val
== 0)
10504 printf (_(" None\n"));
10507 unsigned long int val
= entry
->d_un
.d_val
;
10509 if (val
& DTF_1_PARINIT
)
10511 printf (" PARINIT");
10512 val
^= DTF_1_PARINIT
;
10514 if (val
& DTF_1_CONFEXP
)
10516 printf (" CONFEXP");
10517 val
^= DTF_1_CONFEXP
;
10520 printf (" %lx", val
);
10529 printf (_("Flags:"));
10531 if (entry
->d_un
.d_val
== 0)
10532 printf (_(" None\n"));
10535 unsigned long int val
= entry
->d_un
.d_val
;
10537 if (val
& DF_P1_LAZYLOAD
)
10539 printf (" LAZYLOAD");
10540 val
^= DF_P1_LAZYLOAD
;
10542 if (val
& DF_P1_GROUPPERM
)
10544 printf (" GROUPPERM");
10545 val
^= DF_P1_GROUPPERM
;
10548 printf (" %lx", val
);
10557 printf (_("Flags:"));
10558 if (entry
->d_un
.d_val
== 0)
10559 printf (_(" None\n"));
10562 unsigned long int val
= entry
->d_un
.d_val
;
10564 if (val
& DF_1_NOW
)
10569 if (val
& DF_1_GLOBAL
)
10571 printf (" GLOBAL");
10572 val
^= DF_1_GLOBAL
;
10574 if (val
& DF_1_GROUP
)
10579 if (val
& DF_1_NODELETE
)
10581 printf (" NODELETE");
10582 val
^= DF_1_NODELETE
;
10584 if (val
& DF_1_LOADFLTR
)
10586 printf (" LOADFLTR");
10587 val
^= DF_1_LOADFLTR
;
10589 if (val
& DF_1_INITFIRST
)
10591 printf (" INITFIRST");
10592 val
^= DF_1_INITFIRST
;
10594 if (val
& DF_1_NOOPEN
)
10596 printf (" NOOPEN");
10597 val
^= DF_1_NOOPEN
;
10599 if (val
& DF_1_ORIGIN
)
10601 printf (" ORIGIN");
10602 val
^= DF_1_ORIGIN
;
10604 if (val
& DF_1_DIRECT
)
10606 printf (" DIRECT");
10607 val
^= DF_1_DIRECT
;
10609 if (val
& DF_1_TRANS
)
10614 if (val
& DF_1_INTERPOSE
)
10616 printf (" INTERPOSE");
10617 val
^= DF_1_INTERPOSE
;
10619 if (val
& DF_1_NODEFLIB
)
10621 printf (" NODEFLIB");
10622 val
^= DF_1_NODEFLIB
;
10624 if (val
& DF_1_NODUMP
)
10626 printf (" NODUMP");
10627 val
^= DF_1_NODUMP
;
10629 if (val
& DF_1_CONFALT
)
10631 printf (" CONFALT");
10632 val
^= DF_1_CONFALT
;
10634 if (val
& DF_1_ENDFILTEE
)
10636 printf (" ENDFILTEE");
10637 val
^= DF_1_ENDFILTEE
;
10639 if (val
& DF_1_DISPRELDNE
)
10641 printf (" DISPRELDNE");
10642 val
^= DF_1_DISPRELDNE
;
10644 if (val
& DF_1_DISPRELPND
)
10646 printf (" DISPRELPND");
10647 val
^= DF_1_DISPRELPND
;
10649 if (val
& DF_1_NODIRECT
)
10651 printf (" NODIRECT");
10652 val
^= DF_1_NODIRECT
;
10654 if (val
& DF_1_IGNMULDEF
)
10656 printf (" IGNMULDEF");
10657 val
^= DF_1_IGNMULDEF
;
10659 if (val
& DF_1_NOKSYMS
)
10661 printf (" NOKSYMS");
10662 val
^= DF_1_NOKSYMS
;
10664 if (val
& DF_1_NOHDR
)
10669 if (val
& DF_1_EDITED
)
10671 printf (" EDITED");
10672 val
^= DF_1_EDITED
;
10674 if (val
& DF_1_NORELOC
)
10676 printf (" NORELOC");
10677 val
^= DF_1_NORELOC
;
10679 if (val
& DF_1_SYMINTPOSE
)
10681 printf (" SYMINTPOSE");
10682 val
^= DF_1_SYMINTPOSE
;
10684 if (val
& DF_1_GLOBAUDIT
)
10686 printf (" GLOBAUDIT");
10687 val
^= DF_1_GLOBAUDIT
;
10689 if (val
& DF_1_SINGLETON
)
10691 printf (" SINGLETON");
10692 val
^= DF_1_SINGLETON
;
10694 if (val
& DF_1_STUB
)
10699 if (val
& DF_1_PIE
)
10704 if (val
& DF_1_KMOD
)
10709 if (val
& DF_1_WEAKFILTER
)
10711 printf (" WEAKFILTER");
10712 val
^= DF_1_WEAKFILTER
;
10714 if (val
& DF_1_NOCOMMON
)
10716 printf (" NOCOMMON");
10717 val
^= DF_1_NOCOMMON
;
10720 printf (" %lx", val
);
10727 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10729 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10749 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10755 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10756 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10762 switch (entry
->d_tag
)
10765 printf (_("Shared library: [%s]"), name
);
10767 if (streq (name
, filedata
->program_interpreter
))
10768 printf (_(" program interpreter"));
10772 printf (_("Library soname: [%s]"), name
);
10776 printf (_("Library rpath: [%s]"), name
);
10780 printf (_("Library runpath: [%s]"), name
);
10784 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10789 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10802 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10803 /* Fall through. */
10807 case DT_INIT_ARRAYSZ
:
10808 case DT_FINI_ARRAYSZ
:
10809 case DT_GNU_CONFLICTSZ
:
10810 case DT_GNU_LIBLISTSZ
:
10813 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10814 printf (_(" (bytes)\n"));
10819 case DT_VERNEEDNUM
:
10824 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10833 case DT_INIT_ARRAY
:
10834 case DT_FINI_ARRAY
:
10837 if (entry
->d_tag
== DT_USED
10838 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10840 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10844 printf (_("Not needed object: [%s]\n"), name
);
10849 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10855 /* The value of this entry is ignored. */
10860 case DT_GNU_PRELINKED
:
10864 time_t atime
= entry
->d_un
.d_val
;
10866 tmp
= gmtime (&atime
);
10867 /* PR 17533 file: 041-1244816-0.004. */
10869 printf (_("<corrupt time val: %lx"),
10870 (unsigned long) atime
);
10872 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10873 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10874 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10880 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10883 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10889 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10890 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10891 = entry
->d_un
.d_val
;
10895 switch (filedata
->file_header
.e_machine
)
10898 dynamic_section_aarch64_val (entry
);
10901 case EM_MIPS_RS3_LE
:
10902 dynamic_section_mips_val (filedata
, entry
);
10905 dynamic_section_parisc_val (entry
);
10908 dynamic_section_ia64_val (entry
);
10911 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10923 get_ver_flags (unsigned int flags
)
10925 static char buff
[128];
10932 if (flags
& VER_FLG_BASE
)
10933 strcat (buff
, "BASE");
10935 if (flags
& VER_FLG_WEAK
)
10937 if (flags
& VER_FLG_BASE
)
10938 strcat (buff
, " | ");
10940 strcat (buff
, "WEAK");
10943 if (flags
& VER_FLG_INFO
)
10945 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10946 strcat (buff
, " | ");
10948 strcat (buff
, "INFO");
10951 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10953 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10954 strcat (buff
, " | ");
10956 strcat (buff
, _("<unknown>"));
10962 /* Display the contents of the version sections. */
10965 process_version_sections (Filedata
* filedata
)
10967 Elf_Internal_Shdr
* section
;
10969 bfd_boolean found
= FALSE
;
10974 for (i
= 0, section
= filedata
->section_headers
;
10975 i
< filedata
->file_header
.e_shnum
;
10978 switch (section
->sh_type
)
10980 case SHT_GNU_verdef
:
10982 Elf_External_Verdef
* edefs
;
10989 printf (ngettext ("\nVersion definition section '%s' "
10990 "contains %u entry:\n",
10991 "\nVersion definition section '%s' "
10992 "contains %u entries:\n",
10994 printable_section_name (filedata
, section
),
10997 printf (_(" Addr: 0x"));
10998 printf_vma (section
->sh_addr
);
10999 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11000 (unsigned long) section
->sh_offset
, section
->sh_link
,
11001 printable_section_name_from_index (filedata
, section
->sh_link
));
11003 edefs
= (Elf_External_Verdef
*)
11004 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11005 _("version definition section"));
11008 endbuf
= (char *) edefs
+ section
->sh_size
;
11010 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11013 Elf_External_Verdef
* edef
;
11014 Elf_Internal_Verdef ent
;
11015 Elf_External_Verdaux
* eaux
;
11016 Elf_Internal_Verdaux aux
;
11017 unsigned long isum
;
11020 vstart
= ((char *) edefs
) + idx
;
11021 if (vstart
+ sizeof (*edef
) > endbuf
)
11024 edef
= (Elf_External_Verdef
*) vstart
;
11026 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11027 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11028 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11029 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11030 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11031 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11032 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11034 printf (_(" %#06lx: Rev: %d Flags: %s"),
11035 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11037 printf (_(" Index: %d Cnt: %d "),
11038 ent
.vd_ndx
, ent
.vd_cnt
);
11040 /* Check for overflow. */
11041 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11044 vstart
+= ent
.vd_aux
;
11046 if (vstart
+ sizeof (*eaux
) > endbuf
)
11048 eaux
= (Elf_External_Verdaux
*) vstart
;
11050 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11051 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11053 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11054 printf (_("Name: %s\n"),
11055 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11057 printf (_("Name index: %ld\n"), aux
.vda_name
);
11059 isum
= idx
+ ent
.vd_aux
;
11061 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11063 if (aux
.vda_next
< sizeof (*eaux
)
11064 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11066 warn (_("Invalid vda_next field of %lx\n"),
11071 /* Check for overflow. */
11072 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11075 isum
+= aux
.vda_next
;
11076 vstart
+= aux
.vda_next
;
11078 if (vstart
+ sizeof (*eaux
) > endbuf
)
11080 eaux
= (Elf_External_Verdaux
*) vstart
;
11082 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11083 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11085 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11086 printf (_(" %#06lx: Parent %d: %s\n"),
11088 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11090 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11091 isum
, j
, aux
.vda_name
);
11094 if (j
< ent
.vd_cnt
)
11095 printf (_(" Version def aux past end of section\n"));
11098 file: id:000001,src:000172+005151,op:splice,rep:2. */
11099 if (ent
.vd_next
< sizeof (*edef
)
11100 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11102 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11103 cnt
= section
->sh_info
;
11106 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11109 idx
+= ent
.vd_next
;
11112 if (cnt
< section
->sh_info
)
11113 printf (_(" Version definition past end of section\n"));
11119 case SHT_GNU_verneed
:
11121 Elf_External_Verneed
* eneed
;
11128 printf (ngettext ("\nVersion needs section '%s' "
11129 "contains %u entry:\n",
11130 "\nVersion needs section '%s' "
11131 "contains %u entries:\n",
11133 printable_section_name (filedata
, section
), section
->sh_info
);
11135 printf (_(" Addr: 0x"));
11136 printf_vma (section
->sh_addr
);
11137 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11138 (unsigned long) section
->sh_offset
, section
->sh_link
,
11139 printable_section_name_from_index (filedata
, section
->sh_link
));
11141 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11142 section
->sh_offset
, 1,
11144 _("Version Needs section"));
11147 endbuf
= (char *) eneed
+ section
->sh_size
;
11149 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11151 Elf_External_Verneed
* entry
;
11152 Elf_Internal_Verneed ent
;
11153 unsigned long isum
;
11157 vstart
= ((char *) eneed
) + idx
;
11158 if (vstart
+ sizeof (*entry
) > endbuf
)
11161 entry
= (Elf_External_Verneed
*) vstart
;
11163 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11164 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11165 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11166 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11167 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11169 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11171 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11172 printf (_(" File: %s"),
11173 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11175 printf (_(" File: %lx"), ent
.vn_file
);
11177 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11179 /* Check for overflow. */
11180 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11182 vstart
+= ent
.vn_aux
;
11184 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11186 Elf_External_Vernaux
* eaux
;
11187 Elf_Internal_Vernaux aux
;
11189 if (vstart
+ sizeof (*eaux
) > endbuf
)
11191 eaux
= (Elf_External_Vernaux
*) vstart
;
11193 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11194 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11195 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11196 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11197 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11199 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11200 printf (_(" %#06lx: Name: %s"),
11201 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11203 printf (_(" %#06lx: Name index: %lx"),
11204 isum
, aux
.vna_name
);
11206 printf (_(" Flags: %s Version: %d\n"),
11207 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11209 if (aux
.vna_next
< sizeof (*eaux
)
11210 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11212 warn (_("Invalid vna_next field of %lx\n"),
11217 /* Check for overflow. */
11218 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11220 isum
+= aux
.vna_next
;
11221 vstart
+= aux
.vna_next
;
11224 if (j
< ent
.vn_cnt
)
11225 warn (_("Missing Version Needs auxillary information\n"));
11227 if (ent
.vn_next
< sizeof (*entry
)
11228 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11230 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11231 cnt
= section
->sh_info
;
11234 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11236 idx
+= ent
.vn_next
;
11239 if (cnt
< section
->sh_info
)
11240 warn (_("Missing Version Needs information\n"));
11246 case SHT_GNU_versym
:
11248 Elf_Internal_Shdr
* link_section
;
11251 unsigned char * edata
;
11252 unsigned short * data
;
11254 Elf_Internal_Sym
* symbols
;
11255 Elf_Internal_Shdr
* string_sec
;
11256 unsigned long num_syms
;
11259 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11262 link_section
= filedata
->section_headers
+ section
->sh_link
;
11263 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11265 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11270 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11271 if (symbols
== NULL
)
11274 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11276 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11277 string_sec
->sh_size
,
11278 _("version string table"));
11285 printf (ngettext ("\nVersion symbols section '%s' "
11286 "contains %lu entry:\n",
11287 "\nVersion symbols section '%s' "
11288 "contains %lu entries:\n",
11290 printable_section_name (filedata
, section
), (unsigned long) total
);
11292 printf (_(" Addr: 0x"));
11293 printf_vma (section
->sh_addr
);
11294 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11295 (unsigned long) section
->sh_offset
, section
->sh_link
,
11296 printable_section_name (filedata
, link_section
));
11298 off
= offset_from_vma (filedata
,
11299 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11300 total
* sizeof (short));
11301 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11302 sizeof (short), total
,
11303 _("version symbol data"));
11311 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11313 for (cnt
= total
; cnt
--;)
11314 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11319 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11323 char *invalid
= _("*invalid*");
11325 printf (" %03x:", cnt
);
11327 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11328 switch (data
[cnt
+ j
])
11331 fputs (_(" 0 (*local*) "), stdout
);
11335 fputs (_(" 1 (*global*) "), stdout
);
11339 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11340 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11342 /* If this index value is greater than the size of the symbols
11343 array, break to avoid an out-of-bounds read. */
11344 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11346 warn (_("invalid index into symbol array\n"));
11351 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11353 Elf_Internal_Verneed ivn
;
11354 unsigned long offset
;
11356 offset
= offset_from_vma
11358 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11359 sizeof (Elf_External_Verneed
));
11363 Elf_Internal_Vernaux ivna
;
11364 Elf_External_Verneed evn
;
11365 Elf_External_Vernaux evna
;
11366 unsigned long a_off
;
11368 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11369 _("version need")) == NULL
)
11372 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11373 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11375 a_off
= offset
+ ivn
.vn_aux
;
11379 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11380 1, _("version need aux (2)")) == NULL
)
11383 ivna
.vna_other
= 0;
11387 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11388 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11391 a_off
+= ivna
.vna_next
;
11393 while (ivna
.vna_other
!= data
[cnt
+ j
]
11394 && ivna
.vna_next
!= 0);
11396 if (ivna
.vna_other
== data
[cnt
+ j
])
11398 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11400 if (ivna
.vna_name
>= string_sec
->sh_size
)
11403 name
= strtab
+ ivna
.vna_name
;
11407 offset
+= ivn
.vn_next
;
11409 while (ivn
.vn_next
);
11412 if (data
[cnt
+ j
] != 0x8001
11413 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11415 Elf_Internal_Verdef ivd
;
11416 Elf_External_Verdef evd
;
11417 unsigned long offset
;
11419 offset
= offset_from_vma
11421 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11426 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11427 _("version def")) == NULL
)
11430 /* PR 17531: file: 046-1082287-0.004. */
11431 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11436 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11437 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11440 offset
+= ivd
.vd_next
;
11442 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11443 && ivd
.vd_next
!= 0);
11445 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11447 Elf_External_Verdaux evda
;
11448 Elf_Internal_Verdaux ivda
;
11450 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11452 if (get_data (&evda
, filedata
,
11453 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11455 _("version def aux")) == NULL
)
11458 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11460 if (ivda
.vda_name
>= string_sec
->sh_size
)
11462 else if (name
!= NULL
&& name
!= invalid
)
11463 name
= _("*both*");
11465 name
= strtab
+ ivda
.vda_name
;
11469 nn
+= printf ("(%s%-*s",
11471 12 - (int) strlen (name
),
11475 printf ("%*c", 18 - nn
, ' ');
11493 printf (_("\nNo version information found in this file.\n"));
11498 static const char *
11499 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11501 static char buff
[64];
11505 case STB_LOCAL
: return "LOCAL";
11506 case STB_GLOBAL
: return "GLOBAL";
11507 case STB_WEAK
: return "WEAK";
11509 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11510 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11512 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11514 if (binding
== STB_GNU_UNIQUE
11515 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11517 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11520 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11525 static const char *
11526 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11528 static char buff
[64];
11532 case STT_NOTYPE
: return "NOTYPE";
11533 case STT_OBJECT
: return "OBJECT";
11534 case STT_FUNC
: return "FUNC";
11535 case STT_SECTION
: return "SECTION";
11536 case STT_FILE
: return "FILE";
11537 case STT_COMMON
: return "COMMON";
11538 case STT_TLS
: return "TLS";
11539 case STT_RELC
: return "RELC";
11540 case STT_SRELC
: return "SRELC";
11542 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11544 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11545 return "THUMB_FUNC";
11547 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11550 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11551 return "PARISC_MILLI";
11553 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11555 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11557 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11559 if (type
== STT_HP_OPAQUE
)
11560 return "HP_OPAQUE";
11561 if (type
== STT_HP_STUB
)
11565 if (type
== STT_GNU_IFUNC
11566 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11567 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11570 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11573 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11578 static const char *
11579 get_symbol_visibility (unsigned int visibility
)
11581 switch (visibility
)
11583 case STV_DEFAULT
: return "DEFAULT";
11584 case STV_INTERNAL
: return "INTERNAL";
11585 case STV_HIDDEN
: return "HIDDEN";
11586 case STV_PROTECTED
: return "PROTECTED";
11588 error (_("Unrecognized visibility value: %u\n"), visibility
);
11589 return _("<unknown>");
11593 static const char *
11594 get_alpha_symbol_other (unsigned int other
)
11598 case STO_ALPHA_NOPV
: return "NOPV";
11599 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11601 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11602 return _("<unknown>");
11606 static const char *
11607 get_solaris_symbol_visibility (unsigned int visibility
)
11609 switch (visibility
)
11611 case 4: return "EXPORTED";
11612 case 5: return "SINGLETON";
11613 case 6: return "ELIMINATE";
11614 default: return get_symbol_visibility (visibility
);
11618 static const char *
11619 get_aarch64_symbol_other (unsigned int other
)
11621 static char buf
[32];
11623 if (other
& STO_AARCH64_VARIANT_PCS
)
11625 other
&= ~STO_AARCH64_VARIANT_PCS
;
11627 return "VARIANT_PCS";
11628 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11634 static const char *
11635 get_mips_symbol_other (unsigned int other
)
11639 case STO_OPTIONAL
: return "OPTIONAL";
11640 case STO_MIPS_PLT
: return "MIPS PLT";
11641 case STO_MIPS_PIC
: return "MIPS PIC";
11642 case STO_MICROMIPS
: return "MICROMIPS";
11643 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11644 case STO_MIPS16
: return "MIPS16";
11645 default: return NULL
;
11649 static const char *
11650 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11652 if (is_ia64_vms (filedata
))
11654 static char res
[32];
11658 /* Function types is for images and .STB files only. */
11659 switch (filedata
->file_header
.e_type
)
11663 switch (VMS_ST_FUNC_TYPE (other
))
11665 case VMS_SFT_CODE_ADDR
:
11666 strcat (res
, " CA");
11668 case VMS_SFT_SYMV_IDX
:
11669 strcat (res
, " VEC");
11672 strcat (res
, " FD");
11674 case VMS_SFT_RESERVE
:
11675 strcat (res
, " RSV");
11678 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11679 VMS_ST_FUNC_TYPE (other
));
11680 strcat (res
, " <unknown>");
11687 switch (VMS_ST_LINKAGE (other
))
11689 case VMS_STL_IGNORE
:
11690 strcat (res
, " IGN");
11692 case VMS_STL_RESERVE
:
11693 strcat (res
, " RSV");
11696 strcat (res
, " STD");
11699 strcat (res
, " LNK");
11702 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11703 VMS_ST_LINKAGE (other
));
11704 strcat (res
, " <unknown>");
11716 static const char *
11717 get_ppc64_symbol_other (unsigned int other
)
11719 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11722 other
>>= STO_PPC64_LOCAL_BIT
;
11725 static char buf
[64];
11727 other
= ppc64_decode_local_entry (other
);
11728 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11734 static const char *
11735 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11737 const char * result
= NULL
;
11738 static char buff
[64];
11743 switch (filedata
->file_header
.e_machine
)
11746 result
= get_alpha_symbol_other (other
);
11749 result
= get_aarch64_symbol_other (other
);
11752 result
= get_mips_symbol_other (other
);
11755 result
= get_ia64_symbol_other (filedata
, other
);
11758 result
= get_ppc64_symbol_other (other
);
11768 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11772 static const char *
11773 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11775 static char buff
[32];
11779 case SHN_UNDEF
: return "UND";
11780 case SHN_ABS
: return "ABS";
11781 case SHN_COMMON
: return "COM";
11783 if (type
== SHN_IA_64_ANSI_COMMON
11784 && filedata
->file_header
.e_machine
== EM_IA_64
11785 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11787 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11788 || filedata
->file_header
.e_machine
== EM_L1OM
11789 || filedata
->file_header
.e_machine
== EM_K1OM
)
11790 && type
== SHN_X86_64_LCOMMON
)
11791 return "LARGE_COM";
11792 else if ((type
== SHN_MIPS_SCOMMON
11793 && filedata
->file_header
.e_machine
== EM_MIPS
)
11794 || (type
== SHN_TIC6X_SCOMMON
11795 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11797 else if (type
== SHN_MIPS_SUNDEFINED
11798 && filedata
->file_header
.e_machine
== EM_MIPS
)
11800 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11801 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11802 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11803 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11804 else if (type
>= SHN_LORESERVE
)
11805 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11806 else if (filedata
->file_header
.e_shnum
!= 0
11807 && type
>= filedata
->file_header
.e_shnum
)
11808 sprintf (buff
, _("bad section index[%3d]"), type
);
11810 sprintf (buff
, "%3d", type
);
11817 static const char *
11818 get_symbol_version_string (Filedata
* filedata
,
11819 bfd_boolean is_dynsym
,
11820 const char * strtab
,
11821 unsigned long int strtab_size
,
11823 Elf_Internal_Sym
* psym
,
11824 enum versioned_symbol_info
* sym_info
,
11825 unsigned short * vna_other
)
11827 unsigned char data
[2];
11828 unsigned short vers_data
;
11829 unsigned long offset
;
11830 unsigned short max_vd_ndx
;
11833 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11836 offset
= offset_from_vma (filedata
,
11837 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11838 sizeof data
+ si
* sizeof (vers_data
));
11840 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11841 sizeof (data
), 1, _("version data")) == NULL
)
11844 vers_data
= byte_get (data
, 2);
11846 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11849 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11852 /* Usually we'd only see verdef for defined symbols, and verneed for
11853 undefined symbols. However, symbols defined by the linker in
11854 .dynbss for variables copied from a shared library in order to
11855 avoid text relocations are defined yet have verneed. We could
11856 use a heuristic to detect the special case, for example, check
11857 for verneed first on symbols defined in SHT_NOBITS sections, but
11858 it is simpler and more reliable to just look for both verdef and
11859 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11861 if (psym
->st_shndx
!= SHN_UNDEF
11862 && vers_data
!= 0x8001
11863 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11865 Elf_Internal_Verdef ivd
;
11866 Elf_Internal_Verdaux ivda
;
11867 Elf_External_Verdaux evda
;
11870 off
= offset_from_vma (filedata
,
11871 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11872 sizeof (Elf_External_Verdef
));
11876 Elf_External_Verdef evd
;
11878 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11879 _("version def")) == NULL
)
11888 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11889 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11890 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11891 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11894 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11895 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11897 off
+= ivd
.vd_next
;
11899 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11901 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11903 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11906 off
-= ivd
.vd_next
;
11909 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11910 _("version def aux")) != NULL
)
11912 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11914 if (psym
->st_name
!= ivda
.vda_name
)
11915 return (ivda
.vda_name
< strtab_size
11916 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11921 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11923 Elf_External_Verneed evn
;
11924 Elf_Internal_Verneed ivn
;
11925 Elf_Internal_Vernaux ivna
;
11927 offset
= offset_from_vma (filedata
,
11928 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11932 unsigned long vna_off
;
11934 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11935 _("version need")) == NULL
)
11938 ivna
.vna_other
= 0;
11943 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11944 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11946 vna_off
= offset
+ ivn
.vn_aux
;
11950 Elf_External_Vernaux evna
;
11952 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11953 _("version need aux (3)")) == NULL
)
11956 ivna
.vna_other
= 0;
11961 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11962 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11963 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11966 vna_off
+= ivna
.vna_next
;
11968 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11970 if (ivna
.vna_other
== vers_data
)
11973 offset
+= ivn
.vn_next
;
11975 while (ivn
.vn_next
!= 0);
11977 if (ivna
.vna_other
== vers_data
)
11979 *sym_info
= symbol_undefined
;
11980 *vna_other
= ivna
.vna_other
;
11981 return (ivna
.vna_name
< strtab_size
11982 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11984 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11985 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11986 return _("<corrupt>");
11992 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
11993 Elf_Internal_Sym
*symtab
,
11994 Elf_Internal_Shdr
*section
,
11995 char *strtab
, size_t strtab_size
)
11997 const char *version_string
;
11998 enum versioned_symbol_info sym_info
;
11999 unsigned short vna_other
;
12000 Elf_Internal_Sym
*psym
= symtab
+ si
;
12002 printf ("%6ld: ", si
);
12003 print_vma (psym
->st_value
, LONG_HEX
);
12005 print_vma (psym
->st_size
, DEC_5
);
12006 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12007 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12008 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12009 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12012 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12014 printf (" %-7s", get_symbol_visibility (vis
));
12015 /* Check to see if any other bits in the st_other field are set.
12016 Note - displaying this information disrupts the layout of the
12017 table being generated, but for the moment this case is very rare. */
12018 if (psym
->st_other
^ vis
)
12019 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12021 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12022 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
12024 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12027 = get_symbol_version_string (filedata
,
12029 || section
->sh_type
== SHT_DYNSYM
),
12030 strtab
, strtab_size
, si
,
12031 psym
, &sym_info
, &vna_other
);
12032 if (version_string
)
12034 if (sym_info
== symbol_undefined
)
12035 printf ("@%s (%d)", version_string
, vna_other
);
12037 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12043 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12045 && si
>= section
->sh_info
12046 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12047 && filedata
->file_header
.e_machine
!= EM_MIPS
12048 /* Solaris binaries have been found to violate this requirement as
12049 well. Not sure if this is a bug or an ABI requirement. */
12050 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12051 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12052 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12055 /* Dump the symbol table. */
12057 process_symbol_table (Filedata
* filedata
)
12059 Elf_Internal_Shdr
* section
;
12061 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12064 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12066 && do_using_dynamic
12067 && filedata
->dynamic_strings
!= NULL
12068 && filedata
->dynamic_symbols
!= NULL
)
12072 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12073 "\nSymbol table for image contains %lu entries:\n",
12074 filedata
->num_dynamic_syms
),
12075 filedata
->num_dynamic_syms
);
12077 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12079 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12081 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12082 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12083 filedata
->dynamic_strings
,
12084 filedata
->dynamic_strings_length
);
12086 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12087 && filedata
->section_headers
!= NULL
)
12091 for (i
= 0, section
= filedata
->section_headers
;
12092 i
< filedata
->file_header
.e_shnum
;
12095 char * strtab
= NULL
;
12096 unsigned long int strtab_size
= 0;
12097 Elf_Internal_Sym
* symtab
;
12098 unsigned long si
, num_syms
;
12100 if ((section
->sh_type
!= SHT_SYMTAB
12101 && section
->sh_type
!= SHT_DYNSYM
)
12103 && section
->sh_type
== SHT_SYMTAB
))
12106 if (section
->sh_entsize
== 0)
12108 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12109 printable_section_name (filedata
, section
));
12113 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12114 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12115 "\nSymbol table '%s' contains %lu entries:\n",
12117 printable_section_name (filedata
, section
),
12121 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12123 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12125 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12126 if (symtab
== NULL
)
12129 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12131 strtab
= filedata
->string_table
;
12132 strtab_size
= filedata
->string_table_length
;
12134 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12136 Elf_Internal_Shdr
* string_sec
;
12138 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12140 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12141 1, string_sec
->sh_size
,
12142 _("string table"));
12143 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12146 for (si
= 0; si
< num_syms
; si
++)
12147 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12148 strtab
, strtab_size
);
12151 if (strtab
!= filedata
->string_table
)
12157 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12159 if (do_histogram
&& filedata
->buckets
!= NULL
)
12161 unsigned long * lengths
;
12162 unsigned long * counts
;
12165 unsigned long maxlength
= 0;
12166 unsigned long nzero_counts
= 0;
12167 unsigned long nsyms
= 0;
12170 printf (ngettext ("\nHistogram for bucket list length "
12171 "(total of %lu bucket):\n",
12172 "\nHistogram for bucket list length "
12173 "(total of %lu buckets):\n",
12174 (unsigned long) filedata
->nbuckets
),
12175 (unsigned long) filedata
->nbuckets
);
12177 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12178 sizeof (*lengths
));
12179 if (lengths
== NULL
)
12181 error (_("Out of memory allocating space for histogram buckets\n"));
12184 visited
= xcmalloc (filedata
->nchains
, 1);
12185 memset (visited
, 0, filedata
->nchains
);
12187 printf (_(" Length Number %% of total Coverage\n"));
12188 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12190 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12193 if (maxlength
< ++lengths
[hn
])
12195 if (si
>= filedata
->nchains
|| visited
[si
])
12197 error (_("histogram chain is corrupt\n"));
12205 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12206 if (counts
== NULL
)
12209 error (_("Out of memory allocating space for histogram counts\n"));
12213 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12214 ++counts
[lengths
[hn
]];
12216 if (filedata
->nbuckets
> 0)
12219 printf (" 0 %-10lu (%5.1f%%)\n",
12220 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12221 for (i
= 1; i
<= maxlength
; ++i
)
12223 nzero_counts
+= counts
[i
] * i
;
12224 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12225 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12226 (nzero_counts
* 100.0) / nsyms
);
12234 free (filedata
->buckets
);
12235 filedata
->buckets
= NULL
;
12236 filedata
->nbuckets
= 0;
12237 free (filedata
->chains
);
12238 filedata
->chains
= NULL
;
12240 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12242 unsigned long * lengths
;
12243 unsigned long * counts
;
12245 unsigned long maxlength
= 0;
12246 unsigned long nzero_counts
= 0;
12247 unsigned long nsyms
= 0;
12249 printf (ngettext ("\nHistogram for `%s' bucket list length "
12250 "(total of %lu bucket):\n",
12251 "\nHistogram for `%s' bucket list length "
12252 "(total of %lu buckets):\n",
12253 (unsigned long) filedata
->ngnubuckets
),
12254 GNU_HASH_SECTION_NAME (filedata
),
12255 (unsigned long) filedata
->ngnubuckets
);
12257 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12258 sizeof (*lengths
));
12259 if (lengths
== NULL
)
12261 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12265 printf (_(" Length Number %% of total Coverage\n"));
12267 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12268 if (filedata
->gnubuckets
[hn
] != 0)
12270 bfd_vma off
, length
= 1;
12272 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12273 /* PR 17531 file: 010-77222-0.004. */
12274 off
< filedata
->ngnuchains
12275 && (filedata
->gnuchains
[off
] & 1) == 0;
12278 lengths
[hn
] = length
;
12279 if (length
> maxlength
)
12280 maxlength
= length
;
12284 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12285 if (counts
== NULL
)
12288 error (_("Out of memory allocating space for gnu histogram counts\n"));
12292 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12293 ++counts
[lengths
[hn
]];
12295 if (filedata
->ngnubuckets
> 0)
12298 printf (" 0 %-10lu (%5.1f%%)\n",
12299 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12300 for (j
= 1; j
<= maxlength
; ++j
)
12302 nzero_counts
+= counts
[j
] * j
;
12303 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12304 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12305 (nzero_counts
* 100.0) / nsyms
);
12312 free (filedata
->gnubuckets
);
12313 filedata
->gnubuckets
= NULL
;
12314 filedata
->ngnubuckets
= 0;
12315 free (filedata
->gnuchains
);
12316 filedata
->gnuchains
= NULL
;
12317 filedata
->ngnuchains
= 0;
12318 free (filedata
->mipsxlat
);
12319 filedata
->mipsxlat
= NULL
;
12323 free (filedata
->gnubuckets
);
12324 filedata
->gnubuckets
= NULL
;
12325 filedata
->ngnubuckets
= 0;
12326 free (filedata
->gnuchains
);
12327 filedata
->gnuchains
= NULL
;
12328 filedata
->ngnuchains
= 0;
12329 free (filedata
->mipsxlat
);
12330 filedata
->mipsxlat
= NULL
;
12331 free (filedata
->buckets
);
12332 filedata
->buckets
= NULL
;
12333 filedata
->nbuckets
= 0;
12334 free (filedata
->chains
);
12335 filedata
->chains
= NULL
;
12340 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12344 if (filedata
->dynamic_syminfo
== NULL
12346 /* No syminfo, this is ok. */
12349 /* There better should be a dynamic symbol section. */
12350 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12353 if (filedata
->dynamic_addr
)
12354 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12355 "contains %d entry:\n",
12356 "\nDynamic info segment at offset 0x%lx "
12357 "contains %d entries:\n",
12358 filedata
->dynamic_syminfo_nent
),
12359 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12361 printf (_(" Num: Name BoundTo Flags\n"));
12362 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12364 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12366 printf ("%4d: ", i
);
12367 if (i
>= filedata
->num_dynamic_syms
)
12368 printf (_("<corrupt index>"));
12369 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12370 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12371 filedata
->dynamic_symbols
[i
].st_name
));
12373 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12376 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12378 case SYMINFO_BT_SELF
:
12379 fputs ("SELF ", stdout
);
12381 case SYMINFO_BT_PARENT
:
12382 fputs ("PARENT ", stdout
);
12385 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12386 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12387 && VALID_DYNAMIC_NAME (filedata
,
12388 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12390 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12391 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12395 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12399 if (flags
& SYMINFO_FLG_DIRECT
)
12400 printf (" DIRECT");
12401 if (flags
& SYMINFO_FLG_PASSTHRU
)
12402 printf (" PASSTHRU");
12403 if (flags
& SYMINFO_FLG_COPY
)
12405 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12406 printf (" LAZYLOAD");
12414 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12415 is contained by the region START .. END. The types of ADDR, START
12416 and END should all be the same. Note both ADDR + NELEM and END
12417 point to just beyond the end of the regions that are being tested. */
12418 #define IN_RANGE(START,END,ADDR,NELEM) \
12419 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12421 /* Check to see if the given reloc needs to be handled in a target specific
12422 manner. If so then process the reloc and return TRUE otherwise return
12425 If called with reloc == NULL, then this is a signal that reloc processing
12426 for the current section has finished, and any saved state should be
12430 target_specific_reloc_handling (Filedata
* filedata
,
12431 Elf_Internal_Rela
* reloc
,
12432 unsigned char * start
,
12433 unsigned char * end
,
12434 Elf_Internal_Sym
* symtab
,
12435 unsigned long num_syms
)
12437 unsigned int reloc_type
= 0;
12438 unsigned long sym_index
= 0;
12442 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12443 sym_index
= get_reloc_symindex (reloc
->r_info
);
12446 switch (filedata
->file_header
.e_machine
)
12449 case EM_MSP430_OLD
:
12451 static Elf_Internal_Sym
* saved_sym
= NULL
;
12459 switch (reloc_type
)
12461 case 10: /* R_MSP430_SYM_DIFF */
12462 if (uses_msp430x_relocs (filedata
))
12464 /* Fall through. */
12465 case 21: /* R_MSP430X_SYM_DIFF */
12467 if (sym_index
>= num_syms
)
12468 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12471 saved_sym
= symtab
+ sym_index
;
12474 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12475 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12476 goto handle_sym_diff
;
12478 case 5: /* R_MSP430_16_BYTE */
12479 case 9: /* R_MSP430_8 */
12480 if (uses_msp430x_relocs (filedata
))
12482 goto handle_sym_diff
;
12484 case 2: /* R_MSP430_ABS16 */
12485 case 15: /* R_MSP430X_ABS16 */
12486 if (! uses_msp430x_relocs (filedata
))
12488 goto handle_sym_diff
;
12491 if (saved_sym
!= NULL
)
12493 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12496 if (sym_index
>= num_syms
)
12497 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12501 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12502 - saved_sym
->st_value
);
12504 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12505 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12508 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12509 (long) reloc
->r_offset
);
12518 if (saved_sym
!= NULL
)
12519 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12526 case EM_CYGNUS_MN10300
:
12528 static Elf_Internal_Sym
* saved_sym
= NULL
;
12536 switch (reloc_type
)
12538 case 34: /* R_MN10300_ALIGN */
12540 case 33: /* R_MN10300_SYM_DIFF */
12541 if (sym_index
>= num_syms
)
12542 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12545 saved_sym
= symtab
+ sym_index
;
12548 case 1: /* R_MN10300_32 */
12549 case 2: /* R_MN10300_16 */
12550 if (saved_sym
!= NULL
)
12552 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12555 if (sym_index
>= num_syms
)
12556 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12560 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12561 - saved_sym
->st_value
);
12563 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12564 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12566 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12567 (long) reloc
->r_offset
);
12575 if (saved_sym
!= NULL
)
12576 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12584 static bfd_vma saved_sym1
= 0;
12585 static bfd_vma saved_sym2
= 0;
12586 static bfd_vma value
;
12590 saved_sym1
= saved_sym2
= 0;
12594 switch (reloc_type
)
12596 case 0x80: /* R_RL78_SYM. */
12597 saved_sym1
= saved_sym2
;
12598 if (sym_index
>= num_syms
)
12599 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12603 saved_sym2
= symtab
[sym_index
].st_value
;
12604 saved_sym2
+= reloc
->r_addend
;
12608 case 0x83: /* R_RL78_OPsub. */
12609 value
= saved_sym1
- saved_sym2
;
12610 saved_sym2
= saved_sym1
= 0;
12614 case 0x41: /* R_RL78_ABS32. */
12615 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12616 byte_put (start
+ reloc
->r_offset
, value
, 4);
12618 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12619 (long) reloc
->r_offset
);
12623 case 0x43: /* R_RL78_ABS16. */
12624 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12625 byte_put (start
+ reloc
->r_offset
, value
, 2);
12627 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12628 (long) reloc
->r_offset
);
12642 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12643 DWARF debug sections. This is a target specific test. Note - we do not
12644 go through the whole including-target-headers-multiple-times route, (as
12645 we have already done with <elf/h8.h>) because this would become very
12646 messy and even then this function would have to contain target specific
12647 information (the names of the relocs instead of their numeric values).
12648 FIXME: This is not the correct way to solve this problem. The proper way
12649 is to have target specific reloc sizing and typing functions created by
12650 the reloc-macros.h header, in the same way that it already creates the
12651 reloc naming functions. */
12654 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12656 /* Please keep this table alpha-sorted for ease of visual lookup. */
12657 switch (filedata
->file_header
.e_machine
)
12661 return reloc_type
== 1; /* R_386_32. */
12663 return reloc_type
== 1; /* R_68K_32. */
12665 return reloc_type
== 1; /* R_860_32. */
12667 return reloc_type
== 2; /* R_960_32. */
12669 return (reloc_type
== 258
12670 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12672 return reloc_type
== 11; /* R_BPF_DATA_32 */
12673 case EM_ADAPTEVA_EPIPHANY
:
12674 return reloc_type
== 3;
12676 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12678 return reloc_type
== 1; /* R_ARC_32. */
12679 case EM_ARC_COMPACT
:
12680 case EM_ARC_COMPACT2
:
12681 return reloc_type
== 4; /* R_ARC_32. */
12683 return reloc_type
== 2; /* R_ARM_ABS32 */
12686 return reloc_type
== 1;
12688 return reloc_type
== 0x12; /* R_byte4_data. */
12690 return reloc_type
== 3; /* R_CRIS_32. */
12692 return reloc_type
== 3; /* R_CR16_NUM32. */
12694 return reloc_type
== 15; /* R_CRX_NUM32. */
12696 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12697 case EM_CYGNUS_FRV
:
12698 return reloc_type
== 1;
12699 case EM_CYGNUS_D10V
:
12701 return reloc_type
== 6; /* R_D10V_32. */
12702 case EM_CYGNUS_D30V
:
12704 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12706 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12707 case EM_CYGNUS_FR30
:
12709 return reloc_type
== 3; /* R_FR30_32. */
12711 return reloc_type
== 1; /* R_FT32_32. */
12715 return reloc_type
== 1; /* R_H8_DIR32. */
12717 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12718 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12719 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12720 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12723 return reloc_type
== 2; /* R_IP2K_32. */
12725 return reloc_type
== 2; /* R_IQ2000_32. */
12726 case EM_LATTICEMICO32
:
12727 return reloc_type
== 3; /* R_LM32_32. */
12730 return reloc_type
== 3; /* R_M32C_32. */
12732 return reloc_type
== 34; /* R_M32R_32_RELA. */
12735 return reloc_type
== 6; /* R_M68HC11_32. */
12737 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12738 reloc_type
== 6; /* R_S12Z_CW32. */
12740 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12741 case EM_CYGNUS_MEP
:
12742 return reloc_type
== 4; /* R_MEP_32. */
12744 return reloc_type
== 2; /* R_METAG_ADDR32. */
12745 case EM_MICROBLAZE
:
12746 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12748 return reloc_type
== 2; /* R_MIPS_32. */
12750 return reloc_type
== 4; /* R_MMIX_32. */
12751 case EM_CYGNUS_MN10200
:
12753 return reloc_type
== 1; /* R_MN10200_32. */
12754 case EM_CYGNUS_MN10300
:
12756 return reloc_type
== 1; /* R_MN10300_32. */
12758 return reloc_type
== 1; /* R_MOXIE_32. */
12759 case EM_MSP430_OLD
:
12761 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12763 return reloc_type
== 2; /* R_MT_32. */
12765 return reloc_type
== 20; /* R_NDS32_RELA. */
12766 case EM_ALTERA_NIOS2
:
12767 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12769 return reloc_type
== 1; /* R_NIOS_32. */
12771 return reloc_type
== 1; /* R_OR1K_32. */
12773 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12774 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12775 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12778 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12780 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12782 return reloc_type
== 1; /* R_PPC_ADDR32. */
12784 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12786 return reloc_type
== 1; /* R_RISCV_32. */
12788 return reloc_type
== 1; /* R_RL78_DIR32. */
12790 return reloc_type
== 1; /* R_RX_DIR32. */
12792 return reloc_type
== 1; /* R_I370_ADDR31. */
12795 return reloc_type
== 4; /* R_S390_32. */
12797 return reloc_type
== 8; /* R_SCORE_ABS32. */
12799 return reloc_type
== 1; /* R_SH_DIR32. */
12800 case EM_SPARC32PLUS
:
12803 return reloc_type
== 3 /* R_SPARC_32. */
12804 || reloc_type
== 23; /* R_SPARC_UA32. */
12806 return reloc_type
== 6; /* R_SPU_ADDR32 */
12808 return reloc_type
== 1; /* R_C6000_ABS32. */
12810 return reloc_type
== 2; /* R_TILEGX_32. */
12812 return reloc_type
== 1; /* R_TILEPRO_32. */
12813 case EM_CYGNUS_V850
:
12815 return reloc_type
== 6; /* R_V850_ABS32. */
12817 return reloc_type
== 0x33; /* R_V810_WORD. */
12819 return reloc_type
== 1; /* R_VAX_32. */
12821 return reloc_type
== 3; /* R_VISIUM_32. */
12822 case EM_WEBASSEMBLY
:
12823 return reloc_type
== 1; /* R_WASM32_32. */
12827 return reloc_type
== 10; /* R_X86_64_32. */
12830 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12832 return reloc_type
== 4; /* R_XGATE_32. */
12834 return reloc_type
== 1; /* R_XSTROMY16_32. */
12835 case EM_XTENSA_OLD
:
12837 return reloc_type
== 1; /* R_XTENSA_32. */
12839 return reloc_type
== 6; /* R_Z80_32. */
12842 static unsigned int prev_warn
= 0;
12844 /* Avoid repeating the same warning multiple times. */
12845 if (prev_warn
!= filedata
->file_header
.e_machine
)
12846 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12847 filedata
->file_header
.e_machine
);
12848 prev_warn
= filedata
->file_header
.e_machine
;
12854 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12855 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12858 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12860 switch (filedata
->file_header
.e_machine
)
12861 /* Please keep this table alpha-sorted for ease of visual lookup. */
12865 return reloc_type
== 2; /* R_386_PC32. */
12867 return reloc_type
== 4; /* R_68K_PC32. */
12869 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12870 case EM_ADAPTEVA_EPIPHANY
:
12871 return reloc_type
== 6;
12873 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12874 case EM_ARC_COMPACT
:
12875 case EM_ARC_COMPACT2
:
12876 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12878 return reloc_type
== 3; /* R_ARM_REL32 */
12881 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12882 case EM_MICROBLAZE
:
12883 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12885 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12887 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12889 return reloc_type
== 26; /* R_PPC_REL32. */
12891 return reloc_type
== 26; /* R_PPC64_REL32. */
12893 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12896 return reloc_type
== 5; /* R_390_PC32. */
12898 return reloc_type
== 2; /* R_SH_REL32. */
12899 case EM_SPARC32PLUS
:
12902 return reloc_type
== 6; /* R_SPARC_DISP32. */
12904 return reloc_type
== 13; /* R_SPU_REL32. */
12906 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12908 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12910 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12914 return reloc_type
== 2; /* R_X86_64_PC32. */
12916 return reloc_type
== 4; /* R_VAX_PCREL32. */
12917 case EM_XTENSA_OLD
:
12919 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12921 /* Do not abort or issue an error message here. Not all targets use
12922 pc-relative 32-bit relocs in their DWARF debug information and we
12923 have already tested for target coverage in is_32bit_abs_reloc. A
12924 more helpful warning message will be generated by apply_relocations
12925 anyway, so just return. */
12930 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12931 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12934 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12936 switch (filedata
->file_header
.e_machine
)
12939 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12941 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12943 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12944 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12946 return reloc_type
== 80; /* R_PARISC_DIR64. */
12948 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12950 return reloc_type
== 2; /* R_RISCV_64. */
12951 case EM_SPARC32PLUS
:
12954 return reloc_type
== 32 /* R_SPARC_64. */
12955 || reloc_type
== 54; /* R_SPARC_UA64. */
12959 return reloc_type
== 1; /* R_X86_64_64. */
12962 return reloc_type
== 22; /* R_S390_64. */
12964 return reloc_type
== 1; /* R_TILEGX_64. */
12966 return reloc_type
== 18; /* R_MIPS_64. */
12972 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12973 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12976 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12978 switch (filedata
->file_header
.e_machine
)
12981 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12983 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12985 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12986 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12988 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12990 return reloc_type
== 44; /* R_PPC64_REL64. */
12991 case EM_SPARC32PLUS
:
12994 return reloc_type
== 46; /* R_SPARC_DISP64. */
12998 return reloc_type
== 24; /* R_X86_64_PC64. */
13001 return reloc_type
== 23; /* R_S390_PC64. */
13003 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13009 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13010 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13013 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13015 switch (filedata
->file_header
.e_machine
)
13017 case EM_CYGNUS_MN10200
:
13019 return reloc_type
== 4; /* R_MN10200_24. */
13021 return reloc_type
== 5; /* R_FT32_20. */
13023 return reloc_type
== 5; /* R_Z80_24. */
13029 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13030 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13033 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13035 /* Please keep this table alpha-sorted for ease of visual lookup. */
13036 switch (filedata
->file_header
.e_machine
)
13039 case EM_ARC_COMPACT
:
13040 case EM_ARC_COMPACT2
:
13041 return reloc_type
== 2; /* R_ARC_16. */
13042 case EM_ADAPTEVA_EPIPHANY
:
13043 return reloc_type
== 5;
13046 return reloc_type
== 4; /* R_AVR_16. */
13047 case EM_CYGNUS_D10V
:
13049 return reloc_type
== 3; /* R_D10V_16. */
13051 return reloc_type
== 2; /* R_FT32_16. */
13055 return reloc_type
== R_H8_DIR16
;
13058 return reloc_type
== 1; /* R_IP2K_16. */
13061 return reloc_type
== 1; /* R_M32C_16 */
13062 case EM_CYGNUS_MN10200
:
13064 return reloc_type
== 2; /* R_MN10200_16. */
13065 case EM_CYGNUS_MN10300
:
13067 return reloc_type
== 2; /* R_MN10300_16. */
13069 if (uses_msp430x_relocs (filedata
))
13070 return reloc_type
== 2; /* R_MSP430_ABS16. */
13071 /* Fall through. */
13072 case EM_MSP430_OLD
:
13073 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13075 return reloc_type
== 19; /* R_NDS32_RELA. */
13076 case EM_ALTERA_NIOS2
:
13077 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13079 return reloc_type
== 9; /* R_NIOS_16. */
13081 return reloc_type
== 2; /* R_OR1K_16. */
13083 return reloc_type
== 55; /* R_RISCV_SET16. */
13085 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13087 return reloc_type
== 2; /* R_C6000_ABS16. */
13089 return reloc_type
== 2; /* R_VISIUM_16. */
13092 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13094 return reloc_type
== 3; /* R_XGATE_16. */
13096 return reloc_type
== 4; /* R_Z80_16. */
13102 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13103 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13106 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13108 switch (filedata
->file_header
.e_machine
)
13111 return reloc_type
== 54; /* R_RISCV_SET8. */
13113 return reloc_type
== 1; /* R_Z80_8. */
13119 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13120 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13123 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13125 switch (filedata
->file_header
.e_machine
)
13128 return reloc_type
== 53; /* R_RISCV_SET6. */
13134 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13135 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13138 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13140 /* Please keep this table alpha-sorted for ease of visual lookup. */
13141 switch (filedata
->file_header
.e_machine
)
13144 return reloc_type
== 35; /* R_RISCV_ADD32. */
13150 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13151 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13154 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13156 /* Please keep this table alpha-sorted for ease of visual lookup. */
13157 switch (filedata
->file_header
.e_machine
)
13160 return reloc_type
== 39; /* R_RISCV_SUB32. */
13166 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13167 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13170 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13172 /* Please keep this table alpha-sorted for ease of visual lookup. */
13173 switch (filedata
->file_header
.e_machine
)
13176 return reloc_type
== 36; /* R_RISCV_ADD64. */
13182 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13183 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13186 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13188 /* Please keep this table alpha-sorted for ease of visual lookup. */
13189 switch (filedata
->file_header
.e_machine
)
13192 return reloc_type
== 40; /* R_RISCV_SUB64. */
13198 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13199 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13202 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13204 /* Please keep this table alpha-sorted for ease of visual lookup. */
13205 switch (filedata
->file_header
.e_machine
)
13208 return reloc_type
== 34; /* R_RISCV_ADD16. */
13214 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13215 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13218 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13220 /* Please keep this table alpha-sorted for ease of visual lookup. */
13221 switch (filedata
->file_header
.e_machine
)
13224 return reloc_type
== 38; /* R_RISCV_SUB16. */
13230 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13231 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13234 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13236 /* Please keep this table alpha-sorted for ease of visual lookup. */
13237 switch (filedata
->file_header
.e_machine
)
13240 return reloc_type
== 33; /* R_RISCV_ADD8. */
13246 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13247 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13250 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13252 /* Please keep this table alpha-sorted for ease of visual lookup. */
13253 switch (filedata
->file_header
.e_machine
)
13256 return reloc_type
== 37; /* R_RISCV_SUB8. */
13262 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13263 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13266 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13268 switch (filedata
->file_header
.e_machine
)
13271 return reloc_type
== 52; /* R_RISCV_SUB6. */
13277 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13278 relocation entries (possibly formerly used for SHT_GROUP sections). */
13281 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13283 switch (filedata
->file_header
.e_machine
)
13285 case EM_386
: /* R_386_NONE. */
13286 case EM_68K
: /* R_68K_NONE. */
13287 case EM_ADAPTEVA_EPIPHANY
:
13288 case EM_ALPHA
: /* R_ALPHA_NONE. */
13289 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13290 case EM_ARC
: /* R_ARC_NONE. */
13291 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13292 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13293 case EM_ARM
: /* R_ARM_NONE. */
13294 case EM_C166
: /* R_XC16X_NONE. */
13295 case EM_CRIS
: /* R_CRIS_NONE. */
13296 case EM_FT32
: /* R_FT32_NONE. */
13297 case EM_IA_64
: /* R_IA64_NONE. */
13298 case EM_K1OM
: /* R_X86_64_NONE. */
13299 case EM_L1OM
: /* R_X86_64_NONE. */
13300 case EM_M32R
: /* R_M32R_NONE. */
13301 case EM_MIPS
: /* R_MIPS_NONE. */
13302 case EM_MN10300
: /* R_MN10300_NONE. */
13303 case EM_MOXIE
: /* R_MOXIE_NONE. */
13304 case EM_NIOS32
: /* R_NIOS_NONE. */
13305 case EM_OR1K
: /* R_OR1K_NONE. */
13306 case EM_PARISC
: /* R_PARISC_NONE. */
13307 case EM_PPC64
: /* R_PPC64_NONE. */
13308 case EM_PPC
: /* R_PPC_NONE. */
13309 case EM_RISCV
: /* R_RISCV_NONE. */
13310 case EM_S390
: /* R_390_NONE. */
13312 case EM_SH
: /* R_SH_NONE. */
13313 case EM_SPARC32PLUS
:
13314 case EM_SPARC
: /* R_SPARC_NONE. */
13316 case EM_TILEGX
: /* R_TILEGX_NONE. */
13317 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13318 case EM_TI_C6000
:/* R_C6000_NONE. */
13319 case EM_X86_64
: /* R_X86_64_NONE. */
13321 case EM_Z80
: /* R_Z80_NONE. */
13322 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13323 return reloc_type
== 0;
13326 return reloc_type
== 0 || reloc_type
== 256;
13329 return (reloc_type
== 0 /* R_AVR_NONE. */
13330 || reloc_type
== 30 /* R_AVR_DIFF8. */
13331 || reloc_type
== 31 /* R_AVR_DIFF16. */
13332 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13334 return reloc_type
== 3; /* R_METAG_NONE. */
13336 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13337 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13338 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13339 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13340 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13342 return (reloc_type
== 0 /* R_PRU_NONE. */
13343 || reloc_type
== 65 /* R_PRU_DIFF8. */
13344 || reloc_type
== 66 /* R_PRU_DIFF16. */
13345 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13346 case EM_XTENSA_OLD
:
13348 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13349 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13350 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13351 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13356 /* Returns TRUE if there is a relocation against
13357 section NAME at OFFSET bytes. */
13360 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13362 Elf_Internal_Rela
* relocs
;
13363 Elf_Internal_Rela
* rp
;
13365 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13368 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13370 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13371 if (rp
->r_offset
== offset
)
13377 /* Apply relocations to a section.
13378 Returns TRUE upon success, FALSE otherwise.
13379 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13380 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13381 will be set to the number of relocs loaded.
13383 Note: So far support has been added only for those relocations
13384 which can be found in debug sections. FIXME: Add support for
13385 more relocations ? */
13388 apply_relocations (Filedata
* filedata
,
13389 const Elf_Internal_Shdr
* section
,
13390 unsigned char * start
,
13391 bfd_size_type size
,
13392 void ** relocs_return
,
13393 unsigned long * num_relocs_return
)
13395 Elf_Internal_Shdr
* relsec
;
13396 unsigned char * end
= start
+ size
;
13398 if (relocs_return
!= NULL
)
13400 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13401 * num_relocs_return
= 0;
13404 if (filedata
->file_header
.e_type
!= ET_REL
)
13405 /* No relocs to apply. */
13408 /* Find the reloc section associated with the section. */
13409 for (relsec
= filedata
->section_headers
;
13410 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13413 bfd_boolean is_rela
;
13414 unsigned long num_relocs
;
13415 Elf_Internal_Rela
* relocs
;
13416 Elf_Internal_Rela
* rp
;
13417 Elf_Internal_Shdr
* symsec
;
13418 Elf_Internal_Sym
* symtab
;
13419 unsigned long num_syms
;
13420 Elf_Internal_Sym
* sym
;
13422 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13423 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13424 || filedata
->section_headers
+ relsec
->sh_info
!= section
13425 || relsec
->sh_size
== 0
13426 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13429 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13430 if (symsec
->sh_type
!= SHT_SYMTAB
13431 && symsec
->sh_type
!= SHT_DYNSYM
)
13434 is_rela
= relsec
->sh_type
== SHT_RELA
;
13438 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13439 relsec
->sh_size
, & relocs
, & num_relocs
))
13444 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13445 relsec
->sh_size
, & relocs
, & num_relocs
))
13449 /* SH uses RELA but uses in place value instead of the addend field. */
13450 if (filedata
->file_header
.e_machine
== EM_SH
)
13453 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13455 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13458 unsigned int reloc_type
;
13459 unsigned int reloc_size
;
13460 bfd_boolean reloc_inplace
= FALSE
;
13461 bfd_boolean reloc_subtract
= FALSE
;
13462 unsigned char * rloc
;
13463 unsigned long sym_index
;
13465 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13467 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13469 else if (is_none_reloc (filedata
, reloc_type
))
13471 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13472 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13474 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13475 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13477 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13479 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13481 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13482 || is_6bit_abs_reloc (filedata
, reloc_type
))
13484 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13486 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13489 reloc_inplace
= TRUE
;
13491 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13493 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13496 reloc_inplace
= TRUE
;
13498 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13500 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13503 reloc_inplace
= TRUE
;
13505 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13507 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13510 reloc_inplace
= TRUE
;
13512 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13516 reloc_inplace
= TRUE
;
13520 static unsigned int prev_reloc
= 0;
13522 if (reloc_type
!= prev_reloc
)
13523 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13524 reloc_type
, printable_section_name (filedata
, section
));
13525 prev_reloc
= reloc_type
;
13529 rloc
= start
+ rp
->r_offset
;
13530 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13532 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13533 (unsigned long) rp
->r_offset
,
13534 printable_section_name (filedata
, section
));
13538 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13539 if (sym_index
>= num_syms
)
13541 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13542 sym_index
, printable_section_name (filedata
, section
));
13545 sym
= symtab
+ sym_index
;
13547 /* If the reloc has a symbol associated with it,
13548 make sure that it is of an appropriate type.
13550 Relocations against symbols without type can happen.
13551 Gcc -feliminate-dwarf2-dups may generate symbols
13552 without type for debug info.
13554 Icc generates relocations against function symbols
13555 instead of local labels.
13557 Relocations against object symbols can happen, eg when
13558 referencing a global array. For an example of this see
13559 the _clz.o binary in libgcc.a. */
13561 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13562 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13564 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13565 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13566 printable_section_name (filedata
, relsec
),
13567 (long int)(rp
- relocs
));
13573 addend
+= rp
->r_addend
;
13574 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13575 partial_inplace. */
13577 || (filedata
->file_header
.e_machine
== EM_XTENSA
13578 && reloc_type
== 1)
13579 || ((filedata
->file_header
.e_machine
== EM_PJ
13580 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13581 && reloc_type
== 1)
13582 || ((filedata
->file_header
.e_machine
== EM_D30V
13583 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13584 && reloc_type
== 12)
13587 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13588 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13590 addend
+= byte_get (rloc
, reloc_size
);
13593 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13594 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13596 /* On HPPA, all pc-relative relocations are biased by 8. */
13597 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13599 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13602 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13603 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13605 if (reloc_subtract
)
13606 addend
-= sym
->st_value
;
13608 addend
+= sym
->st_value
;
13609 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13610 byte_put (rloc
, addend
, reloc_size
);
13612 else if (reloc_subtract
)
13613 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13615 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13619 /* Let the target specific reloc processing code know that
13620 we have finished with these relocs. */
13621 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13625 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13626 * num_relocs_return
= num_relocs
;
13637 #ifdef SUPPORT_DISASSEMBLY
13639 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13641 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13643 /* FIXME: XXX -- to be done --- XXX */
13649 /* Reads in the contents of SECTION from FILE, returning a pointer
13650 to a malloc'ed buffer or NULL if something went wrong. */
13653 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13655 bfd_size_type num_bytes
= section
->sh_size
;
13657 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13659 printf (_("Section '%s' has no data to dump.\n"),
13660 printable_section_name (filedata
, section
));
13664 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13665 _("section contents"));
13668 /* Uncompresses a section that was compressed using zlib, in place. */
13671 uncompress_section_contents (unsigned char ** buffer
,
13672 dwarf_size_type uncompressed_size
,
13673 dwarf_size_type
* size
)
13675 dwarf_size_type compressed_size
= *size
;
13676 unsigned char * compressed_buffer
= *buffer
;
13677 unsigned char * uncompressed_buffer
;
13681 /* It is possible the section consists of several compressed
13682 buffers concatenated together, so we uncompress in a loop. */
13683 /* PR 18313: The state field in the z_stream structure is supposed
13684 to be invisible to the user (ie us), but some compilers will
13685 still complain about it being used without initialisation. So
13686 we first zero the entire z_stream structure and then set the fields
13688 memset (& strm
, 0, sizeof strm
);
13689 strm
.avail_in
= compressed_size
;
13690 strm
.next_in
= (Bytef
*) compressed_buffer
;
13691 strm
.avail_out
= uncompressed_size
;
13692 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13694 rc
= inflateInit (& strm
);
13695 while (strm
.avail_in
> 0)
13699 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13700 + (uncompressed_size
- strm
.avail_out
));
13701 rc
= inflate (&strm
, Z_FINISH
);
13702 if (rc
!= Z_STREAM_END
)
13704 rc
= inflateReset (& strm
);
13706 rc
= inflateEnd (& strm
);
13708 || strm
.avail_out
!= 0)
13711 *buffer
= uncompressed_buffer
;
13712 *size
= uncompressed_size
;
13716 free (uncompressed_buffer
);
13717 /* Indicate decompression failure. */
13723 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13725 Elf_Internal_Shdr
* relsec
;
13726 bfd_size_type num_bytes
;
13727 unsigned char * data
;
13728 unsigned char * end
;
13729 unsigned char * real_start
;
13730 unsigned char * start
;
13731 bfd_boolean some_strings_shown
;
13733 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13735 /* PR 21820: Do not fail if the section was empty. */
13736 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13738 num_bytes
= section
->sh_size
;
13740 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13742 if (decompress_dumps
)
13744 dwarf_size_type new_size
= num_bytes
;
13745 dwarf_size_type uncompressed_size
= 0;
13747 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13749 Elf_Internal_Chdr chdr
;
13750 unsigned int compression_header_size
13751 = get_compression_header (& chdr
, (unsigned char *) start
,
13753 if (compression_header_size
== 0)
13754 /* An error message will have already been generated
13755 by get_compression_header. */
13758 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13760 warn (_("section '%s' has unsupported compress type: %d\n"),
13761 printable_section_name (filedata
, section
), chdr
.ch_type
);
13764 uncompressed_size
= chdr
.ch_size
;
13765 start
+= compression_header_size
;
13766 new_size
-= compression_header_size
;
13768 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13770 /* Read the zlib header. In this case, it should be "ZLIB"
13771 followed by the uncompressed section size, 8 bytes in
13772 big-endian order. */
13773 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13774 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13775 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13776 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13777 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13778 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13779 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13780 uncompressed_size
+= start
[11];
13785 if (uncompressed_size
)
13787 if (uncompress_section_contents (& start
,
13788 uncompressed_size
, & new_size
))
13789 num_bytes
= new_size
;
13792 error (_("Unable to decompress section %s\n"),
13793 printable_section_name (filedata
, section
));
13798 start
= real_start
;
13801 /* If the section being dumped has relocations against it the user might
13802 be expecting these relocations to have been applied. Check for this
13803 case and issue a warning message in order to avoid confusion.
13804 FIXME: Maybe we ought to have an option that dumps a section with
13805 relocs applied ? */
13806 for (relsec
= filedata
->section_headers
;
13807 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13810 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13811 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13812 || filedata
->section_headers
+ relsec
->sh_info
!= section
13813 || relsec
->sh_size
== 0
13814 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13817 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13822 end
= start
+ num_bytes
;
13823 some_strings_shown
= FALSE
;
13825 #ifdef HAVE_MBSTATE_T
13827 /* Initialise the multibyte conversion state. */
13828 memset (& state
, 0, sizeof (state
));
13831 bfd_boolean continuing
= FALSE
;
13835 while (!ISPRINT (* data
))
13836 if (++ data
>= end
)
13841 size_t maxlen
= end
- data
;
13846 continuing
= FALSE
;
13851 /* PR 11128: Use two separate invocations in order to work
13852 around bugs in the Solaris 8 implementation of printf. */
13853 printf (" [%6tx] ", data
- start
);
13855 printf (" [%6Ix] ", (size_t) (data
- start
));
13870 /* PR 25543: Treat new-lines as string-ending characters. */
13879 /* Do not print control characters directly as they can affect terminal
13880 settings. Such characters usually appear in the names generated
13881 by the assembler for local labels. */
13884 printf ("^%c", c
+ 0x40);
13886 else if (ISPRINT (c
))
13893 #ifdef HAVE_MBSTATE_T
13896 /* Let printf do the hard work of displaying multibyte characters. */
13897 printf ("%.1s", data
- 1);
13898 #ifdef HAVE_MBSTATE_T
13899 /* Try to find out how many bytes made up the character that was
13900 just printed. Advance the symbol pointer past the bytes that
13902 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13906 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13916 printf (_("<corrupt>\n"));
13919 some_strings_shown
= TRUE
;
13923 if (! some_strings_shown
)
13924 printf (_(" No strings found in this section."));
13937 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13938 Filedata
* filedata
,
13939 bfd_boolean relocate
)
13941 Elf_Internal_Shdr
* relsec
;
13942 bfd_size_type bytes
;
13943 bfd_size_type section_size
;
13945 unsigned char * data
;
13946 unsigned char * real_start
;
13947 unsigned char * start
;
13949 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13951 /* PR 21820: Do not fail if the section was empty. */
13952 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13954 section_size
= section
->sh_size
;
13956 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13958 if (decompress_dumps
)
13960 dwarf_size_type new_size
= section_size
;
13961 dwarf_size_type uncompressed_size
= 0;
13963 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13965 Elf_Internal_Chdr chdr
;
13966 unsigned int compression_header_size
13967 = get_compression_header (& chdr
, start
, section_size
);
13969 if (compression_header_size
== 0)
13970 /* An error message will have already been generated
13971 by get_compression_header. */
13974 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13976 warn (_("section '%s' has unsupported compress type: %d\n"),
13977 printable_section_name (filedata
, section
), chdr
.ch_type
);
13980 uncompressed_size
= chdr
.ch_size
;
13981 start
+= compression_header_size
;
13982 new_size
-= compression_header_size
;
13984 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13986 /* Read the zlib header. In this case, it should be "ZLIB"
13987 followed by the uncompressed section size, 8 bytes in
13988 big-endian order. */
13989 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13990 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13991 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13992 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13993 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13994 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13995 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13996 uncompressed_size
+= start
[11];
14001 if (uncompressed_size
)
14003 if (uncompress_section_contents (& start
, uncompressed_size
,
14006 section_size
= new_size
;
14010 error (_("Unable to decompress section %s\n"),
14011 printable_section_name (filedata
, section
));
14012 /* FIXME: Print the section anyway ? */
14017 start
= real_start
;
14022 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14027 /* If the section being dumped has relocations against it the user might
14028 be expecting these relocations to have been applied. Check for this
14029 case and issue a warning message in order to avoid confusion.
14030 FIXME: Maybe we ought to have an option that dumps a section with
14031 relocs applied ? */
14032 for (relsec
= filedata
->section_headers
;
14033 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14036 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14037 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14038 || filedata
->section_headers
+ relsec
->sh_info
!= section
14039 || relsec
->sh_size
== 0
14040 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14043 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14048 addr
= section
->sh_addr
;
14049 bytes
= section_size
;
14058 lbytes
= (bytes
> 16 ? 16 : bytes
);
14060 printf (" 0x%8.8lx ", (unsigned long) addr
);
14062 for (j
= 0; j
< 16; j
++)
14065 printf ("%2.2x", data
[j
]);
14073 for (j
= 0; j
< lbytes
; j
++)
14076 if (k
>= ' ' && k
< 0x7f)
14099 static ctf_sect_t
*
14100 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14102 buf
->cts_name
= SECTION_NAME (shdr
);
14103 buf
->cts_size
= shdr
->sh_size
;
14104 buf
->cts_entsize
= shdr
->sh_entsize
;
14109 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14110 it is passed, or a pointer to newly-allocated storage, in which case
14111 dump_ctf() will free it when it no longer needs it. */
14113 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14114 char *s
, void *arg
)
14116 const char *blanks
= arg
;
14119 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14125 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14127 Elf_Internal_Shdr
* parent_sec
= NULL
;
14128 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14129 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14130 void * data
= NULL
;
14131 void * symdata
= NULL
;
14132 void * strdata
= NULL
;
14133 void * parentdata
= NULL
;
14134 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14135 ctf_sect_t
* symsectp
= NULL
;
14136 ctf_sect_t
* strsectp
= NULL
;
14137 ctf_file_t
* ctf
= NULL
;
14138 ctf_file_t
* parent
= NULL
;
14140 const char *things
[] = {"Header", "Labels", "Data objects",
14141 "Function objects", "Variables", "Types", "Strings",
14143 const char **thing
;
14145 bfd_boolean ret
= FALSE
;
14148 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14149 data
= get_section_contents (section
, filedata
);
14150 ctfsect
.cts_data
= data
;
14152 if (!dump_ctf_symtab_name
)
14153 dump_ctf_symtab_name
= strdup (".symtab");
14155 if (!dump_ctf_strtab_name
)
14156 dump_ctf_strtab_name
= strdup (".strtab");
14158 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14160 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14162 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14165 if ((symdata
= (void *) get_data (NULL
, filedata
,
14166 symtab_sec
->sh_offset
, 1,
14167 symtab_sec
->sh_size
,
14168 _("symbols"))) == NULL
)
14170 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14171 symsect
.cts_data
= symdata
;
14173 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14175 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14177 error (_("No string table section named %s\n"),
14178 dump_ctf_strtab_name
);
14181 if ((strdata
= (void *) get_data (NULL
, filedata
,
14182 strtab_sec
->sh_offset
, 1,
14183 strtab_sec
->sh_size
,
14184 _("strings"))) == NULL
)
14186 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14187 strsect
.cts_data
= strdata
;
14189 if (dump_ctf_parent_name
)
14191 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14193 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14196 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14197 parent_sec
->sh_offset
, 1,
14198 parent_sec
->sh_size
,
14199 _("CTF parent"))) == NULL
)
14201 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14202 parentsect
.cts_data
= parentdata
;
14205 /* Load the CTF file and dump it. */
14207 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14209 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14215 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14217 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14221 ctf_import (ctf
, parent
);
14226 printf (_("\nDump of CTF section '%s':\n"),
14227 printable_section_name (filedata
, section
));
14229 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14231 ctf_dump_state_t
*s
= NULL
;
14234 printf ("\n %s:\n", *thing
);
14235 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14236 (void *) " ")) != NULL
)
14238 printf ("%s\n", item
);
14242 if (ctf_errno (ctf
))
14244 error (_("Iteration failed: %s, %s\n"), *thing
,
14245 ctf_errmsg (ctf_errno (ctf
)));
14251 ctf_file_close (ctf
);
14252 ctf_file_close (parent
);
14261 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14262 const Elf_Internal_Shdr
* sec
,
14265 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14267 Filedata
* filedata
= (Filedata
*) data
;
14269 if (section
->start
!= NULL
)
14271 /* If it is already loaded, do nothing. */
14272 if (streq (section
->filename
, filedata
->file_name
))
14274 free (section
->start
);
14277 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14278 section
->address
= sec
->sh_addr
;
14279 section
->user_data
= NULL
;
14280 section
->filename
= filedata
->file_name
;
14281 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14283 sec
->sh_size
, buf
);
14284 if (section
->start
== NULL
)
14288 unsigned char *start
= section
->start
;
14289 dwarf_size_type size
= sec
->sh_size
;
14290 dwarf_size_type uncompressed_size
= 0;
14292 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14294 Elf_Internal_Chdr chdr
;
14295 unsigned int compression_header_size
;
14297 if (size
< (is_32bit_elf
14298 ? sizeof (Elf32_External_Chdr
)
14299 : sizeof (Elf64_External_Chdr
)))
14301 warn (_("compressed section %s is too small to contain a compression header\n"),
14306 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14307 if (compression_header_size
== 0)
14308 /* An error message will have already been generated
14309 by get_compression_header. */
14312 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14314 warn (_("section '%s' has unsupported compress type: %d\n"),
14315 section
->name
, chdr
.ch_type
);
14318 uncompressed_size
= chdr
.ch_size
;
14319 start
+= compression_header_size
;
14320 size
-= compression_header_size
;
14322 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14324 /* Read the zlib header. In this case, it should be "ZLIB"
14325 followed by the uncompressed section size, 8 bytes in
14326 big-endian order. */
14327 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14328 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14329 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14330 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14331 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14332 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14333 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14334 uncompressed_size
+= start
[11];
14339 if (uncompressed_size
)
14341 if (uncompress_section_contents (&start
, uncompressed_size
,
14344 /* Free the compressed buffer, update the section buffer
14345 and the section size if uncompress is successful. */
14346 free (section
->start
);
14347 section
->start
= start
;
14351 error (_("Unable to decompress section %s\n"),
14352 printable_section_name (filedata
, sec
));
14357 section
->size
= size
;
14360 if (section
->start
== NULL
)
14363 if (debug_displays
[debug
].relocate
)
14365 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14366 & section
->reloc_info
, & section
->num_relocs
))
14371 section
->reloc_info
= NULL
;
14372 section
->num_relocs
= 0;
14378 #if HAVE_LIBDEBUGINFOD
14379 /* Return a hex string representation of the build-id. */
14381 get_build_id (void * data
)
14383 Filedata
* filedata
= (Filedata
*)data
;
14384 Elf_Internal_Shdr
* shdr
;
14387 /* Iterate through notes to find note.gnu.build-id.
14388 FIXME: Only the first note in any note section is examined. */
14389 for (i
= 0, shdr
= filedata
->section_headers
;
14390 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14393 if (shdr
->sh_type
!= SHT_NOTE
)
14398 size_t data_remaining
;
14400 Elf_External_Note
* enote
;
14401 Elf_Internal_Note inote
;
14403 bfd_vma offset
= shdr
->sh_offset
;
14404 bfd_vma align
= shdr
->sh_addralign
;
14405 bfd_vma length
= shdr
->sh_size
;
14407 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14413 else if (align
!= 4 && align
!= 8)
14419 end
= (char *) enote
+ length
;
14420 data_remaining
= end
- (char *) enote
;
14422 if (!is_ia64_vms (filedata
))
14424 min_notesz
= offsetof (Elf_External_Note
, name
);
14425 if (data_remaining
< min_notesz
)
14428 malformed note encountered in section %s whilst scanning for build-id note\n"),
14429 printable_section_name (filedata
, shdr
));
14433 data_remaining
-= min_notesz
;
14435 inote
.type
= BYTE_GET (enote
->type
);
14436 inote
.namesz
= BYTE_GET (enote
->namesz
);
14437 inote
.namedata
= enote
->name
;
14438 inote
.descsz
= BYTE_GET (enote
->descsz
);
14439 inote
.descdata
= ((char *) enote
14440 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14441 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14442 next
= ((char *) enote
14443 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14447 Elf64_External_VMS_Note
*vms_enote
;
14449 /* PR binutils/15191
14450 Make sure that there is enough data to read. */
14451 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14452 if (data_remaining
< min_notesz
)
14455 malformed note encountered in section %s whilst scanning for build-id note\n"),
14456 printable_section_name (filedata
, shdr
));
14460 data_remaining
-= min_notesz
;
14462 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14463 inote
.type
= BYTE_GET (vms_enote
->type
);
14464 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14465 inote
.namedata
= vms_enote
->name
;
14466 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14467 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14468 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14469 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14472 /* Skip malformed notes. */
14473 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14474 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14475 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14476 || ((size_t) (next
- inote
.descdata
)
14477 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14480 malformed note encountered in section %s whilst scanning for build-id note\n"),
14481 printable_section_name (filedata
, shdr
));
14486 /* Check if this is the build-id note. If so then convert the build-id
14487 bytes to a hex string. */
14488 if (inote
.namesz
> 0
14489 && const_strneq (inote
.namedata
, "GNU")
14490 && inote
.type
== NT_GNU_BUILD_ID
)
14495 build_id
= malloc (inote
.descsz
* 2 + 1);
14496 if (build_id
== NULL
)
14502 for (j
= 0; j
< inote
.descsz
; ++j
)
14503 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14504 build_id
[inote
.descsz
* 2] = '\0';
14507 return (unsigned char *) build_id
;
14514 #endif /* HAVE_LIBDEBUGINFOD */
14516 /* If this is not NULL, load_debug_section will only look for sections
14517 within the list of sections given here. */
14518 static unsigned int * section_subset
= NULL
;
14521 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14523 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14524 Elf_Internal_Shdr
* sec
;
14525 Filedata
* filedata
= (Filedata
*) data
;
14527 /* Without section headers we cannot find any sections. */
14528 if (filedata
->section_headers
== NULL
)
14531 if (filedata
->string_table
== NULL
14532 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14533 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14535 Elf_Internal_Shdr
* strs
;
14537 /* Read in the string table, so that we have section names to scan. */
14538 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14540 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14542 filedata
->string_table
14543 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14544 1, strs
->sh_size
, _("string table"));
14546 filedata
->string_table_length
14547 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14551 /* Locate the debug section. */
14552 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14554 section
->name
= section
->uncompressed_name
;
14557 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14559 section
->name
= section
->compressed_name
;
14564 /* If we're loading from a subset of sections, and we've loaded
14565 a section matching this name before, it's likely that it's a
14567 if (section_subset
!= NULL
)
14568 free_debug_section (debug
);
14570 return load_specific_debug_section (debug
, sec
, data
);
14574 free_debug_section (enum dwarf_section_display_enum debug
)
14576 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14578 if (section
->start
== NULL
)
14581 free ((char *) section
->start
);
14582 section
->start
= NULL
;
14583 section
->address
= 0;
14586 if (section
->reloc_info
!= NULL
)
14588 free (section
->reloc_info
);
14589 section
->reloc_info
= NULL
;
14590 section
->num_relocs
= 0;
14595 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14597 char * name
= SECTION_NAME (section
);
14598 const char * print_name
= printable_section_name (filedata
, section
);
14599 bfd_size_type length
;
14600 bfd_boolean result
= TRUE
;
14603 length
= section
->sh_size
;
14606 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14609 if (section
->sh_type
== SHT_NOBITS
)
14611 /* There is no point in dumping the contents of a debugging section
14612 which has the NOBITS type - the bits in the file will be random.
14613 This can happen when a file containing a .eh_frame section is
14614 stripped with the --only-keep-debug command line option. */
14615 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14620 if (const_strneq (name
, ".gnu.linkonce.wi."))
14621 name
= ".debug_info";
14623 /* See if we know how to display the contents of this section. */
14624 for (i
= 0; i
< max
; i
++)
14626 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14627 struct dwarf_section_display
* display
= debug_displays
+ i
;
14628 struct dwarf_section
* sec
= & display
->section
;
14630 if (streq (sec
->uncompressed_name
, name
)
14631 || (id
== line
&& const_strneq (name
, ".debug_line."))
14632 || streq (sec
->compressed_name
, name
))
14634 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14637 free_debug_section (id
);
14639 if (i
== line
&& const_strneq (name
, ".debug_line."))
14641 else if (streq (sec
->uncompressed_name
, name
))
14642 sec
->name
= sec
->uncompressed_name
;
14644 sec
->name
= sec
->compressed_name
;
14646 if (load_specific_debug_section (id
, section
, filedata
))
14648 /* If this debug section is part of a CU/TU set in a .dwp file,
14649 restrict load_debug_section to the sections in that set. */
14650 section_subset
= find_cu_tu_set (filedata
, shndx
);
14652 result
&= display
->display (sec
, filedata
);
14654 section_subset
= NULL
;
14656 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14657 free_debug_section (id
);
14665 printf (_("Unrecognized debug section: %s\n"), print_name
);
14672 /* Set DUMP_SECTS for all sections where dumps were requested
14673 based on section name. */
14676 initialise_dumps_byname (Filedata
* filedata
)
14678 struct dump_list_entry
* cur
;
14680 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14683 bfd_boolean any
= FALSE
;
14685 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14686 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14688 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14693 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14699 process_section_contents (Filedata
* filedata
)
14701 Elf_Internal_Shdr
* section
;
14703 bfd_boolean res
= TRUE
;
14708 initialise_dumps_byname (filedata
);
14710 for (i
= 0, section
= filedata
->section_headers
;
14711 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14714 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14716 #ifdef SUPPORT_DISASSEMBLY
14717 if (dump
& DISASS_DUMP
)
14719 if (! disassemble_section (section
, filedata
))
14723 if (dump
& HEX_DUMP
)
14725 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14729 if (dump
& RELOC_DUMP
)
14731 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14735 if (dump
& STRING_DUMP
)
14737 if (! dump_section_as_strings (section
, filedata
))
14741 if (dump
& DEBUG_DUMP
)
14743 if (! display_debug_section (i
, section
, filedata
))
14747 if (dump
& CTF_DUMP
)
14749 if (! dump_section_as_ctf (section
, filedata
))
14754 /* Check to see if the user requested a
14755 dump of a section that does not exist. */
14756 while (i
< filedata
->dump
.num_dump_sects
)
14758 if (filedata
->dump
.dump_sects
[i
])
14760 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14770 process_mips_fpe_exception (int mask
)
14774 bfd_boolean first
= TRUE
;
14776 if (mask
& OEX_FPU_INEX
)
14777 fputs ("INEX", stdout
), first
= FALSE
;
14778 if (mask
& OEX_FPU_UFLO
)
14779 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14780 if (mask
& OEX_FPU_OFLO
)
14781 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14782 if (mask
& OEX_FPU_DIV0
)
14783 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14784 if (mask
& OEX_FPU_INVAL
)
14785 printf ("%sINVAL", first
? "" : "|");
14788 fputs ("0", stdout
);
14791 /* Display's the value of TAG at location P. If TAG is
14792 greater than 0 it is assumed to be an unknown tag, and
14793 a message is printed to this effect. Otherwise it is
14794 assumed that a message has already been printed.
14796 If the bottom bit of TAG is set it assumed to have a
14797 string value, otherwise it is assumed to have an integer
14800 Returns an updated P pointing to the first unread byte
14801 beyond the end of TAG's value.
14803 Reads at or beyond END will not be made. */
14805 static unsigned char *
14806 display_tag_value (signed int tag
,
14808 const unsigned char * const end
)
14813 printf (" Tag_unknown_%d: ", tag
);
14817 warn (_("<corrupt tag>\n"));
14821 /* PR 17531 file: 027-19978-0.004. */
14822 size_t maxlen
= (end
- p
) - 1;
14827 print_symbol ((int) maxlen
, (const char *) p
);
14828 p
+= strnlen ((char *) p
, maxlen
) + 1;
14832 printf (_("<corrupt string tag>"));
14833 p
= (unsigned char *) end
;
14839 READ_ULEB (val
, p
, end
);
14840 printf ("%ld (0x%lx)\n", val
, val
);
14847 /* ARC ABI attributes section. */
14849 static unsigned char *
14850 display_arc_attribute (unsigned char * p
,
14851 const unsigned char * const end
)
14856 READ_ULEB (tag
, p
, end
);
14860 case Tag_ARC_PCS_config
:
14861 READ_ULEB (val
, p
, end
);
14862 printf (" Tag_ARC_PCS_config: ");
14866 printf (_("Absent/Non standard\n"));
14869 printf (_("Bare metal/mwdt\n"));
14872 printf (_("Bare metal/newlib\n"));
14875 printf (_("Linux/uclibc\n"));
14878 printf (_("Linux/glibc\n"));
14881 printf (_("Unknown\n"));
14886 case Tag_ARC_CPU_base
:
14887 READ_ULEB (val
, p
, end
);
14888 printf (" Tag_ARC_CPU_base: ");
14893 printf (_("Absent\n"));
14895 case TAG_CPU_ARC6xx
:
14896 printf ("ARC6xx\n");
14898 case TAG_CPU_ARC7xx
:
14899 printf ("ARC7xx\n");
14901 case TAG_CPU_ARCEM
:
14902 printf ("ARCEM\n");
14904 case TAG_CPU_ARCHS
:
14905 printf ("ARCHS\n");
14910 case Tag_ARC_CPU_variation
:
14911 READ_ULEB (val
, p
, end
);
14912 printf (" Tag_ARC_CPU_variation: ");
14916 if (val
> 0 && val
< 16)
14917 printf ("Core%d\n", val
);
14919 printf ("Unknown\n");
14923 printf (_("Absent\n"));
14928 case Tag_ARC_CPU_name
:
14929 printf (" Tag_ARC_CPU_name: ");
14930 p
= display_tag_value (-1, p
, end
);
14933 case Tag_ARC_ABI_rf16
:
14934 READ_ULEB (val
, p
, end
);
14935 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14938 case Tag_ARC_ABI_osver
:
14939 READ_ULEB (val
, p
, end
);
14940 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14943 case Tag_ARC_ABI_pic
:
14944 case Tag_ARC_ABI_sda
:
14945 READ_ULEB (val
, p
, end
);
14946 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14947 : " Tag_ARC_ABI_pic: ");
14951 printf (_("Absent\n"));
14960 printf (_("Unknown\n"));
14965 case Tag_ARC_ABI_tls
:
14966 READ_ULEB (val
, p
, end
);
14967 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14970 case Tag_ARC_ABI_enumsize
:
14971 READ_ULEB (val
, p
, end
);
14972 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14976 case Tag_ARC_ABI_exceptions
:
14977 READ_ULEB (val
, p
, end
);
14978 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14982 case Tag_ARC_ABI_double_size
:
14983 READ_ULEB (val
, p
, end
);
14984 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14987 case Tag_ARC_ISA_config
:
14988 printf (" Tag_ARC_ISA_config: ");
14989 p
= display_tag_value (-1, p
, end
);
14992 case Tag_ARC_ISA_apex
:
14993 printf (" Tag_ARC_ISA_apex: ");
14994 p
= display_tag_value (-1, p
, end
);
14997 case Tag_ARC_ISA_mpy_option
:
14998 READ_ULEB (val
, p
, end
);
14999 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15002 case Tag_ARC_ATR_version
:
15003 READ_ULEB (val
, p
, end
);
15004 printf (" Tag_ARC_ATR_version: %d\n", val
);
15008 return display_tag_value (tag
& 1, p
, end
);
15014 /* ARM EABI attributes section. */
15019 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15021 const char ** table
;
15022 } arm_attr_public_tag
;
15024 static const char * arm_attr_tag_CPU_arch
[] =
15025 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15026 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15027 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15028 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15029 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15030 {"No", "Thumb-1", "Thumb-2", "Yes"};
15031 static const char * arm_attr_tag_FP_arch
[] =
15032 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15033 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15034 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15035 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15036 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15037 "NEON for ARMv8.1"};
15038 static const char * arm_attr_tag_PCS_config
[] =
15039 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15040 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15041 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15042 {"V6", "SB", "TLS", "Unused"};
15043 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15044 {"Absolute", "PC-relative", "SB-relative", "None"};
15045 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15046 {"Absolute", "PC-relative", "None"};
15047 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15048 {"None", "direct", "GOT-indirect"};
15049 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15050 {"None", "??? 1", "2", "??? 3", "4"};
15051 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15052 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15053 {"Unused", "Needed", "Sign only"};
15054 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15055 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15056 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15057 {"Unused", "Finite", "RTABI", "IEEE 754"};
15058 static const char * arm_attr_tag_ABI_enum_size
[] =
15059 {"Unused", "small", "int", "forced to int"};
15060 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15061 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15062 static const char * arm_attr_tag_ABI_VFP_args
[] =
15063 {"AAPCS", "VFP registers", "custom", "compatible"};
15064 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15065 {"AAPCS", "WMMX registers", "custom"};
15066 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15067 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15068 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15069 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15070 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15071 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15072 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15073 static const char * arm_attr_tag_FP_HP_extension
[] =
15074 {"Not Allowed", "Allowed"};
15075 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15076 {"None", "IEEE 754", "Alternative Format"};
15077 static const char * arm_attr_tag_DSP_extension
[] =
15078 {"Follow architecture", "Allowed"};
15079 static const char * arm_attr_tag_MPextension_use
[] =
15080 {"Not Allowed", "Allowed"};
15081 static const char * arm_attr_tag_DIV_use
[] =
15082 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15083 "Allowed in v7-A with integer division extension"};
15084 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15085 static const char * arm_attr_tag_Virtualization_use
[] =
15086 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15087 "TrustZone and Virtualization Extensions"};
15088 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15089 {"Not Allowed", "Allowed"};
15091 static const char * arm_attr_tag_MVE_arch
[] =
15092 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15094 #define LOOKUP(id, name) \
15095 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15096 static arm_attr_public_tag arm_attr_public_tags
[] =
15098 {4, "CPU_raw_name", 1, NULL
},
15099 {5, "CPU_name", 1, NULL
},
15100 LOOKUP(6, CPU_arch
),
15101 {7, "CPU_arch_profile", 0, NULL
},
15102 LOOKUP(8, ARM_ISA_use
),
15103 LOOKUP(9, THUMB_ISA_use
),
15104 LOOKUP(10, FP_arch
),
15105 LOOKUP(11, WMMX_arch
),
15106 LOOKUP(12, Advanced_SIMD_arch
),
15107 LOOKUP(13, PCS_config
),
15108 LOOKUP(14, ABI_PCS_R9_use
),
15109 LOOKUP(15, ABI_PCS_RW_data
),
15110 LOOKUP(16, ABI_PCS_RO_data
),
15111 LOOKUP(17, ABI_PCS_GOT_use
),
15112 LOOKUP(18, ABI_PCS_wchar_t
),
15113 LOOKUP(19, ABI_FP_rounding
),
15114 LOOKUP(20, ABI_FP_denormal
),
15115 LOOKUP(21, ABI_FP_exceptions
),
15116 LOOKUP(22, ABI_FP_user_exceptions
),
15117 LOOKUP(23, ABI_FP_number_model
),
15118 {24, "ABI_align_needed", 0, NULL
},
15119 {25, "ABI_align_preserved", 0, NULL
},
15120 LOOKUP(26, ABI_enum_size
),
15121 LOOKUP(27, ABI_HardFP_use
),
15122 LOOKUP(28, ABI_VFP_args
),
15123 LOOKUP(29, ABI_WMMX_args
),
15124 LOOKUP(30, ABI_optimization_goals
),
15125 LOOKUP(31, ABI_FP_optimization_goals
),
15126 {32, "compatibility", 0, NULL
},
15127 LOOKUP(34, CPU_unaligned_access
),
15128 LOOKUP(36, FP_HP_extension
),
15129 LOOKUP(38, ABI_FP_16bit_format
),
15130 LOOKUP(42, MPextension_use
),
15131 LOOKUP(44, DIV_use
),
15132 LOOKUP(46, DSP_extension
),
15133 LOOKUP(48, MVE_arch
),
15134 {64, "nodefaults", 0, NULL
},
15135 {65, "also_compatible_with", 0, NULL
},
15136 LOOKUP(66, T2EE_use
),
15137 {67, "conformance", 1, NULL
},
15138 LOOKUP(68, Virtualization_use
),
15139 LOOKUP(70, MPextension_use_legacy
)
15143 static unsigned char *
15144 display_arm_attribute (unsigned char * p
,
15145 const unsigned char * const end
)
15149 arm_attr_public_tag
* attr
;
15153 READ_ULEB (tag
, p
, end
);
15155 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15157 if (arm_attr_public_tags
[i
].tag
== tag
)
15159 attr
= &arm_attr_public_tags
[i
];
15166 printf (" Tag_%s: ", attr
->name
);
15167 switch (attr
->type
)
15172 case 7: /* Tag_CPU_arch_profile. */
15173 READ_ULEB (val
, p
, end
);
15176 case 0: printf (_("None\n")); break;
15177 case 'A': printf (_("Application\n")); break;
15178 case 'R': printf (_("Realtime\n")); break;
15179 case 'M': printf (_("Microcontroller\n")); break;
15180 case 'S': printf (_("Application or Realtime\n")); break;
15181 default: printf ("??? (%d)\n", val
); break;
15185 case 24: /* Tag_align_needed. */
15186 READ_ULEB (val
, p
, end
);
15189 case 0: printf (_("None\n")); break;
15190 case 1: printf (_("8-byte\n")); break;
15191 case 2: printf (_("4-byte\n")); break;
15192 case 3: printf ("??? 3\n"); break;
15195 printf (_("8-byte and up to %d-byte extended\n"),
15198 printf ("??? (%d)\n", val
);
15203 case 25: /* Tag_align_preserved. */
15204 READ_ULEB (val
, p
, end
);
15207 case 0: printf (_("None\n")); break;
15208 case 1: printf (_("8-byte, except leaf SP\n")); break;
15209 case 2: printf (_("8-byte\n")); break;
15210 case 3: printf ("??? 3\n"); break;
15213 printf (_("8-byte and up to %d-byte extended\n"),
15216 printf ("??? (%d)\n", val
);
15221 case 32: /* Tag_compatibility. */
15223 READ_ULEB (val
, p
, end
);
15224 printf (_("flag = %d, vendor = "), val
);
15227 size_t maxlen
= (end
- p
) - 1;
15229 print_symbol ((int) maxlen
, (const char *) p
);
15230 p
+= strnlen ((char *) p
, maxlen
) + 1;
15234 printf (_("<corrupt>"));
15235 p
= (unsigned char *) end
;
15241 case 64: /* Tag_nodefaults. */
15242 /* PR 17531: file: 001-505008-0.01. */
15245 printf (_("True\n"));
15248 case 65: /* Tag_also_compatible_with. */
15249 READ_ULEB (val
, p
, end
);
15250 if (val
== 6 /* Tag_CPU_arch. */)
15252 READ_ULEB (val
, p
, end
);
15253 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15254 printf ("??? (%d)\n", val
);
15256 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15260 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15265 printf (_("<unknown: %d>\n"), tag
);
15271 return display_tag_value (-1, p
, end
);
15273 return display_tag_value (0, p
, end
);
15276 assert (attr
->type
& 0x80);
15277 READ_ULEB (val
, p
, end
);
15278 type
= attr
->type
& 0x7f;
15280 printf ("??? (%d)\n", val
);
15282 printf ("%s\n", attr
->table
[val
]);
15287 return display_tag_value (tag
, p
, end
);
15290 static unsigned char *
15291 display_gnu_attribute (unsigned char * p
,
15292 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15293 const unsigned char * const end
)
15298 READ_ULEB (tag
, p
, end
);
15300 /* Tag_compatibility is the only generic GNU attribute defined at
15304 READ_ULEB (val
, p
, end
);
15306 printf (_("flag = %d, vendor = "), val
);
15309 printf (_("<corrupt>\n"));
15310 warn (_("corrupt vendor attribute\n"));
15316 size_t maxlen
= (end
- p
) - 1;
15318 print_symbol ((int) maxlen
, (const char *) p
);
15319 p
+= strnlen ((char *) p
, maxlen
) + 1;
15323 printf (_("<corrupt>"));
15324 p
= (unsigned char *) end
;
15331 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15332 return display_proc_gnu_attribute (p
, tag
, end
);
15334 return display_tag_value (tag
, p
, end
);
15337 static unsigned char *
15338 display_power_gnu_attribute (unsigned char * p
,
15340 const unsigned char * const end
)
15344 if (tag
== Tag_GNU_Power_ABI_FP
)
15346 printf (" Tag_GNU_Power_ABI_FP: ");
15349 printf (_("<corrupt>\n"));
15352 READ_ULEB (val
, p
, end
);
15355 printf ("(%#x), ", val
);
15360 printf (_("unspecified hard/soft float, "));
15363 printf (_("hard float, "));
15366 printf (_("soft float, "));
15369 printf (_("single-precision hard float, "));
15376 printf (_("unspecified long double\n"));
15379 printf (_("128-bit IBM long double\n"));
15382 printf (_("64-bit long double\n"));
15385 printf (_("128-bit IEEE long double\n"));
15391 if (tag
== Tag_GNU_Power_ABI_Vector
)
15393 printf (" Tag_GNU_Power_ABI_Vector: ");
15396 printf (_("<corrupt>\n"));
15399 READ_ULEB (val
, p
, end
);
15402 printf ("(%#x), ", val
);
15407 printf (_("unspecified\n"));
15410 printf (_("generic\n"));
15413 printf ("AltiVec\n");
15422 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15424 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15427 printf (_("<corrupt>\n"));
15430 READ_ULEB (val
, p
, end
);
15433 printf ("(%#x), ", val
);
15438 printf (_("unspecified\n"));
15441 printf ("r3/r4\n");
15444 printf (_("memory\n"));
15453 return display_tag_value (tag
& 1, p
, end
);
15456 static unsigned char *
15457 display_s390_gnu_attribute (unsigned char * p
,
15459 const unsigned char * const end
)
15463 if (tag
== Tag_GNU_S390_ABI_Vector
)
15465 printf (" Tag_GNU_S390_ABI_Vector: ");
15466 READ_ULEB (val
, p
, end
);
15471 printf (_("any\n"));
15474 printf (_("software\n"));
15477 printf (_("hardware\n"));
15480 printf ("??? (%d)\n", val
);
15486 return display_tag_value (tag
& 1, p
, end
);
15490 display_sparc_hwcaps (unsigned int mask
)
15494 bfd_boolean first
= TRUE
;
15496 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15497 fputs ("mul32", stdout
), first
= FALSE
;
15498 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15499 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15500 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15501 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15502 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15503 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15504 if (mask
& ELF_SPARC_HWCAP_POPC
)
15505 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15506 if (mask
& ELF_SPARC_HWCAP_VIS
)
15507 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15508 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15509 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15510 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15511 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15512 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15513 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15514 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15515 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15516 if (mask
& ELF_SPARC_HWCAP_HPC
)
15517 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15518 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15519 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15520 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15521 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15522 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15523 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15524 if (mask
& ELF_SPARC_HWCAP_IMA
)
15525 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15526 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15527 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15530 fputc ('0', stdout
);
15531 fputc ('\n', stdout
);
15535 display_sparc_hwcaps2 (unsigned int mask
)
15539 bfd_boolean first
= TRUE
;
15541 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15542 fputs ("fjathplus", stdout
), first
= FALSE
;
15543 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15544 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15545 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15546 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15547 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15548 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15549 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15550 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15551 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15552 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15553 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15554 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15555 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15556 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15557 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15558 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15559 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15560 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15561 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15562 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15565 fputc ('0', stdout
);
15566 fputc ('\n', stdout
);
15569 static unsigned char *
15570 display_sparc_gnu_attribute (unsigned char * p
,
15572 const unsigned char * const end
)
15576 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15578 READ_ULEB (val
, p
, end
);
15579 printf (" Tag_GNU_Sparc_HWCAPS: ");
15580 display_sparc_hwcaps (val
);
15583 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15585 READ_ULEB (val
, p
, end
);
15586 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15587 display_sparc_hwcaps2 (val
);
15591 return display_tag_value (tag
, p
, end
);
15595 print_mips_fp_abi_value (unsigned int val
)
15599 case Val_GNU_MIPS_ABI_FP_ANY
:
15600 printf (_("Hard or soft float\n"));
15602 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15603 printf (_("Hard float (double precision)\n"));
15605 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15606 printf (_("Hard float (single precision)\n"));
15608 case Val_GNU_MIPS_ABI_FP_SOFT
:
15609 printf (_("Soft float\n"));
15611 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15612 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15614 case Val_GNU_MIPS_ABI_FP_XX
:
15615 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15617 case Val_GNU_MIPS_ABI_FP_64
:
15618 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15620 case Val_GNU_MIPS_ABI_FP_64A
:
15621 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15623 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15624 printf (_("NaN 2008 compatibility\n"));
15627 printf ("??? (%d)\n", val
);
15632 static unsigned char *
15633 display_mips_gnu_attribute (unsigned char * p
,
15635 const unsigned char * const end
)
15637 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15641 printf (" Tag_GNU_MIPS_ABI_FP: ");
15642 READ_ULEB (val
, p
, end
);
15643 print_mips_fp_abi_value (val
);
15647 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15651 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15652 READ_ULEB (val
, p
, end
);
15656 case Val_GNU_MIPS_ABI_MSA_ANY
:
15657 printf (_("Any MSA or not\n"));
15659 case Val_GNU_MIPS_ABI_MSA_128
:
15660 printf (_("128-bit MSA\n"));
15663 printf ("??? (%d)\n", val
);
15669 return display_tag_value (tag
& 1, p
, end
);
15672 static unsigned char *
15673 display_tic6x_attribute (unsigned char * p
,
15674 const unsigned char * const end
)
15679 READ_ULEB (tag
, p
, end
);
15684 printf (" Tag_ISA: ");
15685 READ_ULEB (val
, p
, end
);
15689 case C6XABI_Tag_ISA_none
:
15690 printf (_("None\n"));
15692 case C6XABI_Tag_ISA_C62X
:
15695 case C6XABI_Tag_ISA_C67X
:
15698 case C6XABI_Tag_ISA_C67XP
:
15699 printf ("C67x+\n");
15701 case C6XABI_Tag_ISA_C64X
:
15704 case C6XABI_Tag_ISA_C64XP
:
15705 printf ("C64x+\n");
15707 case C6XABI_Tag_ISA_C674X
:
15708 printf ("C674x\n");
15711 printf ("??? (%d)\n", val
);
15716 case Tag_ABI_wchar_t
:
15717 printf (" Tag_ABI_wchar_t: ");
15718 READ_ULEB (val
, p
, end
);
15722 printf (_("Not used\n"));
15725 printf (_("2 bytes\n"));
15728 printf (_("4 bytes\n"));
15731 printf ("??? (%d)\n", val
);
15736 case Tag_ABI_stack_align_needed
:
15737 printf (" Tag_ABI_stack_align_needed: ");
15738 READ_ULEB (val
, p
, end
);
15742 printf (_("8-byte\n"));
15745 printf (_("16-byte\n"));
15748 printf ("??? (%d)\n", val
);
15753 case Tag_ABI_stack_align_preserved
:
15754 READ_ULEB (val
, p
, end
);
15755 printf (" Tag_ABI_stack_align_preserved: ");
15759 printf (_("8-byte\n"));
15762 printf (_("16-byte\n"));
15765 printf ("??? (%d)\n", val
);
15771 READ_ULEB (val
, p
, end
);
15772 printf (" Tag_ABI_DSBT: ");
15776 printf (_("DSBT addressing not used\n"));
15779 printf (_("DSBT addressing used\n"));
15782 printf ("??? (%d)\n", val
);
15788 READ_ULEB (val
, p
, end
);
15789 printf (" Tag_ABI_PID: ");
15793 printf (_("Data addressing position-dependent\n"));
15796 printf (_("Data addressing position-independent, GOT near DP\n"));
15799 printf (_("Data addressing position-independent, GOT far from DP\n"));
15802 printf ("??? (%d)\n", val
);
15808 READ_ULEB (val
, p
, end
);
15809 printf (" Tag_ABI_PIC: ");
15813 printf (_("Code addressing position-dependent\n"));
15816 printf (_("Code addressing position-independent\n"));
15819 printf ("??? (%d)\n", val
);
15824 case Tag_ABI_array_object_alignment
:
15825 READ_ULEB (val
, p
, end
);
15826 printf (" Tag_ABI_array_object_alignment: ");
15830 printf (_("8-byte\n"));
15833 printf (_("4-byte\n"));
15836 printf (_("16-byte\n"));
15839 printf ("??? (%d)\n", val
);
15844 case Tag_ABI_array_object_align_expected
:
15845 READ_ULEB (val
, p
, end
);
15846 printf (" Tag_ABI_array_object_align_expected: ");
15850 printf (_("8-byte\n"));
15853 printf (_("4-byte\n"));
15856 printf (_("16-byte\n"));
15859 printf ("??? (%d)\n", val
);
15864 case Tag_ABI_compatibility
:
15866 READ_ULEB (val
, p
, end
);
15867 printf (" Tag_ABI_compatibility: ");
15868 printf (_("flag = %d, vendor = "), val
);
15871 size_t maxlen
= (end
- p
) - 1;
15873 print_symbol ((int) maxlen
, (const char *) p
);
15874 p
+= strnlen ((char *) p
, maxlen
) + 1;
15878 printf (_("<corrupt>"));
15879 p
= (unsigned char *) end
;
15885 case Tag_ABI_conformance
:
15887 printf (" Tag_ABI_conformance: \"");
15890 size_t maxlen
= (end
- p
) - 1;
15892 print_symbol ((int) maxlen
, (const char *) p
);
15893 p
+= strnlen ((char *) p
, maxlen
) + 1;
15897 printf (_("<corrupt>"));
15898 p
= (unsigned char *) end
;
15905 return display_tag_value (tag
, p
, end
);
15909 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15911 unsigned long addr
= 0;
15912 size_t bytes
= end
- p
;
15919 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15921 printf (" 0x%8.8lx ", addr
);
15923 for (j
= 0; j
< 16; j
++)
15926 printf ("%2.2x", p
[j
]);
15934 for (j
= 0; j
< lbytes
; j
++)
15937 if (k
>= ' ' && k
< 0x7f)
15953 static unsigned char *
15954 display_msp430x_attribute (unsigned char * p
,
15955 const unsigned char * const end
)
15960 READ_ULEB (tag
, p
, end
);
15964 case OFBA_MSPABI_Tag_ISA
:
15965 printf (" Tag_ISA: ");
15966 READ_ULEB (val
, p
, end
);
15969 case 0: printf (_("None\n")); break;
15970 case 1: printf (_("MSP430\n")); break;
15971 case 2: printf (_("MSP430X\n")); break;
15972 default: printf ("??? (%d)\n", val
); break;
15976 case OFBA_MSPABI_Tag_Code_Model
:
15977 printf (" Tag_Code_Model: ");
15978 READ_ULEB (val
, p
, end
);
15981 case 0: printf (_("None\n")); break;
15982 case 1: printf (_("Small\n")); break;
15983 case 2: printf (_("Large\n")); break;
15984 default: printf ("??? (%d)\n", val
); break;
15988 case OFBA_MSPABI_Tag_Data_Model
:
15989 printf (" Tag_Data_Model: ");
15990 READ_ULEB (val
, p
, end
);
15993 case 0: printf (_("None\n")); break;
15994 case 1: printf (_("Small\n")); break;
15995 case 2: printf (_("Large\n")); break;
15996 case 3: printf (_("Restricted Large\n")); break;
15997 default: printf ("??? (%d)\n", val
); break;
16002 printf (_(" <unknown tag %d>: "), tag
);
16009 size_t maxlen
= (end
- p
) - 1;
16011 print_symbol ((int) maxlen
, (const char *) p
);
16012 p
+= strnlen ((char *) p
, maxlen
) + 1;
16016 printf (_("<corrupt>"));
16017 p
= (unsigned char *) end
;
16023 READ_ULEB (val
, p
, end
);
16024 printf ("%d (0x%x)\n", val
, val
);
16033 static unsigned char *
16034 display_msp430_gnu_attribute (unsigned char * p
,
16036 const unsigned char * const end
)
16038 if (tag
== Tag_GNU_MSP430_Data_Region
)
16042 printf (" Tag_GNU_MSP430_Data_Region: ");
16043 READ_ULEB (val
, p
, end
);
16047 case Val_GNU_MSP430_Data_Region_Any
:
16048 printf (_("Any Region\n"));
16050 case Val_GNU_MSP430_Data_Region_Lower
:
16051 printf (_("Lower Region Only\n"));
16054 printf ("??? (%u)\n", val
);
16058 return display_tag_value (tag
& 1, p
, end
);
16061 struct riscv_attr_tag_t
{
16066 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16068 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16071 T(priv_spec_minor
),
16072 T(priv_spec_revision
),
16073 T(unaligned_access
),
16078 static unsigned char *
16079 display_riscv_attribute (unsigned char *p
,
16080 const unsigned char * const end
)
16084 struct riscv_attr_tag_t
*attr
= NULL
;
16087 READ_ULEB (tag
, p
, end
);
16089 /* Find the name of attribute. */
16090 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16092 if (riscv_attr_tag
[i
].tag
== tag
)
16094 attr
= &riscv_attr_tag
[i
];
16100 printf (" %s: ", attr
->name
);
16102 return display_tag_value (tag
, p
, end
);
16106 case Tag_RISCV_priv_spec
:
16107 case Tag_RISCV_priv_spec_minor
:
16108 case Tag_RISCV_priv_spec_revision
:
16109 READ_ULEB (val
, p
, end
);
16110 printf (_("%u\n"), val
);
16112 case Tag_RISCV_unaligned_access
:
16113 READ_ULEB (val
, p
, end
);
16117 printf (_("No unaligned access\n"));
16120 printf (_("Unaligned access\n"));
16124 case Tag_RISCV_stack_align
:
16125 READ_ULEB (val
, p
, end
);
16126 printf (_("%u-bytes\n"), val
);
16128 case Tag_RISCV_arch
:
16129 p
= display_tag_value (-1, p
, end
);
16132 return display_tag_value (tag
, p
, end
);
16139 process_attributes (Filedata
* filedata
,
16140 const char * public_name
,
16141 unsigned int proc_type
,
16142 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16143 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16145 Elf_Internal_Shdr
* sect
;
16147 bfd_boolean res
= TRUE
;
16149 /* Find the section header so that we get the size. */
16150 for (i
= 0, sect
= filedata
->section_headers
;
16151 i
< filedata
->file_header
.e_shnum
;
16154 unsigned char * contents
;
16157 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16160 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16161 sect
->sh_size
, _("attributes"));
16162 if (contents
== NULL
)
16169 /* The first character is the version of the attributes.
16170 Currently only version 1, (aka 'A') is recognised here. */
16173 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16178 bfd_vma section_len
;
16180 section_len
= sect
->sh_size
- 1;
16183 while (section_len
> 0)
16186 unsigned int namelen
;
16187 bfd_boolean public_section
;
16188 bfd_boolean gnu_section
;
16190 if (section_len
<= 4)
16192 error (_("Tag section ends prematurely\n"));
16196 attr_len
= byte_get (p
, 4);
16199 if (attr_len
> section_len
)
16201 error (_("Bad attribute length (%u > %u)\n"),
16202 (unsigned) attr_len
, (unsigned) section_len
);
16203 attr_len
= section_len
;
16206 /* PR 17531: file: 001-101425-0.004 */
16207 else if (attr_len
< 5)
16209 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16214 section_len
-= attr_len
;
16217 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16218 if (namelen
== 0 || namelen
>= attr_len
)
16220 error (_("Corrupt attribute section name\n"));
16225 printf (_("Attribute Section: "));
16226 print_symbol (INT_MAX
, (const char *) p
);
16229 if (public_name
&& streq ((char *) p
, public_name
))
16230 public_section
= TRUE
;
16232 public_section
= FALSE
;
16234 if (streq ((char *) p
, "gnu"))
16235 gnu_section
= TRUE
;
16237 gnu_section
= FALSE
;
16240 attr_len
-= namelen
;
16242 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16247 unsigned char * end
;
16249 /* PR binutils/17531: Safe handling of corrupt files. */
16252 error (_("Unused bytes at end of section\n"));
16259 size
= byte_get (p
, 4);
16260 if (size
> attr_len
)
16262 error (_("Bad subsection length (%u > %u)\n"),
16263 (unsigned) size
, (unsigned) attr_len
);
16267 /* PR binutils/17531: Safe handling of corrupt files. */
16270 error (_("Bad subsection length (%u < 6)\n"),
16278 end
= p
+ size
- 1;
16279 assert (end
<= contents
+ sect
->sh_size
);
16285 printf (_("File Attributes\n"));
16288 printf (_("Section Attributes:"));
16291 printf (_("Symbol Attributes:"));
16292 /* Fall through. */
16296 READ_ULEB (val
, p
, end
);
16299 printf (" %d", val
);
16304 printf (_("Unknown tag: %d\n"), tag
);
16305 public_section
= FALSE
;
16309 if (public_section
&& display_pub_attribute
!= NULL
)
16312 p
= display_pub_attribute (p
, end
);
16315 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16318 p
= display_gnu_attribute (p
,
16319 display_proc_gnu_attribute
,
16325 printf (_(" Unknown attribute:\n"));
16326 display_raw_attribute (p
, end
);
16341 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16342 Print the Address, Access and Initial fields of an entry at VMA ADDR
16343 and return the VMA of the next entry, or -1 if there was a problem.
16344 Does not read from DATA_END or beyond. */
16347 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16348 unsigned char * data_end
)
16351 print_vma (addr
, LONG_HEX
);
16353 if (addr
< pltgot
+ 0xfff0)
16354 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16356 printf ("%10s", "");
16359 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16363 unsigned char * from
= data
+ addr
- pltgot
;
16365 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16367 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16368 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16369 return (bfd_vma
) -1;
16373 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16374 print_vma (entry
, LONG_HEX
);
16377 return addr
+ (is_32bit_elf
? 4 : 8);
16380 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16381 PLTGOT. Print the Address and Initial fields of an entry at VMA
16382 ADDR and return the VMA of the next entry. */
16385 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16388 print_vma (addr
, LONG_HEX
);
16391 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16396 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16397 print_vma (entry
, LONG_HEX
);
16399 return addr
+ (is_32bit_elf
? 4 : 8);
16403 print_mips_ases (unsigned int mask
)
16405 if (mask
& AFL_ASE_DSP
)
16406 fputs ("\n\tDSP ASE", stdout
);
16407 if (mask
& AFL_ASE_DSPR2
)
16408 fputs ("\n\tDSP R2 ASE", stdout
);
16409 if (mask
& AFL_ASE_DSPR3
)
16410 fputs ("\n\tDSP R3 ASE", stdout
);
16411 if (mask
& AFL_ASE_EVA
)
16412 fputs ("\n\tEnhanced VA Scheme", stdout
);
16413 if (mask
& AFL_ASE_MCU
)
16414 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16415 if (mask
& AFL_ASE_MDMX
)
16416 fputs ("\n\tMDMX ASE", stdout
);
16417 if (mask
& AFL_ASE_MIPS3D
)
16418 fputs ("\n\tMIPS-3D ASE", stdout
);
16419 if (mask
& AFL_ASE_MT
)
16420 fputs ("\n\tMT ASE", stdout
);
16421 if (mask
& AFL_ASE_SMARTMIPS
)
16422 fputs ("\n\tSmartMIPS ASE", stdout
);
16423 if (mask
& AFL_ASE_VIRT
)
16424 fputs ("\n\tVZ ASE", stdout
);
16425 if (mask
& AFL_ASE_MSA
)
16426 fputs ("\n\tMSA ASE", stdout
);
16427 if (mask
& AFL_ASE_MIPS16
)
16428 fputs ("\n\tMIPS16 ASE", stdout
);
16429 if (mask
& AFL_ASE_MICROMIPS
)
16430 fputs ("\n\tMICROMIPS ASE", stdout
);
16431 if (mask
& AFL_ASE_XPA
)
16432 fputs ("\n\tXPA ASE", stdout
);
16433 if (mask
& AFL_ASE_MIPS16E2
)
16434 fputs ("\n\tMIPS16e2 ASE", stdout
);
16435 if (mask
& AFL_ASE_CRC
)
16436 fputs ("\n\tCRC ASE", stdout
);
16437 if (mask
& AFL_ASE_GINV
)
16438 fputs ("\n\tGINV ASE", stdout
);
16439 if (mask
& AFL_ASE_LOONGSON_MMI
)
16440 fputs ("\n\tLoongson MMI ASE", stdout
);
16441 if (mask
& AFL_ASE_LOONGSON_CAM
)
16442 fputs ("\n\tLoongson CAM ASE", stdout
);
16443 if (mask
& AFL_ASE_LOONGSON_EXT
)
16444 fputs ("\n\tLoongson EXT ASE", stdout
);
16445 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16446 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16448 fprintf (stdout
, "\n\t%s", _("None"));
16449 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16450 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16454 print_mips_isa_ext (unsigned int isa_ext
)
16459 fputs (_("None"), stdout
);
16462 fputs ("RMI XLR", stdout
);
16464 case AFL_EXT_OCTEON3
:
16465 fputs ("Cavium Networks Octeon3", stdout
);
16467 case AFL_EXT_OCTEON2
:
16468 fputs ("Cavium Networks Octeon2", stdout
);
16470 case AFL_EXT_OCTEONP
:
16471 fputs ("Cavium Networks OcteonP", stdout
);
16473 case AFL_EXT_OCTEON
:
16474 fputs ("Cavium Networks Octeon", stdout
);
16477 fputs ("Toshiba R5900", stdout
);
16480 fputs ("MIPS R4650", stdout
);
16483 fputs ("LSI R4010", stdout
);
16486 fputs ("NEC VR4100", stdout
);
16489 fputs ("Toshiba R3900", stdout
);
16491 case AFL_EXT_10000
:
16492 fputs ("MIPS R10000", stdout
);
16495 fputs ("Broadcom SB-1", stdout
);
16498 fputs ("NEC VR4111/VR4181", stdout
);
16501 fputs ("NEC VR4120", stdout
);
16504 fputs ("NEC VR5400", stdout
);
16507 fputs ("NEC VR5500", stdout
);
16509 case AFL_EXT_LOONGSON_2E
:
16510 fputs ("ST Microelectronics Loongson 2E", stdout
);
16512 case AFL_EXT_LOONGSON_2F
:
16513 fputs ("ST Microelectronics Loongson 2F", stdout
);
16515 case AFL_EXT_INTERAPTIV_MR2
:
16516 fputs ("Imagination interAptiv MR2", stdout
);
16519 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16524 get_mips_reg_size (int reg_size
)
16526 return (reg_size
== AFL_REG_NONE
) ? 0
16527 : (reg_size
== AFL_REG_32
) ? 32
16528 : (reg_size
== AFL_REG_64
) ? 64
16529 : (reg_size
== AFL_REG_128
) ? 128
16534 process_mips_specific (Filedata
* filedata
)
16536 Elf_Internal_Dyn
* entry
;
16537 Elf_Internal_Shdr
*sect
= NULL
;
16538 size_t liblist_offset
= 0;
16539 size_t liblistno
= 0;
16540 size_t conflictsno
= 0;
16541 size_t options_offset
= 0;
16542 size_t conflicts_offset
= 0;
16543 size_t pltrelsz
= 0;
16545 bfd_vma pltgot
= 0;
16546 bfd_vma mips_pltgot
= 0;
16547 bfd_vma jmprel
= 0;
16548 bfd_vma local_gotno
= 0;
16549 bfd_vma gotsym
= 0;
16550 bfd_vma symtabno
= 0;
16551 bfd_boolean res
= TRUE
;
16553 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16554 display_mips_gnu_attribute
))
16557 sect
= find_section (filedata
, ".MIPS.abiflags");
16561 Elf_External_ABIFlags_v0
*abiflags_ext
;
16562 Elf_Internal_ABIFlags_v0 abiflags_in
;
16564 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16566 error (_("Corrupt MIPS ABI Flags section.\n"));
16571 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16572 sect
->sh_size
, _("MIPS ABI Flags section"));
16575 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16576 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16577 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16578 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16579 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16580 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16581 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16582 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16583 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16584 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16585 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16587 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16588 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16589 if (abiflags_in
.isa_rev
> 1)
16590 printf ("r%d", abiflags_in
.isa_rev
);
16591 printf ("\nGPR size: %d",
16592 get_mips_reg_size (abiflags_in
.gpr_size
));
16593 printf ("\nCPR1 size: %d",
16594 get_mips_reg_size (abiflags_in
.cpr1_size
));
16595 printf ("\nCPR2 size: %d",
16596 get_mips_reg_size (abiflags_in
.cpr2_size
));
16597 fputs ("\nFP ABI: ", stdout
);
16598 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16599 fputs ("ISA Extension: ", stdout
);
16600 print_mips_isa_ext (abiflags_in
.isa_ext
);
16601 fputs ("\nASEs:", stdout
);
16602 print_mips_ases (abiflags_in
.ases
);
16603 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16604 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16605 fputc ('\n', stdout
);
16606 free (abiflags_ext
);
16611 /* We have a lot of special sections. Thanks SGI! */
16612 if (filedata
->dynamic_section
== NULL
)
16614 /* No dynamic information available. See if there is static GOT. */
16615 sect
= find_section (filedata
, ".got");
16618 unsigned char *data_end
;
16619 unsigned char *data
;
16623 pltgot
= sect
->sh_addr
;
16626 addr_size
= (is_32bit_elf
? 4 : 8);
16627 end
= pltgot
+ sect
->sh_size
;
16629 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16631 _("Global Offset Table data"));
16632 /* PR 12855: Null data is handled gracefully throughout. */
16633 data_end
= data
+ (end
- pltgot
);
16635 printf (_("\nStatic GOT:\n"));
16636 printf (_(" Canonical gp value: "));
16637 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16640 /* In a dynamic binary GOT[0] is reserved for the dynamic
16641 loader to store the lazy resolver pointer, however in
16642 a static binary it may well have been omitted and GOT
16643 reduced to a table of addresses.
16644 PR 21344: Check for the entry being fully available
16645 before fetching it. */
16647 && data
+ ent
- pltgot
+ addr_size
<= data_end
16648 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16650 printf (_(" Reserved entries:\n"));
16651 printf (_(" %*s %10s %*s\n"),
16652 addr_size
* 2, _("Address"), _("Access"),
16653 addr_size
* 2, _("Value"));
16654 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16656 if (ent
== (bfd_vma
) -1)
16657 goto sgot_print_fail
;
16659 /* Check for the MSB of GOT[1] being set, identifying a
16660 GNU object. This entry will be used by some runtime
16661 loaders, to store the module pointer. Otherwise this
16662 is an ordinary local entry.
16663 PR 21344: Check for the entry being fully available
16664 before fetching it. */
16666 && data
+ ent
- pltgot
+ addr_size
<= data_end
16667 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16668 >> (addr_size
* 8 - 1)) != 0)
16670 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16672 if (ent
== (bfd_vma
) -1)
16673 goto sgot_print_fail
;
16678 if (data
!= NULL
&& ent
< end
)
16680 printf (_(" Local entries:\n"));
16681 printf (" %*s %10s %*s\n",
16682 addr_size
* 2, _("Address"), _("Access"),
16683 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
;
16701 for (entry
= filedata
->dynamic_section
;
16702 /* PR 17531 file: 012-50589-0.004. */
16703 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16704 && entry
->d_tag
!= DT_NULL
);
16706 switch (entry
->d_tag
)
16708 case DT_MIPS_LIBLIST
:
16710 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16711 liblistno
* sizeof (Elf32_External_Lib
));
16713 case DT_MIPS_LIBLISTNO
:
16714 liblistno
= entry
->d_un
.d_val
;
16716 case DT_MIPS_OPTIONS
:
16717 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16719 case DT_MIPS_CONFLICT
:
16721 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16722 conflictsno
* sizeof (Elf32_External_Conflict
));
16724 case DT_MIPS_CONFLICTNO
:
16725 conflictsno
= entry
->d_un
.d_val
;
16728 pltgot
= entry
->d_un
.d_ptr
;
16730 case DT_MIPS_LOCAL_GOTNO
:
16731 local_gotno
= entry
->d_un
.d_val
;
16733 case DT_MIPS_GOTSYM
:
16734 gotsym
= entry
->d_un
.d_val
;
16736 case DT_MIPS_SYMTABNO
:
16737 symtabno
= entry
->d_un
.d_val
;
16739 case DT_MIPS_PLTGOT
:
16740 mips_pltgot
= entry
->d_un
.d_ptr
;
16743 pltrel
= entry
->d_un
.d_val
;
16746 pltrelsz
= entry
->d_un
.d_val
;
16749 jmprel
= entry
->d_un
.d_ptr
;
16755 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16757 Elf32_External_Lib
* elib
;
16760 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16761 sizeof (Elf32_External_Lib
),
16763 _("liblist section data"));
16766 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16767 "\nSection '.liblist' contains %lu entries:\n",
16768 (unsigned long) liblistno
),
16769 (unsigned long) liblistno
);
16770 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16773 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16780 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16781 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16782 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16783 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16784 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16786 tmp
= gmtime (&atime
);
16787 snprintf (timebuf
, sizeof (timebuf
),
16788 "%04u-%02u-%02uT%02u:%02u:%02u",
16789 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16790 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16792 printf ("%3lu: ", (unsigned long) cnt
);
16793 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
16794 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
16796 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16797 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16798 liblist
.l_version
);
16800 if (liblist
.l_flags
== 0)
16804 static const struct
16811 { " EXACT_MATCH", LL_EXACT_MATCH
},
16812 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16813 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16814 { " EXPORTS", LL_EXPORTS
},
16815 { " DELAY_LOAD", LL_DELAY_LOAD
},
16816 { " DELTA", LL_DELTA
}
16818 int flags
= liblist
.l_flags
;
16821 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16822 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16824 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16825 flags
^= l_flags_vals
[fcnt
].bit
;
16828 printf (" %#x", (unsigned int) flags
);
16840 if (options_offset
!= 0)
16842 Elf_External_Options
* eopt
;
16845 sect
= filedata
->section_headers
;
16847 /* Find the section header so that we get the size. */
16848 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16849 /* PR 17533 file: 012-277276-0.004. */
16852 error (_("No MIPS_OPTIONS header found\n"));
16856 if (sect
->sh_size
< sizeof (* eopt
))
16858 error (_("The MIPS options section is too small.\n"));
16862 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16863 sect
->sh_size
, _("options"));
16866 Elf_Internal_Options
* iopt
;
16867 Elf_Internal_Options
* option
;
16868 Elf_Internal_Options
* iopt_end
;
16870 iopt
= (Elf_Internal_Options
*)
16871 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16874 error (_("Out of memory allocating space for MIPS options\n"));
16881 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16883 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16885 Elf_External_Options
* eoption
;
16887 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16889 option
->kind
= BYTE_GET (eoption
->kind
);
16890 option
->size
= BYTE_GET (eoption
->size
);
16891 option
->section
= BYTE_GET (eoption
->section
);
16892 option
->info
= BYTE_GET (eoption
->info
);
16894 /* PR 17531: file: ffa0fa3b. */
16895 if (option
->size
< sizeof (* eopt
)
16896 || offset
+ option
->size
> sect
->sh_size
)
16898 error (_("Invalid size (%u) for MIPS option\n"),
16904 offset
+= option
->size
;
16910 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16911 "\nSection '%s' contains %d entries:\n",
16913 printable_section_name (filedata
, sect
), cnt
);
16922 switch (option
->kind
)
16925 /* This shouldn't happen. */
16926 printf (" NULL %d %lx", option
->section
, option
->info
);
16930 printf (" REGINFO ");
16931 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16933 Elf32_External_RegInfo
* ereg
;
16934 Elf32_RegInfo reginfo
;
16937 if (option
+ 2 > iopt_end
)
16939 printf (_("<corrupt>\n"));
16940 error (_("Truncated MIPS REGINFO option\n"));
16945 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16947 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16948 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16949 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16950 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16951 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16952 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16954 printf ("GPR %08lx GP 0x%lx\n",
16955 reginfo
.ri_gprmask
,
16956 (unsigned long) reginfo
.ri_gp_value
);
16957 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16958 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16959 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16964 Elf64_External_RegInfo
* ereg
;
16965 Elf64_Internal_RegInfo reginfo
;
16967 if (option
+ 2 > iopt_end
)
16969 printf (_("<corrupt>\n"));
16970 error (_("Truncated MIPS REGINFO option\n"));
16975 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16976 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16977 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16978 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16979 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16980 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16981 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16983 printf ("GPR %08lx GP 0x",
16984 reginfo
.ri_gprmask
);
16985 printf_vma (reginfo
.ri_gp_value
);
16988 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16989 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16990 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16995 case ODK_EXCEPTIONS
:
16996 fputs (" EXCEPTIONS fpe_min(", stdout
);
16997 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16998 fputs (") fpe_max(", stdout
);
16999 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
17000 fputs (")", stdout
);
17002 if (option
->info
& OEX_PAGE0
)
17003 fputs (" PAGE0", stdout
);
17004 if (option
->info
& OEX_SMM
)
17005 fputs (" SMM", stdout
);
17006 if (option
->info
& OEX_FPDBUG
)
17007 fputs (" FPDBUG", stdout
);
17008 if (option
->info
& OEX_DISMISS
)
17009 fputs (" DISMISS", stdout
);
17013 fputs (" PAD ", stdout
);
17014 if (option
->info
& OPAD_PREFIX
)
17015 fputs (" PREFIX", stdout
);
17016 if (option
->info
& OPAD_POSTFIX
)
17017 fputs (" POSTFIX", stdout
);
17018 if (option
->info
& OPAD_SYMBOL
)
17019 fputs (" SYMBOL", stdout
);
17023 fputs (" HWPATCH ", stdout
);
17024 if (option
->info
& OHW_R4KEOP
)
17025 fputs (" R4KEOP", stdout
);
17026 if (option
->info
& OHW_R8KPFETCH
)
17027 fputs (" R8KPFETCH", stdout
);
17028 if (option
->info
& OHW_R5KEOP
)
17029 fputs (" R5KEOP", stdout
);
17030 if (option
->info
& OHW_R5KCVTL
)
17031 fputs (" R5KCVTL", stdout
);
17035 fputs (" FILL ", stdout
);
17036 /* XXX Print content of info word? */
17040 fputs (" TAGS ", stdout
);
17041 /* XXX Print content of info word? */
17045 fputs (" HWAND ", stdout
);
17046 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17047 fputs (" R4KEOP_CHECKED", stdout
);
17048 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17049 fputs (" R4KEOP_CLEAN", stdout
);
17053 fputs (" HWOR ", stdout
);
17054 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17055 fputs (" R4KEOP_CHECKED", stdout
);
17056 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17057 fputs (" R4KEOP_CLEAN", stdout
);
17061 printf (" GP_GROUP %#06lx self-contained %#06lx",
17062 option
->info
& OGP_GROUP
,
17063 (option
->info
& OGP_SELF
) >> 16);
17067 printf (" IDENT %#06lx self-contained %#06lx",
17068 option
->info
& OGP_GROUP
,
17069 (option
->info
& OGP_SELF
) >> 16);
17073 /* This shouldn't happen. */
17074 printf (" %3d ??? %d %lx",
17075 option
->kind
, option
->section
, option
->info
);
17079 len
= sizeof (* eopt
);
17080 while (len
< option
->size
)
17082 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17084 if (ISPRINT (datum
))
17085 printf ("%c", datum
);
17087 printf ("\\%03o", datum
);
17090 fputs ("\n", stdout
);
17092 offset
+= option
->size
;
17102 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17104 Elf32_Conflict
* iconf
;
17107 if (filedata
->dynamic_symbols
== NULL
)
17109 error (_("conflict list found without a dynamic symbol table\n"));
17113 /* PR 21345 - print a slightly more helpful error message
17114 if we are sure that the cmalloc will fail. */
17115 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17117 error (_("Overlarge number of conflicts detected: %lx\n"),
17118 (long) conflictsno
);
17122 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17125 error (_("Out of memory allocating space for dynamic conflicts\n"));
17131 Elf32_External_Conflict
* econf32
;
17133 econf32
= (Elf32_External_Conflict
*)
17134 get_data (NULL
, filedata
, conflicts_offset
,
17135 sizeof (*econf32
), conflictsno
, _("conflict"));
17142 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17143 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17149 Elf64_External_Conflict
* econf64
;
17151 econf64
= (Elf64_External_Conflict
*)
17152 get_data (NULL
, filedata
, conflicts_offset
,
17153 sizeof (*econf64
), conflictsno
, _("conflict"));
17160 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17161 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17166 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17167 "\nSection '.conflict' contains %lu entries:\n",
17168 (unsigned long) conflictsno
),
17169 (unsigned long) conflictsno
);
17170 puts (_(" Num: Index Value Name"));
17172 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17174 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17176 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17177 printf (_("<corrupt symbol index>"));
17180 Elf_Internal_Sym
* psym
;
17182 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17183 print_vma (psym
->st_value
, FULL_HEX
);
17185 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17186 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17188 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17196 if (pltgot
!= 0 && local_gotno
!= 0)
17198 bfd_vma ent
, local_end
, global_end
;
17200 unsigned char * data
;
17201 unsigned char * data_end
;
17205 addr_size
= (is_32bit_elf
? 4 : 8);
17206 local_end
= pltgot
+ local_gotno
* addr_size
;
17208 /* PR binutils/17533 file: 012-111227-0.004 */
17209 if (symtabno
< gotsym
)
17211 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17212 (unsigned long) gotsym
, (unsigned long) symtabno
);
17216 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17217 /* PR 17531: file: 54c91a34. */
17218 if (global_end
< local_end
)
17220 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17224 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17225 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17226 global_end
- pltgot
, 1,
17227 _("Global Offset Table data"));
17228 /* PR 12855: Null data is handled gracefully throughout. */
17229 data_end
= data
+ (global_end
- pltgot
);
17231 printf (_("\nPrimary GOT:\n"));
17232 printf (_(" Canonical gp value: "));
17233 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17236 printf (_(" Reserved entries:\n"));
17237 printf (_(" %*s %10s %*s Purpose\n"),
17238 addr_size
* 2, _("Address"), _("Access"),
17239 addr_size
* 2, _("Initial"));
17240 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17241 printf (_(" Lazy resolver\n"));
17242 if (ent
== (bfd_vma
) -1)
17243 goto got_print_fail
;
17245 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17246 This entry will be used by some runtime loaders, to store the
17247 module pointer. Otherwise this is an ordinary local entry.
17248 PR 21344: Check for the entry being fully available before
17251 && data
+ ent
- pltgot
+ addr_size
<= data_end
17252 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17253 >> (addr_size
* 8 - 1)) != 0)
17255 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17256 printf (_(" Module pointer (GNU extension)\n"));
17257 if (ent
== (bfd_vma
) -1)
17258 goto got_print_fail
;
17262 if (data
!= NULL
&& ent
< local_end
)
17264 printf (_(" Local entries:\n"));
17265 printf (" %*s %10s %*s\n",
17266 addr_size
* 2, _("Address"), _("Access"),
17267 addr_size
* 2, _("Initial"));
17268 while (ent
< local_end
)
17270 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17272 if (ent
== (bfd_vma
) -1)
17273 goto got_print_fail
;
17278 if (data
!= NULL
&& gotsym
< symtabno
)
17282 printf (_(" Global entries:\n"));
17283 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17284 addr_size
* 2, _("Address"),
17286 addr_size
* 2, _("Initial"),
17287 addr_size
* 2, _("Sym.Val."),
17289 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17290 _("Ndx"), _("Name"));
17292 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17294 for (i
= gotsym
; i
< symtabno
; i
++)
17296 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17299 if (filedata
->dynamic_symbols
== NULL
)
17300 printf (_("<no dynamic symbols>"));
17301 else if (i
< filedata
->num_dynamic_syms
)
17303 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17305 print_vma (psym
->st_value
, LONG_HEX
);
17306 printf (" %-7s %3s ",
17307 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17308 get_symbol_index_type (filedata
, psym
->st_shndx
));
17310 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17311 print_symbol (sym_width
,
17312 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17314 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17317 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17318 (unsigned long) i
);
17321 if (ent
== (bfd_vma
) -1)
17332 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17335 size_t offset
, rel_offset
;
17336 unsigned long count
, i
;
17337 unsigned char * data
;
17338 int addr_size
, sym_width
;
17339 Elf_Internal_Rela
* rels
;
17341 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17342 if (pltrel
== DT_RELA
)
17344 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17349 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17354 addr_size
= (is_32bit_elf
? 4 : 8);
17355 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17357 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17358 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17359 1, _("Procedure Linkage Table data"));
17363 printf ("\nPLT GOT:\n\n");
17364 printf (_(" Reserved entries:\n"));
17365 printf (_(" %*s %*s Purpose\n"),
17366 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17367 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17368 printf (_(" PLT lazy resolver\n"));
17369 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17370 printf (_(" Module pointer\n"));
17373 printf (_(" Entries:\n"));
17374 printf (" %*s %*s %*s %-7s %3s %s\n",
17375 addr_size
* 2, _("Address"),
17376 addr_size
* 2, _("Initial"),
17377 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17378 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17379 for (i
= 0; i
< count
; i
++)
17381 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17383 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17386 if (idx
>= filedata
->num_dynamic_syms
)
17387 printf (_("<corrupt symbol index: %lu>"), idx
);
17390 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17392 print_vma (psym
->st_value
, LONG_HEX
);
17393 printf (" %-7s %3s ",
17394 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17395 get_symbol_index_type (filedata
, psym
->st_shndx
));
17396 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17397 print_symbol (sym_width
,
17398 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17400 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17415 process_nds32_specific (Filedata
* filedata
)
17417 Elf_Internal_Shdr
*sect
= NULL
;
17419 sect
= find_section (filedata
, ".nds32_e_flags");
17422 unsigned int *flag
;
17424 printf ("\nNDS32 elf flags section:\n");
17425 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17426 sect
->sh_size
, _("NDS32 elf flags section"));
17431 switch ((*flag
) & 0x3)
17434 printf ("(VEC_SIZE):\tNo entry.\n");
17437 printf ("(VEC_SIZE):\t4 bytes\n");
17440 printf ("(VEC_SIZE):\t16 bytes\n");
17443 printf ("(VEC_SIZE):\treserved\n");
17452 process_gnu_liblist (Filedata
* filedata
)
17454 Elf_Internal_Shdr
* section
;
17455 Elf_Internal_Shdr
* string_sec
;
17456 Elf32_External_Lib
* elib
;
17458 size_t strtab_size
;
17460 unsigned long num_liblist
;
17462 bfd_boolean res
= TRUE
;
17467 for (i
= 0, section
= filedata
->section_headers
;
17468 i
< filedata
->file_header
.e_shnum
;
17471 switch (section
->sh_type
)
17473 case SHT_GNU_LIBLIST
:
17474 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17477 elib
= (Elf32_External_Lib
*)
17478 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17479 _("liblist section data"));
17487 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17488 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17489 string_sec
->sh_size
,
17490 _("liblist string table"));
17492 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17499 strtab_size
= string_sec
->sh_size
;
17501 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17502 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17503 "\nLibrary list section '%s' contains %lu entries:\n",
17505 printable_section_name (filedata
, section
),
17508 puts (_(" Library Time Stamp Checksum Version Flags"));
17510 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17518 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17519 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17520 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17521 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17522 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17524 tmp
= gmtime (&atime
);
17525 snprintf (timebuf
, sizeof (timebuf
),
17526 "%04u-%02u-%02uT%02u:%02u:%02u",
17527 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17528 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17530 printf ("%3lu: ", (unsigned long) cnt
);
17532 printf ("%-20s", liblist
.l_name
< strtab_size
17533 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17535 printf ("%-20.20s", liblist
.l_name
< strtab_size
17536 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17537 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17538 liblist
.l_version
, liblist
.l_flags
);
17549 static const char *
17550 get_note_type (Filedata
* filedata
, unsigned e_type
)
17552 static char buff
[64];
17554 if (filedata
->file_header
.e_type
== ET_CORE
)
17558 return _("NT_AUXV (auxiliary vector)");
17560 return _("NT_PRSTATUS (prstatus structure)");
17562 return _("NT_FPREGSET (floating point registers)");
17564 return _("NT_PRPSINFO (prpsinfo structure)");
17565 case NT_TASKSTRUCT
:
17566 return _("NT_TASKSTRUCT (task structure)");
17568 return _("NT_PRXFPREG (user_xfpregs structure)");
17570 return _("NT_PPC_VMX (ppc Altivec registers)");
17572 return _("NT_PPC_VSX (ppc VSX registers)");
17574 return _("NT_PPC_TAR (ppc TAR register)");
17576 return _("NT_PPC_PPR (ppc PPR register)");
17578 return _("NT_PPC_DSCR (ppc DSCR register)");
17580 return _("NT_PPC_EBB (ppc EBB registers)");
17582 return _("NT_PPC_PMU (ppc PMU registers)");
17583 case NT_PPC_TM_CGPR
:
17584 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17585 case NT_PPC_TM_CFPR
:
17586 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17587 case NT_PPC_TM_CVMX
:
17588 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17589 case NT_PPC_TM_CVSX
:
17590 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17591 case NT_PPC_TM_SPR
:
17592 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17593 case NT_PPC_TM_CTAR
:
17594 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17595 case NT_PPC_TM_CPPR
:
17596 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17597 case NT_PPC_TM_CDSCR
:
17598 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17600 return _("NT_386_TLS (x86 TLS information)");
17601 case NT_386_IOPERM
:
17602 return _("NT_386_IOPERM (x86 I/O permissions)");
17603 case NT_X86_XSTATE
:
17604 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17605 case NT_S390_HIGH_GPRS
:
17606 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17607 case NT_S390_TIMER
:
17608 return _("NT_S390_TIMER (s390 timer register)");
17609 case NT_S390_TODCMP
:
17610 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17611 case NT_S390_TODPREG
:
17612 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17614 return _("NT_S390_CTRS (s390 control registers)");
17615 case NT_S390_PREFIX
:
17616 return _("NT_S390_PREFIX (s390 prefix register)");
17617 case NT_S390_LAST_BREAK
:
17618 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17619 case NT_S390_SYSTEM_CALL
:
17620 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17622 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17623 case NT_S390_VXRS_LOW
:
17624 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17625 case NT_S390_VXRS_HIGH
:
17626 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17627 case NT_S390_GS_CB
:
17628 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17629 case NT_S390_GS_BC
:
17630 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17632 return _("NT_ARM_VFP (arm VFP registers)");
17634 return _("NT_ARM_TLS (AArch TLS registers)");
17635 case NT_ARM_HW_BREAK
:
17636 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17637 case NT_ARM_HW_WATCH
:
17638 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17640 return _("NT_PSTATUS (pstatus structure)");
17642 return _("NT_FPREGS (floating point registers)");
17644 return _("NT_PSINFO (psinfo structure)");
17646 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17648 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17649 case NT_WIN32PSTATUS
:
17650 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17652 return _("NT_SIGINFO (siginfo_t data)");
17654 return _("NT_FILE (mapped files)");
17662 return _("NT_VERSION (version)");
17664 return _("NT_ARCH (architecture)");
17665 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17667 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17673 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17678 print_core_note (Elf_Internal_Note
*pnote
)
17680 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17681 bfd_vma count
, page_size
;
17682 unsigned char *descdata
, *filenames
, *descend
;
17684 if (pnote
->type
!= NT_FILE
)
17694 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17695 /* Still "successful". */
17700 if (pnote
->descsz
< 2 * addr_size
)
17702 error (_(" Malformed note - too short for header\n"));
17706 descdata
= (unsigned char *) pnote
->descdata
;
17707 descend
= descdata
+ pnote
->descsz
;
17709 if (descdata
[pnote
->descsz
- 1] != '\0')
17711 error (_(" Malformed note - does not end with \\0\n"));
17715 count
= byte_get (descdata
, addr_size
);
17716 descdata
+= addr_size
;
17718 page_size
= byte_get (descdata
, addr_size
);
17719 descdata
+= addr_size
;
17721 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17722 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17724 error (_(" Malformed note - too short for supplied file count\n"));
17728 printf (_(" Page size: "));
17729 print_vma (page_size
, DEC
);
17732 printf (_(" %*s%*s%*s\n"),
17733 (int) (2 + 2 * addr_size
), _("Start"),
17734 (int) (4 + 2 * addr_size
), _("End"),
17735 (int) (4 + 2 * addr_size
), _("Page Offset"));
17736 filenames
= descdata
+ count
* 3 * addr_size
;
17737 while (count
-- > 0)
17739 bfd_vma start
, end
, file_ofs
;
17741 if (filenames
== descend
)
17743 error (_(" Malformed note - filenames end too early\n"));
17747 start
= byte_get (descdata
, addr_size
);
17748 descdata
+= addr_size
;
17749 end
= byte_get (descdata
, addr_size
);
17750 descdata
+= addr_size
;
17751 file_ofs
= byte_get (descdata
, addr_size
);
17752 descdata
+= addr_size
;
17755 print_vma (start
, FULL_HEX
);
17757 print_vma (end
, FULL_HEX
);
17759 print_vma (file_ofs
, FULL_HEX
);
17760 printf ("\n %s\n", filenames
);
17762 filenames
+= 1 + strlen ((char *) filenames
);
17768 static const char *
17769 get_gnu_elf_note_type (unsigned e_type
)
17771 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17774 case NT_GNU_ABI_TAG
:
17775 return _("NT_GNU_ABI_TAG (ABI version tag)");
17777 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17778 case NT_GNU_BUILD_ID
:
17779 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17780 case NT_GNU_GOLD_VERSION
:
17781 return _("NT_GNU_GOLD_VERSION (gold version)");
17782 case NT_GNU_PROPERTY_TYPE_0
:
17783 return _("NT_GNU_PROPERTY_TYPE_0");
17784 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17785 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17786 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17787 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17790 static char buff
[64];
17792 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17799 decode_x86_compat_isa (unsigned int bitmask
)
17803 unsigned int bit
= bitmask
& (- bitmask
);
17808 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17811 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17814 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17817 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17820 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17823 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17826 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17829 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17832 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17835 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17838 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17841 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17842 printf ("AVX512F");
17844 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17845 printf ("AVX512CD");
17847 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17848 printf ("AVX512ER");
17850 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17851 printf ("AVX512PF");
17853 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17854 printf ("AVX512VL");
17856 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17857 printf ("AVX512DQ");
17859 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17860 printf ("AVX512BW");
17863 printf (_("<unknown: %x>"), bit
);
17872 decode_x86_isa (unsigned int bitmask
)
17876 printf (_("<None>"));
17882 unsigned int bit
= bitmask
& (- bitmask
);
17887 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17890 case GNU_PROPERTY_X86_ISA_1_SSE
:
17893 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17896 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17899 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17902 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17905 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17908 case GNU_PROPERTY_X86_ISA_1_AVX
:
17911 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17914 case GNU_PROPERTY_X86_ISA_1_FMA
:
17917 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17918 printf ("AVX512F");
17920 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17921 printf ("AVX512CD");
17923 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17924 printf ("AVX512ER");
17926 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17927 printf ("AVX512PF");
17929 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17930 printf ("AVX512VL");
17932 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17933 printf ("AVX512DQ");
17935 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17936 printf ("AVX512BW");
17938 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17939 printf ("AVX512_4FMAPS");
17941 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17942 printf ("AVX512_4VNNIW");
17944 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17945 printf ("AVX512_BITALG");
17947 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17948 printf ("AVX512_IFMA");
17950 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17951 printf ("AVX512_VBMI");
17953 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17954 printf ("AVX512_VBMI2");
17956 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17957 printf ("AVX512_VNNI");
17959 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17960 printf ("AVX512_BF16");
17963 printf (_("<unknown: %x>"), bit
);
17972 decode_x86_feature_1 (unsigned int bitmask
)
17976 printf (_("<None>"));
17982 unsigned int bit
= bitmask
& (- bitmask
);
17987 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17990 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17994 printf (_("<unknown: %x>"), bit
);
18003 decode_x86_feature_2 (unsigned int bitmask
)
18007 printf (_("<None>"));
18013 unsigned int bit
= bitmask
& (- bitmask
);
18018 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18021 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18024 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18027 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18030 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18033 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18036 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18039 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18042 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18043 printf ("XSAVEOPT");
18045 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18049 printf (_("<unknown: %x>"), bit
);
18058 decode_aarch64_feature_1_and (unsigned int bitmask
)
18062 unsigned int bit
= bitmask
& (- bitmask
);
18067 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18071 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18076 printf (_("<unknown: %x>"), bit
);
18085 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18087 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18088 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18089 unsigned int size
= is_32bit_elf
? 4 : 8;
18091 printf (_(" Properties: "));
18093 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18095 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18099 while (ptr
< ptr_end
)
18103 unsigned int datasz
;
18105 if ((size_t) (ptr_end
- ptr
) < 8)
18107 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18111 type
= byte_get (ptr
, 4);
18112 datasz
= byte_get (ptr
+ 4, 4);
18116 if (datasz
> (size_t) (ptr_end
- ptr
))
18118 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18123 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18125 if (filedata
->file_header
.e_machine
== EM_X86_64
18126 || filedata
->file_header
.e_machine
== EM_IAMCU
18127 || filedata
->file_header
.e_machine
== EM_386
)
18129 unsigned int bitmask
;
18132 bitmask
= byte_get (ptr
, 4);
18138 case GNU_PROPERTY_X86_ISA_1_USED
:
18140 printf (_("x86 ISA used: <corrupt length: %#x> "),
18144 printf ("x86 ISA used: ");
18145 decode_x86_isa (bitmask
);
18149 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18151 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18155 printf ("x86 ISA needed: ");
18156 decode_x86_isa (bitmask
);
18160 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18162 printf (_("x86 feature: <corrupt length: %#x> "),
18166 printf ("x86 feature: ");
18167 decode_x86_feature_1 (bitmask
);
18171 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18173 printf (_("x86 feature used: <corrupt length: %#x> "),
18177 printf ("x86 feature used: ");
18178 decode_x86_feature_2 (bitmask
);
18182 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18184 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18187 printf ("x86 feature needed: ");
18188 decode_x86_feature_2 (bitmask
);
18192 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18194 printf (_("x86 ISA used: <corrupt length: %#x> "),
18198 printf ("x86 ISA used: ");
18199 decode_x86_compat_isa (bitmask
);
18203 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18205 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18209 printf ("x86 ISA needed: ");
18210 decode_x86_compat_isa (bitmask
);
18218 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18220 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18222 printf ("AArch64 feature: ");
18224 printf (_("<corrupt length: %#x> "), datasz
);
18226 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18235 case GNU_PROPERTY_STACK_SIZE
:
18236 printf (_("stack size: "));
18237 if (datasz
!= size
)
18238 printf (_("<corrupt length: %#x> "), datasz
);
18240 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18243 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18244 printf ("no copy on protected ");
18246 printf (_("<corrupt length: %#x> "), datasz
);
18254 if (type
< GNU_PROPERTY_LOPROC
)
18255 printf (_("<unknown type %#x data: "), type
);
18256 else if (type
< GNU_PROPERTY_LOUSER
)
18257 printf (_("<procesor-specific type %#x data: "), type
);
18259 printf (_("<application-specific type %#x data: "), type
);
18260 for (j
= 0; j
< datasz
; ++j
)
18261 printf ("%02x ", ptr
[j
] & 0xff);
18265 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18266 if (ptr
== ptr_end
)
18279 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18281 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18282 switch (pnote
->type
)
18284 case NT_GNU_BUILD_ID
:
18288 printf (_(" Build ID: "));
18289 for (i
= 0; i
< pnote
->descsz
; ++i
)
18290 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18295 case NT_GNU_ABI_TAG
:
18297 unsigned long os
, major
, minor
, subminor
;
18298 const char *osname
;
18300 /* PR 17531: file: 030-599401-0.004. */
18301 if (pnote
->descsz
< 16)
18303 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18307 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18308 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18309 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18310 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18314 case GNU_ABI_TAG_LINUX
:
18317 case GNU_ABI_TAG_HURD
:
18320 case GNU_ABI_TAG_SOLARIS
:
18321 osname
= "Solaris";
18323 case GNU_ABI_TAG_FREEBSD
:
18324 osname
= "FreeBSD";
18326 case GNU_ABI_TAG_NETBSD
:
18329 case GNU_ABI_TAG_SYLLABLE
:
18330 osname
= "Syllable";
18332 case GNU_ABI_TAG_NACL
:
18336 osname
= "Unknown";
18340 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18341 major
, minor
, subminor
);
18345 case NT_GNU_GOLD_VERSION
:
18349 printf (_(" Version: "));
18350 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18351 printf ("%c", pnote
->descdata
[i
]);
18358 unsigned long num_entries
, mask
;
18360 /* Hardware capabilities information. Word 0 is the number of entries.
18361 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18362 is a series of entries, where each entry is a single byte followed
18363 by a nul terminated string. The byte gives the bit number to test
18364 if enabled in the bitmask. */
18365 printf (_(" Hardware Capabilities: "));
18366 if (pnote
->descsz
< 8)
18368 error (_("<corrupt GNU_HWCAP>\n"));
18371 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18372 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18373 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18374 /* FIXME: Add code to display the entries... */
18378 case NT_GNU_PROPERTY_TYPE_0
:
18379 print_gnu_property_note (filedata
, pnote
);
18383 /* Handle unrecognised types. An error message should have already been
18384 created by get_gnu_elf_note_type(), so all that we need to do is to
18385 display the data. */
18389 printf (_(" Description data: "));
18390 for (i
= 0; i
< pnote
->descsz
; ++i
)
18391 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18400 static const char *
18401 get_v850_elf_note_type (enum v850_notes n_type
)
18403 static char buff
[64];
18407 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18408 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18409 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18410 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18411 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18412 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18414 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18420 print_v850_note (Elf_Internal_Note
* pnote
)
18424 if (pnote
->descsz
!= 4)
18427 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18431 printf (_("not set\n"));
18435 switch (pnote
->type
)
18437 case V850_NOTE_ALIGNMENT
:
18440 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18441 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18445 case V850_NOTE_DATA_SIZE
:
18448 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18449 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18453 case V850_NOTE_FPU_INFO
:
18456 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18457 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18461 case V850_NOTE_MMU_INFO
:
18462 case V850_NOTE_CACHE_INFO
:
18463 case V850_NOTE_SIMD_INFO
:
18464 if (val
== EF_RH850_SIMD
)
18466 printf (_("yes\n"));
18472 /* An 'unknown note type' message will already have been displayed. */
18476 printf (_("unknown value: %x\n"), val
);
18481 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18483 unsigned int version
;
18485 switch (pnote
->type
)
18487 case NT_NETBSD_IDENT
:
18488 if (pnote
->descsz
< 1)
18490 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18491 if ((version
/ 10000) % 100)
18492 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18493 version
, version
/ 100000000, (version
/ 1000000) % 100,
18494 (version
/ 10000) % 100 > 26 ? "Z" : "",
18495 'A' + (version
/ 10000) % 26);
18497 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18498 version
, version
/ 100000000, (version
/ 1000000) % 100,
18499 (version
/ 100) % 100);
18502 case NT_NETBSD_MARCH
:
18503 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18507 #ifdef NT_NETBSD_PAX
18508 case NT_NETBSD_PAX
:
18509 if (pnote
->descsz
< 1)
18511 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18512 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18513 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18514 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18515 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18516 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18517 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18518 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18523 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18524 pnote
->descsz
, pnote
->type
);
18528 static const char *
18529 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18533 case NT_FREEBSD_THRMISC
:
18534 return _("NT_THRMISC (thrmisc structure)");
18535 case NT_FREEBSD_PROCSTAT_PROC
:
18536 return _("NT_PROCSTAT_PROC (proc data)");
18537 case NT_FREEBSD_PROCSTAT_FILES
:
18538 return _("NT_PROCSTAT_FILES (files data)");
18539 case NT_FREEBSD_PROCSTAT_VMMAP
:
18540 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18541 case NT_FREEBSD_PROCSTAT_GROUPS
:
18542 return _("NT_PROCSTAT_GROUPS (groups data)");
18543 case NT_FREEBSD_PROCSTAT_UMASK
:
18544 return _("NT_PROCSTAT_UMASK (umask data)");
18545 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18546 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18547 case NT_FREEBSD_PROCSTAT_OSREL
:
18548 return _("NT_PROCSTAT_OSREL (osreldate data)");
18549 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18550 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18551 case NT_FREEBSD_PROCSTAT_AUXV
:
18552 return _("NT_PROCSTAT_AUXV (auxv data)");
18553 case NT_FREEBSD_PTLWPINFO
:
18554 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18556 return get_note_type (filedata
, e_type
);
18559 static const char *
18560 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18562 static char buff
[64];
18566 case NT_NETBSDCORE_PROCINFO
:
18567 /* NetBSD core "procinfo" structure. */
18568 return _("NetBSD procinfo structure");
18570 #ifdef NT_NETBSDCORE_AUXV
18571 case NT_NETBSDCORE_AUXV
:
18572 return _("NetBSD ELF auxiliary vector data");
18575 #ifdef NT_NETBSDCORE_LWPSTATUS
18576 case NT_NETBSDCORE_LWPSTATUS
:
18577 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18581 /* As of Jan 2020 there are no other machine-independent notes
18582 defined for NetBSD core files. If the note type is less
18583 than the start of the machine-dependent note types, we don't
18586 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18588 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18594 switch (filedata
->file_header
.e_machine
)
18596 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18597 and PT_GETFPREGS == mach+2. */
18602 case EM_SPARC32PLUS
:
18606 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18607 return _("PT_GETREGS (reg structure)");
18608 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18609 return _("PT_GETFPREGS (fpreg structure)");
18615 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18616 There's also old PT___GETREGS40 == mach + 1 for old reg
18617 structure which lacks GBR. */
18621 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18622 return _("PT___GETREGS40 (old reg structure)");
18623 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18624 return _("PT_GETREGS (reg structure)");
18625 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18626 return _("PT_GETFPREGS (fpreg structure)");
18632 /* On all other arch's, PT_GETREGS == mach+1 and
18633 PT_GETFPREGS == mach+3. */
18637 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18638 return _("PT_GETREGS (reg structure)");
18639 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18640 return _("PT_GETFPREGS (fpreg structure)");
18646 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18647 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18651 static const char *
18652 get_stapsdt_note_type (unsigned e_type
)
18654 static char buff
[64];
18659 return _("NT_STAPSDT (SystemTap probe descriptors)");
18665 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18670 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18672 size_t len
, maxlen
;
18673 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18674 char *data
= pnote
->descdata
;
18675 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18676 bfd_vma pc
, base_addr
, semaphore
;
18677 char *provider
, *probe
, *arg_fmt
;
18679 if (pnote
->descsz
< (addr_size
* 3))
18680 goto stapdt_note_too_small
;
18682 pc
= byte_get ((unsigned char *) data
, addr_size
);
18685 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18688 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18691 if (data
>= data_end
)
18692 goto stapdt_note_too_small
;
18693 maxlen
= data_end
- data
;
18694 len
= strnlen (data
, maxlen
);
18701 goto stapdt_note_too_small
;
18703 if (data
>= data_end
)
18704 goto stapdt_note_too_small
;
18705 maxlen
= data_end
- data
;
18706 len
= strnlen (data
, maxlen
);
18713 goto stapdt_note_too_small
;
18715 if (data
>= data_end
)
18716 goto stapdt_note_too_small
;
18717 maxlen
= data_end
- data
;
18718 len
= strnlen (data
, maxlen
);
18725 goto stapdt_note_too_small
;
18727 printf (_(" Provider: %s\n"), provider
);
18728 printf (_(" Name: %s\n"), probe
);
18729 printf (_(" Location: "));
18730 print_vma (pc
, FULL_HEX
);
18731 printf (_(", Base: "));
18732 print_vma (base_addr
, FULL_HEX
);
18733 printf (_(", Semaphore: "));
18734 print_vma (semaphore
, FULL_HEX
);
18736 printf (_(" Arguments: %s\n"), arg_fmt
);
18738 return data
== data_end
;
18740 stapdt_note_too_small
:
18741 printf (_(" <corrupt - note is too small>\n"));
18742 error (_("corrupt stapdt note - the data size is too small\n"));
18746 static const char *
18747 get_ia64_vms_note_type (unsigned e_type
)
18749 static char buff
[64];
18754 return _("NT_VMS_MHD (module header)");
18756 return _("NT_VMS_LNM (language name)");
18758 return _("NT_VMS_SRC (source files)");
18760 return "NT_VMS_TITLE";
18762 return _("NT_VMS_EIDC (consistency check)");
18763 case NT_VMS_FPMODE
:
18764 return _("NT_VMS_FPMODE (FP mode)");
18765 case NT_VMS_LINKTIME
:
18766 return "NT_VMS_LINKTIME";
18767 case NT_VMS_IMGNAM
:
18768 return _("NT_VMS_IMGNAM (image name)");
18770 return _("NT_VMS_IMGID (image id)");
18771 case NT_VMS_LINKID
:
18772 return _("NT_VMS_LINKID (link id)");
18773 case NT_VMS_IMGBID
:
18774 return _("NT_VMS_IMGBID (build id)");
18775 case NT_VMS_GSTNAM
:
18776 return _("NT_VMS_GSTNAM (sym table name)");
18777 case NT_VMS_ORIG_DYN
:
18778 return "NT_VMS_ORIG_DYN";
18779 case NT_VMS_PATCHTIME
:
18780 return "NT_VMS_PATCHTIME";
18782 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18788 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18790 int maxlen
= pnote
->descsz
;
18792 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18793 goto desc_size_fail
;
18795 switch (pnote
->type
)
18799 goto desc_size_fail
;
18801 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18803 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18804 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18805 if (l
+ 34 < maxlen
)
18807 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18808 if (l
+ 35 < maxlen
)
18809 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18811 printf (_(" Module version : <missing>\n"));
18815 printf (_(" Module name : <missing>\n"));
18816 printf (_(" Module version : <missing>\n"));
18821 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18825 case NT_VMS_FPMODE
:
18826 printf (_(" Floating Point mode: "));
18828 goto desc_size_fail
;
18829 /* FIXME: Generate an error if descsz > 8 ? */
18831 printf ("0x%016" BFD_VMA_FMT
"x\n",
18832 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18835 case NT_VMS_LINKTIME
:
18836 printf (_(" Link time: "));
18838 goto desc_size_fail
;
18839 /* FIXME: Generate an error if descsz > 8 ? */
18842 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18846 case NT_VMS_PATCHTIME
:
18847 printf (_(" Patch time: "));
18849 goto desc_size_fail
;
18850 /* FIXME: Generate an error if descsz > 8 ? */
18853 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18857 case NT_VMS_ORIG_DYN
:
18859 goto desc_size_fail
;
18861 printf (_(" Major id: %u, minor id: %u\n"),
18862 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18863 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18864 printf (_(" Last modified : "));
18866 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18867 printf (_("\n Link flags : "));
18868 printf ("0x%016" BFD_VMA_FMT
"x\n",
18869 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18870 printf (_(" Header flags: 0x%08x\n"),
18871 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18872 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18876 case NT_VMS_IMGNAM
:
18877 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18880 case NT_VMS_GSTNAM
:
18881 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18885 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18888 case NT_VMS_LINKID
:
18889 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18899 printf (_(" <corrupt - data size is too small>\n"));
18900 error (_("corrupt IA64 note: data size is too small\n"));
18904 struct build_attr_cache
{
18905 Filedata
*filedata
;
18907 unsigned long strtablen
;
18908 Elf_Internal_Sym
*symtab
;
18909 unsigned long nsyms
;
18912 /* Find the symbol associated with a build attribute that is attached
18913 to address OFFSET. If PNAME is non-NULL then store the name of
18914 the symbol (if found) in the provided pointer, Returns NULL if a
18915 symbol could not be found. */
18917 static Elf_Internal_Sym
*
18918 get_symbol_for_build_attribute (Filedata
* filedata
,
18919 unsigned long offset
,
18920 bfd_boolean is_open_attr
,
18921 const char ** pname
)
18923 Elf_Internal_Sym
*saved_sym
= NULL
;
18924 Elf_Internal_Sym
*sym
;
18926 if (filedata
->section_headers
!= NULL
18927 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18929 Elf_Internal_Shdr
* symsec
;
18931 free (ba_cache
.strtab
);
18932 ba_cache
.strtab
= NULL
;
18933 free (ba_cache
.symtab
);
18934 ba_cache
.symtab
= NULL
;
18936 /* Load the symbol and string sections. */
18937 for (symsec
= filedata
->section_headers
;
18938 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18941 if (symsec
->sh_type
== SHT_SYMTAB
18942 && get_symtab (filedata
, symsec
,
18943 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18944 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18947 ba_cache
.filedata
= filedata
;
18950 if (ba_cache
.symtab
== NULL
)
18953 /* Find a symbol whose value matches offset. */
18954 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18955 if (sym
->st_value
== offset
)
18957 if (sym
->st_name
>= ba_cache
.strtablen
)
18958 /* Huh ? This should not happen. */
18961 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18964 /* The AArch64 and ARM architectures define mapping symbols
18965 (eg $d, $x, $t) which we want to ignore. */
18966 if (ba_cache
.strtab
[sym
->st_name
] == '$'
18967 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
18968 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
18973 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18974 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18975 FUNC symbols entirely. */
18976 switch (ELF_ST_TYPE (sym
->st_info
))
18983 /* If the symbol has a size associated
18984 with it then we can stop searching. */
18985 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
18990 /* Ignore function symbols. */
18997 switch (ELF_ST_BIND (sym
->st_info
))
19000 if (saved_sym
== NULL
19001 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19006 if (saved_sym
== NULL
)
19016 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19024 if (saved_sym
&& pname
)
19025 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19030 /* Returns true iff addr1 and addr2 are in the same section. */
19033 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19035 Elf_Internal_Shdr
* a1
;
19036 Elf_Internal_Shdr
* a2
;
19038 a1
= find_section_by_address (filedata
, addr1
);
19039 a2
= find_section_by_address (filedata
, addr2
);
19041 return a1
== a2
&& a1
!= NULL
;
19045 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19046 Filedata
* filedata
)
19048 static unsigned long global_offset
= 0;
19049 static unsigned long global_end
= 0;
19050 static unsigned long func_offset
= 0;
19051 static unsigned long func_end
= 0;
19053 Elf_Internal_Sym
* sym
;
19055 unsigned long start
;
19057 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19059 switch (pnote
->descsz
)
19062 /* A zero-length description means that the range of
19063 the previous note of the same type should be used. */
19066 if (global_end
> global_offset
)
19067 printf (_(" Applies to region from %#lx to %#lx\n"),
19068 global_offset
, global_end
);
19070 printf (_(" Applies to region from %#lx\n"), global_offset
);
19074 if (func_end
> func_offset
)
19075 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19077 printf (_(" Applies to region from %#lx\n"), func_offset
);
19082 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19089 /* FIXME: We should check that version 3+ notes are being used here... */
19090 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19091 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19095 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19101 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19102 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19106 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19107 printf (_(" <invalid descsz>"));
19112 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19113 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19114 in order to avoid them being confused with the start address of the
19115 first function in the file... */
19116 if (sym
== NULL
&& is_open_attr
)
19117 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19120 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19121 end
= start
+ sym
->st_size
;
19125 /* FIXME: Need to properly allow for section alignment.
19126 16 is just the alignment used on x86_64. */
19128 && start
> BFD_ALIGN (global_end
, 16)
19129 /* Build notes are not guaranteed to be organised in order of
19130 increasing address, but we should find the all of the notes
19131 for one section in the same place. */
19132 && same_section (filedata
, start
, global_end
))
19133 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19134 global_end
+ 1, start
- 1);
19136 printf (_(" Applies to region from %#lx"), start
);
19137 global_offset
= start
;
19141 printf (_(" to %#lx"), end
);
19147 printf (_(" Applies to region from %#lx"), start
);
19148 func_offset
= start
;
19152 printf (_(" to %#lx"), end
);
19158 printf (_(" (%s)"), name
);
19165 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19167 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19168 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19169 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19171 char name_attribute
;
19172 const char * expected_types
;
19173 const char * name
= pnote
->namedata
;
19177 if (name
== NULL
|| pnote
->namesz
< 2)
19179 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19180 print_symbol (-20, _(" <corrupt name>"));
19189 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19190 if (name
[0] == 'G' && name
[1] == 'A')
19192 if (pnote
->namesz
< 4)
19194 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19195 print_symbol (-20, _(" <corrupt name>"));
19204 switch ((name_type
= * name
))
19206 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19207 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19208 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19209 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19210 printf ("%c", * name
);
19214 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19215 print_symbol (-20, _("<unknown name type>"));
19222 switch ((name_attribute
= * name
))
19224 case GNU_BUILD_ATTRIBUTE_VERSION
:
19225 text
= _("<version>");
19226 expected_types
= string_expected
;
19229 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19230 text
= _("<stack prot>");
19231 expected_types
= "!+*";
19234 case GNU_BUILD_ATTRIBUTE_RELRO
:
19235 text
= _("<relro>");
19236 expected_types
= bool_expected
;
19239 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19240 text
= _("<stack size>");
19241 expected_types
= number_expected
;
19244 case GNU_BUILD_ATTRIBUTE_TOOL
:
19245 text
= _("<tool>");
19246 expected_types
= string_expected
;
19249 case GNU_BUILD_ATTRIBUTE_ABI
:
19251 expected_types
= "$*";
19254 case GNU_BUILD_ATTRIBUTE_PIC
:
19256 expected_types
= number_expected
;
19259 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19260 text
= _("<short enum>");
19261 expected_types
= bool_expected
;
19265 if (ISPRINT (* name
))
19267 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19269 if (len
> left
&& ! do_wide
)
19271 printf ("%.*s:", len
, name
);
19277 static char tmpbuf
[128];
19279 error (_("unrecognised byte in name field: %d\n"), * name
);
19280 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19284 expected_types
= "*$!+";
19289 left
-= printf ("%s", text
);
19291 if (strchr (expected_types
, name_type
) == NULL
)
19292 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19294 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19296 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19297 (unsigned long) pnote
->namesz
,
19298 (long) (name
- pnote
->namedata
));
19302 if (left
< 1 && ! do_wide
)
19307 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19309 unsigned int bytes
;
19310 unsigned long long val
= 0;
19311 unsigned int shift
= 0;
19312 char * decoded
= NULL
;
19314 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19316 /* The -1 is because the name field is always 0 terminated, and we
19317 want to be able to ensure that the shift in the while loop below
19318 will not overflow. */
19321 if (bytes
> sizeof (val
))
19323 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19325 bytes
= sizeof (val
);
19327 /* We do not bother to warn if bytes == 0 as this can
19328 happen with some early versions of the gcc plugin. */
19332 unsigned long byte
= (* name
++) & 0xff;
19334 val
|= byte
<< shift
;
19338 switch (name_attribute
)
19340 case GNU_BUILD_ATTRIBUTE_PIC
:
19343 case 0: decoded
= "static"; break;
19344 case 1: decoded
= "pic"; break;
19345 case 2: decoded
= "PIC"; break;
19346 case 3: decoded
= "pie"; break;
19347 case 4: decoded
= "PIE"; break;
19351 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19354 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19355 case 0: decoded
= "off"; break;
19356 case 1: decoded
= "on"; break;
19357 case 2: decoded
= "all"; break;
19358 case 3: decoded
= "strong"; break;
19359 case 4: decoded
= "explicit"; break;
19367 if (decoded
!= NULL
)
19369 print_symbol (-left
, decoded
);
19380 left
-= printf ("0x%llx", val
);
19382 left
-= printf ("0x%-.*llx", left
, val
);
19386 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19387 left
-= print_symbol (- left
, name
);
19389 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19390 left
-= print_symbol (- left
, "true");
19392 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19393 left
-= print_symbol (- left
, "false");
19397 if (do_wide
&& left
> 0)
19398 printf ("%-*s", left
, " ");
19403 /* Note that by the ELF standard, the name field is already null byte
19404 terminated, and namesz includes the terminating null byte.
19405 I.E. the value of namesz for the name "FSF" is 4.
19407 If the value of namesz is zero, there is no name present. */
19410 process_note (Elf_Internal_Note
* pnote
,
19411 Filedata
* filedata
)
19413 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19416 if (pnote
->namesz
== 0)
19417 /* If there is no note name, then use the default set of
19418 note type strings. */
19419 nt
= get_note_type (filedata
, pnote
->type
);
19421 else if (const_strneq (pnote
->namedata
, "GNU"))
19422 /* GNU-specific object file notes. */
19423 nt
= get_gnu_elf_note_type (pnote
->type
);
19425 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19426 /* FreeBSD-specific core file notes. */
19427 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19429 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19430 /* NetBSD-specific core file notes. */
19431 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19433 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19434 /* NetBSD-specific core file notes. */
19435 return process_netbsd_elf_note (pnote
);
19437 else if (const_strneq (pnote
->namedata
, "PaX"))
19438 /* NetBSD-specific core file notes. */
19439 return process_netbsd_elf_note (pnote
);
19441 else if (strneq (pnote
->namedata
, "SPU/", 4))
19443 /* SPU-specific core file notes. */
19444 nt
= pnote
->namedata
+ 4;
19448 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19449 /* VMS/ia64-specific file notes. */
19450 nt
= get_ia64_vms_note_type (pnote
->type
);
19452 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19453 nt
= get_stapsdt_note_type (pnote
->type
);
19456 /* Don't recognize this note name; just use the default set of
19457 note type strings. */
19458 nt
= get_note_type (filedata
, pnote
->type
);
19462 if (((const_strneq (pnote
->namedata
, "GA")
19463 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19464 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19465 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19466 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19467 print_gnu_build_attribute_name (pnote
);
19469 print_symbol (-20, name
);
19472 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19474 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19476 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19477 return print_ia64_vms_note (pnote
);
19478 else if (const_strneq (pnote
->namedata
, "GNU"))
19479 return print_gnu_note (filedata
, pnote
);
19480 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19481 return print_stapsdt_note (pnote
);
19482 else if (const_strneq (pnote
->namedata
, "CORE"))
19483 return print_core_note (pnote
);
19484 else 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 return print_gnu_build_attribute_description (pnote
, filedata
);
19495 printf (_(" description data: "));
19496 for (i
= 0; i
< pnote
->descsz
; i
++)
19497 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19509 process_notes_at (Filedata
* filedata
,
19510 Elf_Internal_Shdr
* section
,
19515 Elf_External_Note
* pnotes
;
19516 Elf_External_Note
* external
;
19518 bfd_boolean res
= TRUE
;
19525 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19528 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19536 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19539 if (pnotes
== NULL
)
19545 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19547 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19548 (unsigned long) offset
, (unsigned long) length
);
19550 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19551 specifies that notes should be aligned to 4 bytes in 32-bit
19552 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19553 we also support 4 byte alignment in 64-bit objects. If section
19554 alignment is less than 4, we treate alignment as 4 bytes. */
19557 else if (align
!= 4 && align
!= 8)
19559 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19565 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19567 end
= (char *) pnotes
+ length
;
19568 while ((char *) external
< end
)
19570 Elf_Internal_Note inote
;
19573 char * temp
= NULL
;
19574 size_t data_remaining
= end
- (char *) external
;
19576 if (!is_ia64_vms (filedata
))
19578 /* PR binutils/15191
19579 Make sure that there is enough data to read. */
19580 min_notesz
= offsetof (Elf_External_Note
, name
);
19581 if (data_remaining
< min_notesz
)
19583 warn (ngettext ("Corrupt note: only %ld byte remains, "
19584 "not enough for a full note\n",
19585 "Corrupt note: only %ld bytes remain, "
19586 "not enough for a full note\n",
19588 (long) data_remaining
);
19591 data_remaining
-= min_notesz
;
19593 inote
.type
= BYTE_GET (external
->type
);
19594 inote
.namesz
= BYTE_GET (external
->namesz
);
19595 inote
.namedata
= external
->name
;
19596 inote
.descsz
= BYTE_GET (external
->descsz
);
19597 inote
.descdata
= ((char *) external
19598 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19599 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19600 next
= ((char *) external
19601 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19605 Elf64_External_VMS_Note
*vms_external
;
19607 /* PR binutils/15191
19608 Make sure that there is enough data to read. */
19609 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19610 if (data_remaining
< min_notesz
)
19612 warn (ngettext ("Corrupt note: only %ld byte remains, "
19613 "not enough for a full note\n",
19614 "Corrupt note: only %ld bytes remain, "
19615 "not enough for a full note\n",
19617 (long) data_remaining
);
19620 data_remaining
-= min_notesz
;
19622 vms_external
= (Elf64_External_VMS_Note
*) external
;
19623 inote
.type
= BYTE_GET (vms_external
->type
);
19624 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19625 inote
.namedata
= vms_external
->name
;
19626 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19627 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19628 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19629 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19632 /* PR 17531: file: 3443835e. */
19633 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19634 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19635 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19636 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19637 || ((size_t) (next
- inote
.descdata
)
19638 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19640 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19641 (unsigned long) ((char *) external
- (char *) pnotes
));
19642 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19643 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19647 external
= (Elf_External_Note
*) next
;
19649 /* Verify that name is null terminated. It appears that at least
19650 one version of Linux (RedHat 6.0) generates corefiles that don't
19651 comply with the ELF spec by failing to include the null byte in
19653 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19655 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19657 temp
= (char *) malloc (inote
.namesz
+ 1);
19660 error (_("Out of memory allocating space for inote name\n"));
19665 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19666 inote
.namedata
= temp
;
19668 inote
.namedata
[inote
.namesz
] = 0;
19671 if (! process_note (& inote
, filedata
))
19687 process_corefile_note_segments (Filedata
* filedata
)
19689 Elf_Internal_Phdr
* segment
;
19691 bfd_boolean res
= TRUE
;
19693 if (! get_program_headers (filedata
))
19696 for (i
= 0, segment
= filedata
->program_headers
;
19697 i
< filedata
->file_header
.e_phnum
;
19700 if (segment
->p_type
== PT_NOTE
)
19701 if (! process_notes_at (filedata
, NULL
,
19702 (bfd_vma
) segment
->p_offset
,
19703 (bfd_vma
) segment
->p_filesz
,
19704 (bfd_vma
) segment
->p_align
))
19712 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19714 Elf_External_Note
* pnotes
;
19715 Elf_External_Note
* external
;
19717 bfd_boolean res
= TRUE
;
19722 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19724 if (pnotes
== NULL
)
19728 end
= (char*) pnotes
+ length
;
19730 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19731 (unsigned long) offset
, (unsigned long) length
);
19733 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19735 Elf_External_Note
* next
;
19736 Elf_Internal_Note inote
;
19738 inote
.type
= BYTE_GET (external
->type
);
19739 inote
.namesz
= BYTE_GET (external
->namesz
);
19740 inote
.namedata
= external
->name
;
19741 inote
.descsz
= BYTE_GET (external
->descsz
);
19742 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19743 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19745 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19747 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19748 inote
.descdata
= inote
.namedata
;
19752 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19754 if ( ((char *) next
> end
)
19755 || ((char *) next
< (char *) pnotes
))
19757 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19758 (unsigned long) ((char *) external
- (char *) pnotes
));
19759 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19760 inote
.type
, inote
.namesz
, inote
.descsz
);
19766 /* Prevent out-of-bounds indexing. */
19767 if ( inote
.namedata
+ inote
.namesz
> end
19768 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19770 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19771 (unsigned long) ((char *) external
- (char *) pnotes
));
19772 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19773 inote
.type
, inote
.namesz
, inote
.descsz
);
19777 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19779 if (! print_v850_note (& inote
))
19782 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19783 inote
.namesz
, inote
.descsz
);
19793 process_note_sections (Filedata
* filedata
)
19795 Elf_Internal_Shdr
* section
;
19797 unsigned int n
= 0;
19798 bfd_boolean res
= TRUE
;
19800 for (i
= 0, section
= filedata
->section_headers
;
19801 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19804 if (section
->sh_type
== SHT_NOTE
)
19806 if (! process_notes_at (filedata
, section
,
19807 (bfd_vma
) section
->sh_offset
,
19808 (bfd_vma
) section
->sh_size
,
19809 (bfd_vma
) section
->sh_addralign
))
19814 if (( filedata
->file_header
.e_machine
== EM_V800
19815 || filedata
->file_header
.e_machine
== EM_V850
19816 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19817 && section
->sh_type
== SHT_RENESAS_INFO
)
19819 if (! process_v850_notes (filedata
,
19820 (bfd_vma
) section
->sh_offset
,
19821 (bfd_vma
) section
->sh_size
))
19828 /* Try processing NOTE segments instead. */
19829 return process_corefile_note_segments (filedata
);
19835 process_notes (Filedata
* filedata
)
19837 /* If we have not been asked to display the notes then do nothing. */
19841 if (filedata
->file_header
.e_type
!= ET_CORE
)
19842 return process_note_sections (filedata
);
19844 /* No program headers means no NOTE segment. */
19845 if (filedata
->file_header
.e_phnum
> 0)
19846 return process_corefile_note_segments (filedata
);
19848 printf (_("No note segments present in the core file.\n"));
19852 static unsigned char *
19853 display_public_gnu_attributes (unsigned char * start
,
19854 const unsigned char * const end
)
19856 printf (_(" Unknown GNU attribute: %s\n"), start
);
19858 start
+= strnlen ((char *) start
, end
- start
);
19859 display_raw_attribute (start
, end
);
19861 return (unsigned char *) end
;
19864 static unsigned char *
19865 display_generic_attribute (unsigned char * start
,
19867 const unsigned char * const end
)
19870 return (unsigned char *) end
;
19872 return display_tag_value (tag
, start
, end
);
19876 process_arch_specific (Filedata
* filedata
)
19881 switch (filedata
->file_header
.e_machine
)
19884 case EM_ARC_COMPACT
:
19885 case EM_ARC_COMPACT2
:
19886 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19887 display_arc_attribute
,
19888 display_generic_attribute
);
19890 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19891 display_arm_attribute
,
19892 display_generic_attribute
);
19895 case EM_MIPS_RS3_LE
:
19896 return process_mips_specific (filedata
);
19899 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19900 display_msp430x_attribute
,
19901 display_msp430_gnu_attribute
);
19904 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19905 display_riscv_attribute
,
19906 display_generic_attribute
);
19909 return process_nds32_specific (filedata
);
19913 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19914 display_power_gnu_attribute
);
19918 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19919 display_s390_gnu_attribute
);
19922 case EM_SPARC32PLUS
:
19924 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19925 display_sparc_gnu_attribute
);
19928 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19929 display_tic6x_attribute
,
19930 display_generic_attribute
);
19933 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19934 display_public_gnu_attributes
,
19935 display_generic_attribute
);
19940 get_file_header (Filedata
* filedata
)
19942 /* Read in the identity array. */
19943 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19946 /* Determine how to read the rest of the header. */
19947 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19952 byte_get
= byte_get_little_endian
;
19953 byte_put
= byte_put_little_endian
;
19956 byte_get
= byte_get_big_endian
;
19957 byte_put
= byte_put_big_endian
;
19961 /* For now we only support 32 bit and 64 bit ELF files. */
19962 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19964 /* Read in the rest of the header. */
19967 Elf32_External_Ehdr ehdr32
;
19969 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19972 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19973 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19974 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19975 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19976 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19977 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19978 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19979 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19980 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19981 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19982 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19983 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19984 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19988 Elf64_External_Ehdr ehdr64
;
19990 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19991 we will not be able to cope with the 64bit data found in
19992 64 ELF files. Detect this now and abort before we start
19993 overwriting things. */
19994 if (sizeof (bfd_vma
) < 8)
19996 error (_("This instance of readelf has been built without support for a\n\
19997 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20001 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20004 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20005 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20006 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20007 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20008 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20009 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20010 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20011 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20012 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20013 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20014 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20015 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20016 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20019 if (filedata
->file_header
.e_shoff
)
20021 /* There may be some extensions in the first section header. Don't
20022 bomb if we can't read it. */
20024 get_32bit_section_headers (filedata
, TRUE
);
20026 get_64bit_section_headers (filedata
, TRUE
);
20033 close_file (Filedata
* filedata
)
20037 if (filedata
->handle
)
20038 fclose (filedata
->handle
);
20044 close_debug_file (void * data
)
20046 close_file ((Filedata
*) data
);
20050 open_file (const char * pathname
)
20052 struct stat statbuf
;
20053 Filedata
* filedata
= NULL
;
20055 if (stat (pathname
, & statbuf
) < 0
20056 || ! S_ISREG (statbuf
.st_mode
))
20059 filedata
= calloc (1, sizeof * filedata
);
20060 if (filedata
== NULL
)
20063 filedata
->handle
= fopen (pathname
, "rb");
20064 if (filedata
->handle
== NULL
)
20067 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20068 filedata
->file_name
= pathname
;
20070 if (! get_file_header (filedata
))
20073 if (filedata
->file_header
.e_shoff
)
20077 /* Read the section headers again, this time for real. */
20079 res
= get_32bit_section_headers (filedata
, FALSE
);
20081 res
= get_64bit_section_headers (filedata
, FALSE
);
20092 if (filedata
->handle
)
20093 fclose (filedata
->handle
);
20100 open_debug_file (const char * pathname
)
20102 return open_file (pathname
);
20105 /* Process one ELF object file according to the command line options.
20106 This file may actually be stored in an archive. The file is
20107 positioned at the start of the ELF object. Returns TRUE if no
20108 problems were encountered, FALSE otherwise. */
20111 process_object (Filedata
* filedata
)
20113 bfd_boolean have_separate_files
;
20115 bfd_boolean res
= TRUE
;
20117 if (! get_file_header (filedata
))
20119 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20123 /* Initialise per file variables. */
20124 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20125 filedata
->version_info
[i
] = 0;
20127 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20128 filedata
->dynamic_info
[i
] = 0;
20129 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20130 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20132 /* Process the file. */
20134 printf (_("\nFile: %s\n"), filedata
->file_name
);
20136 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20137 Note we do this even if cmdline_dump_sects is empty because we
20138 must make sure that the dump_sets array is zeroed out before each
20139 object file is processed. */
20140 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20141 memset (filedata
->dump
.dump_sects
, 0,
20142 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20144 if (cmdline
.num_dump_sects
> 0)
20146 if (filedata
->dump
.num_dump_sects
== 0)
20147 /* A sneaky way of allocating the dump_sects array. */
20148 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20150 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20151 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20152 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20155 if (! process_file_header (filedata
))
20158 if (! process_section_headers (filedata
))
20160 /* Without loaded section headers we cannot process lots of things. */
20161 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20163 if (! do_using_dynamic
)
20164 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20167 if (! process_section_groups (filedata
))
20168 /* Without loaded section groups we cannot process unwind. */
20171 if (process_program_headers (filedata
))
20172 process_dynamic_section (filedata
);
20176 if (! process_relocs (filedata
))
20179 if (! process_unwind (filedata
))
20182 if (! process_symbol_table (filedata
))
20185 if (! process_syminfo (filedata
))
20188 if (! process_version_sections (filedata
))
20191 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20192 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20194 have_separate_files
= FALSE
;
20196 if (! process_section_contents (filedata
))
20199 if (have_separate_files
)
20203 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20205 if (! process_section_headers (d
->handle
))
20207 else if (! process_section_contents (d
->handle
))
20211 /* The file handles are closed by the call to free_debug_memory() below. */
20214 if (! process_notes (filedata
))
20217 if (! process_gnu_liblist (filedata
))
20220 if (! process_arch_specific (filedata
))
20223 free (filedata
->program_headers
);
20224 filedata
->program_headers
= NULL
;
20226 free (filedata
->section_headers
);
20227 filedata
->section_headers
= NULL
;
20229 free (filedata
->string_table
);
20230 filedata
->string_table
= NULL
;
20231 filedata
->string_table_length
= 0;
20233 if (filedata
->dump
.dump_sects
!= NULL
)
20235 free (filedata
->dump
.dump_sects
);
20236 filedata
->dump
.dump_sects
= NULL
;
20237 filedata
->dump
.num_dump_sects
= 0;
20240 if (filedata
->dynamic_strings
)
20242 free (filedata
->dynamic_strings
);
20243 filedata
->dynamic_strings
= NULL
;
20244 filedata
->dynamic_strings_length
= 0;
20247 if (filedata
->dynamic_symbols
)
20249 free (filedata
->dynamic_symbols
);
20250 filedata
->dynamic_symbols
= NULL
;
20251 filedata
->num_dynamic_syms
= 0;
20254 if (filedata
->dynamic_syminfo
)
20256 free (filedata
->dynamic_syminfo
);
20257 filedata
->dynamic_syminfo
= NULL
;
20260 if (filedata
->dynamic_section
)
20262 free (filedata
->dynamic_section
);
20263 filedata
->dynamic_section
= NULL
;
20266 while (filedata
->symtab_shndx_list
!= NULL
)
20268 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20269 free (filedata
->symtab_shndx_list
);
20270 filedata
->symtab_shndx_list
= next
;
20273 if (filedata
->section_headers_groups
)
20275 free (filedata
->section_headers_groups
);
20276 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
)
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))
20722 else if (optind
>= argc
)
20724 warn (_("Nothing to do.\n"));
20729 while (optind
< argc
)
20730 if (! process_file (argv
[optind
++]))
20733 if (cmdline
.dump_sects
!= NULL
)
20734 free (cmdline
.dump_sects
);
20736 free (dump_ctf_symtab_name
);
20737 free (dump_ctf_strtab_name
);
20738 free (dump_ctf_parent_name
);
20740 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;