1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/csky.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
107 #include "elf/epiphany.h"
108 #include "elf/fr30.h"
110 #include "elf/ft32.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/s12z.h"
126 #include "elf/mcore.h"
128 #include "elf/metag.h"
129 #include "elf/microblaze.h"
130 #include "elf/mips.h"
131 #include "elf/mmix.h"
132 #include "elf/mn10200.h"
133 #include "elf/mn10300.h"
134 #include "elf/moxie.h"
136 #include "elf/msp430.h"
137 #include "elf/nds32.h"
139 #include "elf/nios2.h"
140 #include "elf/or1k.h"
143 #include "elf/ppc64.h"
145 #include "elf/riscv.h"
146 #include "elf/rl78.h"
148 #include "elf/s390.h"
149 #include "elf/score.h"
151 #include "elf/sparc.h"
153 #include "elf/tic6x.h"
154 #include "elf/tilegx.h"
155 #include "elf/tilepro.h"
156 #include "elf/v850.h"
158 #include "elf/visium.h"
159 #include "elf/wasm32.h"
160 #include "elf/x86-64.h"
161 #include "elf/xc16x.h"
162 #include "elf/xgate.h"
163 #include "elf/xstormy16.h"
164 #include "elf/xtensa.h"
168 #include "libiberty.h"
169 #include "safe-ctype.h"
170 #include "filenames.h"
173 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
176 typedef struct elf_section_list
178 Elf_Internal_Shdr
* hdr
;
179 struct elf_section_list
* next
;
182 /* Flag bits indicating particular types of dump. */
183 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
184 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
187 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
190 typedef unsigned char dump_type
;
192 /* A linked list of the section names for which dumps were requested. */
193 struct dump_list_entry
197 struct dump_list_entry
* next
;
200 /* A dynamic array of flags indicating for which sections a dump
201 has been requested via command line switches. */
204 dump_type
* dump_sects
;
205 unsigned int num_dump_sects
;
208 static struct dump_data cmdline
;
210 static struct dump_list_entry
* dump_sects_byname
;
212 char * program_name
= "readelf";
214 static bfd_boolean show_name
= FALSE
;
215 static bfd_boolean do_dynamic
= FALSE
;
216 static bfd_boolean do_syms
= FALSE
;
217 static bfd_boolean do_dyn_syms
= FALSE
;
218 static bfd_boolean do_reloc
= FALSE
;
219 static bfd_boolean do_sections
= FALSE
;
220 static bfd_boolean do_section_groups
= FALSE
;
221 static bfd_boolean do_section_details
= FALSE
;
222 static bfd_boolean do_segments
= FALSE
;
223 static bfd_boolean do_unwind
= FALSE
;
224 static bfd_boolean do_using_dynamic
= FALSE
;
225 static bfd_boolean do_header
= FALSE
;
226 static bfd_boolean do_dump
= FALSE
;
227 static bfd_boolean do_version
= FALSE
;
228 static bfd_boolean do_histogram
= FALSE
;
229 static bfd_boolean do_debugging
= FALSE
;
230 static bfd_boolean do_ctf
= FALSE
;
231 static bfd_boolean do_arch
= FALSE
;
232 static bfd_boolean do_notes
= FALSE
;
233 static bfd_boolean do_archive_index
= FALSE
;
234 static bfd_boolean check_all
= FALSE
;
235 static bfd_boolean is_32bit_elf
= FALSE
;
236 static bfd_boolean decompress_dumps
= FALSE
;
238 static char *dump_ctf_parent_name
;
239 static char *dump_ctf_symtab_name
;
240 static char *dump_ctf_strtab_name
;
244 struct group_list
* next
;
245 unsigned int section_index
;
250 struct group_list
* root
;
251 unsigned int group_index
;
254 typedef struct filedata
256 const char * file_name
;
258 bfd_size_type file_size
;
259 Elf_Internal_Ehdr file_header
;
260 Elf_Internal_Shdr
* section_headers
;
261 Elf_Internal_Phdr
* program_headers
;
263 unsigned long string_table_length
;
264 unsigned long archive_file_offset
;
265 unsigned long archive_file_size
;
266 unsigned long dynamic_addr
;
267 bfd_size_type dynamic_size
;
269 Elf_Internal_Dyn
* dynamic_section
;
270 char * dynamic_strings
;
271 unsigned long dynamic_strings_length
;
272 unsigned long num_dynamic_syms
;
273 Elf_Internal_Sym
* dynamic_symbols
;
274 bfd_vma version_info
[16];
275 unsigned int dynamic_syminfo_nent
;
276 Elf_Internal_Syminfo
* dynamic_syminfo
;
277 unsigned long dynamic_syminfo_offset
;
278 bfd_size_type nbuckets
;
279 bfd_size_type nchains
;
282 bfd_size_type ngnubuckets
;
283 bfd_size_type ngnuchains
;
284 bfd_vma
* gnubuckets
;
288 char program_interpreter
[PATH_MAX
];
289 bfd_vma dynamic_info
[DT_ENCODING
];
290 bfd_vma dynamic_info_DT_GNU_HASH
;
291 bfd_vma dynamic_info_DT_MIPS_XHASH
;
292 elf_section_list
* symtab_shndx_list
;
294 struct group
* section_groups
;
295 struct group
** section_headers_groups
;
296 /* A dynamic array of flags indicating for which sections a dump of
297 some kind has been requested. It is reset on a per-object file
298 basis and then initialised from the cmdline_dump_sects array,
299 the results of interpreting the -w switch, and the
300 dump_sects_byname list. */
301 struct dump_data dump
;
304 /* How to print a vma value. */
305 typedef enum print_mode
317 /* Versioned symbol info. */
318 enum versioned_symbol_info
325 static const char * get_symbol_version_string
326 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
327 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
331 #define SECTION_NAME(X) \
332 ((X) == NULL ? _("<none>") \
333 : filedata->string_table == NULL ? _("<no-strings>") \
334 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
335 : filedata->string_table + (X)->sh_name))
337 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
339 #define GET_ELF_SYMBOLS(file, section, sym_count) \
340 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
341 : get_64bit_elf_symbols (file, section, sym_count))
343 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
344 (strtab != NULL && offset < strtab_size)
345 #define VALID_DYNAMIC_NAME(filedata, offset) \
346 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
347 filedata->dynamic_strings_length, offset)
348 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
349 already been called and verified that the string exists. */
350 #define GET_DYNAMIC_NAME(filedata, offset) \
351 (filedata->dynamic_strings + offset)
353 #define REMOVE_ARCH_BITS(ADDR) \
356 if (filedata->file_header.e_machine == EM_ARM) \
361 /* Get the correct GNU hash section name. */
362 #define GNU_HASH_SECTION_NAME(filedata) \
363 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
365 /* Print a BFD_VMA to an internal buffer, for use in error messages.
366 BFD_FMA_FMT can't be used in translated strings. */
369 bfd_vmatoa (char *fmtch
, bfd_vma value
)
371 /* bfd_vmatoa is used more then once in a printf call for output.
372 Cycle through an array of buffers. */
373 static int buf_pos
= 0;
374 static struct bfd_vmatoa_buf
381 ret
= buf
[buf_pos
++].place
;
382 buf_pos
%= ARRAY_SIZE (buf
);
384 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
385 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
389 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
390 OFFSET + the offset of the current archive member, if we are examining an
391 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
392 allocate a buffer using malloc and fill that. In either case return the
393 pointer to the start of the retrieved data or NULL if something went wrong.
394 If something does go wrong and REASON is not NULL then emit an error
395 message using REASON as part of the context. */
398 get_data (void * var
,
400 unsigned long offset
,
406 bfd_size_type amt
= size
* nmemb
;
408 if (size
== 0 || nmemb
== 0)
411 /* If the size_t type is smaller than the bfd_size_type, eg because
412 you are building a 32-bit tool on a 64-bit host, then make sure
413 that when the sizes are cast to (size_t) no information is lost. */
414 if ((size_t) size
!= size
415 || (size_t) nmemb
!= nmemb
416 || (size_t) amt
!= amt
)
419 error (_("Size truncation prevents reading %s"
420 " elements of size %s for %s\n"),
421 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
425 /* Check for size overflow. */
426 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
429 error (_("Size overflow prevents reading %s"
430 " elements of size %s for %s\n"),
431 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
435 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
436 attempting to allocate memory when the read is bound to fail. */
437 if (filedata
->archive_file_offset
> filedata
->file_size
438 || offset
> filedata
->file_size
- filedata
->archive_file_offset
439 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
442 error (_("Reading %s bytes extends past end of file for %s\n"),
443 bfd_vmatoa ("u", amt
), reason
);
447 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
451 error (_("Unable to seek to 0x%lx for %s\n"),
452 filedata
->archive_file_offset
+ offset
, reason
);
459 /* + 1 so that we can '\0' terminate invalid string table sections. */
460 mvar
= malloc ((size_t) amt
+ 1);
465 error (_("Out of memory allocating %s bytes for %s\n"),
466 bfd_vmatoa ("u", amt
), reason
);
470 ((char *) mvar
)[amt
] = '\0';
473 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
476 error (_("Unable to read in %s bytes of %s\n"),
477 bfd_vmatoa ("u", amt
), reason
);
486 /* Print a VMA value in the MODE specified.
487 Returns the number of characters displayed. */
490 print_vma (bfd_vma vma
, print_mode mode
)
502 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
509 return printf ("%5" BFD_VMA_FMT
"d", vma
);
515 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
518 return printf ("%" BFD_VMA_FMT
"d", vma
);
521 return printf ("%" BFD_VMA_FMT
"u", vma
);
524 /* FIXME: Report unrecognised mode ? */
529 /* Display a symbol on stdout. Handles the display of control characters and
530 multibye characters (assuming the host environment supports them).
532 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
534 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
535 padding as necessary.
537 Returns the number of emitted characters. */
540 print_symbol (signed int width
, const char *symbol
)
542 bfd_boolean extra_padding
= FALSE
;
543 signed int num_printed
= 0;
544 #ifdef HAVE_MBSTATE_T
547 unsigned int width_remaining
;
551 /* Keep the width positive. This helps the code below. */
553 extra_padding
= TRUE
;
559 /* Set the remaining width to a very large value.
560 This simplifies the code below. */
561 width_remaining
= INT_MAX
;
563 width_remaining
= width
;
565 #ifdef HAVE_MBSTATE_T
566 /* Initialise the multibyte conversion state. */
567 memset (& state
, 0, sizeof (state
));
570 while (width_remaining
)
573 const char c
= *symbol
++;
578 /* Do not print control characters directly as they can affect terminal
579 settings. Such characters usually appear in the names generated
580 by the assembler for local labels. */
583 if (width_remaining
< 2)
586 printf ("^%c", c
+ 0x40);
587 width_remaining
-= 2;
590 else if (ISPRINT (c
))
598 #ifdef HAVE_MBSTATE_T
601 /* Let printf do the hard work of displaying multibyte characters. */
602 printf ("%.1s", symbol
- 1);
606 #ifdef HAVE_MBSTATE_T
607 /* Try to find out how many bytes made up the character that was
608 just printed. Advance the symbol pointer past the bytes that
610 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
614 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
619 if (extra_padding
&& num_printed
< width
)
621 /* Fill in the remaining spaces. */
622 printf ("%-*s", width
- num_printed
, " ");
629 /* Returns a pointer to a static buffer containing a printable version of
630 the given section's name. Like print_symbol, except that it does not try
631 to print multibyte characters, it just interprets them as hex values. */
634 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
636 #define MAX_PRINT_SEC_NAME_LEN 128
637 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
638 const char * name
= SECTION_NAME (sec
);
639 char * buf
= sec_name_buf
;
641 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
643 while ((c
= * name
++) != 0)
654 else if (ISPRINT (c
))
661 static char hex
[17] = "0123456789ABCDEF";
666 * buf
++ = hex
[(c
& 0xf0) >> 4];
667 * buf
++ = hex
[c
& 0x0f];
681 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
683 if (ndx
>= filedata
->file_header
.e_shnum
)
684 return _("<corrupt>");
686 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
689 /* Return a pointer to section NAME, or NULL if no such section exists. */
691 static Elf_Internal_Shdr
*
692 find_section (Filedata
* filedata
, const char * name
)
696 if (filedata
->section_headers
== NULL
)
699 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
700 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
701 return filedata
->section_headers
+ i
;
706 /* Return a pointer to a section containing ADDR, or NULL if no such
709 static Elf_Internal_Shdr
*
710 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
714 if (filedata
->section_headers
== NULL
)
717 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
719 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
721 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
728 static Elf_Internal_Shdr
*
729 find_section_by_type (Filedata
* filedata
, unsigned int type
)
733 if (filedata
->section_headers
== NULL
)
736 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
738 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
740 if (sec
->sh_type
== type
)
747 /* Return a pointer to section NAME, or NULL if no such section exists,
748 restricted to the list of sections given in SET. */
750 static Elf_Internal_Shdr
*
751 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
755 if (filedata
->section_headers
== NULL
)
760 while ((i
= *set
++) > 0)
762 /* See PR 21156 for a reproducer. */
763 if (i
>= filedata
->file_header
.e_shnum
)
764 continue; /* FIXME: Should we issue an error message ? */
766 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
767 return filedata
->section_headers
+ i
;
771 return find_section (filedata
, name
);
774 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
775 This OS has so many departures from the ELF standard that we test it at
778 static inline bfd_boolean
779 is_ia64_vms (Filedata
* filedata
)
781 return filedata
->file_header
.e_machine
== EM_IA_64
782 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
785 /* Guess the relocation size commonly used by the specific machines. */
788 guess_is_rela (unsigned int e_machine
)
792 /* Targets that use REL relocations. */
809 /* Targets that use RELA relocations. */
813 case EM_ADAPTEVA_EPIPHANY
:
815 case EM_ALTERA_NIOS2
:
818 case EM_ARC_COMPACT2
:
839 case EM_LATTICEMICO32
:
848 case EM_CYGNUS_MN10200
:
850 case EM_CYGNUS_MN10300
:
886 case EM_MICROBLAZE_OLD
:
908 warn (_("Don't know about relocations on this machine architecture\n"));
913 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
914 Returns TRUE upon success, FALSE otherwise. If successful then a
915 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
916 and the number of relocs loaded is placed in *NRELASP. It is the caller's
917 responsibility to free the allocated buffer. */
920 slurp_rela_relocs (Filedata
* filedata
,
921 unsigned long rel_offset
,
922 unsigned long rel_size
,
923 Elf_Internal_Rela
** relasp
,
924 unsigned long * nrelasp
)
926 Elf_Internal_Rela
* relas
;
932 Elf32_External_Rela
* erelas
;
934 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
935 rel_size
, _("32-bit relocation data"));
939 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
941 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
942 sizeof (Elf_Internal_Rela
));
947 error (_("out of memory parsing relocs\n"));
951 for (i
= 0; i
< nrelas
; i
++)
953 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
954 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
955 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
962 Elf64_External_Rela
* erelas
;
964 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
965 rel_size
, _("64-bit relocation data"));
969 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
971 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
972 sizeof (Elf_Internal_Rela
));
977 error (_("out of memory parsing relocs\n"));
981 for (i
= 0; i
< nrelas
; i
++)
983 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
984 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
985 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
987 /* The #ifdef BFD64 below is to prevent a compile time
988 warning. We know that if we do not have a 64 bit data
989 type that we will never execute this code anyway. */
991 if (filedata
->file_header
.e_machine
== EM_MIPS
992 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
994 /* In little-endian objects, r_info isn't really a
995 64-bit little-endian value: it has a 32-bit
996 little-endian symbol index followed by four
997 individual byte fields. Reorder INFO
999 bfd_vma inf
= relas
[i
].r_info
;
1000 inf
= (((inf
& 0xffffffff) << 32)
1001 | ((inf
>> 56) & 0xff)
1002 | ((inf
>> 40) & 0xff00)
1003 | ((inf
>> 24) & 0xff0000)
1004 | ((inf
>> 8) & 0xff000000));
1005 relas
[i
].r_info
= inf
;
1018 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1019 Returns TRUE upon success, FALSE otherwise. If successful then a
1020 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1021 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1022 responsibility to free the allocated buffer. */
1025 slurp_rel_relocs (Filedata
* filedata
,
1026 unsigned long rel_offset
,
1027 unsigned long rel_size
,
1028 Elf_Internal_Rela
** relsp
,
1029 unsigned long * nrelsp
)
1031 Elf_Internal_Rela
* rels
;
1037 Elf32_External_Rel
* erels
;
1039 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1040 rel_size
, _("32-bit relocation data"));
1044 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1046 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1051 error (_("out of memory parsing relocs\n"));
1055 for (i
= 0; i
< nrels
; i
++)
1057 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1058 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1059 rels
[i
].r_addend
= 0;
1066 Elf64_External_Rel
* erels
;
1068 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1069 rel_size
, _("64-bit relocation data"));
1073 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1075 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1080 error (_("out of memory parsing relocs\n"));
1084 for (i
= 0; i
< nrels
; i
++)
1086 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1087 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1088 rels
[i
].r_addend
= 0;
1090 /* The #ifdef BFD64 below is to prevent a compile time
1091 warning. We know that if we do not have a 64 bit data
1092 type that we will never execute this code anyway. */
1094 if (filedata
->file_header
.e_machine
== EM_MIPS
1095 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1097 /* In little-endian objects, r_info isn't really a
1098 64-bit little-endian value: it has a 32-bit
1099 little-endian symbol index followed by four
1100 individual byte fields. Reorder INFO
1102 bfd_vma inf
= rels
[i
].r_info
;
1103 inf
= (((inf
& 0xffffffff) << 32)
1104 | ((inf
>> 56) & 0xff)
1105 | ((inf
>> 40) & 0xff00)
1106 | ((inf
>> 24) & 0xff0000)
1107 | ((inf
>> 8) & 0xff000000));
1108 rels
[i
].r_info
= inf
;
1121 /* Returns the reloc type extracted from the reloc info field. */
1124 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1127 return ELF32_R_TYPE (reloc_info
);
1129 switch (filedata
->file_header
.e_machine
)
1132 /* Note: We assume that reloc_info has already been adjusted for us. */
1133 return ELF64_MIPS_R_TYPE (reloc_info
);
1136 return ELF64_R_TYPE_ID (reloc_info
);
1139 return ELF64_R_TYPE (reloc_info
);
1143 /* Return the symbol index extracted from the reloc info field. */
1146 get_reloc_symindex (bfd_vma reloc_info
)
1148 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1151 static inline bfd_boolean
1152 uses_msp430x_relocs (Filedata
* filedata
)
1155 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1156 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1157 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1158 /* TI compiler uses ELFOSABI_NONE. */
1159 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1162 /* Display the contents of the relocation data found at the specified
1166 dump_relocations (Filedata
* filedata
,
1167 unsigned long rel_offset
,
1168 unsigned long rel_size
,
1169 Elf_Internal_Sym
* symtab
,
1170 unsigned long nsyms
,
1172 unsigned long strtablen
,
1174 bfd_boolean is_dynsym
)
1177 Elf_Internal_Rela
* rels
;
1178 bfd_boolean res
= TRUE
;
1180 if (is_rela
== UNKNOWN
)
1181 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1185 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1190 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1199 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1201 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1206 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1208 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1216 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1218 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1223 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1225 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1229 for (i
= 0; i
< rel_size
; i
++)
1234 bfd_vma symtab_index
;
1237 offset
= rels
[i
].r_offset
;
1238 inf
= rels
[i
].r_info
;
1240 type
= get_reloc_type (filedata
, inf
);
1241 symtab_index
= get_reloc_symindex (inf
);
1245 printf ("%8.8lx %8.8lx ",
1246 (unsigned long) offset
& 0xffffffff,
1247 (unsigned long) inf
& 0xffffffff);
1251 #if BFD_HOST_64BIT_LONG
1253 ? "%16.16lx %16.16lx "
1254 : "%12.12lx %12.12lx ",
1256 #elif BFD_HOST_64BIT_LONG_LONG
1259 ? "%16.16llx %16.16llx "
1260 : "%12.12llx %12.12llx ",
1264 ? "%16.16I64x %16.16I64x "
1265 : "%12.12I64x %12.12I64x ",
1270 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1271 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1272 _bfd_int64_high (offset
),
1273 _bfd_int64_low (offset
),
1274 _bfd_int64_high (inf
),
1275 _bfd_int64_low (inf
));
1279 switch (filedata
->file_header
.e_machine
)
1286 rtype
= elf_aarch64_reloc_type (type
);
1290 case EM_CYGNUS_M32R
:
1291 rtype
= elf_m32r_reloc_type (type
);
1296 rtype
= elf_i386_reloc_type (type
);
1301 rtype
= elf_m68hc11_reloc_type (type
);
1305 rtype
= elf_s12z_reloc_type (type
);
1309 rtype
= elf_m68k_reloc_type (type
);
1313 rtype
= elf_i960_reloc_type (type
);
1318 rtype
= elf_avr_reloc_type (type
);
1321 case EM_OLD_SPARCV9
:
1322 case EM_SPARC32PLUS
:
1325 rtype
= elf_sparc_reloc_type (type
);
1329 rtype
= elf_spu_reloc_type (type
);
1333 rtype
= v800_reloc_type (type
);
1336 case EM_CYGNUS_V850
:
1337 rtype
= v850_reloc_type (type
);
1341 case EM_CYGNUS_D10V
:
1342 rtype
= elf_d10v_reloc_type (type
);
1346 case EM_CYGNUS_D30V
:
1347 rtype
= elf_d30v_reloc_type (type
);
1351 rtype
= elf_dlx_reloc_type (type
);
1355 rtype
= elf_sh_reloc_type (type
);
1359 case EM_CYGNUS_MN10300
:
1360 rtype
= elf_mn10300_reloc_type (type
);
1364 case EM_CYGNUS_MN10200
:
1365 rtype
= elf_mn10200_reloc_type (type
);
1369 case EM_CYGNUS_FR30
:
1370 rtype
= elf_fr30_reloc_type (type
);
1374 rtype
= elf_frv_reloc_type (type
);
1378 rtype
= elf_csky_reloc_type (type
);
1382 rtype
= elf_ft32_reloc_type (type
);
1386 rtype
= elf_mcore_reloc_type (type
);
1390 rtype
= elf_mmix_reloc_type (type
);
1394 rtype
= elf_moxie_reloc_type (type
);
1398 if (uses_msp430x_relocs (filedata
))
1400 rtype
= elf_msp430x_reloc_type (type
);
1405 rtype
= elf_msp430_reloc_type (type
);
1409 rtype
= elf_nds32_reloc_type (type
);
1413 rtype
= elf_ppc_reloc_type (type
);
1417 rtype
= elf_ppc64_reloc_type (type
);
1421 case EM_MIPS_RS3_LE
:
1422 rtype
= elf_mips_reloc_type (type
);
1426 rtype
= elf_riscv_reloc_type (type
);
1430 rtype
= elf_alpha_reloc_type (type
);
1434 rtype
= elf_arm_reloc_type (type
);
1438 case EM_ARC_COMPACT
:
1439 case EM_ARC_COMPACT2
:
1440 rtype
= elf_arc_reloc_type (type
);
1444 rtype
= elf_hppa_reloc_type (type
);
1450 rtype
= elf_h8_reloc_type (type
);
1454 rtype
= elf_or1k_reloc_type (type
);
1459 rtype
= elf_pj_reloc_type (type
);
1462 rtype
= elf_ia64_reloc_type (type
);
1466 rtype
= elf_cris_reloc_type (type
);
1470 rtype
= elf_i860_reloc_type (type
);
1476 rtype
= elf_x86_64_reloc_type (type
);
1480 rtype
= i370_reloc_type (type
);
1485 rtype
= elf_s390_reloc_type (type
);
1489 rtype
= elf_score_reloc_type (type
);
1493 rtype
= elf_xstormy16_reloc_type (type
);
1497 rtype
= elf_crx_reloc_type (type
);
1501 rtype
= elf_vax_reloc_type (type
);
1505 rtype
= elf_visium_reloc_type (type
);
1509 rtype
= elf_bpf_reloc_type (type
);
1512 case EM_ADAPTEVA_EPIPHANY
:
1513 rtype
= elf_epiphany_reloc_type (type
);
1518 rtype
= elf_ip2k_reloc_type (type
);
1522 rtype
= elf_iq2000_reloc_type (type
);
1527 rtype
= elf_xtensa_reloc_type (type
);
1530 case EM_LATTICEMICO32
:
1531 rtype
= elf_lm32_reloc_type (type
);
1536 rtype
= elf_m32c_reloc_type (type
);
1540 rtype
= elf_mt_reloc_type (type
);
1544 rtype
= elf_bfin_reloc_type (type
);
1548 rtype
= elf_mep_reloc_type (type
);
1552 rtype
= elf_cr16_reloc_type (type
);
1556 case EM_MICROBLAZE_OLD
:
1557 rtype
= elf_microblaze_reloc_type (type
);
1561 rtype
= elf_rl78_reloc_type (type
);
1565 rtype
= elf_rx_reloc_type (type
);
1569 rtype
= elf_metag_reloc_type (type
);
1574 rtype
= elf_xc16x_reloc_type (type
);
1578 rtype
= elf_tic6x_reloc_type (type
);
1582 rtype
= elf_tilegx_reloc_type (type
);
1586 rtype
= elf_tilepro_reloc_type (type
);
1589 case EM_WEBASSEMBLY
:
1590 rtype
= elf_wasm32_reloc_type (type
);
1594 rtype
= elf_xgate_reloc_type (type
);
1597 case EM_ALTERA_NIOS2
:
1598 rtype
= elf_nios2_reloc_type (type
);
1602 rtype
= elf_pru_reloc_type (type
);
1606 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1607 rtype
= elf_nfp3200_reloc_type (type
);
1609 rtype
= elf_nfp_reloc_type (type
);
1613 rtype
= elf_z80_reloc_type (type
);
1618 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1620 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1622 if (filedata
->file_header
.e_machine
== EM_ALPHA
1624 && streq (rtype
, "R_ALPHA_LITUSE")
1627 switch (rels
[i
].r_addend
)
1629 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1630 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1631 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1632 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1633 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1634 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1635 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1636 default: rtype
= NULL
;
1640 printf (" (%s)", rtype
);
1644 printf (_("<unknown addend: %lx>"),
1645 (unsigned long) rels
[i
].r_addend
);
1649 else if (symtab_index
)
1651 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1653 error (_(" bad symbol index: %08lx in reloc\n"),
1654 (unsigned long) symtab_index
);
1659 Elf_Internal_Sym
* psym
;
1660 const char * version_string
;
1661 enum versioned_symbol_info sym_info
;
1662 unsigned short vna_other
;
1664 psym
= symtab
+ symtab_index
;
1667 = get_symbol_version_string (filedata
, is_dynsym
,
1676 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1680 unsigned int width
= is_32bit_elf
? 8 : 14;
1682 /* Relocations against GNU_IFUNC symbols do not use the value
1683 of the symbol as the address to relocate against. Instead
1684 they invoke the function named by the symbol and use its
1685 result as the address for relocation.
1687 To indicate this to the user, do not display the value of
1688 the symbol in the "Symbols's Value" field. Instead show
1689 its name followed by () as a hint that the symbol is
1693 || psym
->st_name
== 0
1694 || psym
->st_name
>= strtablen
)
1697 name
= strtab
+ psym
->st_name
;
1699 len
= print_symbol (width
, name
);
1701 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1703 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1707 print_vma (psym
->st_value
, LONG_HEX
);
1709 printf (is_32bit_elf
? " " : " ");
1712 if (psym
->st_name
== 0)
1714 const char * sec_name
= "<null>";
1717 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1719 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1720 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1721 else if (psym
->st_shndx
== SHN_ABS
)
1723 else if (psym
->st_shndx
== SHN_COMMON
)
1724 sec_name
= "COMMON";
1725 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1726 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1727 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1728 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1729 sec_name
= "SCOMMON";
1730 else if (filedata
->file_header
.e_machine
== EM_MIPS
1731 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1732 sec_name
= "SUNDEF";
1733 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1734 || filedata
->file_header
.e_machine
== EM_L1OM
1735 || filedata
->file_header
.e_machine
== EM_K1OM
)
1736 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1737 sec_name
= "LARGE_COMMON";
1738 else if (filedata
->file_header
.e_machine
== EM_IA_64
1739 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1740 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1741 sec_name
= "ANSI_COM";
1742 else if (is_ia64_vms (filedata
)
1743 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1744 sec_name
= "VMS_SYMVEC";
1747 sprintf (name_buf
, "<section 0x%x>",
1748 (unsigned int) psym
->st_shndx
);
1749 sec_name
= name_buf
;
1752 print_symbol (22, sec_name
);
1754 else if (strtab
== NULL
)
1755 printf (_("<string table index: %3ld>"), psym
->st_name
);
1756 else if (psym
->st_name
>= strtablen
)
1758 error (_("<corrupt string table index: %3ld>\n"),
1764 print_symbol (22, strtab
+ psym
->st_name
);
1766 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1772 bfd_vma off
= rels
[i
].r_addend
;
1774 if ((bfd_signed_vma
) off
< 0)
1775 printf (" - %" BFD_VMA_FMT
"x", - off
);
1777 printf (" + %" BFD_VMA_FMT
"x", off
);
1783 bfd_vma off
= rels
[i
].r_addend
;
1785 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1786 if ((bfd_signed_vma
) off
< 0)
1787 printf ("-%" BFD_VMA_FMT
"x", - off
);
1789 printf ("%" BFD_VMA_FMT
"x", off
);
1792 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1794 && streq (rtype
, "R_SPARC_OLO10"))
1795 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1800 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1802 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1803 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1804 const char * rtype2
= elf_mips_reloc_type (type2
);
1805 const char * rtype3
= elf_mips_reloc_type (type3
);
1807 printf (" Type2: ");
1810 printf (_("unrecognized: %-7lx"),
1811 (unsigned long) type2
& 0xffffffff);
1813 printf ("%-17.17s", rtype2
);
1815 printf ("\n Type3: ");
1818 printf (_("unrecognized: %-7lx"),
1819 (unsigned long) type3
& 0xffffffff);
1821 printf ("%-17.17s", rtype3
);
1834 get_aarch64_dynamic_type (unsigned long type
)
1838 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1839 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1840 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1847 get_mips_dynamic_type (unsigned long type
)
1851 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1852 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1853 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1854 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1855 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1856 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1857 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1858 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1859 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1860 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1861 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1862 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1863 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1864 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1865 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1866 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1867 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1868 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1869 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1870 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1871 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1872 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1873 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1874 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1875 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1876 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1877 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1878 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1879 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1880 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1881 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1882 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1883 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1884 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1885 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1886 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1887 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1888 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1889 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1890 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1891 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1892 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1893 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1894 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1895 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1896 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1897 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1904 get_sparc64_dynamic_type (unsigned long type
)
1908 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1915 get_ppc_dynamic_type (unsigned long type
)
1919 case DT_PPC_GOT
: return "PPC_GOT";
1920 case DT_PPC_OPT
: return "PPC_OPT";
1927 get_ppc64_dynamic_type (unsigned long type
)
1931 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1932 case DT_PPC64_OPD
: return "PPC64_OPD";
1933 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1934 case DT_PPC64_OPT
: return "PPC64_OPT";
1941 get_parisc_dynamic_type (unsigned long type
)
1945 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1946 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1947 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1948 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1949 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1950 case DT_HP_PREINIT
: return "HP_PREINIT";
1951 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1952 case DT_HP_NEEDED
: return "HP_NEEDED";
1953 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1954 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1955 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1956 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1957 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1958 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1959 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1960 case DT_HP_FILTERED
: return "HP_FILTERED";
1961 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1962 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1963 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1964 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1965 case DT_PLT
: return "PLT";
1966 case DT_PLT_SIZE
: return "PLT_SIZE";
1967 case DT_DLT
: return "DLT";
1968 case DT_DLT_SIZE
: return "DLT_SIZE";
1975 get_ia64_dynamic_type (unsigned long type
)
1979 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1980 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1981 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1982 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1983 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1984 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1985 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1986 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1987 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1988 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1989 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1990 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1991 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1992 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1993 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1994 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1995 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1996 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1997 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1998 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1999 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2000 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2001 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2002 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2003 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2004 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2005 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2006 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2007 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2008 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2009 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2016 get_solaris_section_type (unsigned long type
)
2020 case 0x6fffffee: return "SUNW_ancillary";
2021 case 0x6fffffef: return "SUNW_capchain";
2022 case 0x6ffffff0: return "SUNW_capinfo";
2023 case 0x6ffffff1: return "SUNW_symsort";
2024 case 0x6ffffff2: return "SUNW_tlssort";
2025 case 0x6ffffff3: return "SUNW_LDYNSYM";
2026 case 0x6ffffff4: return "SUNW_dof";
2027 case 0x6ffffff5: return "SUNW_cap";
2028 case 0x6ffffff6: return "SUNW_SIGNATURE";
2029 case 0x6ffffff7: return "SUNW_ANNOTATE";
2030 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2031 case 0x6ffffff9: return "SUNW_DEBUG";
2032 case 0x6ffffffa: return "SUNW_move";
2033 case 0x6ffffffb: return "SUNW_COMDAT";
2034 case 0x6ffffffc: return "SUNW_syminfo";
2035 case 0x6ffffffd: return "SUNW_verdef";
2036 case 0x6ffffffe: return "SUNW_verneed";
2037 case 0x6fffffff: return "SUNW_versym";
2038 case 0x70000000: return "SPARC_GOTDATA";
2039 default: return NULL
;
2044 get_alpha_dynamic_type (unsigned long type
)
2048 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2049 default: return NULL
;
2054 get_score_dynamic_type (unsigned long type
)
2058 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2059 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2060 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2061 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2062 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2063 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2064 default: return NULL
;
2069 get_tic6x_dynamic_type (unsigned long type
)
2073 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2074 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2075 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2076 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2077 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2078 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2079 default: return NULL
;
2084 get_nios2_dynamic_type (unsigned long type
)
2088 case DT_NIOS2_GP
: return "NIOS2_GP";
2089 default: return NULL
;
2094 get_solaris_dynamic_type (unsigned long type
)
2098 case 0x6000000d: return "SUNW_AUXILIARY";
2099 case 0x6000000e: return "SUNW_RTLDINF";
2100 case 0x6000000f: return "SUNW_FILTER";
2101 case 0x60000010: return "SUNW_CAP";
2102 case 0x60000011: return "SUNW_SYMTAB";
2103 case 0x60000012: return "SUNW_SYMSZ";
2104 case 0x60000013: return "SUNW_SORTENT";
2105 case 0x60000014: return "SUNW_SYMSORT";
2106 case 0x60000015: return "SUNW_SYMSORTSZ";
2107 case 0x60000016: return "SUNW_TLSSORT";
2108 case 0x60000017: return "SUNW_TLSSORTSZ";
2109 case 0x60000018: return "SUNW_CAPINFO";
2110 case 0x60000019: return "SUNW_STRPAD";
2111 case 0x6000001a: return "SUNW_CAPCHAIN";
2112 case 0x6000001b: return "SUNW_LDMACH";
2113 case 0x6000001d: return "SUNW_CAPCHAINENT";
2114 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2115 case 0x60000021: return "SUNW_PARENT";
2116 case 0x60000023: return "SUNW_ASLR";
2117 case 0x60000025: return "SUNW_RELAX";
2118 case 0x60000029: return "SUNW_NXHEAP";
2119 case 0x6000002b: return "SUNW_NXSTACK";
2121 case 0x70000001: return "SPARC_REGISTER";
2122 case 0x7ffffffd: return "AUXILIARY";
2123 case 0x7ffffffe: return "USED";
2124 case 0x7fffffff: return "FILTER";
2126 default: return NULL
;
2131 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2133 static char buff
[64];
2137 case DT_NULL
: return "NULL";
2138 case DT_NEEDED
: return "NEEDED";
2139 case DT_PLTRELSZ
: return "PLTRELSZ";
2140 case DT_PLTGOT
: return "PLTGOT";
2141 case DT_HASH
: return "HASH";
2142 case DT_STRTAB
: return "STRTAB";
2143 case DT_SYMTAB
: return "SYMTAB";
2144 case DT_RELA
: return "RELA";
2145 case DT_RELASZ
: return "RELASZ";
2146 case DT_RELAENT
: return "RELAENT";
2147 case DT_STRSZ
: return "STRSZ";
2148 case DT_SYMENT
: return "SYMENT";
2149 case DT_INIT
: return "INIT";
2150 case DT_FINI
: return "FINI";
2151 case DT_SONAME
: return "SONAME";
2152 case DT_RPATH
: return "RPATH";
2153 case DT_SYMBOLIC
: return "SYMBOLIC";
2154 case DT_REL
: return "REL";
2155 case DT_RELSZ
: return "RELSZ";
2156 case DT_RELENT
: return "RELENT";
2157 case DT_PLTREL
: return "PLTREL";
2158 case DT_DEBUG
: return "DEBUG";
2159 case DT_TEXTREL
: return "TEXTREL";
2160 case DT_JMPREL
: return "JMPREL";
2161 case DT_BIND_NOW
: return "BIND_NOW";
2162 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2163 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2164 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2165 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2166 case DT_RUNPATH
: return "RUNPATH";
2167 case DT_FLAGS
: return "FLAGS";
2169 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2170 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2171 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2173 case DT_CHECKSUM
: return "CHECKSUM";
2174 case DT_PLTPADSZ
: return "PLTPADSZ";
2175 case DT_MOVEENT
: return "MOVEENT";
2176 case DT_MOVESZ
: return "MOVESZ";
2177 case DT_FEATURE
: return "FEATURE";
2178 case DT_POSFLAG_1
: return "POSFLAG_1";
2179 case DT_SYMINSZ
: return "SYMINSZ";
2180 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2182 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2183 case DT_CONFIG
: return "CONFIG";
2184 case DT_DEPAUDIT
: return "DEPAUDIT";
2185 case DT_AUDIT
: return "AUDIT";
2186 case DT_PLTPAD
: return "PLTPAD";
2187 case DT_MOVETAB
: return "MOVETAB";
2188 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2190 case DT_VERSYM
: return "VERSYM";
2192 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2193 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2194 case DT_RELACOUNT
: return "RELACOUNT";
2195 case DT_RELCOUNT
: return "RELCOUNT";
2196 case DT_FLAGS_1
: return "FLAGS_1";
2197 case DT_VERDEF
: return "VERDEF";
2198 case DT_VERDEFNUM
: return "VERDEFNUM";
2199 case DT_VERNEED
: return "VERNEED";
2200 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2202 case DT_AUXILIARY
: return "AUXILIARY";
2203 case DT_USED
: return "USED";
2204 case DT_FILTER
: return "FILTER";
2206 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2207 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2208 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2209 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2210 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2211 case DT_GNU_HASH
: return "GNU_HASH";
2214 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2216 const char * result
;
2218 switch (filedata
->file_header
.e_machine
)
2221 result
= get_aarch64_dynamic_type (type
);
2224 case EM_MIPS_RS3_LE
:
2225 result
= get_mips_dynamic_type (type
);
2228 result
= get_sparc64_dynamic_type (type
);
2231 result
= get_ppc_dynamic_type (type
);
2234 result
= get_ppc64_dynamic_type (type
);
2237 result
= get_ia64_dynamic_type (type
);
2240 result
= get_alpha_dynamic_type (type
);
2243 result
= get_score_dynamic_type (type
);
2246 result
= get_tic6x_dynamic_type (type
);
2248 case EM_ALTERA_NIOS2
:
2249 result
= get_nios2_dynamic_type (type
);
2252 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2253 result
= get_solaris_dynamic_type (type
);
2262 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2264 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2265 || (filedata
->file_header
.e_machine
== EM_PARISC
2266 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2268 const char * result
;
2270 switch (filedata
->file_header
.e_machine
)
2273 result
= get_parisc_dynamic_type (type
);
2276 result
= get_ia64_dynamic_type (type
);
2279 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2280 result
= get_solaris_dynamic_type (type
);
2289 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2293 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2300 get_file_type (unsigned e_type
)
2302 static char buff
[64];
2306 case ET_NONE
: return _("NONE (None)");
2307 case ET_REL
: return _("REL (Relocatable file)");
2308 case ET_EXEC
: return _("EXEC (Executable file)");
2309 case ET_DYN
: return _("DYN (Shared object file)");
2310 case ET_CORE
: return _("CORE (Core file)");
2313 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2314 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2315 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2316 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2318 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2324 get_machine_name (unsigned e_machine
)
2326 static char buff
[64]; /* XXX */
2330 /* Please keep this switch table sorted by increasing EM_ value. */
2332 case EM_NONE
: return _("None");
2333 case EM_M32
: return "WE32100";
2334 case EM_SPARC
: return "Sparc";
2335 case EM_386
: return "Intel 80386";
2336 case EM_68K
: return "MC68000";
2337 case EM_88K
: return "MC88000";
2338 case EM_IAMCU
: return "Intel MCU";
2339 case EM_860
: return "Intel 80860";
2340 case EM_MIPS
: return "MIPS R3000";
2341 case EM_S370
: return "IBM System/370";
2343 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2344 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2345 case EM_PARISC
: return "HPPA";
2346 case EM_VPP550
: return "Fujitsu VPP500";
2347 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2348 case EM_960
: return "Intel 80960";
2349 case EM_PPC
: return "PowerPC";
2351 case EM_PPC64
: return "PowerPC64";
2353 case EM_S390
: return "IBM S/390";
2354 case EM_SPU
: return "SPU";
2356 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2357 case EM_FR20
: return "Fujitsu FR20";
2358 case EM_RH32
: return "TRW RH32";
2359 case EM_MCORE
: return "MCORE";
2361 case EM_ARM
: return "ARM";
2362 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2363 case EM_SH
: return "Renesas / SuperH SH";
2364 case EM_SPARCV9
: return "Sparc v9";
2365 case EM_TRICORE
: return "Siemens Tricore";
2366 case EM_ARC
: return "ARC";
2367 case EM_H8_300
: return "Renesas H8/300";
2368 case EM_H8_300H
: return "Renesas H8/300H";
2369 case EM_H8S
: return "Renesas H8S";
2370 case EM_H8_500
: return "Renesas H8/500";
2372 case EM_IA_64
: return "Intel IA-64";
2373 case EM_MIPS_X
: return "Stanford MIPS-X";
2374 case EM_COLDFIRE
: return "Motorola Coldfire";
2375 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2376 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2377 case EM_PCP
: return "Siemens PCP";
2378 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2379 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2380 case EM_STARCORE
: return "Motorola Star*Core processor";
2381 case EM_ME16
: return "Toyota ME16 processor";
2383 case EM_ST100
: return "STMicroelectronics ST100 processor";
2384 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2385 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2386 case EM_PDSP
: return "Sony DSP processor";
2387 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2388 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2389 case EM_FX66
: return "Siemens FX66 microcontroller";
2390 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2391 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2392 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2394 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2395 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2396 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2397 case EM_SVX
: return "Silicon Graphics SVx";
2398 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2399 case EM_VAX
: return "Digital VAX";
2400 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2401 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2402 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2403 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2405 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2406 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2407 case EM_PRISM
: return "Vitesse Prism";
2409 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2410 case EM_CYGNUS_FR30
:
2411 case EM_FR30
: return "Fujitsu FR30";
2412 case EM_CYGNUS_D10V
:
2413 case EM_D10V
: return "d10v";
2414 case EM_CYGNUS_D30V
:
2415 case EM_D30V
: return "d30v";
2416 case EM_CYGNUS_V850
:
2417 case EM_V850
: return "Renesas V850";
2418 case EM_CYGNUS_M32R
:
2419 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2420 case EM_CYGNUS_MN10300
:
2421 case EM_MN10300
: return "mn10300";
2423 case EM_CYGNUS_MN10200
:
2424 case EM_MN10200
: return "mn10200";
2425 case EM_PJ
: return "picoJava";
2426 case EM_OR1K
: return "OpenRISC 1000";
2427 case EM_ARC_COMPACT
: return "ARCompact";
2429 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2430 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2431 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2432 case EM_NS32K
: return "National Semiconductor 32000 series";
2433 case EM_TPC
: return "Tenor Network TPC processor";
2434 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2436 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2438 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2439 case EM_MAX
: return "MAX Processor";
2440 case EM_CR
: return "National Semiconductor CompactRISC";
2441 case EM_F2MC16
: return "Fujitsu F2MC16";
2442 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2443 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2444 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2445 case EM_SEP
: return "Sharp embedded microprocessor";
2446 case EM_ARCA
: return "Arca RISC microprocessor";
2448 case EM_UNICORE
: return "Unicore";
2449 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2450 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2451 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2452 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2453 case EM_XGATE
: return "Motorola XGATE embedded processor";
2455 case EM_XC16X
: return "Infineon Technologies xc16x";
2456 case EM_M16C
: return "Renesas M16C series microprocessors";
2457 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2458 case EM_CE
: return "Freescale Communication Engine RISC core";
2460 case EM_M32C
: return "Renesas M32c";
2462 case EM_TSK3000
: return "Altium TSK3000 core";
2463 case EM_RS08
: return "Freescale RS08 embedded processor";
2464 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2465 case EM_SCORE
: return "SUNPLUS S+Core";
2466 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2467 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2468 case EM_LATTICEMICO32
: return "Lattice Mico32";
2469 case EM_SE_C17
: return "Seiko Epson C17 family";
2471 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2472 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2473 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2474 case EM_TI_PRU
: return "TI PRU I/O processor";
2476 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2477 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2478 case EM_R32C
: return "Renesas R32C series microprocessors";
2479 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2480 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2481 case EM_8051
: return "Intel 8051 and variants";
2482 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2483 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2484 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2485 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2487 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2488 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2489 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2490 case EM_RX
: return "Renesas RX";
2491 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2492 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2493 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2496 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2497 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2498 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2500 case EM_L1OM
: return "Intel L1OM";
2501 case EM_K1OM
: return "Intel K1OM";
2502 case EM_INTEL182
: return "Intel (reserved)";
2503 case EM_AARCH64
: return "AArch64";
2504 case EM_ARM184
: return "ARM (reserved)";
2505 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2506 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2507 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2508 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2510 case EM_CUDA
: return "NVIDIA CUDA architecture";
2511 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2512 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2513 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2514 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2515 case EM_ARC_COMPACT2
: return "ARCv2";
2516 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2517 case EM_RL78
: return "Renesas RL78";
2518 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2519 case EM_78K0R
: return "Renesas 78K0R";
2521 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2522 case EM_BA1
: return "Beyond BA1 CPU architecture";
2523 case EM_BA2
: return "Beyond BA2 CPU architecture";
2524 case EM_XCORE
: return "XMOS xCORE processor family";
2525 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2527 case EM_KM32
: return "KM211 KM32 32-bit processor";
2528 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2529 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2530 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2531 case EM_KVARC
: return "KM211 KVARC processor";
2532 case EM_CDP
: return "Paneve CDP architecture family";
2533 case EM_COGE
: return "Cognitive Smart Memory Processor";
2534 case EM_COOL
: return "Bluechip Systems CoolEngine";
2535 case EM_NORC
: return "Nanoradio Optimized RISC";
2536 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2538 case EM_Z80
: return "Zilog Z80";
2539 case EM_VISIUM
: return "CDS VISIUMcore processor";
2540 case EM_FT32
: return "FTDI Chip FT32";
2541 case EM_MOXIE
: return "Moxie";
2542 case EM_AMDGPU
: return "AMD GPU";
2543 case EM_RISCV
: return "RISC-V";
2544 case EM_LANAI
: return "Lanai 32-bit processor";
2545 case EM_BPF
: return "Linux BPF";
2546 case EM_NFP
: return "Netronome Flow Processor";
2548 /* Large numbers... */
2549 case EM_MT
: return "Morpho Techologies MT processor";
2550 case EM_ALPHA
: return "Alpha";
2551 case EM_WEBASSEMBLY
: return "Web Assembly";
2552 case EM_DLX
: return "OpenDLX";
2553 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2554 case EM_IQ2000
: return "Vitesse IQ2000";
2556 case EM_NIOS32
: return "Altera Nios";
2557 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2558 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2559 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2560 case EM_S12Z
: return "Freescale S12Z";
2561 case EM_CSKY
: return "C-SKY";
2564 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2570 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2572 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2573 other compilers don't a specific architecture type in the e_flags, and
2574 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2575 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2578 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2579 but also sets a specific architecture type in the e_flags field.
2581 However, when decoding the flags we don't worry if we see an
2582 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2583 ARCEM architecture type. */
2585 switch (e_flags
& EF_ARC_MACH_MSK
)
2587 /* We only expect these to occur for EM_ARC_COMPACT2. */
2588 case EF_ARC_CPU_ARCV2EM
:
2589 strcat (buf
, ", ARC EM");
2591 case EF_ARC_CPU_ARCV2HS
:
2592 strcat (buf
, ", ARC HS");
2595 /* We only expect these to occur for EM_ARC_COMPACT. */
2596 case E_ARC_MACH_ARC600
:
2597 strcat (buf
, ", ARC600");
2599 case E_ARC_MACH_ARC601
:
2600 strcat (buf
, ", ARC601");
2602 case E_ARC_MACH_ARC700
:
2603 strcat (buf
, ", ARC700");
2606 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2607 new ELF with new architecture being read by an old version of
2608 readelf, or (c) An ELF built with non-GNU compiler that does not
2609 set the architecture in the e_flags. */
2611 if (e_machine
== EM_ARC_COMPACT
)
2612 strcat (buf
, ", Unknown ARCompact");
2614 strcat (buf
, ", Unknown ARC");
2618 switch (e_flags
& EF_ARC_OSABI_MSK
)
2620 case E_ARC_OSABI_ORIG
:
2621 strcat (buf
, ", (ABI:legacy)");
2623 case E_ARC_OSABI_V2
:
2624 strcat (buf
, ", (ABI:v2)");
2626 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2627 case E_ARC_OSABI_V3
:
2628 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2630 case E_ARC_OSABI_V4
:
2631 strcat (buf
, ", v4 ABI");
2634 strcat (buf
, ", unrecognised ARC OSABI flag");
2640 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2643 bfd_boolean unknown
= FALSE
;
2645 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2646 e_flags
&= ~ EF_ARM_EABIMASK
;
2648 /* Handle "generic" ARM flags. */
2649 if (e_flags
& EF_ARM_RELEXEC
)
2651 strcat (buf
, ", relocatable executable");
2652 e_flags
&= ~ EF_ARM_RELEXEC
;
2655 if (e_flags
& EF_ARM_PIC
)
2657 strcat (buf
, ", position independent");
2658 e_flags
&= ~ EF_ARM_PIC
;
2661 /* Now handle EABI specific flags. */
2665 strcat (buf
, ", <unrecognized EABI>");
2670 case EF_ARM_EABI_VER1
:
2671 strcat (buf
, ", Version1 EABI");
2676 /* Process flags one bit at a time. */
2677 flag
= e_flags
& - e_flags
;
2682 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2683 strcat (buf
, ", sorted symbol tables");
2693 case EF_ARM_EABI_VER2
:
2694 strcat (buf
, ", Version2 EABI");
2699 /* Process flags one bit at a time. */
2700 flag
= e_flags
& - e_flags
;
2705 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2706 strcat (buf
, ", sorted symbol tables");
2709 case EF_ARM_DYNSYMSUSESEGIDX
:
2710 strcat (buf
, ", dynamic symbols use segment index");
2713 case EF_ARM_MAPSYMSFIRST
:
2714 strcat (buf
, ", mapping symbols precede others");
2724 case EF_ARM_EABI_VER3
:
2725 strcat (buf
, ", Version3 EABI");
2728 case EF_ARM_EABI_VER4
:
2729 strcat (buf
, ", Version4 EABI");
2734 /* Process flags one bit at a time. */
2735 flag
= e_flags
& - e_flags
;
2741 strcat (buf
, ", BE8");
2745 strcat (buf
, ", LE8");
2755 case EF_ARM_EABI_VER5
:
2756 strcat (buf
, ", Version5 EABI");
2761 /* Process flags one bit at a time. */
2762 flag
= e_flags
& - e_flags
;
2768 strcat (buf
, ", BE8");
2772 strcat (buf
, ", LE8");
2775 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2776 strcat (buf
, ", soft-float ABI");
2779 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2780 strcat (buf
, ", hard-float ABI");
2790 case EF_ARM_EABI_UNKNOWN
:
2791 strcat (buf
, ", GNU EABI");
2796 /* Process flags one bit at a time. */
2797 flag
= e_flags
& - e_flags
;
2802 case EF_ARM_INTERWORK
:
2803 strcat (buf
, ", interworking enabled");
2806 case EF_ARM_APCS_26
:
2807 strcat (buf
, ", uses APCS/26");
2810 case EF_ARM_APCS_FLOAT
:
2811 strcat (buf
, ", uses APCS/float");
2815 strcat (buf
, ", position independent");
2819 strcat (buf
, ", 8 bit structure alignment");
2822 case EF_ARM_NEW_ABI
:
2823 strcat (buf
, ", uses new ABI");
2826 case EF_ARM_OLD_ABI
:
2827 strcat (buf
, ", uses old ABI");
2830 case EF_ARM_SOFT_FLOAT
:
2831 strcat (buf
, ", software FP");
2834 case EF_ARM_VFP_FLOAT
:
2835 strcat (buf
, ", VFP");
2838 case EF_ARM_MAVERICK_FLOAT
:
2839 strcat (buf
, ", Maverick FP");
2850 strcat (buf
,_(", <unknown>"));
2854 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2856 --size
; /* Leave space for null terminator. */
2858 switch (e_flags
& EF_AVR_MACH
)
2860 case E_AVR_MACH_AVR1
:
2861 strncat (buf
, ", avr:1", size
);
2863 case E_AVR_MACH_AVR2
:
2864 strncat (buf
, ", avr:2", size
);
2866 case E_AVR_MACH_AVR25
:
2867 strncat (buf
, ", avr:25", size
);
2869 case E_AVR_MACH_AVR3
:
2870 strncat (buf
, ", avr:3", size
);
2872 case E_AVR_MACH_AVR31
:
2873 strncat (buf
, ", avr:31", size
);
2875 case E_AVR_MACH_AVR35
:
2876 strncat (buf
, ", avr:35", size
);
2878 case E_AVR_MACH_AVR4
:
2879 strncat (buf
, ", avr:4", size
);
2881 case E_AVR_MACH_AVR5
:
2882 strncat (buf
, ", avr:5", size
);
2884 case E_AVR_MACH_AVR51
:
2885 strncat (buf
, ", avr:51", size
);
2887 case E_AVR_MACH_AVR6
:
2888 strncat (buf
, ", avr:6", size
);
2890 case E_AVR_MACH_AVRTINY
:
2891 strncat (buf
, ", avr:100", size
);
2893 case E_AVR_MACH_XMEGA1
:
2894 strncat (buf
, ", avr:101", size
);
2896 case E_AVR_MACH_XMEGA2
:
2897 strncat (buf
, ", avr:102", size
);
2899 case E_AVR_MACH_XMEGA3
:
2900 strncat (buf
, ", avr:103", size
);
2902 case E_AVR_MACH_XMEGA4
:
2903 strncat (buf
, ", avr:104", size
);
2905 case E_AVR_MACH_XMEGA5
:
2906 strncat (buf
, ", avr:105", size
);
2908 case E_AVR_MACH_XMEGA6
:
2909 strncat (buf
, ", avr:106", size
);
2911 case E_AVR_MACH_XMEGA7
:
2912 strncat (buf
, ", avr:107", size
);
2915 strncat (buf
, ", avr:<unknown>", size
);
2919 size
-= strlen (buf
);
2920 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2921 strncat (buf
, ", link-relax", size
);
2925 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2931 bfd_boolean has_fpu
= FALSE
;
2934 static const char *ABI_STRINGS
[] =
2936 "ABI v0", /* use r5 as return register; only used in N1213HC */
2937 "ABI v1", /* use r0 as return register */
2938 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2939 "ABI v2fp", /* for FPU */
2943 static const char *VER_STRINGS
[] =
2945 "Andes ELF V1.3 or older",
2949 static const char *ARCH_STRINGS
[] =
2958 abi
= EF_NDS_ABI
& e_flags
;
2959 arch
= EF_NDS_ARCH
& e_flags
;
2960 config
= EF_NDS_INST
& e_flags
;
2961 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2963 memset (buf
, 0, size
);
2970 case E_NDS_ABI_V2FP
:
2971 case E_NDS_ABI_AABI
:
2972 case E_NDS_ABI_V2FP_PLUS
:
2973 /* In case there are holes in the array. */
2974 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2978 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2984 case E_NDS32_ELF_VER_1_2
:
2985 case E_NDS32_ELF_VER_1_3
:
2986 case E_NDS32_ELF_VER_1_4
:
2987 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2991 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2995 if (E_NDS_ABI_V0
== abi
)
2997 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2998 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2999 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3000 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3006 case E_NDS_ARCH_STAR_V1_0
:
3007 case E_NDS_ARCH_STAR_V2_0
:
3008 case E_NDS_ARCH_STAR_V3_0
:
3009 case E_NDS_ARCH_STAR_V3_M
:
3010 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3014 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3015 /* ARCH version determines how the e_flags are interpreted.
3016 If it is unknown, we cannot proceed. */
3020 /* Newer ABI; Now handle architecture specific flags. */
3021 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3023 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3024 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3026 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3027 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3029 if (config
& E_NDS32_HAS_DIV_INST
)
3030 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3032 if (config
& E_NDS32_HAS_16BIT_INST
)
3033 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3037 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3039 if (version
<= E_NDS32_ELF_VER_1_3
)
3040 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3042 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3045 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3046 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3048 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3049 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3051 if (config
& E_NDS32_HAS_16BIT_INST
)
3053 if (version
<= E_NDS32_ELF_VER_1_3
)
3054 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3056 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3060 if (config
& E_NDS32_HAS_EXT_INST
)
3061 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3063 if (config
& E_NDS32_HAS_EXT2_INST
)
3064 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3066 if (config
& E_NDS32_HAS_FPU_INST
)
3069 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3072 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3075 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3078 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3081 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3086 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3088 case E_NDS32_FPU_REG_8SP_4DP
:
3089 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3091 case E_NDS32_FPU_REG_16SP_8DP
:
3092 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3094 case E_NDS32_FPU_REG_32SP_16DP
:
3095 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3097 case E_NDS32_FPU_REG_32SP_32DP
:
3098 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3103 if (config
& E_NDS32_HAS_AUDIO_INST
)
3104 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3106 if (config
& E_NDS32_HAS_STRING_INST
)
3107 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3109 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3110 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3112 if (config
& E_NDS32_HAS_VIDEO_INST
)
3114 if (version
<= E_NDS32_ELF_VER_1_3
)
3115 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3117 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3120 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3121 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3123 if (config
& E_NDS32_HAS_L2C_INST
)
3124 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3128 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3130 static char buf
[1024];
3141 case EM_ARC_COMPACT2
:
3142 case EM_ARC_COMPACT
:
3143 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3147 decode_ARM_machine_flags (e_flags
, buf
);
3151 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3155 if (e_flags
& EF_BFIN_PIC
)
3156 strcat (buf
, ", PIC");
3158 if (e_flags
& EF_BFIN_FDPIC
)
3159 strcat (buf
, ", FDPIC");
3161 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3162 strcat (buf
, ", code in L1");
3164 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3165 strcat (buf
, ", data in L1");
3170 switch (e_flags
& EF_FRV_CPU_MASK
)
3172 case EF_FRV_CPU_GENERIC
:
3176 strcat (buf
, ", fr???");
3179 case EF_FRV_CPU_FR300
:
3180 strcat (buf
, ", fr300");
3183 case EF_FRV_CPU_FR400
:
3184 strcat (buf
, ", fr400");
3186 case EF_FRV_CPU_FR405
:
3187 strcat (buf
, ", fr405");
3190 case EF_FRV_CPU_FR450
:
3191 strcat (buf
, ", fr450");
3194 case EF_FRV_CPU_FR500
:
3195 strcat (buf
, ", fr500");
3197 case EF_FRV_CPU_FR550
:
3198 strcat (buf
, ", fr550");
3201 case EF_FRV_CPU_SIMPLE
:
3202 strcat (buf
, ", simple");
3204 case EF_FRV_CPU_TOMCAT
:
3205 strcat (buf
, ", tomcat");
3211 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3212 strcat (buf
, ", m68000");
3213 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3214 strcat (buf
, ", cpu32");
3215 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3216 strcat (buf
, ", fido_a");
3219 char const * isa
= _("unknown");
3220 char const * mac
= _("unknown mac");
3221 char const * additional
= NULL
;
3223 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3225 case EF_M68K_CF_ISA_A_NODIV
:
3227 additional
= ", nodiv";
3229 case EF_M68K_CF_ISA_A
:
3232 case EF_M68K_CF_ISA_A_PLUS
:
3235 case EF_M68K_CF_ISA_B_NOUSP
:
3237 additional
= ", nousp";
3239 case EF_M68K_CF_ISA_B
:
3242 case EF_M68K_CF_ISA_C
:
3245 case EF_M68K_CF_ISA_C_NODIV
:
3247 additional
= ", nodiv";
3250 strcat (buf
, ", cf, isa ");
3253 strcat (buf
, additional
);
3254 if (e_flags
& EF_M68K_CF_FLOAT
)
3255 strcat (buf
, ", float");
3256 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3261 case EF_M68K_CF_MAC
:
3264 case EF_M68K_CF_EMAC
:
3267 case EF_M68K_CF_EMAC_B
:
3280 switch (e_flags
& EF_MEP_CPU_MASK
)
3282 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3283 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3284 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3285 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3286 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3287 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3288 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3291 switch (e_flags
& EF_MEP_COP_MASK
)
3293 case EF_MEP_COP_NONE
: break;
3294 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3295 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3296 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3297 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3298 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3301 if (e_flags
& EF_MEP_LIBRARY
)
3302 strcat (buf
, ", Built for Library");
3304 if (e_flags
& EF_MEP_INDEX_MASK
)
3305 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3306 e_flags
& EF_MEP_INDEX_MASK
);
3308 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3309 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3310 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3314 if (e_flags
& EF_PPC_EMB
)
3315 strcat (buf
, ", emb");
3317 if (e_flags
& EF_PPC_RELOCATABLE
)
3318 strcat (buf
, _(", relocatable"));
3320 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3321 strcat (buf
, _(", relocatable-lib"));
3325 if (e_flags
& EF_PPC64_ABI
)
3327 char abi
[] = ", abiv0";
3329 abi
[6] += e_flags
& EF_PPC64_ABI
;
3335 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3336 strcat (buf
, ", RH850 ABI");
3338 if (e_flags
& EF_V800_850E3
)
3339 strcat (buf
, ", V3 architecture");
3341 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3342 strcat (buf
, ", FPU not used");
3344 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3345 strcat (buf
, ", regmode: COMMON");
3347 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3348 strcat (buf
, ", r4 not used");
3350 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3351 strcat (buf
, ", r30 not used");
3353 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3354 strcat (buf
, ", r5 not used");
3356 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3357 strcat (buf
, ", r2 not used");
3359 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3361 switch (e_flags
& - e_flags
)
3363 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3364 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3365 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3366 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3367 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3368 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3369 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3370 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3371 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3372 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3373 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3374 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3381 case EM_CYGNUS_V850
:
3382 switch (e_flags
& EF_V850_ARCH
)
3384 case E_V850E3V5_ARCH
:
3385 strcat (buf
, ", v850e3v5");
3387 case E_V850E2V3_ARCH
:
3388 strcat (buf
, ", v850e2v3");
3391 strcat (buf
, ", v850e2");
3394 strcat (buf
, ", v850e1");
3397 strcat (buf
, ", v850e");
3400 strcat (buf
, ", v850");
3403 strcat (buf
, _(", unknown v850 architecture variant"));
3409 case EM_CYGNUS_M32R
:
3410 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3411 strcat (buf
, ", m32r");
3415 case EM_MIPS_RS3_LE
:
3416 if (e_flags
& EF_MIPS_NOREORDER
)
3417 strcat (buf
, ", noreorder");
3419 if (e_flags
& EF_MIPS_PIC
)
3420 strcat (buf
, ", pic");
3422 if (e_flags
& EF_MIPS_CPIC
)
3423 strcat (buf
, ", cpic");
3425 if (e_flags
& EF_MIPS_UCODE
)
3426 strcat (buf
, ", ugen_reserved");
3428 if (e_flags
& EF_MIPS_ABI2
)
3429 strcat (buf
, ", abi2");
3431 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3432 strcat (buf
, ", odk first");
3434 if (e_flags
& EF_MIPS_32BITMODE
)
3435 strcat (buf
, ", 32bitmode");
3437 if (e_flags
& EF_MIPS_NAN2008
)
3438 strcat (buf
, ", nan2008");
3440 if (e_flags
& EF_MIPS_FP64
)
3441 strcat (buf
, ", fp64");
3443 switch ((e_flags
& EF_MIPS_MACH
))
3445 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3446 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3447 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3448 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3449 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3450 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3451 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3452 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3453 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3454 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3455 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3456 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3457 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3458 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3459 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3460 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3461 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3462 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3463 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3464 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3465 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3467 /* We simply ignore the field in this case to avoid confusion:
3468 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3471 default: strcat (buf
, _(", unknown CPU")); break;
3474 switch ((e_flags
& EF_MIPS_ABI
))
3476 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3477 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3478 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3479 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3481 /* We simply ignore the field in this case to avoid confusion:
3482 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3483 This means it is likely to be an o32 file, but not for
3486 default: strcat (buf
, _(", unknown ABI")); break;
3489 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3490 strcat (buf
, ", mdmx");
3492 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3493 strcat (buf
, ", mips16");
3495 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3496 strcat (buf
, ", micromips");
3498 switch ((e_flags
& EF_MIPS_ARCH
))
3500 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3501 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3502 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3503 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3504 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3505 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3506 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3507 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3508 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3509 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3510 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3511 default: strcat (buf
, _(", unknown ISA")); break;
3516 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3520 switch (EF_NFP_MACH (e_flags
))
3522 case E_NFP_MACH_3200
:
3523 strcat (buf
, ", NFP-32xx");
3525 case E_NFP_MACH_6000
:
3526 strcat (buf
, ", NFP-6xxx");
3532 if (e_flags
& EF_RISCV_RVC
)
3533 strcat (buf
, ", RVC");
3535 if (e_flags
& EF_RISCV_RVE
)
3536 strcat (buf
, ", RVE");
3538 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3540 case EF_RISCV_FLOAT_ABI_SOFT
:
3541 strcat (buf
, ", soft-float ABI");
3544 case EF_RISCV_FLOAT_ABI_SINGLE
:
3545 strcat (buf
, ", single-float ABI");
3548 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3549 strcat (buf
, ", double-float ABI");
3552 case EF_RISCV_FLOAT_ABI_QUAD
:
3553 strcat (buf
, ", quad-float ABI");
3559 switch ((e_flags
& EF_SH_MACH_MASK
))
3561 case EF_SH1
: strcat (buf
, ", sh1"); break;
3562 case EF_SH2
: strcat (buf
, ", sh2"); break;
3563 case EF_SH3
: strcat (buf
, ", sh3"); break;
3564 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3565 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3566 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3567 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3568 case EF_SH4
: strcat (buf
, ", sh4"); break;
3569 case EF_SH5
: strcat (buf
, ", sh5"); break;
3570 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3571 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3572 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3573 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3574 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3575 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3576 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3577 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3578 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3579 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3580 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3581 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3582 default: strcat (buf
, _(", unknown ISA")); break;
3585 if (e_flags
& EF_SH_PIC
)
3586 strcat (buf
, ", pic");
3588 if (e_flags
& EF_SH_FDPIC
)
3589 strcat (buf
, ", fdpic");
3593 if (e_flags
& EF_OR1K_NODELAY
)
3594 strcat (buf
, ", no delay");
3598 if (e_flags
& EF_SPARC_32PLUS
)
3599 strcat (buf
, ", v8+");
3601 if (e_flags
& EF_SPARC_SUN_US1
)
3602 strcat (buf
, ", ultrasparcI");
3604 if (e_flags
& EF_SPARC_SUN_US3
)
3605 strcat (buf
, ", ultrasparcIII");
3607 if (e_flags
& EF_SPARC_HAL_R1
)
3608 strcat (buf
, ", halr1");
3610 if (e_flags
& EF_SPARC_LEDATA
)
3611 strcat (buf
, ", ledata");
3613 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3614 strcat (buf
, ", tso");
3616 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3617 strcat (buf
, ", pso");
3619 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3620 strcat (buf
, ", rmo");
3624 switch (e_flags
& EF_PARISC_ARCH
)
3626 case EFA_PARISC_1_0
:
3627 strcpy (buf
, ", PA-RISC 1.0");
3629 case EFA_PARISC_1_1
:
3630 strcpy (buf
, ", PA-RISC 1.1");
3632 case EFA_PARISC_2_0
:
3633 strcpy (buf
, ", PA-RISC 2.0");
3638 if (e_flags
& EF_PARISC_TRAPNIL
)
3639 strcat (buf
, ", trapnil");
3640 if (e_flags
& EF_PARISC_EXT
)
3641 strcat (buf
, ", ext");
3642 if (e_flags
& EF_PARISC_LSB
)
3643 strcat (buf
, ", lsb");
3644 if (e_flags
& EF_PARISC_WIDE
)
3645 strcat (buf
, ", wide");
3646 if (e_flags
& EF_PARISC_NO_KABP
)
3647 strcat (buf
, ", no kabp");
3648 if (e_flags
& EF_PARISC_LAZYSWAP
)
3649 strcat (buf
, ", lazyswap");
3654 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3655 strcat (buf
, ", new calling convention");
3657 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3658 strcat (buf
, ", gnu calling convention");
3662 if ((e_flags
& EF_IA_64_ABI64
))
3663 strcat (buf
, ", 64-bit");
3665 strcat (buf
, ", 32-bit");
3666 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3667 strcat (buf
, ", reduced fp model");
3668 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3669 strcat (buf
, ", no function descriptors, constant gp");
3670 else if ((e_flags
& EF_IA_64_CONS_GP
))
3671 strcat (buf
, ", constant gp");
3672 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3673 strcat (buf
, ", absolute");
3674 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3676 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3677 strcat (buf
, ", vms_linkages");
3678 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3680 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3682 case EF_IA_64_VMS_COMCOD_WARNING
:
3683 strcat (buf
, ", warning");
3685 case EF_IA_64_VMS_COMCOD_ERROR
:
3686 strcat (buf
, ", error");
3688 case EF_IA_64_VMS_COMCOD_ABORT
:
3689 strcat (buf
, ", abort");
3692 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3693 e_flags
& EF_IA_64_VMS_COMCOD
);
3694 strcat (buf
, ", <unknown>");
3700 if ((e_flags
& EF_VAX_NONPIC
))
3701 strcat (buf
, ", non-PIC");
3702 if ((e_flags
& EF_VAX_DFLOAT
))
3703 strcat (buf
, ", D-Float");
3704 if ((e_flags
& EF_VAX_GFLOAT
))
3705 strcat (buf
, ", G-Float");
3709 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3710 strcat (buf
, ", mcm");
3711 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3712 strcat (buf
, ", mcm24");
3713 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3714 strcat (buf
, ", gr6");
3718 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3720 case E_FLAG_RL78_ANY_CPU
: break;
3721 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3722 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3723 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3725 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3726 strcat (buf
, ", 64-bit doubles");
3730 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3731 strcat (buf
, ", 64-bit doubles");
3732 if (e_flags
& E_FLAG_RX_DSP
)
3733 strcat (buf
, ", dsp");
3734 if (e_flags
& E_FLAG_RX_PID
)
3735 strcat (buf
, ", pid");
3736 if (e_flags
& E_FLAG_RX_ABI
)
3737 strcat (buf
, ", RX ABI");
3738 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3739 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3740 ? ", uses String instructions" : ", bans String instructions");
3741 if (e_flags
& E_FLAG_RX_V2
)
3742 strcat (buf
, ", V2");
3743 if (e_flags
& E_FLAG_RX_V3
)
3744 strcat (buf
, ", V3");
3748 if (e_flags
& EF_S390_HIGH_GPRS
)
3749 strcat (buf
, ", highgprs");
3753 if ((e_flags
& EF_C6000_REL
))
3754 strcat (buf
, ", relocatable module");
3758 strcat (buf
, _(": architecture variant: "));
3759 switch (e_flags
& EF_MSP430_MACH
)
3761 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3762 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3763 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3764 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3765 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3766 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3767 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3768 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3769 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3770 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3771 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3772 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3773 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3774 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3775 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3777 strcat (buf
, _(": unknown")); break;
3780 if (e_flags
& ~ EF_MSP430_MACH
)
3781 strcat (buf
, _(": unknown extra flag bits also present"));
3785 switch (e_flags
& EF_Z80_MACH_MSK
)
3787 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3788 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3789 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3790 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3791 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3792 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3793 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3795 strcat (buf
, _(", unknown")); break;
3805 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3807 static char buff
[32];
3811 case ELFOSABI_NONE
: return "UNIX - System V";
3812 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3813 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3814 case ELFOSABI_GNU
: return "UNIX - GNU";
3815 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3816 case ELFOSABI_AIX
: return "UNIX - AIX";
3817 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3818 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3819 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3820 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3821 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3822 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3823 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3824 case ELFOSABI_AROS
: return "AROS";
3825 case ELFOSABI_FENIXOS
: return "FenixOS";
3826 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3827 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3830 switch (filedata
->file_header
.e_machine
)
3835 case ELFOSABI_ARM
: return "ARM";
3836 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3847 case ELFOSABI_STANDALONE
: return _("Standalone App");
3856 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3857 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3866 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3872 get_aarch64_segment_type (unsigned long type
)
3876 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3877 default: return NULL
;
3882 get_arm_segment_type (unsigned long type
)
3886 case PT_ARM_EXIDX
: return "EXIDX";
3887 default: return NULL
;
3892 get_s390_segment_type (unsigned long type
)
3896 case PT_S390_PGSTE
: return "S390_PGSTE";
3897 default: return NULL
;
3902 get_mips_segment_type (unsigned long type
)
3906 case PT_MIPS_REGINFO
: return "REGINFO";
3907 case PT_MIPS_RTPROC
: return "RTPROC";
3908 case PT_MIPS_OPTIONS
: return "OPTIONS";
3909 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3910 default: return NULL
;
3915 get_parisc_segment_type (unsigned long type
)
3919 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3920 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3921 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3922 default: return NULL
;
3927 get_ia64_segment_type (unsigned long type
)
3931 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3932 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3933 default: return NULL
;
3938 get_tic6x_segment_type (unsigned long type
)
3942 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3943 default: return NULL
;
3948 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3950 if (e_machine
== EM_PARISC
)
3953 case PT_HP_TLS
: return "HP_TLS";
3954 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3955 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3956 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3957 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3958 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3959 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3960 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3961 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3962 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3963 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3964 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3965 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3966 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3967 case PT_HP_STACK
: return "HP_STACK";
3968 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3969 default: return NULL
;
3972 if (e_machine
== EM_IA_64
)
3975 case PT_HP_TLS
: return "HP_TLS";
3976 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3977 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3978 case PT_IA_64_HP_STACK
: return "HP_STACK";
3979 default: return NULL
;
3986 get_solaris_segment_type (unsigned long type
)
3990 case 0x6464e550: return "PT_SUNW_UNWIND";
3991 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3992 case 0x6ffffff7: return "PT_LOSUNW";
3993 case 0x6ffffffa: return "PT_SUNWBSS";
3994 case 0x6ffffffb: return "PT_SUNWSTACK";
3995 case 0x6ffffffc: return "PT_SUNWDTRACE";
3996 case 0x6ffffffd: return "PT_SUNWCAP";
3997 case 0x6fffffff: return "PT_HISUNW";
3998 default: return NULL
;
4003 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4005 static char buff
[32];
4009 case PT_NULL
: return "NULL";
4010 case PT_LOAD
: return "LOAD";
4011 case PT_DYNAMIC
: return "DYNAMIC";
4012 case PT_INTERP
: return "INTERP";
4013 case PT_NOTE
: return "NOTE";
4014 case PT_SHLIB
: return "SHLIB";
4015 case PT_PHDR
: return "PHDR";
4016 case PT_TLS
: return "TLS";
4017 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4018 case PT_GNU_STACK
: return "GNU_STACK";
4019 case PT_GNU_RELRO
: return "GNU_RELRO";
4020 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4023 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4025 const char * result
;
4027 switch (filedata
->file_header
.e_machine
)
4030 result
= get_aarch64_segment_type (p_type
);
4033 result
= get_arm_segment_type (p_type
);
4036 case EM_MIPS_RS3_LE
:
4037 result
= get_mips_segment_type (p_type
);
4040 result
= get_parisc_segment_type (p_type
);
4043 result
= get_ia64_segment_type (p_type
);
4046 result
= get_tic6x_segment_type (p_type
);
4050 result
= get_s390_segment_type (p_type
);
4060 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4062 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4064 const char * result
= NULL
;
4066 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4069 case ELFOSABI_FREEBSD
:
4070 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4072 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4077 result
= get_hpux_segment_type (p_type
,
4078 filedata
->file_header
.e_machine
);
4080 case ELFOSABI_SOLARIS
:
4081 result
= get_solaris_segment_type (p_type
);
4089 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4092 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4099 get_arc_section_type_name (unsigned int sh_type
)
4103 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4111 get_mips_section_type_name (unsigned int sh_type
)
4115 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4116 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4117 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4118 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4119 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4120 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4121 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4122 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4123 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4124 case SHT_MIPS_RELD
: return "MIPS_RELD";
4125 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4126 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4127 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4128 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4129 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4130 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4131 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4132 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4133 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4134 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4135 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4136 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4137 case SHT_MIPS_LINE
: return "MIPS_LINE";
4138 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4139 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4140 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4141 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4142 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4143 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4144 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4145 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4146 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4147 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4148 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4149 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4150 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4151 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4152 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4153 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4154 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4155 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4163 get_parisc_section_type_name (unsigned int sh_type
)
4167 case SHT_PARISC_EXT
: return "PARISC_EXT";
4168 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4169 case SHT_PARISC_DOC
: return "PARISC_DOC";
4170 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4171 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4172 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4173 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4174 default: return NULL
;
4179 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4181 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4182 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4183 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4187 case SHT_IA_64_EXT
: return "IA_64_EXT";
4188 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4189 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4190 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4191 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4192 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4193 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4194 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4195 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4196 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4204 get_x86_64_section_type_name (unsigned int sh_type
)
4208 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4209 default: return NULL
;
4214 get_aarch64_section_type_name (unsigned int sh_type
)
4218 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4219 default: return NULL
;
4224 get_arm_section_type_name (unsigned int sh_type
)
4228 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4229 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4230 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4231 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4232 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4233 default: return NULL
;
4238 get_tic6x_section_type_name (unsigned int sh_type
)
4242 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4243 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4244 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4245 case SHT_TI_ICODE
: return "TI_ICODE";
4246 case SHT_TI_XREF
: return "TI_XREF";
4247 case SHT_TI_HANDLER
: return "TI_HANDLER";
4248 case SHT_TI_INITINFO
: return "TI_INITINFO";
4249 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4250 default: return NULL
;
4255 get_msp430x_section_type_name (unsigned int sh_type
)
4259 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4260 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4261 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4262 default: return NULL
;
4267 get_nfp_section_type_name (unsigned int sh_type
)
4271 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4272 case SHT_NFP_INITREG
: return "NFP_INITREG";
4273 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4274 default: return NULL
;
4279 get_v850_section_type_name (unsigned int sh_type
)
4283 case SHT_V850_SCOMMON
: return "V850 Small Common";
4284 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4285 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4286 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4287 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4288 default: return NULL
;
4293 get_riscv_section_type_name (unsigned int sh_type
)
4297 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4298 default: return NULL
;
4303 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4305 static char buff
[32];
4306 const char * result
;
4310 case SHT_NULL
: return "NULL";
4311 case SHT_PROGBITS
: return "PROGBITS";
4312 case SHT_SYMTAB
: return "SYMTAB";
4313 case SHT_STRTAB
: return "STRTAB";
4314 case SHT_RELA
: return "RELA";
4315 case SHT_HASH
: return "HASH";
4316 case SHT_DYNAMIC
: return "DYNAMIC";
4317 case SHT_NOTE
: return "NOTE";
4318 case SHT_NOBITS
: return "NOBITS";
4319 case SHT_REL
: return "REL";
4320 case SHT_SHLIB
: return "SHLIB";
4321 case SHT_DYNSYM
: return "DYNSYM";
4322 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4323 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4324 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4325 case SHT_GNU_HASH
: return "GNU_HASH";
4326 case SHT_GROUP
: return "GROUP";
4327 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4328 case SHT_GNU_verdef
: return "VERDEF";
4329 case SHT_GNU_verneed
: return "VERNEED";
4330 case SHT_GNU_versym
: return "VERSYM";
4331 case 0x6ffffff0: return "VERSYM";
4332 case 0x6ffffffc: return "VERDEF";
4333 case 0x7ffffffd: return "AUXILIARY";
4334 case 0x7fffffff: return "FILTER";
4335 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4338 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4340 switch (filedata
->file_header
.e_machine
)
4343 case EM_ARC_COMPACT
:
4344 case EM_ARC_COMPACT2
:
4345 result
= get_arc_section_type_name (sh_type
);
4348 case EM_MIPS_RS3_LE
:
4349 result
= get_mips_section_type_name (sh_type
);
4352 result
= get_parisc_section_type_name (sh_type
);
4355 result
= get_ia64_section_type_name (filedata
, sh_type
);
4360 result
= get_x86_64_section_type_name (sh_type
);
4363 result
= get_aarch64_section_type_name (sh_type
);
4366 result
= get_arm_section_type_name (sh_type
);
4369 result
= get_tic6x_section_type_name (sh_type
);
4372 result
= get_msp430x_section_type_name (sh_type
);
4375 result
= get_nfp_section_type_name (sh_type
);
4379 case EM_CYGNUS_V850
:
4380 result
= get_v850_section_type_name (sh_type
);
4383 result
= get_riscv_section_type_name (sh_type
);
4393 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4395 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4397 switch (filedata
->file_header
.e_machine
)
4400 result
= get_ia64_section_type_name (filedata
, sh_type
);
4403 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4404 result
= get_solaris_section_type (sh_type
);
4409 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4410 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4411 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4412 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4424 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4426 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4428 switch (filedata
->file_header
.e_machine
)
4432 case EM_CYGNUS_V850
:
4433 result
= get_v850_section_type_name (sh_type
);
4443 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4446 /* This message is probably going to be displayed in a 15
4447 character wide field, so put the hex value first. */
4448 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4454 #define OPTION_DEBUG_DUMP 512
4455 #define OPTION_DYN_SYMS 513
4456 #define OPTION_DWARF_DEPTH 514
4457 #define OPTION_DWARF_START 515
4458 #define OPTION_DWARF_CHECK 516
4459 #define OPTION_CTF_DUMP 517
4460 #define OPTION_CTF_PARENT 518
4461 #define OPTION_CTF_SYMBOLS 519
4462 #define OPTION_CTF_STRINGS 520
4464 static struct option options
[] =
4466 {"all", no_argument
, 0, 'a'},
4467 {"file-header", no_argument
, 0, 'h'},
4468 {"program-headers", no_argument
, 0, 'l'},
4469 {"headers", no_argument
, 0, 'e'},
4470 {"histogram", no_argument
, 0, 'I'},
4471 {"segments", no_argument
, 0, 'l'},
4472 {"sections", no_argument
, 0, 'S'},
4473 {"section-headers", no_argument
, 0, 'S'},
4474 {"section-groups", no_argument
, 0, 'g'},
4475 {"section-details", no_argument
, 0, 't'},
4476 {"full-section-name",no_argument
, 0, 'N'},
4477 {"symbols", no_argument
, 0, 's'},
4478 {"syms", no_argument
, 0, 's'},
4479 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4480 {"relocs", no_argument
, 0, 'r'},
4481 {"notes", no_argument
, 0, 'n'},
4482 {"dynamic", no_argument
, 0, 'd'},
4483 {"lint", no_argument
, 0, 'L'},
4484 {"enable-checks", no_argument
, 0, 'L'},
4485 {"arch-specific", no_argument
, 0, 'A'},
4486 {"version-info", no_argument
, 0, 'V'},
4487 {"use-dynamic", no_argument
, 0, 'D'},
4488 {"unwind", no_argument
, 0, 'u'},
4489 {"archive-index", no_argument
, 0, 'c'},
4490 {"hex-dump", required_argument
, 0, 'x'},
4491 {"relocated-dump", required_argument
, 0, 'R'},
4492 {"string-dump", required_argument
, 0, 'p'},
4493 {"decompress", no_argument
, 0, 'z'},
4494 #ifdef SUPPORT_DISASSEMBLY
4495 {"instruction-dump", required_argument
, 0, 'i'},
4497 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4499 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4500 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4501 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4503 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4505 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4506 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4507 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4509 {"version", no_argument
, 0, 'v'},
4510 {"wide", no_argument
, 0, 'W'},
4511 {"help", no_argument
, 0, 'H'},
4512 {0, no_argument
, 0, 0}
4516 usage (FILE * stream
)
4518 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4519 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4520 fprintf (stream
, _(" Options are:\n\
4521 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4522 -h --file-header Display the ELF file header\n\
4523 -l --program-headers Display the program headers\n\
4524 --segments An alias for --program-headers\n\
4525 -S --section-headers Display the sections' header\n\
4526 --sections An alias for --section-headers\n\
4527 -g --section-groups Display the section groups\n\
4528 -t --section-details Display the section details\n\
4529 -e --headers Equivalent to: -h -l -S\n\
4530 -s --syms Display the symbol table\n\
4531 --symbols An alias for --syms\n\
4532 --dyn-syms Display the dynamic symbol table\n\
4533 -n --notes Display the core notes (if present)\n\
4534 -r --relocs Display the relocations (if present)\n\
4535 -u --unwind Display the unwind info (if present)\n\
4536 -d --dynamic Display the dynamic section (if present)\n\
4537 -V --version-info Display the version sections (if present)\n\
4538 -A --arch-specific Display architecture specific information (if any)\n\
4539 -c --archive-index Display the symbol/file index in an archive\n\
4540 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4541 -L --lint|--enable-checks Display warning messages for possible problems\n\
4542 -x --hex-dump=<number|name>\n\
4543 Dump the contents of section <number|name> as bytes\n\
4544 -p --string-dump=<number|name>\n\
4545 Dump the contents of section <number|name> as strings\n\
4546 -R --relocated-dump=<number|name>\n\
4547 Dump the contents of section <number|name> as relocated bytes\n\
4548 -z --decompress Decompress section before dumping it\n\
4549 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4550 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4551 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4552 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4553 =addr,=cu_index,=links,=follow-links]\n\
4554 Display the contents of DWARF debug sections\n"));
4555 fprintf (stream
, _("\
4556 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4557 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4559 fprintf (stream
, _("\
4560 --ctf=<number|name> Display CTF info from section <number|name>\n\
4561 --ctf-parent=<number|name>\n\
4562 Use section <number|name> as the CTF parent\n\n\
4563 --ctf-symbols=<number|name>\n\
4564 Use section <number|name> as the CTF external symtab\n\n\
4565 --ctf-strings=<number|name>\n\
4566 Use section <number|name> as the CTF external strtab\n\n"));
4568 #ifdef SUPPORT_DISASSEMBLY
4569 fprintf (stream
, _("\
4570 -i --instruction-dump=<number|name>\n\
4571 Disassemble the contents of section <number|name>\n"));
4573 fprintf (stream
, _("\
4574 -I --histogram Display histogram of bucket list lengths\n\
4575 -W --wide Allow output width to exceed 80 characters\n\
4576 @<file> Read options from <file>\n\
4577 -H --help Display this information\n\
4578 -v --version Display the version number of readelf\n"));
4580 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4581 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4583 exit (stream
== stdout
? 0 : 1);
4586 /* Record the fact that the user wants the contents of section number
4587 SECTION to be displayed using the method(s) encoded as flags bits
4588 in TYPE. Note, TYPE can be zero if we are creating the array for
4592 request_dump_bynumber (struct dump_data
*dumpdata
,
4593 unsigned int section
, dump_type type
)
4595 if (section
>= dumpdata
->num_dump_sects
)
4597 dump_type
* new_dump_sects
;
4599 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4600 sizeof (* new_dump_sects
));
4602 if (new_dump_sects
== NULL
)
4603 error (_("Out of memory allocating dump request table.\n"));
4606 if (dumpdata
->dump_sects
)
4608 /* Copy current flag settings. */
4609 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4610 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4612 free (dumpdata
->dump_sects
);
4615 dumpdata
->dump_sects
= new_dump_sects
;
4616 dumpdata
->num_dump_sects
= section
+ 1;
4620 if (dumpdata
->dump_sects
)
4621 dumpdata
->dump_sects
[section
] |= type
;
4624 /* Request a dump by section name. */
4627 request_dump_byname (const char * section
, dump_type type
)
4629 struct dump_list_entry
* new_request
;
4631 new_request
= (struct dump_list_entry
*)
4632 malloc (sizeof (struct dump_list_entry
));
4634 error (_("Out of memory allocating dump request table.\n"));
4636 new_request
->name
= strdup (section
);
4637 if (!new_request
->name
)
4638 error (_("Out of memory allocating dump request table.\n"));
4640 new_request
->type
= type
;
4642 new_request
->next
= dump_sects_byname
;
4643 dump_sects_byname
= new_request
;
4647 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4653 section
= strtoul (optarg
, & cp
, 0);
4655 if (! *cp
&& section
>= 0)
4656 request_dump_bynumber (dumpdata
, section
, type
);
4658 request_dump_byname (optarg
, type
);
4662 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4669 while ((c
= getopt_long
4670 (argc
, argv
, "ADHILNR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4688 do_section_groups
= TRUE
;
4691 do_histogram
= TRUE
;
4696 do_section_groups
= TRUE
;
4701 do_section_details
= TRUE
;
4712 do_using_dynamic
= TRUE
;
4736 do_histogram
= TRUE
;
4742 do_archive_index
= TRUE
;
4748 request_dump (dumpdata
, HEX_DUMP
);
4751 request_dump (dumpdata
, STRING_DUMP
);
4754 request_dump (dumpdata
, RELOC_DUMP
);
4757 decompress_dumps
= TRUE
;
4763 do_debugging
= TRUE
;
4764 dwarf_select_sections_all ();
4768 do_debugging
= FALSE
;
4769 dwarf_select_sections_by_letters (optarg
);
4772 case OPTION_DEBUG_DUMP
:
4775 do_debugging
= TRUE
;
4778 do_debugging
= FALSE
;
4779 dwarf_select_sections_by_names (optarg
);
4782 case OPTION_DWARF_DEPTH
:
4786 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4789 case OPTION_DWARF_START
:
4793 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4796 case OPTION_DWARF_CHECK
:
4799 case OPTION_CTF_DUMP
:
4801 request_dump (dumpdata
, CTF_DUMP
);
4803 case OPTION_CTF_SYMBOLS
:
4804 dump_ctf_symtab_name
= strdup (optarg
);
4806 case OPTION_CTF_STRINGS
:
4807 dump_ctf_strtab_name
= strdup (optarg
);
4809 case OPTION_CTF_PARENT
:
4810 dump_ctf_parent_name
= strdup (optarg
);
4812 case OPTION_DYN_SYMS
:
4815 #ifdef SUPPORT_DISASSEMBLY
4817 request_dump (dumpdata
, DISASS_DUMP
);
4821 print_version (program_name
);
4830 /* xgettext:c-format */
4831 error (_("Invalid option '-%c'\n"), c
);
4838 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4839 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4840 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4841 && !do_section_groups
&& !do_archive_index
4847 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= TRUE
;
4848 do_segments
= do_header
= do_dump
= do_version
= TRUE
;
4849 do_histogram
= do_debugging
= do_arch
= do_notes
= TRUE
;
4850 do_section_groups
= do_archive_index
= do_dyn_syms
= TRUE
;
4858 get_elf_class (unsigned int elf_class
)
4860 static char buff
[32];
4864 case ELFCLASSNONE
: return _("none");
4865 case ELFCLASS32
: return "ELF32";
4866 case ELFCLASS64
: return "ELF64";
4868 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4874 get_data_encoding (unsigned int encoding
)
4876 static char buff
[32];
4880 case ELFDATANONE
: return _("none");
4881 case ELFDATA2LSB
: return _("2's complement, little endian");
4882 case ELFDATA2MSB
: return _("2's complement, big endian");
4884 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4889 /* Decode the data held in 'filedata->file_header'. */
4892 process_file_header (Filedata
* filedata
)
4894 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4896 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4897 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4898 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4899 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4902 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4906 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4912 printf (_("ELF Header:\n"));
4913 printf (_(" Magic: "));
4914 for (i
= 0; i
< EI_NIDENT
; i
++)
4915 printf ("%2.2x ", header
->e_ident
[i
]);
4917 printf (_(" Class: %s\n"),
4918 get_elf_class (header
->e_ident
[EI_CLASS
]));
4919 printf (_(" Data: %s\n"),
4920 get_data_encoding (header
->e_ident
[EI_DATA
]));
4921 printf (_(" Version: %d%s\n"),
4922 header
->e_ident
[EI_VERSION
],
4923 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4925 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4928 printf (_(" OS/ABI: %s\n"),
4929 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4930 printf (_(" ABI Version: %d\n"),
4931 header
->e_ident
[EI_ABIVERSION
]);
4932 printf (_(" Type: %s\n"),
4933 get_file_type (header
->e_type
));
4934 printf (_(" Machine: %s\n"),
4935 get_machine_name (header
->e_machine
));
4936 printf (_(" Version: 0x%lx\n"),
4939 printf (_(" Entry point address: "));
4940 print_vma (header
->e_entry
, PREFIX_HEX
);
4941 printf (_("\n Start of program headers: "));
4942 print_vma (header
->e_phoff
, DEC
);
4943 printf (_(" (bytes into file)\n Start of section headers: "));
4944 print_vma (header
->e_shoff
, DEC
);
4945 printf (_(" (bytes into file)\n"));
4947 printf (_(" Flags: 0x%lx%s\n"),
4949 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4950 printf (_(" Size of this header: %u (bytes)\n"),
4952 printf (_(" Size of program headers: %u (bytes)\n"),
4953 header
->e_phentsize
);
4954 printf (_(" Number of program headers: %u"),
4956 if (filedata
->section_headers
!= NULL
4957 && header
->e_phnum
== PN_XNUM
4958 && filedata
->section_headers
[0].sh_info
!= 0)
4960 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4961 printf (" (%u)", header
->e_phnum
);
4963 putc ('\n', stdout
);
4964 printf (_(" Size of section headers: %u (bytes)\n"),
4965 header
->e_shentsize
);
4966 printf (_(" Number of section headers: %u"),
4968 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4970 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4971 printf (" (%u)", header
->e_shnum
);
4973 putc ('\n', stdout
);
4974 printf (_(" Section header string table index: %u"),
4975 header
->e_shstrndx
);
4976 if (filedata
->section_headers
!= NULL
4977 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4979 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4980 printf (" (%u)", header
->e_shstrndx
);
4982 if (header
->e_shstrndx
!= SHN_UNDEF
4983 && header
->e_shstrndx
>= header
->e_shnum
)
4985 header
->e_shstrndx
= SHN_UNDEF
;
4986 printf (_(" <corrupt: out of range>"));
4988 putc ('\n', stdout
);
4991 if (filedata
->section_headers
!= NULL
)
4993 if (header
->e_phnum
== PN_XNUM
4994 && filedata
->section_headers
[0].sh_info
!= 0)
4995 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4996 if (header
->e_shnum
== SHN_UNDEF
)
4997 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4998 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4999 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5000 if (header
->e_shstrndx
>= header
->e_shnum
)
5001 header
->e_shstrndx
= SHN_UNDEF
;
5002 free (filedata
->section_headers
);
5003 filedata
->section_headers
= NULL
;
5009 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5010 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5013 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5015 Elf32_External_Phdr
* phdrs
;
5016 Elf32_External_Phdr
* external
;
5017 Elf_Internal_Phdr
* internal
;
5019 unsigned int size
= filedata
->file_header
.e_phentsize
;
5020 unsigned int num
= filedata
->file_header
.e_phnum
;
5022 /* PR binutils/17531: Cope with unexpected section header sizes. */
5023 if (size
== 0 || num
== 0)
5025 if (size
< sizeof * phdrs
)
5027 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5030 if (size
> sizeof * phdrs
)
5031 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5033 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5034 size
, num
, _("program headers"));
5038 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5039 i
< filedata
->file_header
.e_phnum
;
5040 i
++, internal
++, external
++)
5042 internal
->p_type
= BYTE_GET (external
->p_type
);
5043 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5044 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5045 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5046 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5047 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5048 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5049 internal
->p_align
= BYTE_GET (external
->p_align
);
5056 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5057 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5060 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5062 Elf64_External_Phdr
* phdrs
;
5063 Elf64_External_Phdr
* external
;
5064 Elf_Internal_Phdr
* internal
;
5066 unsigned int size
= filedata
->file_header
.e_phentsize
;
5067 unsigned int num
= filedata
->file_header
.e_phnum
;
5069 /* PR binutils/17531: Cope with unexpected section header sizes. */
5070 if (size
== 0 || num
== 0)
5072 if (size
< sizeof * phdrs
)
5074 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5077 if (size
> sizeof * phdrs
)
5078 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5080 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5081 size
, num
, _("program headers"));
5085 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5086 i
< filedata
->file_header
.e_phnum
;
5087 i
++, internal
++, external
++)
5089 internal
->p_type
= BYTE_GET (external
->p_type
);
5090 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5091 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5092 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5093 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5094 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5095 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5096 internal
->p_align
= BYTE_GET (external
->p_align
);
5103 /* Returns TRUE if the program headers were read into `program_headers'. */
5106 get_program_headers (Filedata
* filedata
)
5108 Elf_Internal_Phdr
* phdrs
;
5110 /* Check cache of prior read. */
5111 if (filedata
->program_headers
!= NULL
)
5114 /* Be kind to memory checkers by looking for
5115 e_phnum values which we know must be invalid. */
5116 if (filedata
->file_header
.e_phnum
5117 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5118 >= filedata
->file_size
)
5120 error (_("Too many program headers - %#x - the file is not that big\n"),
5121 filedata
->file_header
.e_phnum
);
5125 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5126 sizeof (Elf_Internal_Phdr
));
5129 error (_("Out of memory reading %u program headers\n"),
5130 filedata
->file_header
.e_phnum
);
5135 ? get_32bit_program_headers (filedata
, phdrs
)
5136 : get_64bit_program_headers (filedata
, phdrs
))
5138 filedata
->program_headers
= phdrs
;
5146 /* Returns TRUE if the program headers were loaded. */
5149 process_program_headers (Filedata
* filedata
)
5151 Elf_Internal_Phdr
* segment
;
5153 Elf_Internal_Phdr
* previous_load
= NULL
;
5155 filedata
->dynamic_addr
= 0;
5156 filedata
->dynamic_size
= 0;
5158 if (filedata
->file_header
.e_phnum
== 0)
5160 /* PR binutils/12467. */
5161 if (filedata
->file_header
.e_phoff
!= 0)
5163 warn (_("possibly corrupt ELF header - it has a non-zero program"
5164 " header offset, but no program headers\n"));
5167 else if (do_segments
)
5168 printf (_("\nThere are no program headers in this file.\n"));
5172 if (do_segments
&& !do_header
)
5174 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5175 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5176 printf (ngettext ("There is %d program header, starting at offset %s\n",
5177 "There are %d program headers, starting at offset %s\n",
5178 filedata
->file_header
.e_phnum
),
5179 filedata
->file_header
.e_phnum
,
5180 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5183 if (! get_program_headers (filedata
))
5188 if (filedata
->file_header
.e_phnum
> 1)
5189 printf (_("\nProgram Headers:\n"));
5191 printf (_("\nProgram Headers:\n"));
5195 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5198 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5202 (_(" Type Offset VirtAddr PhysAddr\n"));
5204 (_(" FileSiz MemSiz Flags Align\n"));
5208 for (i
= 0, segment
= filedata
->program_headers
;
5209 i
< filedata
->file_header
.e_phnum
;
5214 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5218 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5219 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5220 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5221 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5222 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5224 (segment
->p_flags
& PF_R
? 'R' : ' '),
5225 (segment
->p_flags
& PF_W
? 'W' : ' '),
5226 (segment
->p_flags
& PF_X
? 'E' : ' '));
5227 printf ("%#lx", (unsigned long) segment
->p_align
);
5231 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5232 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5235 print_vma (segment
->p_offset
, FULL_HEX
);
5239 print_vma (segment
->p_vaddr
, FULL_HEX
);
5241 print_vma (segment
->p_paddr
, FULL_HEX
);
5244 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5245 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5248 print_vma (segment
->p_filesz
, FULL_HEX
);
5252 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5253 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5256 print_vma (segment
->p_memsz
, FULL_HEX
);
5260 (segment
->p_flags
& PF_R
? 'R' : ' '),
5261 (segment
->p_flags
& PF_W
? 'W' : ' '),
5262 (segment
->p_flags
& PF_X
? 'E' : ' '));
5264 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5265 printf ("%#lx", (unsigned long) segment
->p_align
);
5268 print_vma (segment
->p_align
, PREFIX_HEX
);
5273 print_vma (segment
->p_offset
, FULL_HEX
);
5275 print_vma (segment
->p_vaddr
, FULL_HEX
);
5277 print_vma (segment
->p_paddr
, FULL_HEX
);
5279 print_vma (segment
->p_filesz
, FULL_HEX
);
5281 print_vma (segment
->p_memsz
, FULL_HEX
);
5283 (segment
->p_flags
& PF_R
? 'R' : ' '),
5284 (segment
->p_flags
& PF_W
? 'W' : ' '),
5285 (segment
->p_flags
& PF_X
? 'E' : ' '));
5286 print_vma (segment
->p_align
, PREFIX_HEX
);
5289 putc ('\n', stdout
);
5292 switch (segment
->p_type
)
5295 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5296 required by the ELF standard, several programs, including the Linux
5297 kernel, make use of non-ordered segments. */
5299 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5300 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5302 if (segment
->p_memsz
< segment
->p_filesz
)
5303 error (_("the segment's file size is larger than its memory size\n"));
5304 previous_load
= segment
;
5308 /* PR 20815 - Verify that the program header is loaded into memory. */
5309 if (i
> 0 && previous_load
!= NULL
)
5310 error (_("the PHDR segment must occur before any LOAD segment\n"));
5311 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5315 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5317 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5318 if (load
->p_type
== PT_LOAD
5319 && load
->p_offset
<= segment
->p_offset
5320 && (load
->p_offset
+ load
->p_filesz
5321 >= segment
->p_offset
+ segment
->p_filesz
)
5322 && load
->p_vaddr
<= segment
->p_vaddr
5323 && (load
->p_vaddr
+ load
->p_filesz
5324 >= segment
->p_vaddr
+ segment
->p_filesz
))
5327 if (j
== filedata
->file_header
.e_phnum
)
5328 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5333 if (filedata
->dynamic_addr
)
5334 error (_("more than one dynamic segment\n"));
5336 /* By default, assume that the .dynamic section is the first
5337 section in the DYNAMIC segment. */
5338 filedata
->dynamic_addr
= segment
->p_offset
;
5339 filedata
->dynamic_size
= segment
->p_filesz
;
5341 /* Try to locate the .dynamic section. If there is
5342 a section header table, we can easily locate it. */
5343 if (filedata
->section_headers
!= NULL
)
5345 Elf_Internal_Shdr
* sec
;
5347 sec
= find_section (filedata
, ".dynamic");
5348 if (sec
== NULL
|| sec
->sh_size
== 0)
5350 /* A corresponding .dynamic section is expected, but on
5351 IA-64/OpenVMS it is OK for it to be missing. */
5352 if (!is_ia64_vms (filedata
))
5353 error (_("no .dynamic section in the dynamic segment\n"));
5357 if (sec
->sh_type
== SHT_NOBITS
)
5359 filedata
->dynamic_size
= 0;
5363 filedata
->dynamic_addr
= sec
->sh_offset
;
5364 filedata
->dynamic_size
= sec
->sh_size
;
5366 if (filedata
->dynamic_addr
< segment
->p_offset
5367 || filedata
->dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5368 warn (_("the .dynamic section is not contained"
5369 " within the dynamic segment\n"));
5370 else if (filedata
->dynamic_addr
> segment
->p_offset
)
5371 warn (_("the .dynamic section is not the first section"
5372 " in the dynamic segment.\n"));
5375 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5376 segment. Check this after matching against the section headers
5377 so we don't warn on debuginfo file (which have NOBITS .dynamic
5379 if (filedata
->dynamic_addr
> filedata
->file_size
5380 || (filedata
->dynamic_size
5381 > filedata
->file_size
- filedata
->dynamic_addr
))
5383 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5384 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5389 if (fseek (filedata
->handle
,
5390 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5392 error (_("Unable to find program interpreter name\n"));
5396 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5398 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5399 error (_("Internal error: failed to create format string to display program interpreter\n"));
5401 filedata
->program_interpreter
[0] = 0;
5402 if (fscanf (filedata
->handle
, fmt
,
5403 filedata
->program_interpreter
) <= 0)
5404 error (_("Unable to read program interpreter name\n"));
5407 printf (_(" [Requesting program interpreter: %s]\n"),
5408 filedata
->program_interpreter
);
5415 && filedata
->section_headers
!= NULL
5416 && filedata
->string_table
!= NULL
)
5418 printf (_("\n Section to Segment mapping:\n"));
5419 printf (_(" Segment Sections...\n"));
5421 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5424 Elf_Internal_Shdr
* section
;
5426 segment
= filedata
->program_headers
+ i
;
5427 section
= filedata
->section_headers
+ 1;
5429 printf (" %2.2d ", i
);
5431 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5433 if (!ELF_TBSS_SPECIAL (section
, segment
)
5434 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5435 printf ("%s ", printable_section_name (filedata
, section
));
5446 /* Find the file offset corresponding to VMA by using the program headers. */
5449 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5451 Elf_Internal_Phdr
* seg
;
5453 if (! get_program_headers (filedata
))
5455 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5459 for (seg
= filedata
->program_headers
;
5460 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5463 if (seg
->p_type
!= PT_LOAD
)
5466 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5467 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5468 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5471 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5472 (unsigned long) vma
);
5477 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5478 If PROBE is true, this is just a probe and we do not generate any error
5479 messages if the load fails. */
5482 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5484 Elf32_External_Shdr
* shdrs
;
5485 Elf_Internal_Shdr
* internal
;
5487 unsigned int size
= filedata
->file_header
.e_shentsize
;
5488 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5490 /* PR binutils/17531: Cope with unexpected section header sizes. */
5491 if (size
== 0 || num
== 0)
5493 if (size
< sizeof * shdrs
)
5496 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5499 if (!probe
&& size
> sizeof * shdrs
)
5500 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5502 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5504 probe
? NULL
: _("section headers"));
5508 free (filedata
->section_headers
);
5509 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5510 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5511 if (filedata
->section_headers
== NULL
)
5514 error (_("Out of memory reading %u section headers\n"), num
);
5519 for (i
= 0, internal
= filedata
->section_headers
;
5523 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5524 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5525 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5526 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5527 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5528 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5529 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5530 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5531 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5532 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5533 if (!probe
&& internal
->sh_link
> num
)
5534 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5535 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5536 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5543 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5546 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5548 Elf64_External_Shdr
* shdrs
;
5549 Elf_Internal_Shdr
* internal
;
5551 unsigned int size
= filedata
->file_header
.e_shentsize
;
5552 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5554 /* PR binutils/17531: Cope with unexpected section header sizes. */
5555 if (size
== 0 || num
== 0)
5558 if (size
< sizeof * shdrs
)
5561 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5565 if (! probe
&& size
> sizeof * shdrs
)
5566 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5568 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5569 filedata
->file_header
.e_shoff
,
5571 probe
? NULL
: _("section headers"));
5575 free (filedata
->section_headers
);
5576 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5577 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5578 if (filedata
->section_headers
== NULL
)
5581 error (_("Out of memory reading %u section headers\n"), num
);
5586 for (i
= 0, internal
= filedata
->section_headers
;
5590 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5591 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5592 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5593 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5594 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5595 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5596 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5597 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5598 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5599 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5600 if (!probe
&& internal
->sh_link
> num
)
5601 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5602 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5603 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5610 static Elf_Internal_Sym
*
5611 get_32bit_elf_symbols (Filedata
* filedata
,
5612 Elf_Internal_Shdr
* section
,
5613 unsigned long * num_syms_return
)
5615 unsigned long number
= 0;
5616 Elf32_External_Sym
* esyms
= NULL
;
5617 Elf_External_Sym_Shndx
* shndx
= NULL
;
5618 Elf_Internal_Sym
* isyms
= NULL
;
5619 Elf_Internal_Sym
* psym
;
5621 elf_section_list
* entry
;
5623 if (section
->sh_size
== 0)
5625 if (num_syms_return
!= NULL
)
5626 * num_syms_return
= 0;
5630 /* Run some sanity checks first. */
5631 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5633 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5634 printable_section_name (filedata
, section
),
5635 (unsigned long) section
->sh_entsize
);
5639 if (section
->sh_size
> filedata
->file_size
)
5641 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5642 printable_section_name (filedata
, section
),
5643 (unsigned long) section
->sh_size
);
5647 number
= section
->sh_size
/ section
->sh_entsize
;
5649 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5651 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5652 (unsigned long) section
->sh_size
,
5653 printable_section_name (filedata
, section
),
5654 (unsigned long) section
->sh_entsize
);
5658 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5659 section
->sh_size
, _("symbols"));
5664 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5666 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5671 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5675 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5676 entry
->hdr
->sh_offset
,
5677 1, entry
->hdr
->sh_size
,
5678 _("symbol table section indices"));
5682 /* PR17531: file: heap-buffer-overflow */
5683 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5685 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5686 printable_section_name (filedata
, entry
->hdr
),
5687 (unsigned long) entry
->hdr
->sh_size
,
5688 (unsigned long) section
->sh_size
);
5693 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5697 error (_("Out of memory reading %lu symbols\n"),
5698 (unsigned long) number
);
5702 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5704 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5705 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5706 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5707 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5708 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5710 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5711 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5712 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5713 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5714 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5721 if (num_syms_return
!= NULL
)
5722 * num_syms_return
= isyms
== NULL
? 0 : number
;
5727 static Elf_Internal_Sym
*
5728 get_64bit_elf_symbols (Filedata
* filedata
,
5729 Elf_Internal_Shdr
* section
,
5730 unsigned long * num_syms_return
)
5732 unsigned long number
= 0;
5733 Elf64_External_Sym
* esyms
= NULL
;
5734 Elf_External_Sym_Shndx
* shndx
= NULL
;
5735 Elf_Internal_Sym
* isyms
= NULL
;
5736 Elf_Internal_Sym
* psym
;
5738 elf_section_list
* entry
;
5740 if (section
->sh_size
== 0)
5742 if (num_syms_return
!= NULL
)
5743 * num_syms_return
= 0;
5747 /* Run some sanity checks first. */
5748 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5750 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5751 printable_section_name (filedata
, section
),
5752 (unsigned long) section
->sh_entsize
);
5756 if (section
->sh_size
> filedata
->file_size
)
5758 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5759 printable_section_name (filedata
, section
),
5760 (unsigned long) section
->sh_size
);
5764 number
= section
->sh_size
/ section
->sh_entsize
;
5766 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5768 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5769 (unsigned long) section
->sh_size
,
5770 printable_section_name (filedata
, section
),
5771 (unsigned long) section
->sh_entsize
);
5775 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5776 section
->sh_size
, _("symbols"));
5781 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5783 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5788 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5792 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5793 entry
->hdr
->sh_offset
,
5794 1, entry
->hdr
->sh_size
,
5795 _("symbol table section indices"));
5799 /* PR17531: file: heap-buffer-overflow */
5800 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5802 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5803 printable_section_name (filedata
, entry
->hdr
),
5804 (unsigned long) entry
->hdr
->sh_size
,
5805 (unsigned long) section
->sh_size
);
5810 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5814 error (_("Out of memory reading %lu symbols\n"),
5815 (unsigned long) number
);
5819 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5821 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5822 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5823 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5824 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5826 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5828 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5829 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5830 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5832 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5833 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5840 if (num_syms_return
!= NULL
)
5841 * num_syms_return
= isyms
== NULL
? 0 : number
;
5847 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5849 static char buff
[1024];
5851 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5853 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5854 bfd_vma os_flags
= 0;
5855 bfd_vma proc_flags
= 0;
5856 bfd_vma unknown_flags
= 0;
5864 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5865 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5866 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5867 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5868 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5869 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5870 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5871 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5872 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5873 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5874 /* IA-64 specific. */
5875 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5876 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5877 /* IA-64 OpenVMS specific. */
5878 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5879 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5880 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5881 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5882 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5883 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5885 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5886 /* SPARC specific. */
5887 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5888 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5890 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5891 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5892 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5894 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5896 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5899 if (do_section_details
)
5901 sprintf (buff
, "[%*.*lx]: ",
5902 field_size
, field_size
, (unsigned long) sh_flags
);
5903 p
+= field_size
+ 4;
5910 flag
= sh_flags
& - sh_flags
;
5913 if (do_section_details
)
5917 case SHF_WRITE
: sindex
= 0; break;
5918 case SHF_ALLOC
: sindex
= 1; break;
5919 case SHF_EXECINSTR
: sindex
= 2; break;
5920 case SHF_MERGE
: sindex
= 3; break;
5921 case SHF_STRINGS
: sindex
= 4; break;
5922 case SHF_INFO_LINK
: sindex
= 5; break;
5923 case SHF_LINK_ORDER
: sindex
= 6; break;
5924 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5925 case SHF_GROUP
: sindex
= 8; break;
5926 case SHF_TLS
: sindex
= 9; break;
5927 case SHF_EXCLUDE
: sindex
= 18; break;
5928 case SHF_COMPRESSED
: sindex
= 20; break;
5929 case SHF_GNU_MBIND
: sindex
= 24; break;
5933 switch (filedata
->file_header
.e_machine
)
5936 if (flag
== SHF_IA_64_SHORT
)
5938 else if (flag
== SHF_IA_64_NORECOV
)
5941 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5944 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5945 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5946 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5947 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5948 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5949 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5960 case EM_OLD_SPARCV9
:
5961 case EM_SPARC32PLUS
:
5964 if (flag
== SHF_ORDERED
)
5971 case SHF_ENTRYSECT
: sindex
= 21; break;
5972 case SHF_ARM_PURECODE
: sindex
= 22; break;
5973 case SHF_COMDEF
: sindex
= 23; break;
5978 if (flag
== SHF_PPC_VLE
)
5989 if (p
!= buff
+ field_size
+ 4)
5991 if (size
< (10 + 2))
5993 warn (_("Internal error: not enough buffer room for section flag info"));
5994 return _("<unknown>");
6001 size
-= flags
[sindex
].len
;
6002 p
= stpcpy (p
, flags
[sindex
].str
);
6004 else if (flag
& SHF_MASKOS
)
6006 else if (flag
& SHF_MASKPROC
)
6009 unknown_flags
|= flag
;
6015 case SHF_WRITE
: *p
= 'W'; break;
6016 case SHF_ALLOC
: *p
= 'A'; break;
6017 case SHF_EXECINSTR
: *p
= 'X'; break;
6018 case SHF_MERGE
: *p
= 'M'; break;
6019 case SHF_STRINGS
: *p
= 'S'; break;
6020 case SHF_INFO_LINK
: *p
= 'I'; break;
6021 case SHF_LINK_ORDER
: *p
= 'L'; break;
6022 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6023 case SHF_GROUP
: *p
= 'G'; break;
6024 case SHF_TLS
: *p
= 'T'; break;
6025 case SHF_EXCLUDE
: *p
= 'E'; break;
6026 case SHF_COMPRESSED
: *p
= 'C'; break;
6027 case SHF_GNU_MBIND
: *p
= 'D'; break;
6030 if ((filedata
->file_header
.e_machine
== EM_X86_64
6031 || filedata
->file_header
.e_machine
== EM_L1OM
6032 || filedata
->file_header
.e_machine
== EM_K1OM
)
6033 && flag
== SHF_X86_64_LARGE
)
6035 else if (filedata
->file_header
.e_machine
== EM_ARM
6036 && flag
== SHF_ARM_PURECODE
)
6038 else if (filedata
->file_header
.e_machine
== EM_PPC
6039 && flag
== SHF_PPC_VLE
)
6041 else if (flag
& SHF_MASKOS
)
6044 sh_flags
&= ~ SHF_MASKOS
;
6046 else if (flag
& SHF_MASKPROC
)
6049 sh_flags
&= ~ SHF_MASKPROC
;
6059 if (do_section_details
)
6063 size
-= 5 + field_size
;
6064 if (p
!= buff
+ field_size
+ 4)
6068 warn (_("Internal error: not enough buffer room for section flag info"));
6069 return _("<unknown>");
6075 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6076 (unsigned long) os_flags
);
6077 p
+= 5 + field_size
;
6081 size
-= 7 + field_size
;
6082 if (p
!= buff
+ field_size
+ 4)
6086 warn (_("Internal error: not enough buffer room for section flag info"));
6087 return _("<unknown>");
6093 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6094 (unsigned long) proc_flags
);
6095 p
+= 7 + field_size
;
6099 size
-= 10 + field_size
;
6100 if (p
!= buff
+ field_size
+ 4)
6104 warn (_("Internal error: not enough buffer room for section flag info"));
6105 return _("<unknown>");
6111 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6112 (unsigned long) unknown_flags
);
6113 p
+= 10 + field_size
;
6121 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6122 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6126 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6128 if (size
< sizeof (* echdr
))
6130 error (_("Compressed section is too small even for a compression header\n"));
6134 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6135 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6136 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6137 return sizeof (*echdr
);
6141 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6143 if (size
< sizeof (* echdr
))
6145 error (_("Compressed section is too small even for a compression header\n"));
6149 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6150 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6151 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6152 return sizeof (*echdr
);
6157 process_section_headers (Filedata
* filedata
)
6159 Elf_Internal_Shdr
* section
;
6162 free (filedata
->section_headers
);
6163 filedata
->section_headers
= NULL
;
6164 free (filedata
->dynamic_symbols
);
6165 filedata
->dynamic_symbols
= NULL
;
6166 filedata
->num_dynamic_syms
= 0;
6167 free (filedata
->dynamic_strings
);
6168 filedata
->dynamic_strings
= NULL
;
6169 filedata
->dynamic_strings_length
= 0;
6170 free (filedata
->dynamic_syminfo
);
6171 filedata
->dynamic_syminfo
= NULL
;
6172 while (filedata
->symtab_shndx_list
!= NULL
)
6174 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6175 free (filedata
->symtab_shndx_list
);
6176 filedata
->symtab_shndx_list
= next
;
6179 if (filedata
->file_header
.e_shnum
== 0)
6181 /* PR binutils/12467. */
6182 if (filedata
->file_header
.e_shoff
!= 0)
6184 warn (_("possibly corrupt ELF file header - it has a non-zero"
6185 " section header offset, but no section headers\n"));
6188 else if (do_sections
)
6189 printf (_("\nThere are no sections in this file.\n"));
6194 if (do_sections
&& !do_header
)
6195 printf (ngettext ("There is %d section header, "
6196 "starting at offset 0x%lx:\n",
6197 "There are %d section headers, "
6198 "starting at offset 0x%lx:\n",
6199 filedata
->file_header
.e_shnum
),
6200 filedata
->file_header
.e_shnum
,
6201 (unsigned long) filedata
->file_header
.e_shoff
);
6205 if (! get_32bit_section_headers (filedata
, FALSE
))
6210 if (! get_64bit_section_headers (filedata
, FALSE
))
6214 /* Read in the string table, so that we have names to display. */
6215 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6216 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6218 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6220 if (section
->sh_size
!= 0)
6222 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6223 1, section
->sh_size
,
6226 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6230 /* Scan the sections for the dynamic symbol table
6231 and dynamic string table and debug sections. */
6232 eh_addr_size
= is_32bit_elf
? 4 : 8;
6233 switch (filedata
->file_header
.e_machine
)
6236 case EM_MIPS_RS3_LE
:
6237 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6238 FDE addresses. However, the ABI also has a semi-official ILP32
6239 variant for which the normal FDE address size rules apply.
6241 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6242 section, where XX is the size of longs in bits. Unfortunately,
6243 earlier compilers provided no way of distinguishing ILP32 objects
6244 from LP64 objects, so if there's any doubt, we should assume that
6245 the official LP64 form is being used. */
6246 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6247 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6253 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6255 case E_H8_MACH_H8300
:
6256 case E_H8_MACH_H8300HN
:
6257 case E_H8_MACH_H8300SN
:
6258 case E_H8_MACH_H8300SXN
:
6261 case E_H8_MACH_H8300H
:
6262 case E_H8_MACH_H8300S
:
6263 case E_H8_MACH_H8300SX
:
6271 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6273 case EF_M32C_CPU_M16C
:
6280 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6283 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6284 if (section->sh_entsize != expected_entsize) \
6287 sprintf_vma (buf, section->sh_entsize); \
6288 /* Note: coded this way so that there is a single string for \
6290 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6291 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6292 (unsigned) expected_entsize); \
6293 section->sh_entsize = expected_entsize; \
6298 #define CHECK_ENTSIZE(section, i, type) \
6299 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6300 sizeof (Elf64_External_##type))
6302 for (i
= 0, section
= filedata
->section_headers
;
6303 i
< filedata
->file_header
.e_shnum
;
6306 char * name
= SECTION_NAME (section
);
6308 /* Run some sanity checks on the headers and
6309 possibly fill in some file data as well. */
6310 switch (section
->sh_type
)
6313 if (filedata
->dynamic_symbols
!= NULL
)
6315 error (_("File contains multiple dynamic symbol tables\n"));
6319 CHECK_ENTSIZE (section
, i
, Sym
);
6320 filedata
->dynamic_symbols
6321 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6325 if (streq (name
, ".dynstr"))
6327 if (filedata
->dynamic_strings
!= NULL
)
6329 error (_("File contains multiple dynamic string tables\n"));
6333 filedata
->dynamic_strings
6334 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6335 1, section
->sh_size
, _("dynamic strings"));
6336 filedata
->dynamic_strings_length
6337 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6341 case SHT_SYMTAB_SHNDX
:
6343 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6345 entry
->hdr
= section
;
6346 entry
->next
= filedata
->symtab_shndx_list
;
6347 filedata
->symtab_shndx_list
= entry
;
6352 CHECK_ENTSIZE (section
, i
, Sym
);
6356 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6360 CHECK_ENTSIZE (section
, i
, Rel
);
6361 if (do_checks
&& section
->sh_size
== 0)
6362 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6366 CHECK_ENTSIZE (section
, i
, Rela
);
6367 if (do_checks
&& section
->sh_size
== 0)
6368 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6373 /* Having a zero sized section is not illegal according to the
6374 ELF standard, but it might be an indication that something
6375 is wrong. So issue a warning if we are running in lint mode. */
6376 if (do_checks
&& section
->sh_size
== 0)
6377 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6384 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6385 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6386 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6387 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6388 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6389 && (const_strneq (name
, ".debug_")
6390 || const_strneq (name
, ".zdebug_")))
6393 name
+= sizeof (".zdebug_") - 1;
6395 name
+= sizeof (".debug_") - 1;
6398 || (do_debug_info
&& const_strneq (name
, "info"))
6399 || (do_debug_info
&& const_strneq (name
, "types"))
6400 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6401 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6402 || (do_debug_lines
&& const_strneq (name
, "line."))
6403 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6404 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6405 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6406 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6407 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6408 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6409 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6410 || (do_debug_frames
&& const_strneq (name
, "frame"))
6411 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6412 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6413 || (do_debug_str
&& const_strneq (name
, "str"))
6414 || (do_debug_loc
&& const_strneq (name
, "loc"))
6415 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6416 || (do_debug_addr
&& const_strneq (name
, "addr"))
6417 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6418 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6420 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6422 /* Linkonce section to be combined with .debug_info at link time. */
6423 else if ((do_debugging
|| do_debug_info
)
6424 && const_strneq (name
, ".gnu.linkonce.wi."))
6425 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6426 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6427 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6428 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6429 || streq (name
, ".debug_names")))
6430 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6431 /* Trace sections for Itanium VMS. */
6432 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6433 || do_trace_aranges
)
6434 && const_strneq (name
, ".trace_"))
6436 name
+= sizeof (".trace_") - 1;
6439 || (do_trace_info
&& streq (name
, "info"))
6440 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6441 || (do_trace_aranges
&& streq (name
, "aranges"))
6443 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6445 else if ((do_debugging
|| do_debug_links
)
6446 && (const_strneq (name
, ".gnu_debuglink")
6447 || const_strneq (name
, ".gnu_debugaltlink")))
6448 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6454 if (filedata
->file_header
.e_shnum
> 1)
6455 printf (_("\nSection Headers:\n"));
6457 printf (_("\nSection Header:\n"));
6461 if (do_section_details
)
6463 printf (_(" [Nr] Name\n"));
6464 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6468 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6472 if (do_section_details
)
6474 printf (_(" [Nr] Name\n"));
6475 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6479 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6483 if (do_section_details
)
6485 printf (_(" [Nr] Name\n"));
6486 printf (_(" Type Address Offset Link\n"));
6487 printf (_(" Size EntSize Info Align\n"));
6491 printf (_(" [Nr] Name Type Address Offset\n"));
6492 printf (_(" Size EntSize Flags Link Info Align\n"));
6496 if (do_section_details
)
6497 printf (_(" Flags\n"));
6499 for (i
= 0, section
= filedata
->section_headers
;
6500 i
< filedata
->file_header
.e_shnum
;
6503 /* Run some sanity checks on the section header. */
6505 /* Check the sh_link field. */
6506 switch (section
->sh_type
)
6510 if (section
->sh_link
== 0
6511 && (filedata
->file_header
.e_type
== ET_EXEC
6512 || filedata
->file_header
.e_type
== ET_DYN
))
6513 /* A dynamic relocation section where all entries use a
6514 zero symbol index need not specify a symtab section. */
6517 case SHT_SYMTAB_SHNDX
:
6521 case SHT_GNU_versym
:
6522 if (section
->sh_link
== 0
6523 || section
->sh_link
>= filedata
->file_header
.e_shnum
6524 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6525 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6526 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6527 i
, section
->sh_link
);
6533 case SHT_GNU_verneed
:
6534 case SHT_GNU_verdef
:
6535 case SHT_GNU_LIBLIST
:
6536 if (section
->sh_link
== 0
6537 || section
->sh_link
>= filedata
->file_header
.e_shnum
6538 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6539 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6540 i
, section
->sh_link
);
6543 case SHT_INIT_ARRAY
:
6544 case SHT_FINI_ARRAY
:
6545 case SHT_PREINIT_ARRAY
:
6546 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6547 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6548 i
, section
->sh_link
);
6552 /* FIXME: Add support for target specific section types. */
6553 #if 0 /* Currently we do not check other section types as there are too
6554 many special cases. Stab sections for example have a type
6555 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6557 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6558 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6559 i
, section
->sh_link
);
6564 /* Check the sh_info field. */
6565 switch (section
->sh_type
)
6569 if (section
->sh_info
== 0
6570 && (filedata
->file_header
.e_type
== ET_EXEC
6571 || filedata
->file_header
.e_type
== ET_DYN
))
6572 /* Dynamic relocations apply to segments, so they do not
6573 need to specify the section they relocate. */
6575 if (section
->sh_info
== 0
6576 || section
->sh_info
>= filedata
->file_header
.e_shnum
6577 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6578 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6579 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6580 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6581 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6582 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6583 /* FIXME: Are other section types valid ? */
6584 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6585 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6586 i
, section
->sh_info
);
6591 case SHT_SYMTAB_SHNDX
:
6592 case SHT_INIT_ARRAY
:
6593 case SHT_FINI_ARRAY
:
6594 case SHT_PREINIT_ARRAY
:
6595 if (section
->sh_info
!= 0)
6596 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6597 i
, section
->sh_info
);
6603 /* A symbol index - we assume that it is valid. */
6607 /* FIXME: Add support for target specific section types. */
6608 if (section
->sh_type
== SHT_NOBITS
)
6609 /* NOBITS section headers with non-zero sh_info fields can be
6610 created when a binary is stripped of everything but its debug
6611 information. The stripped sections have their headers
6612 preserved but their types set to SHT_NOBITS. So do not check
6613 this type of section. */
6615 else if (section
->sh_flags
& SHF_INFO_LINK
)
6617 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6618 warn (_("[%2u]: Expected link to another section in info field"), i
);
6620 else if (section
->sh_type
< SHT_LOOS
6621 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6622 && section
->sh_info
!= 0)
6623 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6624 i
, section
->sh_info
);
6628 /* Check the sh_size field. */
6629 if (section
->sh_size
> filedata
->file_size
6630 && section
->sh_type
!= SHT_NOBITS
6631 && section
->sh_type
!= SHT_NULL
6632 && section
->sh_type
< SHT_LOOS
)
6633 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6635 printf (" [%2u] ", i
);
6636 if (do_section_details
)
6637 printf ("%s\n ", printable_section_name (filedata
, section
));
6639 print_symbol (-17, SECTION_NAME (section
));
6641 printf (do_wide
? " %-15s " : " %-15.15s ",
6642 get_section_type_name (filedata
, section
->sh_type
));
6646 const char * link_too_big
= NULL
;
6648 print_vma (section
->sh_addr
, LONG_HEX
);
6650 printf ( " %6.6lx %6.6lx %2.2lx",
6651 (unsigned long) section
->sh_offset
,
6652 (unsigned long) section
->sh_size
,
6653 (unsigned long) section
->sh_entsize
);
6655 if (do_section_details
)
6656 fputs (" ", stdout
);
6658 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6660 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6663 /* The sh_link value is out of range. Normally this indicates
6664 an error but it can have special values in Solaris binaries. */
6665 switch (filedata
->file_header
.e_machine
)
6672 case EM_OLD_SPARCV9
:
6673 case EM_SPARC32PLUS
:
6676 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6677 link_too_big
= "BEFORE";
6678 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6679 link_too_big
= "AFTER";
6686 if (do_section_details
)
6688 if (link_too_big
!= NULL
&& * link_too_big
)
6689 printf ("<%s> ", link_too_big
);
6691 printf ("%2u ", section
->sh_link
);
6692 printf ("%3u %2lu\n", section
->sh_info
,
6693 (unsigned long) section
->sh_addralign
);
6696 printf ("%2u %3u %2lu\n",
6699 (unsigned long) section
->sh_addralign
);
6701 if (link_too_big
&& ! * link_too_big
)
6702 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6703 i
, section
->sh_link
);
6707 print_vma (section
->sh_addr
, LONG_HEX
);
6709 if ((long) section
->sh_offset
== section
->sh_offset
)
6710 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6714 print_vma (section
->sh_offset
, LONG_HEX
);
6717 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6718 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6722 print_vma (section
->sh_size
, LONG_HEX
);
6725 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6726 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6730 print_vma (section
->sh_entsize
, LONG_HEX
);
6733 if (do_section_details
)
6734 fputs (" ", stdout
);
6736 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6738 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6740 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6741 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6744 print_vma (section
->sh_addralign
, DEC
);
6748 else if (do_section_details
)
6751 print_vma (section
->sh_addr
, LONG_HEX
);
6752 if ((long) section
->sh_offset
== section
->sh_offset
)
6753 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6757 print_vma (section
->sh_offset
, LONG_HEX
);
6759 printf (" %u\n ", section
->sh_link
);
6760 print_vma (section
->sh_size
, LONG_HEX
);
6762 print_vma (section
->sh_entsize
, LONG_HEX
);
6764 printf (" %-16u %lu\n",
6766 (unsigned long) section
->sh_addralign
);
6771 print_vma (section
->sh_addr
, LONG_HEX
);
6772 if ((long) section
->sh_offset
== section
->sh_offset
)
6773 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6777 print_vma (section
->sh_offset
, LONG_HEX
);
6780 print_vma (section
->sh_size
, LONG_HEX
);
6782 print_vma (section
->sh_entsize
, LONG_HEX
);
6784 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6786 printf (" %2u %3u %lu\n",
6789 (unsigned long) section
->sh_addralign
);
6792 if (do_section_details
)
6794 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6795 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6797 /* Minimum section size is 12 bytes for 32-bit compression
6798 header + 12 bytes for compressed data header. */
6799 unsigned char buf
[24];
6801 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6802 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6803 sizeof (buf
), _("compression header")))
6805 Elf_Internal_Chdr chdr
;
6807 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6808 printf (_(" [<corrupt>]\n"));
6811 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6814 printf (_(" [<unknown>: 0x%x], "),
6816 print_vma (chdr
.ch_size
, LONG_HEX
);
6817 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6824 if (!do_section_details
)
6826 /* The ordering of the letters shown here matches the ordering of the
6827 corresponding SHF_xxx values, and hence the order in which these
6828 letters will be displayed to the user. */
6829 printf (_("Key to Flags:\n\
6830 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6831 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6832 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6833 if (filedata
->file_header
.e_machine
== EM_X86_64
6834 || filedata
->file_header
.e_machine
== EM_L1OM
6835 || filedata
->file_header
.e_machine
== EM_K1OM
)
6836 printf (_("l (large), "));
6837 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6838 printf (_("y (purecode), "));
6839 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6840 printf (_("v (VLE), "));
6841 printf ("p (processor specific)\n");
6848 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6849 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6850 char **strtab
, unsigned long *strtablen
)
6854 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6856 if (*symtab
== NULL
)
6859 if (symsec
->sh_link
!= 0)
6861 Elf_Internal_Shdr
*strsec
;
6863 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6865 error (_("Bad sh_link in symbol table section\n"));
6872 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6874 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6875 1, strsec
->sh_size
, _("string table"));
6876 if (*strtab
== NULL
)
6883 *strtablen
= strsec
->sh_size
;
6889 get_group_flags (unsigned int flags
)
6891 static char buff
[128];
6895 else if (flags
== GRP_COMDAT
)
6898 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6900 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6901 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6902 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6903 ? _("<unknown>") : ""));
6909 process_section_groups (Filedata
* filedata
)
6911 Elf_Internal_Shdr
* section
;
6913 struct group
* group
;
6914 Elf_Internal_Shdr
* symtab_sec
;
6915 Elf_Internal_Shdr
* strtab_sec
;
6916 Elf_Internal_Sym
* symtab
;
6917 unsigned long num_syms
;
6921 /* Don't process section groups unless needed. */
6922 if (!do_unwind
&& !do_section_groups
)
6925 if (filedata
->file_header
.e_shnum
== 0)
6927 if (do_section_groups
)
6928 printf (_("\nThere are no sections to group in this file.\n"));
6933 if (filedata
->section_headers
== NULL
)
6935 error (_("Section headers are not available!\n"));
6936 /* PR 13622: This can happen with a corrupt ELF header. */
6940 filedata
->section_headers_groups
6941 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6942 sizeof (struct group
*));
6944 if (filedata
->section_headers_groups
== NULL
)
6946 error (_("Out of memory reading %u section group headers\n"),
6947 filedata
->file_header
.e_shnum
);
6951 /* Scan the sections for the group section. */
6952 filedata
->group_count
= 0;
6953 for (i
= 0, section
= filedata
->section_headers
;
6954 i
< filedata
->file_header
.e_shnum
;
6956 if (section
->sh_type
== SHT_GROUP
)
6957 filedata
->group_count
++;
6959 if (filedata
->group_count
== 0)
6961 if (do_section_groups
)
6962 printf (_("\nThere are no section groups in this file.\n"));
6967 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
6968 sizeof (struct group
));
6970 if (filedata
->section_groups
== NULL
)
6972 error (_("Out of memory reading %lu groups\n"),
6973 (unsigned long) filedata
->group_count
);
6983 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
6984 i
< filedata
->file_header
.e_shnum
;
6987 if (section
->sh_type
== SHT_GROUP
)
6989 const char * name
= printable_section_name (filedata
, section
);
6990 const char * group_name
;
6991 unsigned char * start
;
6992 unsigned char * indices
;
6993 unsigned int entry
, j
, size
;
6994 Elf_Internal_Shdr
* sec
;
6995 Elf_Internal_Sym
* sym
;
6997 /* Get the symbol table. */
6998 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6999 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7002 error (_("Bad sh_link in group section `%s'\n"), name
);
7006 if (symtab_sec
!= sec
)
7011 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7016 error (_("Corrupt header in group section `%s'\n"), name
);
7020 if (section
->sh_info
>= num_syms
)
7022 error (_("Bad sh_info in group section `%s'\n"), name
);
7026 sym
= symtab
+ section
->sh_info
;
7028 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7030 if (sym
->st_shndx
== 0
7031 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7033 error (_("Bad sh_info in group section `%s'\n"), name
);
7037 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
7046 /* Get the string table. */
7047 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7056 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7062 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7063 1, strtab_sec
->sh_size
,
7065 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7067 group_name
= sym
->st_name
< strtab_size
7068 ? strtab
+ sym
->st_name
: _("<corrupt>");
7071 /* PR 17531: file: loop. */
7072 if (section
->sh_entsize
> section
->sh_size
)
7074 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7075 printable_section_name (filedata
, section
),
7076 (unsigned long) section
->sh_entsize
,
7077 (unsigned long) section
->sh_size
);
7081 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7082 1, section
->sh_size
,
7088 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7089 entry
= byte_get (indices
, 4);
7092 if (do_section_groups
)
7094 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7095 get_group_flags (entry
), i
, name
, group_name
, size
);
7097 printf (_(" [Index] Name\n"));
7100 group
->group_index
= i
;
7102 for (j
= 0; j
< size
; j
++)
7104 struct group_list
* g
;
7106 entry
= byte_get (indices
, 4);
7109 if (entry
>= filedata
->file_header
.e_shnum
)
7111 static unsigned num_group_errors
= 0;
7113 if (num_group_errors
++ < 10)
7115 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7116 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7117 if (num_group_errors
== 10)
7118 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7123 if (filedata
->section_headers_groups
[entry
] != NULL
)
7127 static unsigned num_errs
= 0;
7129 if (num_errs
++ < 10)
7131 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7133 filedata
->section_headers_groups
[entry
]->group_index
);
7135 warn (_("Further error messages about already contained group sections suppressed\n"));
7141 /* Intel C/C++ compiler may put section 0 in a
7142 section group. We just warn it the first time
7143 and ignore it afterwards. */
7144 static bfd_boolean warned
= FALSE
;
7147 error (_("section 0 in group section [%5u]\n"),
7148 filedata
->section_headers_groups
[entry
]->group_index
);
7154 filedata
->section_headers_groups
[entry
] = group
;
7156 if (do_section_groups
)
7158 sec
= filedata
->section_headers
+ entry
;
7159 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7162 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7163 g
->section_index
= entry
;
7164 g
->next
= group
->root
;
7182 /* Data used to display dynamic fixups. */
7184 struct ia64_vms_dynfixup
7186 bfd_vma needed_ident
; /* Library ident number. */
7187 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7188 bfd_vma fixup_needed
; /* Index of the library. */
7189 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7190 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7193 /* Data used to display dynamic relocations. */
7195 struct ia64_vms_dynimgrela
7197 bfd_vma img_rela_cnt
; /* Number of relocations. */
7198 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7201 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7205 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7206 struct ia64_vms_dynfixup
* fixup
,
7207 const char * strtab
,
7208 unsigned int strtab_sz
)
7210 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7212 const char * lib_name
;
7214 imfs
= get_data (NULL
, filedata
,
7215 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7216 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7217 _("dynamic section image fixups"));
7221 if (fixup
->needed
< strtab_sz
)
7222 lib_name
= strtab
+ fixup
->needed
;
7225 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7226 (unsigned long) fixup
->needed
);
7230 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7231 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7233 (_("Seg Offset Type SymVec DataType\n"));
7235 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7240 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7241 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7242 type
= BYTE_GET (imfs
[i
].type
);
7243 rtype
= elf_ia64_reloc_type (type
);
7245 printf (" 0x%08x ", type
);
7247 printf (" %-32s ", rtype
);
7248 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7249 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7256 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7259 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7261 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7264 imrs
= get_data (NULL
, filedata
,
7265 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7266 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7267 _("dynamic section image relocations"));
7271 printf (_("\nImage relocs\n"));
7273 (_("Seg Offset Type Addend Seg Sym Off\n"));
7275 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7280 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7281 printf ("%08" BFD_VMA_FMT
"x ",
7282 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7283 type
= BYTE_GET (imrs
[i
].type
);
7284 rtype
= elf_ia64_reloc_type (type
);
7286 printf ("0x%08x ", type
);
7288 printf ("%-31s ", rtype
);
7289 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7290 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7291 printf ("%08" BFD_VMA_FMT
"x\n",
7292 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7299 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7302 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7304 struct ia64_vms_dynfixup fixup
;
7305 struct ia64_vms_dynimgrela imgrela
;
7306 Elf_Internal_Dyn
*entry
;
7307 bfd_vma strtab_off
= 0;
7308 bfd_vma strtab_sz
= 0;
7309 char *strtab
= NULL
;
7310 bfd_boolean res
= TRUE
;
7312 memset (&fixup
, 0, sizeof (fixup
));
7313 memset (&imgrela
, 0, sizeof (imgrela
));
7315 /* Note: the order of the entries is specified by the OpenVMS specs. */
7316 for (entry
= filedata
->dynamic_section
;
7317 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7320 switch (entry
->d_tag
)
7322 case DT_IA_64_VMS_STRTAB_OFFSET
:
7323 strtab_off
= entry
->d_un
.d_val
;
7326 strtab_sz
= entry
->d_un
.d_val
;
7328 strtab
= get_data (NULL
, filedata
,
7329 filedata
->dynamic_addr
+ strtab_off
,
7330 1, strtab_sz
, _("dynamic string section"));
7335 case DT_IA_64_VMS_NEEDED_IDENT
:
7336 fixup
.needed_ident
= entry
->d_un
.d_val
;
7339 fixup
.needed
= entry
->d_un
.d_val
;
7341 case DT_IA_64_VMS_FIXUP_NEEDED
:
7342 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7344 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7345 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7347 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7348 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7349 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7352 case DT_IA_64_VMS_IMG_RELA_CNT
:
7353 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7355 case DT_IA_64_VMS_IMG_RELA_OFF
:
7356 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7357 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7379 dynamic_relocations
[] =
7381 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7382 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7383 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7386 /* Process the reloc section. */
7389 process_relocs (Filedata
* filedata
)
7391 unsigned long rel_size
;
7392 unsigned long rel_offset
;
7397 if (do_using_dynamic
)
7401 bfd_boolean has_dynamic_reloc
;
7404 has_dynamic_reloc
= FALSE
;
7406 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7408 is_rela
= dynamic_relocations
[i
].rela
;
7409 name
= dynamic_relocations
[i
].name
;
7410 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7411 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7414 has_dynamic_reloc
= TRUE
;
7416 if (is_rela
== UNKNOWN
)
7418 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7419 switch (filedata
->dynamic_info
[DT_PLTREL
])
7433 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7434 name
, rel_offset
, rel_size
);
7436 dump_relocations (filedata
,
7437 offset_from_vma (filedata
, rel_offset
, rel_size
),
7439 filedata
->dynamic_symbols
,
7440 filedata
->num_dynamic_syms
,
7441 filedata
->dynamic_strings
,
7442 filedata
->dynamic_strings_length
,
7443 is_rela
, TRUE
/* is_dynamic */);
7447 if (is_ia64_vms (filedata
))
7448 if (process_ia64_vms_dynamic_relocs (filedata
))
7449 has_dynamic_reloc
= TRUE
;
7451 if (! has_dynamic_reloc
)
7452 printf (_("\nThere are no dynamic relocations in this file.\n"));
7456 Elf_Internal_Shdr
* section
;
7458 bfd_boolean found
= FALSE
;
7460 for (i
= 0, section
= filedata
->section_headers
;
7461 i
< filedata
->file_header
.e_shnum
;
7464 if ( section
->sh_type
!= SHT_RELA
7465 && section
->sh_type
!= SHT_REL
)
7468 rel_offset
= section
->sh_offset
;
7469 rel_size
= section
->sh_size
;
7474 unsigned long num_rela
;
7476 printf (_("\nRelocation section "));
7478 if (filedata
->string_table
== NULL
)
7479 printf ("%d", section
->sh_name
);
7481 printf ("'%s'", printable_section_name (filedata
, section
));
7483 num_rela
= rel_size
/ section
->sh_entsize
;
7484 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7485 " at offset 0x%lx contains %lu entries:\n",
7487 rel_offset
, num_rela
);
7489 is_rela
= section
->sh_type
== SHT_RELA
;
7491 if (section
->sh_link
!= 0
7492 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7494 Elf_Internal_Shdr
* symsec
;
7495 Elf_Internal_Sym
* symtab
;
7496 unsigned long nsyms
;
7497 unsigned long strtablen
= 0;
7498 char * strtab
= NULL
;
7500 symsec
= filedata
->section_headers
+ section
->sh_link
;
7501 if (symsec
->sh_type
!= SHT_SYMTAB
7502 && symsec
->sh_type
!= SHT_DYNSYM
)
7505 if (!get_symtab (filedata
, symsec
,
7506 &symtab
, &nsyms
, &strtab
, &strtablen
))
7509 dump_relocations (filedata
, rel_offset
, rel_size
,
7510 symtab
, nsyms
, strtab
, strtablen
,
7512 symsec
->sh_type
== SHT_DYNSYM
);
7518 dump_relocations (filedata
, rel_offset
, rel_size
,
7519 NULL
, 0, NULL
, 0, is_rela
,
7520 FALSE
/* is_dynamic */);
7528 /* Users sometimes forget the -D option, so try to be helpful. */
7529 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7531 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7533 printf (_("\nThere are no static relocations in this file."));
7534 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7539 if (i
== ARRAY_SIZE (dynamic_relocations
))
7540 printf (_("\nThere are no relocations in this file.\n"));
7547 /* An absolute address consists of a section and an offset. If the
7548 section is NULL, the offset itself is the address, otherwise, the
7549 address equals to LOAD_ADDRESS(section) + offset. */
7553 unsigned short section
;
7557 /* Find the nearest symbol at or below ADDR. Returns the symbol
7558 name, if found, and the offset from the symbol to ADDR. */
7561 find_symbol_for_address (Filedata
* filedata
,
7562 Elf_Internal_Sym
* symtab
,
7563 unsigned long nsyms
,
7564 const char * strtab
,
7565 unsigned long strtab_size
,
7566 struct absaddr addr
,
7567 const char ** symname
,
7570 bfd_vma dist
= 0x100000;
7571 Elf_Internal_Sym
* sym
;
7572 Elf_Internal_Sym
* beg
;
7573 Elf_Internal_Sym
* end
;
7574 Elf_Internal_Sym
* best
= NULL
;
7576 REMOVE_ARCH_BITS (addr
.offset
);
7578 end
= symtab
+ nsyms
;
7584 sym
= beg
+ (end
- beg
) / 2;
7586 value
= sym
->st_value
;
7587 REMOVE_ARCH_BITS (value
);
7589 if (sym
->st_name
!= 0
7590 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7591 && addr
.offset
>= value
7592 && addr
.offset
- value
< dist
)
7595 dist
= addr
.offset
- value
;
7600 if (addr
.offset
< value
)
7608 *symname
= (best
->st_name
>= strtab_size
7609 ? _("<corrupt>") : strtab
+ best
->st_name
);
7615 *offset
= addr
.offset
;
7618 static /* signed */ int
7619 symcmp (const void *p
, const void *q
)
7621 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7622 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7624 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7627 /* Process the unwind section. */
7629 #include "unwind-ia64.h"
7631 struct ia64_unw_table_entry
7633 struct absaddr start
;
7635 struct absaddr info
;
7638 struct ia64_unw_aux_info
7640 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7641 unsigned long table_len
; /* Length of unwind table. */
7642 unsigned char * info
; /* Unwind info. */
7643 unsigned long info_size
; /* Size of unwind info. */
7644 bfd_vma info_addr
; /* Starting address of unwind info. */
7645 bfd_vma seg_base
; /* Starting address of segment. */
7646 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7647 unsigned long nsyms
; /* Number of symbols. */
7648 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7649 unsigned long nfuns
; /* Number of entries in funtab. */
7650 char * strtab
; /* The string table. */
7651 unsigned long strtab_size
; /* Size of string table. */
7655 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7657 struct ia64_unw_table_entry
* tp
;
7658 unsigned long j
, nfuns
;
7660 bfd_boolean res
= TRUE
;
7662 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7663 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7664 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7665 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7667 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7669 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7673 const unsigned char * dp
;
7674 const unsigned char * head
;
7675 const unsigned char * end
;
7676 const char * procname
;
7678 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7679 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7681 fputs ("\n<", stdout
);
7685 fputs (procname
, stdout
);
7688 printf ("+%lx", (unsigned long) offset
);
7691 fputs (">: [", stdout
);
7692 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7693 fputc ('-', stdout
);
7694 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7695 printf ("], info at +0x%lx\n",
7696 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7698 /* PR 17531: file: 86232b32. */
7699 if (aux
->info
== NULL
)
7702 offset
= tp
->info
.offset
;
7703 if (tp
->info
.section
)
7705 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7707 warn (_("Invalid section %u in table entry %ld\n"),
7708 tp
->info
.section
, (long) (tp
- aux
->table
));
7712 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7714 offset
-= aux
->info_addr
;
7715 /* PR 17531: file: 0997b4d1. */
7716 if (offset
>= aux
->info_size
7717 || aux
->info_size
- offset
< 8)
7719 warn (_("Invalid offset %lx in table entry %ld\n"),
7720 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7725 head
= aux
->info
+ offset
;
7726 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7728 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7729 (unsigned) UNW_VER (stamp
),
7730 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7731 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7732 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7733 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7735 if (UNW_VER (stamp
) != 1)
7737 printf (_("\tUnknown version.\n"));
7742 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7743 /* PR 17531: file: 16ceda89. */
7744 if (end
> aux
->info
+ aux
->info_size
)
7745 end
= aux
->info
+ aux
->info_size
;
7746 for (dp
= head
+ 8; dp
< end
;)
7747 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7756 slurp_ia64_unwind_table (Filedata
* filedata
,
7757 struct ia64_unw_aux_info
* aux
,
7758 Elf_Internal_Shdr
* sec
)
7760 unsigned long size
, nrelas
, i
;
7761 Elf_Internal_Phdr
* seg
;
7762 struct ia64_unw_table_entry
* tep
;
7763 Elf_Internal_Shdr
* relsec
;
7764 Elf_Internal_Rela
* rela
;
7765 Elf_Internal_Rela
* rp
;
7766 unsigned char * table
;
7768 Elf_Internal_Sym
* sym
;
7769 const char * relname
;
7773 /* First, find the starting address of the segment that includes
7776 if (filedata
->file_header
.e_phnum
)
7778 if (! get_program_headers (filedata
))
7781 for (seg
= filedata
->program_headers
;
7782 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7785 if (seg
->p_type
!= PT_LOAD
)
7788 if (sec
->sh_addr
>= seg
->p_vaddr
7789 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7791 aux
->seg_base
= seg
->p_vaddr
;
7797 /* Second, build the unwind table from the contents of the unwind section: */
7798 size
= sec
->sh_size
;
7799 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7804 aux
->table_len
= size
/ (3 * eh_addr_size
);
7805 aux
->table
= (struct ia64_unw_table_entry
*)
7806 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7809 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7811 tep
->start
.section
= SHN_UNDEF
;
7812 tep
->end
.section
= SHN_UNDEF
;
7813 tep
->info
.section
= SHN_UNDEF
;
7814 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7815 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7816 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7817 tep
->start
.offset
+= aux
->seg_base
;
7818 tep
->end
.offset
+= aux
->seg_base
;
7819 tep
->info
.offset
+= aux
->seg_base
;
7823 /* Third, apply any relocations to the unwind table: */
7824 for (relsec
= filedata
->section_headers
;
7825 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7828 if (relsec
->sh_type
!= SHT_RELA
7829 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7830 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7833 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7842 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7844 unsigned int sym_ndx
;
7845 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7846 relname
= elf_ia64_reloc_type (r_type
);
7848 /* PR 17531: file: 9fa67536. */
7849 if (relname
== NULL
)
7851 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7855 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7857 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7861 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7863 /* PR 17531: file: 5bc8d9bf. */
7864 if (i
>= aux
->table_len
)
7866 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7870 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7871 if (sym_ndx
>= aux
->nsyms
)
7873 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7877 sym
= aux
->symtab
+ sym_ndx
;
7879 switch (rp
->r_offset
/ eh_addr_size
% 3)
7882 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7883 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7886 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7887 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7890 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7891 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7905 ia64_process_unwind (Filedata
* filedata
)
7907 Elf_Internal_Shdr
* sec
;
7908 Elf_Internal_Shdr
* unwsec
= NULL
;
7909 unsigned long i
, unwcount
= 0, unwstart
= 0;
7910 struct ia64_unw_aux_info aux
;
7911 bfd_boolean res
= TRUE
;
7913 memset (& aux
, 0, sizeof (aux
));
7915 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7917 if (sec
->sh_type
== SHT_SYMTAB
)
7921 error (_("Multiple symbol tables encountered\n"));
7927 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7928 &aux
.strtab
, &aux
.strtab_size
))
7931 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7936 printf (_("\nThere are no unwind sections in this file.\n"));
7938 while (unwcount
-- > 0)
7943 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7944 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7945 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7950 /* We have already counted the number of SHT_IA64_UNWIND
7951 sections so the loop above should never fail. */
7952 assert (unwsec
!= NULL
);
7955 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7957 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7959 /* We need to find which section group it is in. */
7960 struct group_list
* g
;
7962 if (filedata
->section_headers_groups
== NULL
7963 || filedata
->section_headers_groups
[i
] == NULL
)
7964 i
= filedata
->file_header
.e_shnum
;
7967 g
= filedata
->section_headers_groups
[i
]->root
;
7969 for (; g
!= NULL
; g
= g
->next
)
7971 sec
= filedata
->section_headers
+ g
->section_index
;
7973 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7978 i
= filedata
->file_header
.e_shnum
;
7981 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7983 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7984 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7985 suffix
= SECTION_NAME (unwsec
) + len
;
7986 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7988 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7989 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7994 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7995 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7996 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7997 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7999 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
8000 suffix
= SECTION_NAME (unwsec
) + len
;
8001 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
8003 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
8004 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8008 if (i
== filedata
->file_header
.e_shnum
)
8010 printf (_("\nCould not find unwind info section for "));
8012 if (filedata
->string_table
== NULL
)
8013 printf ("%d", unwsec
->sh_name
);
8015 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8019 aux
.info_addr
= sec
->sh_addr
;
8020 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8023 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8025 printf (_("\nUnwind section "));
8027 if (filedata
->string_table
== NULL
)
8028 printf ("%d", unwsec
->sh_name
);
8030 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8032 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8033 (unsigned long) unwsec
->sh_offset
,
8034 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8036 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8037 && aux
.table_len
> 0)
8038 dump_ia64_unwind (filedata
, & aux
);
8041 free ((char *) aux
.table
);
8043 free ((char *) aux
.info
);
8052 free ((char *) aux
.strtab
);
8057 struct hppa_unw_table_entry
8059 struct absaddr start
;
8061 unsigned int Cannot_unwind
:1; /* 0 */
8062 unsigned int Millicode
:1; /* 1 */
8063 unsigned int Millicode_save_sr0
:1; /* 2 */
8064 unsigned int Region_description
:2; /* 3..4 */
8065 unsigned int reserved1
:1; /* 5 */
8066 unsigned int Entry_SR
:1; /* 6 */
8067 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8068 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8069 unsigned int Args_stored
:1; /* 16 */
8070 unsigned int Variable_Frame
:1; /* 17 */
8071 unsigned int Separate_Package_Body
:1; /* 18 */
8072 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8073 unsigned int Stack_Overflow_Check
:1; /* 20 */
8074 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8075 unsigned int Ada_Region
:1; /* 22 */
8076 unsigned int cxx_info
:1; /* 23 */
8077 unsigned int cxx_try_catch
:1; /* 24 */
8078 unsigned int sched_entry_seq
:1; /* 25 */
8079 unsigned int reserved2
:1; /* 26 */
8080 unsigned int Save_SP
:1; /* 27 */
8081 unsigned int Save_RP
:1; /* 28 */
8082 unsigned int Save_MRP_in_frame
:1; /* 29 */
8083 unsigned int extn_ptr_defined
:1; /* 30 */
8084 unsigned int Cleanup_defined
:1; /* 31 */
8086 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8087 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8088 unsigned int Large_frame
:1; /* 2 */
8089 unsigned int Pseudo_SP_Set
:1; /* 3 */
8090 unsigned int reserved4
:1; /* 4 */
8091 unsigned int Total_frame_size
:27; /* 5..31 */
8094 struct hppa_unw_aux_info
8096 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8097 unsigned long table_len
; /* Length of unwind table. */
8098 bfd_vma seg_base
; /* Starting address of segment. */
8099 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8100 unsigned long nsyms
; /* Number of symbols. */
8101 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8102 unsigned long nfuns
; /* Number of entries in funtab. */
8103 char * strtab
; /* The string table. */
8104 unsigned long strtab_size
; /* Size of string table. */
8108 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8110 struct hppa_unw_table_entry
* tp
;
8111 unsigned long j
, nfuns
;
8112 bfd_boolean res
= TRUE
;
8114 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8115 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8116 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8117 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8119 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8121 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8124 const char * procname
;
8126 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8127 aux
->strtab_size
, tp
->start
, &procname
,
8130 fputs ("\n<", stdout
);
8134 fputs (procname
, stdout
);
8137 printf ("+%lx", (unsigned long) offset
);
8140 fputs (">: [", stdout
);
8141 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8142 fputc ('-', stdout
);
8143 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8146 #define PF(_m) if (tp->_m) printf (#_m " ");
8147 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8150 PF(Millicode_save_sr0
);
8151 /* PV(Region_description); */
8157 PF(Separate_Package_Body
);
8158 PF(Frame_Extension_Millicode
);
8159 PF(Stack_Overflow_Check
);
8160 PF(Two_Instruction_SP_Increment
);
8164 PF(sched_entry_seq
);
8167 PF(Save_MRP_in_frame
);
8168 PF(extn_ptr_defined
);
8169 PF(Cleanup_defined
);
8170 PF(MPE_XL_interrupt_marker
);
8171 PF(HP_UX_interrupt_marker
);
8174 PV(Total_frame_size
);
8187 slurp_hppa_unwind_table (Filedata
* filedata
,
8188 struct hppa_unw_aux_info
* aux
,
8189 Elf_Internal_Shdr
* sec
)
8191 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8192 Elf_Internal_Phdr
* seg
;
8193 struct hppa_unw_table_entry
* tep
;
8194 Elf_Internal_Shdr
* relsec
;
8195 Elf_Internal_Rela
* rela
;
8196 Elf_Internal_Rela
* rp
;
8197 unsigned char * table
;
8199 Elf_Internal_Sym
* sym
;
8200 const char * relname
;
8202 /* First, find the starting address of the segment that includes
8204 if (filedata
->file_header
.e_phnum
)
8206 if (! get_program_headers (filedata
))
8209 for (seg
= filedata
->program_headers
;
8210 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8213 if (seg
->p_type
!= PT_LOAD
)
8216 if (sec
->sh_addr
>= seg
->p_vaddr
8217 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8219 aux
->seg_base
= seg
->p_vaddr
;
8225 /* Second, build the unwind table from the contents of the unwind
8227 size
= sec
->sh_size
;
8228 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8234 nentries
= size
/ unw_ent_size
;
8235 size
= unw_ent_size
* nentries
;
8237 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8238 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8240 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8242 unsigned int tmp1
, tmp2
;
8244 tep
->start
.section
= SHN_UNDEF
;
8245 tep
->end
.section
= SHN_UNDEF
;
8247 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8248 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8249 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8250 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8252 tep
->start
.offset
+= aux
->seg_base
;
8253 tep
->end
.offset
+= aux
->seg_base
;
8255 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8256 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8257 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8258 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8259 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8260 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8261 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8262 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8263 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8264 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8265 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8266 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8267 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8268 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8269 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8270 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8271 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8272 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8273 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8274 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8275 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8276 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8277 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8278 tep
->Cleanup_defined
= tmp1
& 0x1;
8280 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8281 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8282 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8283 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8284 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8285 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8289 /* Third, apply any relocations to the unwind table. */
8290 for (relsec
= filedata
->section_headers
;
8291 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8294 if (relsec
->sh_type
!= SHT_RELA
8295 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8296 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8299 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8303 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8305 unsigned int sym_ndx
;
8306 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8307 relname
= elf_hppa_reloc_type (r_type
);
8309 if (relname
== NULL
)
8311 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8315 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8316 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8318 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8322 i
= rp
->r_offset
/ unw_ent_size
;
8323 if (i
>= aux
->table_len
)
8325 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8329 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8330 if (sym_ndx
>= aux
->nsyms
)
8332 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8336 sym
= aux
->symtab
+ sym_ndx
;
8338 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8341 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8342 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8345 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8346 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8356 aux
->table_len
= nentries
;
8362 hppa_process_unwind (Filedata
* filedata
)
8364 struct hppa_unw_aux_info aux
;
8365 Elf_Internal_Shdr
* unwsec
= NULL
;
8366 Elf_Internal_Shdr
* sec
;
8368 bfd_boolean res
= TRUE
;
8370 if (filedata
->string_table
== NULL
)
8373 memset (& aux
, 0, sizeof (aux
));
8375 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8377 if (sec
->sh_type
== SHT_SYMTAB
)
8381 error (_("Multiple symbol tables encountered\n"));
8387 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8388 &aux
.strtab
, &aux
.strtab_size
))
8391 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8396 printf (_("\nThere are no unwind sections in this file.\n"));
8398 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8400 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8402 unsigned long num_unwind
= sec
->sh_size
/ 16;
8404 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8405 "contains %lu entry:\n",
8406 "\nUnwind section '%s' at offset 0x%lx "
8407 "contains %lu entries:\n",
8409 printable_section_name (filedata
, sec
),
8410 (unsigned long) sec
->sh_offset
,
8413 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8416 if (res
&& aux
.table_len
> 0)
8418 if (! dump_hppa_unwind (filedata
, &aux
))
8423 free ((char *) aux
.table
);
8431 free ((char *) aux
.strtab
);
8438 unsigned char * data
; /* The unwind data. */
8439 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8440 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8441 unsigned long nrelas
; /* The number of relocations. */
8442 unsigned int rel_type
; /* REL or RELA ? */
8443 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8446 struct arm_unw_aux_info
8448 Filedata
* filedata
; /* The file containing the unwind sections. */
8449 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8450 unsigned long nsyms
; /* Number of symbols. */
8451 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8452 unsigned long nfuns
; /* Number of these symbols. */
8453 char * strtab
; /* The file's string table. */
8454 unsigned long strtab_size
; /* Size of string table. */
8458 arm_print_vma_and_name (Filedata
* filedata
,
8459 struct arm_unw_aux_info
* aux
,
8461 struct absaddr addr
)
8463 const char *procname
;
8466 if (addr
.section
== SHN_UNDEF
)
8469 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8470 aux
->strtab_size
, addr
, &procname
,
8473 print_vma (fn
, PREFIX_HEX
);
8477 fputs (" <", stdout
);
8478 fputs (procname
, stdout
);
8481 printf ("+0x%lx", (unsigned long) sym_offset
);
8482 fputc ('>', stdout
);
8489 arm_free_section (struct arm_section
*arm_sec
)
8491 if (arm_sec
->data
!= NULL
)
8492 free (arm_sec
->data
);
8494 if (arm_sec
->rela
!= NULL
)
8495 free (arm_sec
->rela
);
8498 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8499 cached section and install SEC instead.
8500 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8501 and return its valued in * WORDP, relocating if necessary.
8502 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8503 relocation's offset in ADDR.
8504 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8505 into the string table of the symbol associated with the reloc. If no
8506 reloc was applied store -1 there.
8507 5) Return TRUE upon success, FALSE otherwise. */
8510 get_unwind_section_word (Filedata
* filedata
,
8511 struct arm_unw_aux_info
* aux
,
8512 struct arm_section
* arm_sec
,
8513 Elf_Internal_Shdr
* sec
,
8514 bfd_vma word_offset
,
8515 unsigned int * wordp
,
8516 struct absaddr
* addr
,
8519 Elf_Internal_Rela
*rp
;
8520 Elf_Internal_Sym
*sym
;
8521 const char * relname
;
8523 bfd_boolean wrapped
;
8525 if (sec
== NULL
|| arm_sec
== NULL
)
8528 addr
->section
= SHN_UNDEF
;
8531 if (sym_name
!= NULL
)
8532 *sym_name
= (bfd_vma
) -1;
8534 /* If necessary, update the section cache. */
8535 if (sec
!= arm_sec
->sec
)
8537 Elf_Internal_Shdr
*relsec
;
8539 arm_free_section (arm_sec
);
8542 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8543 sec
->sh_size
, _("unwind data"));
8544 arm_sec
->rela
= NULL
;
8545 arm_sec
->nrelas
= 0;
8547 for (relsec
= filedata
->section_headers
;
8548 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8551 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8552 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8553 /* PR 15745: Check the section type as well. */
8554 || (relsec
->sh_type
!= SHT_REL
8555 && relsec
->sh_type
!= SHT_RELA
))
8558 arm_sec
->rel_type
= relsec
->sh_type
;
8559 if (relsec
->sh_type
== SHT_REL
)
8561 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8563 & arm_sec
->rela
, & arm_sec
->nrelas
))
8566 else /* relsec->sh_type == SHT_RELA */
8568 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8570 & arm_sec
->rela
, & arm_sec
->nrelas
))
8576 arm_sec
->next_rela
= arm_sec
->rela
;
8579 /* If there is no unwind data we can do nothing. */
8580 if (arm_sec
->data
== NULL
)
8583 /* If the offset is invalid then fail. */
8584 if (/* PR 21343 *//* PR 18879 */
8586 || word_offset
> (sec
->sh_size
- 4)
8587 || ((bfd_signed_vma
) word_offset
) < 0)
8590 /* Get the word at the required offset. */
8591 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8593 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8594 if (arm_sec
->rela
== NULL
)
8600 /* Look through the relocs to find the one that applies to the provided offset. */
8602 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8604 bfd_vma prelval
, offset
;
8606 if (rp
->r_offset
> word_offset
&& !wrapped
)
8611 if (rp
->r_offset
> word_offset
)
8614 if (rp
->r_offset
& 3)
8616 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8617 (unsigned long) rp
->r_offset
);
8621 if (rp
->r_offset
< word_offset
)
8624 /* PR 17531: file: 027-161405-0.004 */
8625 if (aux
->symtab
== NULL
)
8628 if (arm_sec
->rel_type
== SHT_REL
)
8630 offset
= word
& 0x7fffffff;
8631 if (offset
& 0x40000000)
8632 offset
|= ~ (bfd_vma
) 0x7fffffff;
8634 else if (arm_sec
->rel_type
== SHT_RELA
)
8635 offset
= rp
->r_addend
;
8638 error (_("Unknown section relocation type %d encountered\n"),
8643 /* PR 17531 file: 027-1241568-0.004. */
8644 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8646 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8647 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8651 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8652 offset
+= sym
->st_value
;
8653 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8655 /* Check that we are processing the expected reloc type. */
8656 if (filedata
->file_header
.e_machine
== EM_ARM
)
8658 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8659 if (relname
== NULL
)
8661 warn (_("Skipping unknown ARM relocation type: %d\n"),
8662 (int) ELF32_R_TYPE (rp
->r_info
));
8666 if (streq (relname
, "R_ARM_NONE"))
8669 if (! streq (relname
, "R_ARM_PREL31"))
8671 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8675 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8677 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8678 if (relname
== NULL
)
8680 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8681 (int) ELF32_R_TYPE (rp
->r_info
));
8685 if (streq (relname
, "R_C6000_NONE"))
8688 if (! streq (relname
, "R_C6000_PREL31"))
8690 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8698 /* This function currently only supports ARM and TI unwinders. */
8699 warn (_("Only TI and ARM unwinders are currently supported\n"));
8703 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8704 addr
->section
= sym
->st_shndx
;
8705 addr
->offset
= offset
;
8708 * sym_name
= sym
->st_name
;
8713 arm_sec
->next_rela
= rp
;
8718 static const char *tic6x_unwind_regnames
[16] =
8720 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8721 "A14", "A13", "A12", "A11", "A10",
8722 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8726 decode_tic6x_unwind_regmask (unsigned int mask
)
8730 for (i
= 12; mask
; mask
>>= 1, i
--)
8734 fputs (tic6x_unwind_regnames
[i
], stdout
);
8736 fputs (", ", stdout
);
8742 if (remaining == 0 && more_words) \
8745 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8746 data_offset, & word, & addr, NULL)) \
8752 #define GET_OP(OP) \
8757 (OP) = word >> 24; \
8762 printf (_("[Truncated opcode]\n")); \
8765 printf ("0x%02x ", OP)
8768 decode_arm_unwind_bytecode (Filedata
* filedata
,
8769 struct arm_unw_aux_info
* aux
,
8771 unsigned int remaining
,
8772 unsigned int more_words
,
8773 bfd_vma data_offset
,
8774 Elf_Internal_Shdr
* data_sec
,
8775 struct arm_section
* data_arm_sec
)
8777 struct absaddr addr
;
8778 bfd_boolean res
= TRUE
;
8780 /* Decode the unwinding instructions. */
8783 unsigned int op
, op2
;
8792 printf (" 0x%02x ", op
);
8794 if ((op
& 0xc0) == 0x00)
8796 int offset
= ((op
& 0x3f) << 2) + 4;
8798 printf (" vsp = vsp + %d", offset
);
8800 else if ((op
& 0xc0) == 0x40)
8802 int offset
= ((op
& 0x3f) << 2) + 4;
8804 printf (" vsp = vsp - %d", offset
);
8806 else if ((op
& 0xf0) == 0x80)
8809 if (op
== 0x80 && op2
== 0)
8810 printf (_("Refuse to unwind"));
8813 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8814 bfd_boolean first
= TRUE
;
8818 for (i
= 0; i
< 12; i
++)
8819 if (mask
& (1 << i
))
8825 printf ("r%d", 4 + i
);
8830 else if ((op
& 0xf0) == 0x90)
8832 if (op
== 0x9d || op
== 0x9f)
8833 printf (_(" [Reserved]"));
8835 printf (" vsp = r%d", op
& 0x0f);
8837 else if ((op
& 0xf0) == 0xa0)
8839 int end
= 4 + (op
& 0x07);
8840 bfd_boolean first
= TRUE
;
8844 for (i
= 4; i
<= end
; i
++)
8860 else if (op
== 0xb0)
8861 printf (_(" finish"));
8862 else if (op
== 0xb1)
8865 if (op2
== 0 || (op2
& 0xf0) != 0)
8866 printf (_("[Spare]"));
8869 unsigned int mask
= op2
& 0x0f;
8870 bfd_boolean first
= TRUE
;
8874 for (i
= 0; i
< 12; i
++)
8875 if (mask
& (1 << i
))
8886 else if (op
== 0xb2)
8888 unsigned char buf
[9];
8889 unsigned int i
, len
;
8890 unsigned long offset
;
8892 for (i
= 0; i
< sizeof (buf
); i
++)
8895 if ((buf
[i
] & 0x80) == 0)
8898 if (i
== sizeof (buf
))
8900 error (_("corrupt change to vsp\n"));
8905 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8906 assert (len
== i
+ 1);
8907 offset
= offset
* 4 + 0x204;
8908 printf ("vsp = vsp + %ld", offset
);
8911 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8913 unsigned int first
, last
;
8920 printf ("pop {D%d", first
);
8922 printf ("-D%d", first
+ last
);
8925 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8927 unsigned int count
= op
& 0x07;
8931 printf ("-D%d", 8 + count
);
8934 else if (op
>= 0xc0 && op
<= 0xc5)
8936 unsigned int count
= op
& 0x07;
8938 printf (" pop {wR10");
8940 printf ("-wR%d", 10 + count
);
8943 else if (op
== 0xc6)
8945 unsigned int first
, last
;
8950 printf ("pop {wR%d", first
);
8952 printf ("-wR%d", first
+ last
);
8955 else if (op
== 0xc7)
8958 if (op2
== 0 || (op2
& 0xf0) != 0)
8959 printf (_("[Spare]"));
8962 unsigned int mask
= op2
& 0x0f;
8963 bfd_boolean first
= TRUE
;
8967 for (i
= 0; i
< 4; i
++)
8968 if (mask
& (1 << i
))
8974 printf ("wCGR%d", i
);
8981 printf (_(" [unsupported opcode]"));
8992 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8993 struct arm_unw_aux_info
* aux
,
8995 unsigned int remaining
,
8996 unsigned int more_words
,
8997 bfd_vma data_offset
,
8998 Elf_Internal_Shdr
* data_sec
,
8999 struct arm_section
* data_arm_sec
)
9001 struct absaddr addr
;
9003 /* Decode the unwinding instructions. */
9006 unsigned int op
, op2
;
9015 printf (" 0x%02x ", op
);
9017 if ((op
& 0xc0) == 0x00)
9019 int offset
= ((op
& 0x3f) << 3) + 8;
9020 printf (" sp = sp + %d", offset
);
9022 else if ((op
& 0xc0) == 0x80)
9025 if (op
== 0x80 && op2
== 0)
9026 printf (_("Refuse to unwind"));
9029 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9031 printf ("pop compact {");
9035 decode_tic6x_unwind_regmask (mask
);
9039 else if ((op
& 0xf0) == 0xc0)
9047 unsigned int offset
;
9051 /* Scan entire instruction first so that GET_OP output is not
9052 interleaved with disassembly. */
9054 for (i
= 0; nregs
< (op
& 0xf); i
++)
9060 regpos
[nregs
].offset
= i
* 2;
9061 regpos
[nregs
].reg
= reg
;
9068 regpos
[nregs
].offset
= i
* 2 + 1;
9069 regpos
[nregs
].reg
= reg
;
9074 printf (_("pop frame {"));
9077 printf (_("*corrupt* - no registers specified"));
9082 for (i
= i
* 2; i
> 0; i
--)
9084 if (regpos
[reg
].offset
== i
- 1)
9086 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9093 fputs (name
, stdout
);
9101 else if (op
== 0xd0)
9102 printf (" MOV FP, SP");
9103 else if (op
== 0xd1)
9104 printf (" __c6xabi_pop_rts");
9105 else if (op
== 0xd2)
9107 unsigned char buf
[9];
9108 unsigned int i
, len
;
9109 unsigned long offset
;
9111 for (i
= 0; i
< sizeof (buf
); i
++)
9114 if ((buf
[i
] & 0x80) == 0)
9117 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9118 if (i
== sizeof (buf
))
9120 warn (_("Corrupt stack pointer adjustment detected\n"));
9124 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9125 assert (len
== i
+ 1);
9126 offset
= offset
* 8 + 0x408;
9127 printf (_("sp = sp + %ld"), offset
);
9129 else if ((op
& 0xf0) == 0xe0)
9131 if ((op
& 0x0f) == 7)
9134 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9138 printf (_(" [unsupported opcode]"));
9147 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9151 offset
= word
& 0x7fffffff;
9152 if (offset
& 0x40000000)
9153 offset
|= ~ (bfd_vma
) 0x7fffffff;
9155 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9158 return offset
+ where
;
9162 decode_arm_unwind (Filedata
* filedata
,
9163 struct arm_unw_aux_info
* aux
,
9165 unsigned int remaining
,
9166 bfd_vma data_offset
,
9167 Elf_Internal_Shdr
* data_sec
,
9168 struct arm_section
* data_arm_sec
)
9171 unsigned int more_words
= 0;
9172 struct absaddr addr
;
9173 bfd_vma sym_name
= (bfd_vma
) -1;
9174 bfd_boolean res
= TRUE
;
9178 /* Fetch the first word.
9179 Note - when decoding an object file the address extracted
9180 here will always be 0. So we also pass in the sym_name
9181 parameter so that we can find the symbol associated with
9182 the personality routine. */
9183 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9184 & word
, & addr
, & sym_name
))
9191 addr
.section
= SHN_UNDEF
;
9195 if ((word
& 0x80000000) == 0)
9197 /* Expand prel31 for personality routine. */
9199 const char *procname
;
9201 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9202 printf (_(" Personality routine: "));
9204 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9205 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9207 procname
= aux
->strtab
+ sym_name
;
9208 print_vma (fn
, PREFIX_HEX
);
9211 fputs (" <", stdout
);
9212 fputs (procname
, stdout
);
9213 fputc ('>', stdout
);
9217 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9218 fputc ('\n', stdout
);
9220 /* The GCC personality routines use the standard compact
9221 encoding, starting with one byte giving the number of
9223 if (procname
!= NULL
9224 && (const_strneq (procname
, "__gcc_personality_v0")
9225 || const_strneq (procname
, "__gxx_personality_v0")
9226 || const_strneq (procname
, "__gcj_personality_v0")
9227 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9234 printf (_(" [Truncated data]\n"));
9237 more_words
= word
>> 24;
9247 /* ARM EHABI Section 6.3:
9249 An exception-handling table entry for the compact model looks like:
9253 1 0 index Data for personalityRoutine[index] */
9255 if (filedata
->file_header
.e_machine
== EM_ARM
9256 && (word
& 0x70000000))
9258 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9262 per_index
= (word
>> 24) & 0x7f;
9263 printf (_(" Compact model index: %d\n"), per_index
);
9270 else if (per_index
< 3)
9272 more_words
= (word
>> 16) & 0xff;
9278 switch (filedata
->file_header
.e_machine
)
9283 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9284 data_offset
, data_sec
, data_arm_sec
))
9289 warn (_("Unknown ARM compact model index encountered\n"));
9290 printf (_(" [reserved]\n"));
9298 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9299 data_offset
, data_sec
, data_arm_sec
))
9302 else if (per_index
< 5)
9304 if (((word
>> 17) & 0x7f) == 0x7f)
9305 printf (_(" Restore stack from frame pointer\n"));
9307 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9308 printf (_(" Registers restored: "));
9310 printf (" (compact) ");
9311 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9313 printf (_(" Return register: %s\n"),
9314 tic6x_unwind_regnames
[word
& 0xf]);
9317 printf (_(" [reserved (%d)]\n"), per_index
);
9321 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9322 filedata
->file_header
.e_machine
);
9326 /* Decode the descriptors. Not implemented. */
9332 dump_arm_unwind (Filedata
* filedata
,
9333 struct arm_unw_aux_info
* aux
,
9334 Elf_Internal_Shdr
* exidx_sec
)
9336 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9337 unsigned int i
, exidx_len
;
9338 unsigned long j
, nfuns
;
9339 bfd_boolean res
= TRUE
;
9341 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9342 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9343 exidx_len
= exidx_sec
->sh_size
/ 8;
9345 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9346 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9347 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9348 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9350 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9352 for (i
= 0; i
< exidx_len
; i
++)
9354 unsigned int exidx_fn
, exidx_entry
;
9355 struct absaddr fn_addr
, entry_addr
;
9358 fputc ('\n', stdout
);
9360 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9361 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9362 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9363 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9366 arm_free_section (& exidx_arm_sec
);
9367 arm_free_section (& extab_arm_sec
);
9371 /* ARM EHABI, Section 5:
9372 An index table entry consists of 2 words.
9373 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9374 if (exidx_fn
& 0x80000000)
9376 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9380 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9382 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9383 fputs (": ", stdout
);
9385 if (exidx_entry
== 1)
9387 print_vma (exidx_entry
, PREFIX_HEX
);
9388 fputs (" [cantunwind]\n", stdout
);
9390 else if (exidx_entry
& 0x80000000)
9392 print_vma (exidx_entry
, PREFIX_HEX
);
9393 fputc ('\n', stdout
);
9394 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9398 bfd_vma table
, table_offset
= 0;
9399 Elf_Internal_Shdr
*table_sec
;
9401 fputs ("@", stdout
);
9402 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9403 print_vma (table
, PREFIX_HEX
);
9406 /* Locate the matching .ARM.extab. */
9407 if (entry_addr
.section
!= SHN_UNDEF
9408 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9410 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9411 table_offset
= entry_addr
.offset
;
9413 if (table_offset
> table_sec
->sh_size
9414 || ((bfd_signed_vma
) table_offset
) < 0)
9416 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9417 (unsigned long) table_offset
,
9418 printable_section_name (filedata
, table_sec
));
9425 table_sec
= find_section_by_address (filedata
, table
);
9426 if (table_sec
!= NULL
)
9427 table_offset
= table
- table_sec
->sh_addr
;
9430 if (table_sec
== NULL
)
9432 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9433 (unsigned long) table
);
9438 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9447 arm_free_section (&exidx_arm_sec
);
9448 arm_free_section (&extab_arm_sec
);
9453 /* Used for both ARM and C6X unwinding tables. */
9456 arm_process_unwind (Filedata
* filedata
)
9458 struct arm_unw_aux_info aux
;
9459 Elf_Internal_Shdr
*unwsec
= NULL
;
9460 Elf_Internal_Shdr
*sec
;
9462 unsigned int sec_type
;
9463 bfd_boolean res
= TRUE
;
9465 switch (filedata
->file_header
.e_machine
)
9468 sec_type
= SHT_ARM_EXIDX
;
9472 sec_type
= SHT_C6000_UNWIND
;
9476 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9477 filedata
->file_header
.e_machine
);
9481 if (filedata
->string_table
== NULL
)
9484 memset (& aux
, 0, sizeof (aux
));
9485 aux
.filedata
= filedata
;
9487 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9489 if (sec
->sh_type
== SHT_SYMTAB
)
9493 error (_("Multiple symbol tables encountered\n"));
9499 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9500 &aux
.strtab
, &aux
.strtab_size
))
9503 else if (sec
->sh_type
== sec_type
)
9508 printf (_("\nThere are no unwind sections in this file.\n"));
9510 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9512 if (sec
->sh_type
== sec_type
)
9514 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9515 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9516 "contains %lu entry:\n",
9517 "\nUnwind section '%s' at offset 0x%lx "
9518 "contains %lu entries:\n",
9520 printable_section_name (filedata
, sec
),
9521 (unsigned long) sec
->sh_offset
,
9524 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9532 free ((char *) aux
.strtab
);
9538 process_unwind (Filedata
* filedata
)
9540 struct unwind_handler
9542 unsigned int machtype
;
9543 bfd_boolean (* handler
)(Filedata
*);
9546 { EM_ARM
, arm_process_unwind
},
9547 { EM_IA_64
, ia64_process_unwind
},
9548 { EM_PARISC
, hppa_process_unwind
},
9549 { EM_TI_C6000
, arm_process_unwind
},
9557 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9558 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9559 return handlers
[i
].handler (filedata
);
9561 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9562 get_machine_name (filedata
->file_header
.e_machine
));
9567 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9569 switch (entry
->d_tag
)
9571 case DT_AARCH64_BTI_PLT
:
9572 case DT_AARCH64_PAC_PLT
:
9575 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9582 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9584 switch (entry
->d_tag
)
9587 if (entry
->d_un
.d_val
== 0)
9591 static const char * opts
[] =
9593 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9594 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9595 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9596 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9600 bfd_boolean first
= TRUE
;
9602 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9603 if (entry
->d_un
.d_val
& (1 << cnt
))
9605 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9611 case DT_MIPS_IVERSION
:
9612 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9613 printf (_("Interface Version: %s"),
9614 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9618 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9619 /* Note: coded this way so that there is a single string for translation. */
9620 printf (_("<corrupt: %s>"), buf
);
9624 case DT_MIPS_TIME_STAMP
:
9628 time_t atime
= entry
->d_un
.d_val
;
9630 tmp
= gmtime (&atime
);
9631 /* PR 17531: file: 6accc532. */
9633 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9635 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9636 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9637 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9638 printf (_("Time Stamp: %s"), timebuf
);
9642 case DT_MIPS_RLD_VERSION
:
9643 case DT_MIPS_LOCAL_GOTNO
:
9644 case DT_MIPS_CONFLICTNO
:
9645 case DT_MIPS_LIBLISTNO
:
9646 case DT_MIPS_SYMTABNO
:
9647 case DT_MIPS_UNREFEXTNO
:
9648 case DT_MIPS_HIPAGENO
:
9649 case DT_MIPS_DELTA_CLASS_NO
:
9650 case DT_MIPS_DELTA_INSTANCE_NO
:
9651 case DT_MIPS_DELTA_RELOC_NO
:
9652 case DT_MIPS_DELTA_SYM_NO
:
9653 case DT_MIPS_DELTA_CLASSSYM_NO
:
9654 case DT_MIPS_COMPACT_SIZE
:
9655 print_vma (entry
->d_un
.d_val
, DEC
);
9659 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9660 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9661 /* Falls through. */
9664 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9670 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9672 switch (entry
->d_tag
)
9674 case DT_HP_DLD_FLAGS
:
9683 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9684 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9685 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9686 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9687 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9688 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9689 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9690 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9691 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9692 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9693 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9694 { DT_HP_GST
, "HP_GST" },
9695 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9696 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9697 { DT_HP_NODELETE
, "HP_NODELETE" },
9698 { DT_HP_GROUP
, "HP_GROUP" },
9699 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9701 bfd_boolean first
= TRUE
;
9703 bfd_vma val
= entry
->d_un
.d_val
;
9705 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9706 if (val
& flags
[cnt
].bit
)
9710 fputs (flags
[cnt
].str
, stdout
);
9712 val
^= flags
[cnt
].bit
;
9715 if (val
!= 0 || first
)
9719 print_vma (val
, HEX
);
9725 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9733 /* VMS vs Unix time offset and factor. */
9735 #define VMS_EPOCH_OFFSET 35067168000000000LL
9736 #define VMS_GRANULARITY_FACTOR 10000000
9738 /* Display a VMS time in a human readable format. */
9741 print_vms_time (bfd_int64_t vmstime
)
9746 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9747 tm
= gmtime (&unxtime
);
9748 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9749 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9750 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9755 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9757 switch (entry
->d_tag
)
9759 case DT_IA_64_PLT_RESERVE
:
9760 /* First 3 slots reserved. */
9761 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9763 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9766 case DT_IA_64_VMS_LINKTIME
:
9768 print_vms_time (entry
->d_un
.d_val
);
9772 case DT_IA_64_VMS_LNKFLAGS
:
9773 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9774 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9775 printf (" CALL_DEBUG");
9776 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9777 printf (" NOP0BUFS");
9778 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9779 printf (" P0IMAGE");
9780 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9781 printf (" MKTHREADS");
9782 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9783 printf (" UPCALLS");
9784 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9786 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9787 printf (" INITIALIZE");
9788 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9790 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9791 printf (" EXE_INIT");
9792 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9793 printf (" TBK_IN_IMG");
9794 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9795 printf (" DBG_IN_IMG");
9796 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9797 printf (" TBK_IN_DSF");
9798 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9799 printf (" DBG_IN_DSF");
9800 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9801 printf (" SIGNATURES");
9802 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9803 printf (" REL_SEG_OFF");
9807 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9814 get_32bit_dynamic_section (Filedata
* filedata
)
9816 Elf32_External_Dyn
* edyn
;
9817 Elf32_External_Dyn
* ext
;
9818 Elf_Internal_Dyn
* entry
;
9820 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9821 filedata
->dynamic_addr
, 1,
9822 filedata
->dynamic_size
,
9823 _("dynamic section"));
9827 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9828 might not have the luxury of section headers. Look for the DT_NULL
9829 terminator to determine the number of entries. */
9830 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9831 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9834 filedata
->dynamic_nent
++;
9835 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9839 filedata
->dynamic_section
9840 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9841 if (filedata
->dynamic_section
== NULL
)
9843 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9844 (unsigned long) filedata
->dynamic_nent
);
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 get_64bit_dynamic_section (Filedata
* filedata
)
9865 Elf64_External_Dyn
* edyn
;
9866 Elf64_External_Dyn
* ext
;
9867 Elf_Internal_Dyn
* entry
;
9869 /* Read in the data. */
9870 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9871 filedata
->dynamic_addr
, 1,
9872 filedata
->dynamic_size
,
9873 _("dynamic section"));
9877 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9878 might not have the luxury of section headers. Look for the DT_NULL
9879 terminator to determine the number of entries. */
9880 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9881 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9882 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9885 filedata
->dynamic_nent
++;
9886 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9890 filedata
->dynamic_section
9891 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9892 if (filedata
->dynamic_section
== NULL
)
9894 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9895 (unsigned long) filedata
->dynamic_nent
);
9900 /* Convert from external to internal formats. */
9901 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9902 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9905 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9906 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9915 print_dynamic_flags (bfd_vma flags
)
9917 bfd_boolean first
= TRUE
;
9923 flag
= flags
& - flags
;
9933 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9934 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9935 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9936 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9937 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9938 default: fputs (_("unknown"), stdout
); break;
9945 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9947 unsigned char * e_data
;
9950 /* If the size_t type is smaller than the bfd_size_type, eg because
9951 you are building a 32-bit tool on a 64-bit host, then make sure
9952 that when (number) is cast to (size_t) no information is lost. */
9953 if (sizeof (size_t) < sizeof (bfd_size_type
)
9954 && (bfd_size_type
) ((size_t) number
) != number
)
9956 error (_("Size truncation prevents reading %s elements of size %u\n"),
9957 bfd_vmatoa ("u", number
), ent_size
);
9961 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9962 attempting to allocate memory when the read is bound to fail. */
9963 if (ent_size
* number
> filedata
->file_size
)
9965 error (_("Invalid number of dynamic entries: %s\n"),
9966 bfd_vmatoa ("u", number
));
9970 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9973 error (_("Out of memory reading %s dynamic entries\n"),
9974 bfd_vmatoa ("u", number
));
9978 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9980 error (_("Unable to read in %s bytes of dynamic data\n"),
9981 bfd_vmatoa ("u", number
* ent_size
));
9986 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
9989 error (_("Out of memory allocating space for %s dynamic entries\n"),
9990 bfd_vmatoa ("u", number
));
9996 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10003 static unsigned long
10004 get_num_dynamic_syms (Filedata
* filedata
)
10006 unsigned long num_of_syms
= 0;
10008 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10009 return num_of_syms
;
10011 if (filedata
->dynamic_info
[DT_HASH
])
10013 unsigned char nb
[8];
10014 unsigned char nc
[8];
10015 unsigned int hash_ent_size
= 4;
10017 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10018 || filedata
->file_header
.e_machine
== EM_S390
10019 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10020 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10023 if (fseek (filedata
->handle
,
10024 (filedata
->archive_file_offset
10025 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10026 sizeof nb
+ sizeof nc
)),
10029 error (_("Unable to seek to start of dynamic information\n"));
10033 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10035 error (_("Failed to read in number of buckets\n"));
10039 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10041 error (_("Failed to read in number of chains\n"));
10045 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10046 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10048 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10050 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10052 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10055 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10056 num_of_syms
= filedata
->nchains
;
10059 if (num_of_syms
== 0)
10061 if (filedata
->buckets
)
10063 free (filedata
->buckets
);
10064 filedata
->buckets
= NULL
;
10066 if (filedata
->chains
)
10068 free (filedata
->chains
);
10069 filedata
->chains
= NULL
;
10071 filedata
->nbuckets
= 0;
10075 if (filedata
->dynamic_info_DT_GNU_HASH
)
10077 unsigned char nb
[16];
10078 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10079 bfd_vma buckets_vma
;
10082 if (fseek (filedata
->handle
,
10083 (filedata
->archive_file_offset
10084 + offset_from_vma (filedata
,
10085 filedata
->dynamic_info_DT_GNU_HASH
,
10089 error (_("Unable to seek to start of dynamic information\n"));
10093 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10095 error (_("Failed to read in number of buckets\n"));
10099 filedata
->ngnubuckets
= byte_get (nb
, 4);
10100 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10101 bitmaskwords
= byte_get (nb
+ 8, 4);
10102 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10104 buckets_vma
+= bitmaskwords
* 4;
10106 buckets_vma
+= bitmaskwords
* 8;
10108 if (fseek (filedata
->handle
,
10109 (filedata
->archive_file_offset
10110 + offset_from_vma (filedata
, buckets_vma
, 4)),
10113 error (_("Unable to seek to start of dynamic information\n"));
10117 filedata
->gnubuckets
10118 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10120 if (filedata
->gnubuckets
== NULL
)
10123 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10124 if (filedata
->gnubuckets
[i
] != 0)
10126 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10129 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10130 maxchain
= filedata
->gnubuckets
[i
];
10133 if (maxchain
== 0xffffffff)
10136 maxchain
-= filedata
->gnusymidx
;
10138 if (fseek (filedata
->handle
,
10139 (filedata
->archive_file_offset
10140 + offset_from_vma (filedata
,
10141 buckets_vma
+ 4 * (filedata
->ngnubuckets
10146 error (_("Unable to seek to start of dynamic information\n"));
10152 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10154 error (_("Failed to determine last chain length\n"));
10158 if (maxchain
+ 1 == 0)
10163 while ((byte_get (nb
, 4) & 1) == 0);
10165 if (fseek (filedata
->handle
,
10166 (filedata
->archive_file_offset
10167 + offset_from_vma (filedata
, (buckets_vma
10168 + 4 * filedata
->ngnubuckets
),
10172 error (_("Unable to seek to start of dynamic information\n"));
10176 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10177 filedata
->ngnuchains
= maxchain
;
10179 if (filedata
->gnuchains
== NULL
)
10182 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10184 if (fseek (filedata
->handle
,
10185 (filedata
->archive_file_offset
10186 + offset_from_vma (filedata
, (buckets_vma
10187 + 4 * (filedata
->ngnubuckets
10191 error (_("Unable to seek to start of dynamic information\n"));
10195 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10196 if (filedata
->mipsxlat
== NULL
)
10200 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10201 if (filedata
->gnubuckets
[hn
] != 0)
10203 bfd_vma si
= filedata
->gnubuckets
[hn
];
10204 bfd_vma off
= si
- filedata
->gnusymidx
;
10208 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10210 if (filedata
->mipsxlat
[off
] >= num_of_syms
)
10211 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10215 if (si
>= num_of_syms
)
10216 num_of_syms
= si
+ 1;
10220 while (off
< filedata
->ngnuchains
10221 && (filedata
->gnuchains
[off
++] & 1) == 0);
10224 if (num_of_syms
== 0)
10227 if (filedata
->mipsxlat
)
10229 free (filedata
->mipsxlat
);
10230 filedata
->mipsxlat
= NULL
;
10232 if (filedata
->gnuchains
)
10234 free (filedata
->gnuchains
);
10235 filedata
->gnuchains
= NULL
;
10237 if (filedata
->gnubuckets
)
10239 free (filedata
->gnubuckets
);
10240 filedata
->gnubuckets
= NULL
;
10242 filedata
->ngnubuckets
= 0;
10243 filedata
->ngnuchains
= 0;
10247 return num_of_syms
;
10250 /* Parse and display the contents of the dynamic section. */
10253 process_dynamic_section (Filedata
* filedata
)
10255 Elf_Internal_Dyn
* entry
;
10257 if (filedata
->dynamic_size
== 0)
10260 printf (_("\nThere is no dynamic section in this file.\n"));
10267 if (! get_32bit_dynamic_section (filedata
))
10272 if (! get_64bit_dynamic_section (filedata
))
10276 /* Find the appropriate symbol table. */
10277 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10279 unsigned long num_of_syms
;
10281 for (entry
= filedata
->dynamic_section
;
10282 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10284 if (entry
->d_tag
== DT_SYMTAB
)
10285 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10286 else if (entry
->d_tag
== DT_SYMENT
)
10287 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10288 else if (entry
->d_tag
== DT_HASH
)
10289 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10290 else if (entry
->d_tag
== DT_GNU_HASH
)
10291 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10292 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10293 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10294 && entry
->d_tag
== DT_MIPS_XHASH
)
10296 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10297 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10300 num_of_syms
= get_num_dynamic_syms (filedata
);
10302 if (num_of_syms
!= 0
10303 && filedata
->dynamic_symbols
== NULL
10304 && filedata
->dynamic_info
[DT_SYMTAB
]
10305 && filedata
->dynamic_info
[DT_SYMENT
])
10307 Elf_Internal_Phdr
*seg
;
10308 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10310 if (! get_program_headers (filedata
))
10312 error (_("Cannot interpret virtual addresses "
10313 "without program headers.\n"));
10317 for (seg
= filedata
->program_headers
;
10318 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10321 if (seg
->p_type
!= PT_LOAD
)
10324 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10326 /* See PR 21379 for a reproducer. */
10327 error (_("Invalid PT_LOAD entry\n"));
10331 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10332 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10334 /* Since we do not know how big the symbol table is,
10335 we default to reading in up to the end of PT_LOAD
10336 segment and processing that. This is overkill, I
10337 know, but it should work. */
10338 Elf_Internal_Shdr section
;
10339 section
.sh_offset
= (vma
- seg
->p_vaddr
10341 section
.sh_size
= (num_of_syms
10342 * filedata
->dynamic_info
[DT_SYMENT
]);
10343 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10344 section
.sh_name
= filedata
->string_table_length
;
10345 filedata
->dynamic_symbols
10346 = GET_ELF_SYMBOLS (filedata
, §ion
,
10347 &filedata
->num_dynamic_syms
);
10348 if (filedata
->dynamic_symbols
== NULL
10349 || filedata
->num_dynamic_syms
!= num_of_syms
)
10351 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10360 /* Similarly find a string table. */
10361 if (filedata
->dynamic_strings
== NULL
)
10362 for (entry
= filedata
->dynamic_section
;
10363 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10366 if (entry
->d_tag
== DT_STRTAB
)
10367 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10369 if (entry
->d_tag
== DT_STRSZ
)
10370 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10372 if (filedata
->dynamic_info
[DT_STRTAB
]
10373 && filedata
->dynamic_info
[DT_STRSZ
])
10375 unsigned long offset
;
10376 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10378 offset
= offset_from_vma (filedata
,
10379 filedata
->dynamic_info
[DT_STRTAB
],
10381 filedata
->dynamic_strings
10382 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10383 _("dynamic string table"));
10384 if (filedata
->dynamic_strings
== NULL
)
10386 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10390 filedata
->dynamic_strings_length
= str_tab_len
;
10395 /* And find the syminfo section if available. */
10396 if (filedata
->dynamic_syminfo
== NULL
)
10398 unsigned long syminsz
= 0;
10400 for (entry
= filedata
->dynamic_section
;
10401 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10404 if (entry
->d_tag
== DT_SYMINENT
)
10406 /* Note: these braces are necessary to avoid a syntax
10407 error from the SunOS4 C compiler. */
10408 /* PR binutils/17531: A corrupt file can trigger this test.
10409 So do not use an assert, instead generate an error message. */
10410 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10411 error (_("Bad value (%d) for SYMINENT entry\n"),
10412 (int) entry
->d_un
.d_val
);
10414 else if (entry
->d_tag
== DT_SYMINSZ
)
10415 syminsz
= entry
->d_un
.d_val
;
10416 else if (entry
->d_tag
== DT_SYMINFO
)
10417 filedata
->dynamic_syminfo_offset
10418 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10421 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10423 Elf_External_Syminfo
* extsyminfo
;
10424 Elf_External_Syminfo
* extsym
;
10425 Elf_Internal_Syminfo
* syminfo
;
10427 /* There is a syminfo section. Read the data. */
10428 extsyminfo
= (Elf_External_Syminfo
*)
10429 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10430 1, syminsz
, _("symbol information"));
10434 if (filedata
->dynamic_syminfo
!= NULL
)
10436 error (_("Multiple dynamic symbol information sections found\n"));
10437 free (filedata
->dynamic_syminfo
);
10439 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10440 if (filedata
->dynamic_syminfo
== NULL
)
10442 error (_("Out of memory allocating %lu bytes "
10443 "for dynamic symbol info\n"),
10444 (unsigned long) syminsz
);
10448 filedata
->dynamic_syminfo_nent
10449 = syminsz
/ sizeof (Elf_External_Syminfo
);
10450 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10451 syminfo
< (filedata
->dynamic_syminfo
10452 + filedata
->dynamic_syminfo_nent
);
10453 ++syminfo
, ++extsym
)
10455 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10456 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10463 if (do_dynamic
&& filedata
->dynamic_addr
)
10464 printf (ngettext ("\nDynamic section at offset 0x%lx "
10465 "contains %lu entry:\n",
10466 "\nDynamic section at offset 0x%lx "
10467 "contains %lu entries:\n",
10468 filedata
->dynamic_nent
),
10469 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10471 printf (_(" Tag Type Name/Value\n"));
10473 for (entry
= filedata
->dynamic_section
;
10474 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10479 const char * dtype
;
10482 print_vma (entry
->d_tag
, FULL_HEX
);
10483 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10484 printf (" (%s)%*s", dtype
,
10485 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10488 switch (entry
->d_tag
)
10492 print_dynamic_flags (entry
->d_un
.d_val
);
10502 switch (entry
->d_tag
)
10505 printf (_("Auxiliary library"));
10509 printf (_("Filter library"));
10513 printf (_("Configuration file"));
10517 printf (_("Dependency audit library"));
10521 printf (_("Audit library"));
10525 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10526 printf (": [%s]\n",
10527 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10531 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10540 printf (_("Flags:"));
10542 if (entry
->d_un
.d_val
== 0)
10543 printf (_(" None\n"));
10546 unsigned long int val
= entry
->d_un
.d_val
;
10548 if (val
& DTF_1_PARINIT
)
10550 printf (" PARINIT");
10551 val
^= DTF_1_PARINIT
;
10553 if (val
& DTF_1_CONFEXP
)
10555 printf (" CONFEXP");
10556 val
^= DTF_1_CONFEXP
;
10559 printf (" %lx", val
);
10568 printf (_("Flags:"));
10570 if (entry
->d_un
.d_val
== 0)
10571 printf (_(" None\n"));
10574 unsigned long int val
= entry
->d_un
.d_val
;
10576 if (val
& DF_P1_LAZYLOAD
)
10578 printf (" LAZYLOAD");
10579 val
^= DF_P1_LAZYLOAD
;
10581 if (val
& DF_P1_GROUPPERM
)
10583 printf (" GROUPPERM");
10584 val
^= DF_P1_GROUPPERM
;
10587 printf (" %lx", val
);
10596 printf (_("Flags:"));
10597 if (entry
->d_un
.d_val
== 0)
10598 printf (_(" None\n"));
10601 unsigned long int val
= entry
->d_un
.d_val
;
10603 if (val
& DF_1_NOW
)
10608 if (val
& DF_1_GLOBAL
)
10610 printf (" GLOBAL");
10611 val
^= DF_1_GLOBAL
;
10613 if (val
& DF_1_GROUP
)
10618 if (val
& DF_1_NODELETE
)
10620 printf (" NODELETE");
10621 val
^= DF_1_NODELETE
;
10623 if (val
& DF_1_LOADFLTR
)
10625 printf (" LOADFLTR");
10626 val
^= DF_1_LOADFLTR
;
10628 if (val
& DF_1_INITFIRST
)
10630 printf (" INITFIRST");
10631 val
^= DF_1_INITFIRST
;
10633 if (val
& DF_1_NOOPEN
)
10635 printf (" NOOPEN");
10636 val
^= DF_1_NOOPEN
;
10638 if (val
& DF_1_ORIGIN
)
10640 printf (" ORIGIN");
10641 val
^= DF_1_ORIGIN
;
10643 if (val
& DF_1_DIRECT
)
10645 printf (" DIRECT");
10646 val
^= DF_1_DIRECT
;
10648 if (val
& DF_1_TRANS
)
10653 if (val
& DF_1_INTERPOSE
)
10655 printf (" INTERPOSE");
10656 val
^= DF_1_INTERPOSE
;
10658 if (val
& DF_1_NODEFLIB
)
10660 printf (" NODEFLIB");
10661 val
^= DF_1_NODEFLIB
;
10663 if (val
& DF_1_NODUMP
)
10665 printf (" NODUMP");
10666 val
^= DF_1_NODUMP
;
10668 if (val
& DF_1_CONFALT
)
10670 printf (" CONFALT");
10671 val
^= DF_1_CONFALT
;
10673 if (val
& DF_1_ENDFILTEE
)
10675 printf (" ENDFILTEE");
10676 val
^= DF_1_ENDFILTEE
;
10678 if (val
& DF_1_DISPRELDNE
)
10680 printf (" DISPRELDNE");
10681 val
^= DF_1_DISPRELDNE
;
10683 if (val
& DF_1_DISPRELPND
)
10685 printf (" DISPRELPND");
10686 val
^= DF_1_DISPRELPND
;
10688 if (val
& DF_1_NODIRECT
)
10690 printf (" NODIRECT");
10691 val
^= DF_1_NODIRECT
;
10693 if (val
& DF_1_IGNMULDEF
)
10695 printf (" IGNMULDEF");
10696 val
^= DF_1_IGNMULDEF
;
10698 if (val
& DF_1_NOKSYMS
)
10700 printf (" NOKSYMS");
10701 val
^= DF_1_NOKSYMS
;
10703 if (val
& DF_1_NOHDR
)
10708 if (val
& DF_1_EDITED
)
10710 printf (" EDITED");
10711 val
^= DF_1_EDITED
;
10713 if (val
& DF_1_NORELOC
)
10715 printf (" NORELOC");
10716 val
^= DF_1_NORELOC
;
10718 if (val
& DF_1_SYMINTPOSE
)
10720 printf (" SYMINTPOSE");
10721 val
^= DF_1_SYMINTPOSE
;
10723 if (val
& DF_1_GLOBAUDIT
)
10725 printf (" GLOBAUDIT");
10726 val
^= DF_1_GLOBAUDIT
;
10728 if (val
& DF_1_SINGLETON
)
10730 printf (" SINGLETON");
10731 val
^= DF_1_SINGLETON
;
10733 if (val
& DF_1_STUB
)
10738 if (val
& DF_1_PIE
)
10743 if (val
& DF_1_KMOD
)
10748 if (val
& DF_1_WEAKFILTER
)
10750 printf (" WEAKFILTER");
10751 val
^= DF_1_WEAKFILTER
;
10753 if (val
& DF_1_NOCOMMON
)
10755 printf (" NOCOMMON");
10756 val
^= DF_1_NOCOMMON
;
10759 printf (" %lx", val
);
10766 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10768 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10788 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10794 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10795 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10801 switch (entry
->d_tag
)
10804 printf (_("Shared library: [%s]"), name
);
10806 if (streq (name
, filedata
->program_interpreter
))
10807 printf (_(" program interpreter"));
10811 printf (_("Library soname: [%s]"), name
);
10815 printf (_("Library rpath: [%s]"), name
);
10819 printf (_("Library runpath: [%s]"), name
);
10823 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10828 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10841 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10842 /* Fall through. */
10846 case DT_INIT_ARRAYSZ
:
10847 case DT_FINI_ARRAYSZ
:
10848 case DT_GNU_CONFLICTSZ
:
10849 case DT_GNU_LIBLISTSZ
:
10852 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10853 printf (_(" (bytes)\n"));
10858 case DT_VERNEEDNUM
:
10863 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10872 case DT_INIT_ARRAY
:
10873 case DT_FINI_ARRAY
:
10876 if (entry
->d_tag
== DT_USED
10877 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10879 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10883 printf (_("Not needed object: [%s]\n"), name
);
10888 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10894 /* The value of this entry is ignored. */
10899 case DT_GNU_PRELINKED
:
10903 time_t atime
= entry
->d_un
.d_val
;
10905 tmp
= gmtime (&atime
);
10906 /* PR 17533 file: 041-1244816-0.004. */
10908 printf (_("<corrupt time val: %lx"),
10909 (unsigned long) atime
);
10911 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10912 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10913 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10919 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10922 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10928 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10929 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10930 = entry
->d_un
.d_val
;
10934 switch (filedata
->file_header
.e_machine
)
10937 dynamic_section_aarch64_val (entry
);
10940 case EM_MIPS_RS3_LE
:
10941 dynamic_section_mips_val (filedata
, entry
);
10944 dynamic_section_parisc_val (entry
);
10947 dynamic_section_ia64_val (entry
);
10950 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10962 get_ver_flags (unsigned int flags
)
10964 static char buff
[128];
10971 if (flags
& VER_FLG_BASE
)
10972 strcat (buff
, "BASE");
10974 if (flags
& VER_FLG_WEAK
)
10976 if (flags
& VER_FLG_BASE
)
10977 strcat (buff
, " | ");
10979 strcat (buff
, "WEAK");
10982 if (flags
& VER_FLG_INFO
)
10984 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10985 strcat (buff
, " | ");
10987 strcat (buff
, "INFO");
10990 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10992 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10993 strcat (buff
, " | ");
10995 strcat (buff
, _("<unknown>"));
11001 /* Display the contents of the version sections. */
11004 process_version_sections (Filedata
* filedata
)
11006 Elf_Internal_Shdr
* section
;
11008 bfd_boolean found
= FALSE
;
11013 for (i
= 0, section
= filedata
->section_headers
;
11014 i
< filedata
->file_header
.e_shnum
;
11017 switch (section
->sh_type
)
11019 case SHT_GNU_verdef
:
11021 Elf_External_Verdef
* edefs
;
11028 printf (ngettext ("\nVersion definition section '%s' "
11029 "contains %u entry:\n",
11030 "\nVersion definition section '%s' "
11031 "contains %u entries:\n",
11033 printable_section_name (filedata
, section
),
11036 printf (_(" Addr: 0x"));
11037 printf_vma (section
->sh_addr
);
11038 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11039 (unsigned long) section
->sh_offset
, section
->sh_link
,
11040 printable_section_name_from_index (filedata
, section
->sh_link
));
11042 edefs
= (Elf_External_Verdef
*)
11043 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11044 _("version definition section"));
11047 endbuf
= (char *) edefs
+ section
->sh_size
;
11049 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11052 Elf_External_Verdef
* edef
;
11053 Elf_Internal_Verdef ent
;
11054 Elf_External_Verdaux
* eaux
;
11055 Elf_Internal_Verdaux aux
;
11056 unsigned long isum
;
11059 vstart
= ((char *) edefs
) + idx
;
11060 if (vstart
+ sizeof (*edef
) > endbuf
)
11063 edef
= (Elf_External_Verdef
*) vstart
;
11065 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11066 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11067 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11068 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11069 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11070 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11071 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11073 printf (_(" %#06lx: Rev: %d Flags: %s"),
11074 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11076 printf (_(" Index: %d Cnt: %d "),
11077 ent
.vd_ndx
, ent
.vd_cnt
);
11079 /* Check for overflow. */
11080 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11083 vstart
+= ent
.vd_aux
;
11085 if (vstart
+ sizeof (*eaux
) > endbuf
)
11087 eaux
= (Elf_External_Verdaux
*) vstart
;
11089 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11090 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11092 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11093 printf (_("Name: %s\n"),
11094 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11096 printf (_("Name index: %ld\n"), aux
.vda_name
);
11098 isum
= idx
+ ent
.vd_aux
;
11100 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11102 if (aux
.vda_next
< sizeof (*eaux
)
11103 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11105 warn (_("Invalid vda_next field of %lx\n"),
11110 /* Check for overflow. */
11111 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11114 isum
+= aux
.vda_next
;
11115 vstart
+= aux
.vda_next
;
11117 if (vstart
+ sizeof (*eaux
) > endbuf
)
11119 eaux
= (Elf_External_Verdaux
*) vstart
;
11121 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11122 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11124 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11125 printf (_(" %#06lx: Parent %d: %s\n"),
11127 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11129 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11130 isum
, j
, aux
.vda_name
);
11133 if (j
< ent
.vd_cnt
)
11134 printf (_(" Version def aux past end of section\n"));
11137 file: id:000001,src:000172+005151,op:splice,rep:2. */
11138 if (ent
.vd_next
< sizeof (*edef
)
11139 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11141 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11142 cnt
= section
->sh_info
;
11145 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11148 idx
+= ent
.vd_next
;
11151 if (cnt
< section
->sh_info
)
11152 printf (_(" Version definition past end of section\n"));
11158 case SHT_GNU_verneed
:
11160 Elf_External_Verneed
* eneed
;
11167 printf (ngettext ("\nVersion needs section '%s' "
11168 "contains %u entry:\n",
11169 "\nVersion needs section '%s' "
11170 "contains %u entries:\n",
11172 printable_section_name (filedata
, section
), section
->sh_info
);
11174 printf (_(" Addr: 0x"));
11175 printf_vma (section
->sh_addr
);
11176 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11177 (unsigned long) section
->sh_offset
, section
->sh_link
,
11178 printable_section_name_from_index (filedata
, section
->sh_link
));
11180 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11181 section
->sh_offset
, 1,
11183 _("Version Needs section"));
11186 endbuf
= (char *) eneed
+ section
->sh_size
;
11188 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11190 Elf_External_Verneed
* entry
;
11191 Elf_Internal_Verneed ent
;
11192 unsigned long isum
;
11196 vstart
= ((char *) eneed
) + idx
;
11197 if (vstart
+ sizeof (*entry
) > endbuf
)
11200 entry
= (Elf_External_Verneed
*) vstart
;
11202 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11203 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11204 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11205 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11206 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11208 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11210 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11211 printf (_(" File: %s"),
11212 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11214 printf (_(" File: %lx"), ent
.vn_file
);
11216 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11218 /* Check for overflow. */
11219 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11221 vstart
+= ent
.vn_aux
;
11223 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11225 Elf_External_Vernaux
* eaux
;
11226 Elf_Internal_Vernaux aux
;
11228 if (vstart
+ sizeof (*eaux
) > endbuf
)
11230 eaux
= (Elf_External_Vernaux
*) vstart
;
11232 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11233 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11234 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11235 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11236 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11238 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11239 printf (_(" %#06lx: Name: %s"),
11240 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11242 printf (_(" %#06lx: Name index: %lx"),
11243 isum
, aux
.vna_name
);
11245 printf (_(" Flags: %s Version: %d\n"),
11246 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11248 if (aux
.vna_next
< sizeof (*eaux
)
11249 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11251 warn (_("Invalid vna_next field of %lx\n"),
11256 /* Check for overflow. */
11257 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11259 isum
+= aux
.vna_next
;
11260 vstart
+= aux
.vna_next
;
11263 if (j
< ent
.vn_cnt
)
11264 warn (_("Missing Version Needs auxillary information\n"));
11266 if (ent
.vn_next
< sizeof (*entry
)
11267 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11269 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11270 cnt
= section
->sh_info
;
11273 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11275 idx
+= ent
.vn_next
;
11278 if (cnt
< section
->sh_info
)
11279 warn (_("Missing Version Needs information\n"));
11285 case SHT_GNU_versym
:
11287 Elf_Internal_Shdr
* link_section
;
11290 unsigned char * edata
;
11291 unsigned short * data
;
11293 Elf_Internal_Sym
* symbols
;
11294 Elf_Internal_Shdr
* string_sec
;
11295 unsigned long num_syms
;
11298 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11301 link_section
= filedata
->section_headers
+ section
->sh_link
;
11302 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11304 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11309 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11310 if (symbols
== NULL
)
11313 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11315 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11316 string_sec
->sh_size
,
11317 _("version string table"));
11324 printf (ngettext ("\nVersion symbols section '%s' "
11325 "contains %lu entry:\n",
11326 "\nVersion symbols section '%s' "
11327 "contains %lu entries:\n",
11329 printable_section_name (filedata
, section
), (unsigned long) total
);
11331 printf (_(" Addr: 0x"));
11332 printf_vma (section
->sh_addr
);
11333 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11334 (unsigned long) section
->sh_offset
, section
->sh_link
,
11335 printable_section_name (filedata
, link_section
));
11337 off
= offset_from_vma (filedata
,
11338 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11339 total
* sizeof (short));
11340 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11341 sizeof (short), total
,
11342 _("version symbol data"));
11350 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11352 for (cnt
= total
; cnt
--;)
11353 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11358 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11362 char *invalid
= _("*invalid*");
11364 printf (" %03x:", cnt
);
11366 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11367 switch (data
[cnt
+ j
])
11370 fputs (_(" 0 (*local*) "), stdout
);
11374 fputs (_(" 1 (*global*) "), stdout
);
11378 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11379 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11381 /* If this index value is greater than the size of the symbols
11382 array, break to avoid an out-of-bounds read. */
11383 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11385 warn (_("invalid index into symbol array\n"));
11390 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11392 Elf_Internal_Verneed ivn
;
11393 unsigned long offset
;
11395 offset
= offset_from_vma
11397 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11398 sizeof (Elf_External_Verneed
));
11402 Elf_Internal_Vernaux ivna
;
11403 Elf_External_Verneed evn
;
11404 Elf_External_Vernaux evna
;
11405 unsigned long a_off
;
11407 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11408 _("version need")) == NULL
)
11411 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11412 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11414 a_off
= offset
+ ivn
.vn_aux
;
11418 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11419 1, _("version need aux (2)")) == NULL
)
11422 ivna
.vna_other
= 0;
11426 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11427 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11430 a_off
+= ivna
.vna_next
;
11432 while (ivna
.vna_other
!= data
[cnt
+ j
]
11433 && ivna
.vna_next
!= 0);
11435 if (ivna
.vna_other
== data
[cnt
+ j
])
11437 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11439 if (ivna
.vna_name
>= string_sec
->sh_size
)
11442 name
= strtab
+ ivna
.vna_name
;
11446 offset
+= ivn
.vn_next
;
11448 while (ivn
.vn_next
);
11451 if (data
[cnt
+ j
] != 0x8001
11452 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11454 Elf_Internal_Verdef ivd
;
11455 Elf_External_Verdef evd
;
11456 unsigned long offset
;
11458 offset
= offset_from_vma
11460 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11465 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11466 _("version def")) == NULL
)
11469 /* PR 17531: file: 046-1082287-0.004. */
11470 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11475 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11476 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11479 offset
+= ivd
.vd_next
;
11481 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11482 && ivd
.vd_next
!= 0);
11484 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11486 Elf_External_Verdaux evda
;
11487 Elf_Internal_Verdaux ivda
;
11489 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11491 if (get_data (&evda
, filedata
,
11492 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11494 _("version def aux")) == NULL
)
11497 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11499 if (ivda
.vda_name
>= string_sec
->sh_size
)
11501 else if (name
!= NULL
&& name
!= invalid
)
11502 name
= _("*both*");
11504 name
= strtab
+ ivda
.vda_name
;
11508 nn
+= printf ("(%s%-*s",
11510 12 - (int) strlen (name
),
11514 printf ("%*c", 18 - nn
, ' ');
11532 printf (_("\nNo version information found in this file.\n"));
11537 static const char *
11538 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11540 static char buff
[64];
11544 case STB_LOCAL
: return "LOCAL";
11545 case STB_GLOBAL
: return "GLOBAL";
11546 case STB_WEAK
: return "WEAK";
11548 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11549 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11551 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11553 if (binding
== STB_GNU_UNIQUE
11554 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11556 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11559 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11564 static const char *
11565 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11567 static char buff
[64];
11571 case STT_NOTYPE
: return "NOTYPE";
11572 case STT_OBJECT
: return "OBJECT";
11573 case STT_FUNC
: return "FUNC";
11574 case STT_SECTION
: return "SECTION";
11575 case STT_FILE
: return "FILE";
11576 case STT_COMMON
: return "COMMON";
11577 case STT_TLS
: return "TLS";
11578 case STT_RELC
: return "RELC";
11579 case STT_SRELC
: return "SRELC";
11581 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11583 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11584 return "THUMB_FUNC";
11586 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11589 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11590 return "PARISC_MILLI";
11592 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11594 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11596 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11598 if (type
== STT_HP_OPAQUE
)
11599 return "HP_OPAQUE";
11600 if (type
== STT_HP_STUB
)
11604 if (type
== STT_GNU_IFUNC
11605 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11606 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11609 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11612 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11617 static const char *
11618 get_symbol_visibility (unsigned int visibility
)
11620 switch (visibility
)
11622 case STV_DEFAULT
: return "DEFAULT";
11623 case STV_INTERNAL
: return "INTERNAL";
11624 case STV_HIDDEN
: return "HIDDEN";
11625 case STV_PROTECTED
: return "PROTECTED";
11627 error (_("Unrecognized visibility value: %u\n"), visibility
);
11628 return _("<unknown>");
11632 static const char *
11633 get_alpha_symbol_other (unsigned int other
)
11637 case STO_ALPHA_NOPV
: return "NOPV";
11638 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11640 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11641 return _("<unknown>");
11645 static const char *
11646 get_solaris_symbol_visibility (unsigned int visibility
)
11648 switch (visibility
)
11650 case 4: return "EXPORTED";
11651 case 5: return "SINGLETON";
11652 case 6: return "ELIMINATE";
11653 default: return get_symbol_visibility (visibility
);
11657 static const char *
11658 get_aarch64_symbol_other (unsigned int other
)
11660 static char buf
[32];
11662 if (other
& STO_AARCH64_VARIANT_PCS
)
11664 other
&= ~STO_AARCH64_VARIANT_PCS
;
11666 return "VARIANT_PCS";
11667 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11673 static const char *
11674 get_mips_symbol_other (unsigned int other
)
11678 case STO_OPTIONAL
: return "OPTIONAL";
11679 case STO_MIPS_PLT
: return "MIPS PLT";
11680 case STO_MIPS_PIC
: return "MIPS PIC";
11681 case STO_MICROMIPS
: return "MICROMIPS";
11682 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11683 case STO_MIPS16
: return "MIPS16";
11684 default: return NULL
;
11688 static const char *
11689 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11691 if (is_ia64_vms (filedata
))
11693 static char res
[32];
11697 /* Function types is for images and .STB files only. */
11698 switch (filedata
->file_header
.e_type
)
11702 switch (VMS_ST_FUNC_TYPE (other
))
11704 case VMS_SFT_CODE_ADDR
:
11705 strcat (res
, " CA");
11707 case VMS_SFT_SYMV_IDX
:
11708 strcat (res
, " VEC");
11711 strcat (res
, " FD");
11713 case VMS_SFT_RESERVE
:
11714 strcat (res
, " RSV");
11717 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11718 VMS_ST_FUNC_TYPE (other
));
11719 strcat (res
, " <unknown>");
11726 switch (VMS_ST_LINKAGE (other
))
11728 case VMS_STL_IGNORE
:
11729 strcat (res
, " IGN");
11731 case VMS_STL_RESERVE
:
11732 strcat (res
, " RSV");
11735 strcat (res
, " STD");
11738 strcat (res
, " LNK");
11741 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11742 VMS_ST_LINKAGE (other
));
11743 strcat (res
, " <unknown>");
11755 static const char *
11756 get_ppc64_symbol_other (unsigned int other
)
11758 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11761 other
>>= STO_PPC64_LOCAL_BIT
;
11764 static char buf
[64];
11766 other
= ppc64_decode_local_entry (other
);
11767 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11773 static const char *
11774 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11776 const char * result
= NULL
;
11777 static char buff
[64];
11782 switch (filedata
->file_header
.e_machine
)
11785 result
= get_alpha_symbol_other (other
);
11788 result
= get_aarch64_symbol_other (other
);
11791 result
= get_mips_symbol_other (other
);
11794 result
= get_ia64_symbol_other (filedata
, other
);
11797 result
= get_ppc64_symbol_other (other
);
11807 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11811 static const char *
11812 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11814 static char buff
[32];
11818 case SHN_UNDEF
: return "UND";
11819 case SHN_ABS
: return "ABS";
11820 case SHN_COMMON
: return "COM";
11822 if (type
== SHN_IA_64_ANSI_COMMON
11823 && filedata
->file_header
.e_machine
== EM_IA_64
11824 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11826 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11827 || filedata
->file_header
.e_machine
== EM_L1OM
11828 || filedata
->file_header
.e_machine
== EM_K1OM
)
11829 && type
== SHN_X86_64_LCOMMON
)
11830 return "LARGE_COM";
11831 else if ((type
== SHN_MIPS_SCOMMON
11832 && filedata
->file_header
.e_machine
== EM_MIPS
)
11833 || (type
== SHN_TIC6X_SCOMMON
11834 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11836 else if (type
== SHN_MIPS_SUNDEFINED
11837 && filedata
->file_header
.e_machine
== EM_MIPS
)
11839 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11840 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11841 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11842 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11843 else if (type
>= SHN_LORESERVE
)
11844 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11845 else if (filedata
->file_header
.e_shnum
!= 0
11846 && type
>= filedata
->file_header
.e_shnum
)
11847 sprintf (buff
, _("bad section index[%3d]"), type
);
11849 sprintf (buff
, "%3d", type
);
11856 static const char *
11857 get_symbol_version_string (Filedata
* filedata
,
11858 bfd_boolean is_dynsym
,
11859 const char * strtab
,
11860 unsigned long int strtab_size
,
11862 Elf_Internal_Sym
* psym
,
11863 enum versioned_symbol_info
* sym_info
,
11864 unsigned short * vna_other
)
11866 unsigned char data
[2];
11867 unsigned short vers_data
;
11868 unsigned long offset
;
11869 unsigned short max_vd_ndx
;
11872 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11875 offset
= offset_from_vma (filedata
,
11876 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11877 sizeof data
+ si
* sizeof (vers_data
));
11879 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11880 sizeof (data
), 1, _("version data")) == NULL
)
11883 vers_data
= byte_get (data
, 2);
11885 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11888 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11891 /* Usually we'd only see verdef for defined symbols, and verneed for
11892 undefined symbols. However, symbols defined by the linker in
11893 .dynbss for variables copied from a shared library in order to
11894 avoid text relocations are defined yet have verneed. We could
11895 use a heuristic to detect the special case, for example, check
11896 for verneed first on symbols defined in SHT_NOBITS sections, but
11897 it is simpler and more reliable to just look for both verdef and
11898 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11900 if (psym
->st_shndx
!= SHN_UNDEF
11901 && vers_data
!= 0x8001
11902 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11904 Elf_Internal_Verdef ivd
;
11905 Elf_Internal_Verdaux ivda
;
11906 Elf_External_Verdaux evda
;
11909 off
= offset_from_vma (filedata
,
11910 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11911 sizeof (Elf_External_Verdef
));
11915 Elf_External_Verdef evd
;
11917 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11918 _("version def")) == NULL
)
11927 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11928 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11929 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11930 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11933 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11934 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11936 off
+= ivd
.vd_next
;
11938 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11940 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11942 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11945 off
-= ivd
.vd_next
;
11948 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11949 _("version def aux")) != NULL
)
11951 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11953 if (psym
->st_name
!= ivda
.vda_name
)
11954 return (ivda
.vda_name
< strtab_size
11955 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11960 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11962 Elf_External_Verneed evn
;
11963 Elf_Internal_Verneed ivn
;
11964 Elf_Internal_Vernaux ivna
;
11966 offset
= offset_from_vma (filedata
,
11967 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11971 unsigned long vna_off
;
11973 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11974 _("version need")) == NULL
)
11977 ivna
.vna_other
= 0;
11982 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11983 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11985 vna_off
= offset
+ ivn
.vn_aux
;
11989 Elf_External_Vernaux evna
;
11991 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11992 _("version need aux (3)")) == NULL
)
11995 ivna
.vna_other
= 0;
12000 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12001 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12002 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12005 vna_off
+= ivna
.vna_next
;
12007 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12009 if (ivna
.vna_other
== vers_data
)
12012 offset
+= ivn
.vn_next
;
12014 while (ivn
.vn_next
!= 0);
12016 if (ivna
.vna_other
== vers_data
)
12018 *sym_info
= symbol_undefined
;
12019 *vna_other
= ivna
.vna_other
;
12020 return (ivna
.vna_name
< strtab_size
12021 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12023 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12024 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12025 return _("<corrupt>");
12031 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12032 Elf_Internal_Sym
*symtab
,
12033 Elf_Internal_Shdr
*section
,
12034 char *strtab
, size_t strtab_size
)
12036 const char *version_string
;
12037 enum versioned_symbol_info sym_info
;
12038 unsigned short vna_other
;
12039 Elf_Internal_Sym
*psym
= symtab
+ si
;
12041 printf ("%6ld: ", si
);
12042 print_vma (psym
->st_value
, LONG_HEX
);
12044 print_vma (psym
->st_size
, DEC_5
);
12045 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12046 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12047 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12048 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12051 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12053 printf (" %-7s", get_symbol_visibility (vis
));
12054 /* Check to see if any other bits in the st_other field are set.
12055 Note - displaying this information disrupts the layout of the
12056 table being generated, but for the moment this case is very rare. */
12057 if (psym
->st_other
^ vis
)
12058 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12060 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12061 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
12063 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12066 = get_symbol_version_string (filedata
,
12068 || section
->sh_type
== SHT_DYNSYM
),
12069 strtab
, strtab_size
, si
,
12070 psym
, &sym_info
, &vna_other
);
12071 if (version_string
)
12073 if (sym_info
== symbol_undefined
)
12074 printf ("@%s (%d)", version_string
, vna_other
);
12076 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12082 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12084 && si
>= section
->sh_info
12085 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12086 && filedata
->file_header
.e_machine
!= EM_MIPS
12087 /* Solaris binaries have been found to violate this requirement as
12088 well. Not sure if this is a bug or an ABI requirement. */
12089 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12090 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12091 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12094 /* Dump the symbol table. */
12096 process_symbol_table (Filedata
* filedata
)
12098 Elf_Internal_Shdr
* section
;
12100 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12103 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12105 && do_using_dynamic
12106 && filedata
->dynamic_strings
!= NULL
12107 && filedata
->dynamic_symbols
!= NULL
)
12111 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12112 "\nSymbol table for image contains %lu entries:\n",
12113 filedata
->num_dynamic_syms
),
12114 filedata
->num_dynamic_syms
);
12116 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12118 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12120 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12121 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12122 filedata
->dynamic_strings
,
12123 filedata
->dynamic_strings_length
);
12125 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12126 && filedata
->section_headers
!= NULL
)
12130 for (i
= 0, section
= filedata
->section_headers
;
12131 i
< filedata
->file_header
.e_shnum
;
12134 char * strtab
= NULL
;
12135 unsigned long int strtab_size
= 0;
12136 Elf_Internal_Sym
* symtab
;
12137 unsigned long si
, num_syms
;
12139 if ((section
->sh_type
!= SHT_SYMTAB
12140 && section
->sh_type
!= SHT_DYNSYM
)
12142 && section
->sh_type
== SHT_SYMTAB
))
12145 if (section
->sh_entsize
== 0)
12147 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12148 printable_section_name (filedata
, section
));
12152 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12153 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12154 "\nSymbol table '%s' contains %lu entries:\n",
12156 printable_section_name (filedata
, section
),
12160 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12162 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12164 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12165 if (symtab
== NULL
)
12168 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12170 strtab
= filedata
->string_table
;
12171 strtab_size
= filedata
->string_table_length
;
12173 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12175 Elf_Internal_Shdr
* string_sec
;
12177 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12179 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12180 1, string_sec
->sh_size
,
12181 _("string table"));
12182 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12185 for (si
= 0; si
< num_syms
; si
++)
12186 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12187 strtab
, strtab_size
);
12190 if (strtab
!= filedata
->string_table
)
12196 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12198 if (do_histogram
&& filedata
->buckets
!= NULL
)
12200 unsigned long * lengths
;
12201 unsigned long * counts
;
12204 unsigned long maxlength
= 0;
12205 unsigned long nzero_counts
= 0;
12206 unsigned long nsyms
= 0;
12209 printf (ngettext ("\nHistogram for bucket list length "
12210 "(total of %lu bucket):\n",
12211 "\nHistogram for bucket list length "
12212 "(total of %lu buckets):\n",
12213 (unsigned long) filedata
->nbuckets
),
12214 (unsigned long) filedata
->nbuckets
);
12216 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12217 sizeof (*lengths
));
12218 if (lengths
== NULL
)
12220 error (_("Out of memory allocating space for histogram buckets\n"));
12223 visited
= xcmalloc (filedata
->nchains
, 1);
12224 memset (visited
, 0, filedata
->nchains
);
12226 printf (_(" Length Number %% of total Coverage\n"));
12227 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12229 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12232 if (maxlength
< ++lengths
[hn
])
12234 if (si
>= filedata
->nchains
|| visited
[si
])
12236 error (_("histogram chain is corrupt\n"));
12244 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12245 if (counts
== NULL
)
12248 error (_("Out of memory allocating space for histogram counts\n"));
12252 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12253 ++counts
[lengths
[hn
]];
12255 if (filedata
->nbuckets
> 0)
12258 printf (" 0 %-10lu (%5.1f%%)\n",
12259 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12260 for (i
= 1; i
<= maxlength
; ++i
)
12262 nzero_counts
+= counts
[i
] * i
;
12263 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12264 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12265 (nzero_counts
* 100.0) / nsyms
);
12273 free (filedata
->buckets
);
12274 filedata
->buckets
= NULL
;
12275 filedata
->nbuckets
= 0;
12276 free (filedata
->chains
);
12277 filedata
->chains
= NULL
;
12279 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12281 unsigned long * lengths
;
12282 unsigned long * counts
;
12284 unsigned long maxlength
= 0;
12285 unsigned long nzero_counts
= 0;
12286 unsigned long nsyms
= 0;
12288 printf (ngettext ("\nHistogram for `%s' bucket list length "
12289 "(total of %lu bucket):\n",
12290 "\nHistogram for `%s' bucket list length "
12291 "(total of %lu buckets):\n",
12292 (unsigned long) filedata
->ngnubuckets
),
12293 GNU_HASH_SECTION_NAME (filedata
),
12294 (unsigned long) filedata
->ngnubuckets
);
12296 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12297 sizeof (*lengths
));
12298 if (lengths
== NULL
)
12300 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12304 printf (_(" Length Number %% of total Coverage\n"));
12306 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12307 if (filedata
->gnubuckets
[hn
] != 0)
12309 bfd_vma off
, length
= 1;
12311 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12312 /* PR 17531 file: 010-77222-0.004. */
12313 off
< filedata
->ngnuchains
12314 && (filedata
->gnuchains
[off
] & 1) == 0;
12317 lengths
[hn
] = length
;
12318 if (length
> maxlength
)
12319 maxlength
= length
;
12323 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12324 if (counts
== NULL
)
12327 error (_("Out of memory allocating space for gnu histogram counts\n"));
12331 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12332 ++counts
[lengths
[hn
]];
12334 if (filedata
->ngnubuckets
> 0)
12337 printf (" 0 %-10lu (%5.1f%%)\n",
12338 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12339 for (j
= 1; j
<= maxlength
; ++j
)
12341 nzero_counts
+= counts
[j
] * j
;
12342 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12343 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12344 (nzero_counts
* 100.0) / nsyms
);
12351 free (filedata
->gnubuckets
);
12352 filedata
->gnubuckets
= NULL
;
12353 filedata
->ngnubuckets
= 0;
12354 free (filedata
->gnuchains
);
12355 filedata
->gnuchains
= NULL
;
12356 filedata
->ngnuchains
= 0;
12357 free (filedata
->mipsxlat
);
12358 filedata
->mipsxlat
= NULL
;
12362 free (filedata
->gnubuckets
);
12363 filedata
->gnubuckets
= NULL
;
12364 filedata
->ngnubuckets
= 0;
12365 free (filedata
->gnuchains
);
12366 filedata
->gnuchains
= NULL
;
12367 filedata
->ngnuchains
= 0;
12368 free (filedata
->mipsxlat
);
12369 filedata
->mipsxlat
= NULL
;
12370 free (filedata
->buckets
);
12371 filedata
->buckets
= NULL
;
12372 filedata
->nbuckets
= 0;
12373 free (filedata
->chains
);
12374 filedata
->chains
= NULL
;
12379 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12383 if (filedata
->dynamic_syminfo
== NULL
12385 /* No syminfo, this is ok. */
12388 /* There better should be a dynamic symbol section. */
12389 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12392 if (filedata
->dynamic_addr
)
12393 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12394 "contains %d entry:\n",
12395 "\nDynamic info segment at offset 0x%lx "
12396 "contains %d entries:\n",
12397 filedata
->dynamic_syminfo_nent
),
12398 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12400 printf (_(" Num: Name BoundTo Flags\n"));
12401 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12403 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12405 printf ("%4d: ", i
);
12406 if (i
>= filedata
->num_dynamic_syms
)
12407 printf (_("<corrupt index>"));
12408 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12409 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12410 filedata
->dynamic_symbols
[i
].st_name
));
12412 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12415 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12417 case SYMINFO_BT_SELF
:
12418 fputs ("SELF ", stdout
);
12420 case SYMINFO_BT_PARENT
:
12421 fputs ("PARENT ", stdout
);
12424 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12425 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12426 && VALID_DYNAMIC_NAME (filedata
,
12427 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12429 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12430 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12434 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12438 if (flags
& SYMINFO_FLG_DIRECT
)
12439 printf (" DIRECT");
12440 if (flags
& SYMINFO_FLG_PASSTHRU
)
12441 printf (" PASSTHRU");
12442 if (flags
& SYMINFO_FLG_COPY
)
12444 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12445 printf (" LAZYLOAD");
12453 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12454 is contained by the region START .. END. The types of ADDR, START
12455 and END should all be the same. Note both ADDR + NELEM and END
12456 point to just beyond the end of the regions that are being tested. */
12457 #define IN_RANGE(START,END,ADDR,NELEM) \
12458 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12460 /* Check to see if the given reloc needs to be handled in a target specific
12461 manner. If so then process the reloc and return TRUE otherwise return
12464 If called with reloc == NULL, then this is a signal that reloc processing
12465 for the current section has finished, and any saved state should be
12469 target_specific_reloc_handling (Filedata
* filedata
,
12470 Elf_Internal_Rela
* reloc
,
12471 unsigned char * start
,
12472 unsigned char * end
,
12473 Elf_Internal_Sym
* symtab
,
12474 unsigned long num_syms
)
12476 unsigned int reloc_type
= 0;
12477 unsigned long sym_index
= 0;
12481 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12482 sym_index
= get_reloc_symindex (reloc
->r_info
);
12485 switch (filedata
->file_header
.e_machine
)
12488 case EM_MSP430_OLD
:
12490 static Elf_Internal_Sym
* saved_sym
= NULL
;
12498 switch (reloc_type
)
12500 case 10: /* R_MSP430_SYM_DIFF */
12501 if (uses_msp430x_relocs (filedata
))
12503 /* Fall through. */
12504 case 21: /* R_MSP430X_SYM_DIFF */
12506 if (sym_index
>= num_syms
)
12507 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12510 saved_sym
= symtab
+ sym_index
;
12513 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12514 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12515 goto handle_sym_diff
;
12517 case 5: /* R_MSP430_16_BYTE */
12518 case 9: /* R_MSP430_8 */
12519 if (uses_msp430x_relocs (filedata
))
12521 goto handle_sym_diff
;
12523 case 2: /* R_MSP430_ABS16 */
12524 case 15: /* R_MSP430X_ABS16 */
12525 if (! uses_msp430x_relocs (filedata
))
12527 goto handle_sym_diff
;
12530 if (saved_sym
!= NULL
)
12532 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12535 if (sym_index
>= num_syms
)
12536 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12540 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12541 - saved_sym
->st_value
);
12543 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12544 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12547 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12548 (long) reloc
->r_offset
);
12557 if (saved_sym
!= NULL
)
12558 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12565 case EM_CYGNUS_MN10300
:
12567 static Elf_Internal_Sym
* saved_sym
= NULL
;
12575 switch (reloc_type
)
12577 case 34: /* R_MN10300_ALIGN */
12579 case 33: /* R_MN10300_SYM_DIFF */
12580 if (sym_index
>= num_syms
)
12581 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12584 saved_sym
= symtab
+ sym_index
;
12587 case 1: /* R_MN10300_32 */
12588 case 2: /* R_MN10300_16 */
12589 if (saved_sym
!= NULL
)
12591 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12594 if (sym_index
>= num_syms
)
12595 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12599 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12600 - saved_sym
->st_value
);
12602 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12603 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12605 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12606 (long) reloc
->r_offset
);
12614 if (saved_sym
!= NULL
)
12615 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12623 static bfd_vma saved_sym1
= 0;
12624 static bfd_vma saved_sym2
= 0;
12625 static bfd_vma value
;
12629 saved_sym1
= saved_sym2
= 0;
12633 switch (reloc_type
)
12635 case 0x80: /* R_RL78_SYM. */
12636 saved_sym1
= saved_sym2
;
12637 if (sym_index
>= num_syms
)
12638 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12642 saved_sym2
= symtab
[sym_index
].st_value
;
12643 saved_sym2
+= reloc
->r_addend
;
12647 case 0x83: /* R_RL78_OPsub. */
12648 value
= saved_sym1
- saved_sym2
;
12649 saved_sym2
= saved_sym1
= 0;
12653 case 0x41: /* R_RL78_ABS32. */
12654 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12655 byte_put (start
+ reloc
->r_offset
, value
, 4);
12657 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12658 (long) reloc
->r_offset
);
12662 case 0x43: /* R_RL78_ABS16. */
12663 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12664 byte_put (start
+ reloc
->r_offset
, value
, 2);
12666 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12667 (long) reloc
->r_offset
);
12681 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12682 DWARF debug sections. This is a target specific test. Note - we do not
12683 go through the whole including-target-headers-multiple-times route, (as
12684 we have already done with <elf/h8.h>) because this would become very
12685 messy and even then this function would have to contain target specific
12686 information (the names of the relocs instead of their numeric values).
12687 FIXME: This is not the correct way to solve this problem. The proper way
12688 is to have target specific reloc sizing and typing functions created by
12689 the reloc-macros.h header, in the same way that it already creates the
12690 reloc naming functions. */
12693 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12695 /* Please keep this table alpha-sorted for ease of visual lookup. */
12696 switch (filedata
->file_header
.e_machine
)
12700 return reloc_type
== 1; /* R_386_32. */
12702 return reloc_type
== 1; /* R_68K_32. */
12704 return reloc_type
== 1; /* R_860_32. */
12706 return reloc_type
== 2; /* R_960_32. */
12708 return (reloc_type
== 258
12709 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12711 return reloc_type
== 11; /* R_BPF_DATA_32 */
12712 case EM_ADAPTEVA_EPIPHANY
:
12713 return reloc_type
== 3;
12715 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12717 return reloc_type
== 1; /* R_ARC_32. */
12718 case EM_ARC_COMPACT
:
12719 case EM_ARC_COMPACT2
:
12720 return reloc_type
== 4; /* R_ARC_32. */
12722 return reloc_type
== 2; /* R_ARM_ABS32 */
12725 return reloc_type
== 1;
12727 return reloc_type
== 0x12; /* R_byte4_data. */
12729 return reloc_type
== 3; /* R_CRIS_32. */
12731 return reloc_type
== 3; /* R_CR16_NUM32. */
12733 return reloc_type
== 15; /* R_CRX_NUM32. */
12735 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12736 case EM_CYGNUS_FRV
:
12737 return reloc_type
== 1;
12738 case EM_CYGNUS_D10V
:
12740 return reloc_type
== 6; /* R_D10V_32. */
12741 case EM_CYGNUS_D30V
:
12743 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12745 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12746 case EM_CYGNUS_FR30
:
12748 return reloc_type
== 3; /* R_FR30_32. */
12750 return reloc_type
== 1; /* R_FT32_32. */
12754 return reloc_type
== 1; /* R_H8_DIR32. */
12756 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12757 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12758 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12759 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12762 return reloc_type
== 2; /* R_IP2K_32. */
12764 return reloc_type
== 2; /* R_IQ2000_32. */
12765 case EM_LATTICEMICO32
:
12766 return reloc_type
== 3; /* R_LM32_32. */
12769 return reloc_type
== 3; /* R_M32C_32. */
12771 return reloc_type
== 34; /* R_M32R_32_RELA. */
12774 return reloc_type
== 6; /* R_M68HC11_32. */
12776 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12777 reloc_type
== 6; /* R_S12Z_CW32. */
12779 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12780 case EM_CYGNUS_MEP
:
12781 return reloc_type
== 4; /* R_MEP_32. */
12783 return reloc_type
== 2; /* R_METAG_ADDR32. */
12784 case EM_MICROBLAZE
:
12785 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12787 return reloc_type
== 2; /* R_MIPS_32. */
12789 return reloc_type
== 4; /* R_MMIX_32. */
12790 case EM_CYGNUS_MN10200
:
12792 return reloc_type
== 1; /* R_MN10200_32. */
12793 case EM_CYGNUS_MN10300
:
12795 return reloc_type
== 1; /* R_MN10300_32. */
12797 return reloc_type
== 1; /* R_MOXIE_32. */
12798 case EM_MSP430_OLD
:
12800 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12802 return reloc_type
== 2; /* R_MT_32. */
12804 return reloc_type
== 20; /* R_NDS32_RELA. */
12805 case EM_ALTERA_NIOS2
:
12806 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12808 return reloc_type
== 1; /* R_NIOS_32. */
12810 return reloc_type
== 1; /* R_OR1K_32. */
12812 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12813 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12814 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12817 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12819 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12821 return reloc_type
== 1; /* R_PPC_ADDR32. */
12823 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12825 return reloc_type
== 1; /* R_RISCV_32. */
12827 return reloc_type
== 1; /* R_RL78_DIR32. */
12829 return reloc_type
== 1; /* R_RX_DIR32. */
12831 return reloc_type
== 1; /* R_I370_ADDR31. */
12834 return reloc_type
== 4; /* R_S390_32. */
12836 return reloc_type
== 8; /* R_SCORE_ABS32. */
12838 return reloc_type
== 1; /* R_SH_DIR32. */
12839 case EM_SPARC32PLUS
:
12842 return reloc_type
== 3 /* R_SPARC_32. */
12843 || reloc_type
== 23; /* R_SPARC_UA32. */
12845 return reloc_type
== 6; /* R_SPU_ADDR32 */
12847 return reloc_type
== 1; /* R_C6000_ABS32. */
12849 return reloc_type
== 2; /* R_TILEGX_32. */
12851 return reloc_type
== 1; /* R_TILEPRO_32. */
12852 case EM_CYGNUS_V850
:
12854 return reloc_type
== 6; /* R_V850_ABS32. */
12856 return reloc_type
== 0x33; /* R_V810_WORD. */
12858 return reloc_type
== 1; /* R_VAX_32. */
12860 return reloc_type
== 3; /* R_VISIUM_32. */
12861 case EM_WEBASSEMBLY
:
12862 return reloc_type
== 1; /* R_WASM32_32. */
12866 return reloc_type
== 10; /* R_X86_64_32. */
12869 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12871 return reloc_type
== 4; /* R_XGATE_32. */
12873 return reloc_type
== 1; /* R_XSTROMY16_32. */
12874 case EM_XTENSA_OLD
:
12876 return reloc_type
== 1; /* R_XTENSA_32. */
12878 return reloc_type
== 6; /* R_Z80_32. */
12881 static unsigned int prev_warn
= 0;
12883 /* Avoid repeating the same warning multiple times. */
12884 if (prev_warn
!= filedata
->file_header
.e_machine
)
12885 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12886 filedata
->file_header
.e_machine
);
12887 prev_warn
= filedata
->file_header
.e_machine
;
12893 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12894 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12897 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12899 switch (filedata
->file_header
.e_machine
)
12900 /* Please keep this table alpha-sorted for ease of visual lookup. */
12904 return reloc_type
== 2; /* R_386_PC32. */
12906 return reloc_type
== 4; /* R_68K_PC32. */
12908 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12909 case EM_ADAPTEVA_EPIPHANY
:
12910 return reloc_type
== 6;
12912 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12913 case EM_ARC_COMPACT
:
12914 case EM_ARC_COMPACT2
:
12915 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12917 return reloc_type
== 3; /* R_ARM_REL32 */
12920 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12921 case EM_MICROBLAZE
:
12922 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12924 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12926 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12928 return reloc_type
== 26; /* R_PPC_REL32. */
12930 return reloc_type
== 26; /* R_PPC64_REL32. */
12932 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12935 return reloc_type
== 5; /* R_390_PC32. */
12937 return reloc_type
== 2; /* R_SH_REL32. */
12938 case EM_SPARC32PLUS
:
12941 return reloc_type
== 6; /* R_SPARC_DISP32. */
12943 return reloc_type
== 13; /* R_SPU_REL32. */
12945 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12947 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12949 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12953 return reloc_type
== 2; /* R_X86_64_PC32. */
12955 return reloc_type
== 4; /* R_VAX_PCREL32. */
12956 case EM_XTENSA_OLD
:
12958 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12960 /* Do not abort or issue an error message here. Not all targets use
12961 pc-relative 32-bit relocs in their DWARF debug information and we
12962 have already tested for target coverage in is_32bit_abs_reloc. A
12963 more helpful warning message will be generated by apply_relocations
12964 anyway, so just return. */
12969 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12970 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12973 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12975 switch (filedata
->file_header
.e_machine
)
12978 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12980 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12982 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12983 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12985 return reloc_type
== 80; /* R_PARISC_DIR64. */
12987 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12989 return reloc_type
== 2; /* R_RISCV_64. */
12990 case EM_SPARC32PLUS
:
12993 return reloc_type
== 32 /* R_SPARC_64. */
12994 || reloc_type
== 54; /* R_SPARC_UA64. */
12998 return reloc_type
== 1; /* R_X86_64_64. */
13001 return reloc_type
== 22; /* R_S390_64. */
13003 return reloc_type
== 1; /* R_TILEGX_64. */
13005 return reloc_type
== 18; /* R_MIPS_64. */
13011 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13012 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13015 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13017 switch (filedata
->file_header
.e_machine
)
13020 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13022 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13024 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13025 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13027 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13029 return reloc_type
== 44; /* R_PPC64_REL64. */
13030 case EM_SPARC32PLUS
:
13033 return reloc_type
== 46; /* R_SPARC_DISP64. */
13037 return reloc_type
== 24; /* R_X86_64_PC64. */
13040 return reloc_type
== 23; /* R_S390_PC64. */
13042 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13048 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13049 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13052 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13054 switch (filedata
->file_header
.e_machine
)
13056 case EM_CYGNUS_MN10200
:
13058 return reloc_type
== 4; /* R_MN10200_24. */
13060 return reloc_type
== 5; /* R_FT32_20. */
13062 return reloc_type
== 5; /* R_Z80_24. */
13068 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13069 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13072 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13074 /* Please keep this table alpha-sorted for ease of visual lookup. */
13075 switch (filedata
->file_header
.e_machine
)
13078 case EM_ARC_COMPACT
:
13079 case EM_ARC_COMPACT2
:
13080 return reloc_type
== 2; /* R_ARC_16. */
13081 case EM_ADAPTEVA_EPIPHANY
:
13082 return reloc_type
== 5;
13085 return reloc_type
== 4; /* R_AVR_16. */
13086 case EM_CYGNUS_D10V
:
13088 return reloc_type
== 3; /* R_D10V_16. */
13090 return reloc_type
== 2; /* R_FT32_16. */
13094 return reloc_type
== R_H8_DIR16
;
13097 return reloc_type
== 1; /* R_IP2K_16. */
13100 return reloc_type
== 1; /* R_M32C_16 */
13101 case EM_CYGNUS_MN10200
:
13103 return reloc_type
== 2; /* R_MN10200_16. */
13104 case EM_CYGNUS_MN10300
:
13106 return reloc_type
== 2; /* R_MN10300_16. */
13108 if (uses_msp430x_relocs (filedata
))
13109 return reloc_type
== 2; /* R_MSP430_ABS16. */
13110 /* Fall through. */
13111 case EM_MSP430_OLD
:
13112 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13114 return reloc_type
== 19; /* R_NDS32_RELA. */
13115 case EM_ALTERA_NIOS2
:
13116 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13118 return reloc_type
== 9; /* R_NIOS_16. */
13120 return reloc_type
== 2; /* R_OR1K_16. */
13122 return reloc_type
== 55; /* R_RISCV_SET16. */
13124 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13126 return reloc_type
== 2; /* R_C6000_ABS16. */
13128 return reloc_type
== 2; /* R_VISIUM_16. */
13131 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13133 return reloc_type
== 3; /* R_XGATE_16. */
13135 return reloc_type
== 4; /* R_Z80_16. */
13141 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13142 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13145 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13147 switch (filedata
->file_header
.e_machine
)
13150 return reloc_type
== 54; /* R_RISCV_SET8. */
13152 return reloc_type
== 1; /* R_Z80_8. */
13158 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13159 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13162 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13164 switch (filedata
->file_header
.e_machine
)
13167 return reloc_type
== 53; /* R_RISCV_SET6. */
13173 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13174 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13177 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13179 /* Please keep this table alpha-sorted for ease of visual lookup. */
13180 switch (filedata
->file_header
.e_machine
)
13183 return reloc_type
== 35; /* R_RISCV_ADD32. */
13189 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13190 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13193 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13195 /* Please keep this table alpha-sorted for ease of visual lookup. */
13196 switch (filedata
->file_header
.e_machine
)
13199 return reloc_type
== 39; /* R_RISCV_SUB32. */
13205 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13206 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13209 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13211 /* Please keep this table alpha-sorted for ease of visual lookup. */
13212 switch (filedata
->file_header
.e_machine
)
13215 return reloc_type
== 36; /* R_RISCV_ADD64. */
13221 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13222 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13225 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13227 /* Please keep this table alpha-sorted for ease of visual lookup. */
13228 switch (filedata
->file_header
.e_machine
)
13231 return reloc_type
== 40; /* R_RISCV_SUB64. */
13237 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13238 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13241 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13243 /* Please keep this table alpha-sorted for ease of visual lookup. */
13244 switch (filedata
->file_header
.e_machine
)
13247 return reloc_type
== 34; /* R_RISCV_ADD16. */
13253 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13254 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13257 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13259 /* Please keep this table alpha-sorted for ease of visual lookup. */
13260 switch (filedata
->file_header
.e_machine
)
13263 return reloc_type
== 38; /* R_RISCV_SUB16. */
13269 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13270 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13273 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13275 /* Please keep this table alpha-sorted for ease of visual lookup. */
13276 switch (filedata
->file_header
.e_machine
)
13279 return reloc_type
== 33; /* R_RISCV_ADD8. */
13285 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13286 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13289 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13291 /* Please keep this table alpha-sorted for ease of visual lookup. */
13292 switch (filedata
->file_header
.e_machine
)
13295 return reloc_type
== 37; /* R_RISCV_SUB8. */
13301 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13302 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13305 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13307 switch (filedata
->file_header
.e_machine
)
13310 return reloc_type
== 52; /* R_RISCV_SUB6. */
13316 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13317 relocation entries (possibly formerly used for SHT_GROUP sections). */
13320 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13322 switch (filedata
->file_header
.e_machine
)
13324 case EM_386
: /* R_386_NONE. */
13325 case EM_68K
: /* R_68K_NONE. */
13326 case EM_ADAPTEVA_EPIPHANY
:
13327 case EM_ALPHA
: /* R_ALPHA_NONE. */
13328 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13329 case EM_ARC
: /* R_ARC_NONE. */
13330 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13331 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13332 case EM_ARM
: /* R_ARM_NONE. */
13333 case EM_C166
: /* R_XC16X_NONE. */
13334 case EM_CRIS
: /* R_CRIS_NONE. */
13335 case EM_FT32
: /* R_FT32_NONE. */
13336 case EM_IA_64
: /* R_IA64_NONE. */
13337 case EM_K1OM
: /* R_X86_64_NONE. */
13338 case EM_L1OM
: /* R_X86_64_NONE. */
13339 case EM_M32R
: /* R_M32R_NONE. */
13340 case EM_MIPS
: /* R_MIPS_NONE. */
13341 case EM_MN10300
: /* R_MN10300_NONE. */
13342 case EM_MOXIE
: /* R_MOXIE_NONE. */
13343 case EM_NIOS32
: /* R_NIOS_NONE. */
13344 case EM_OR1K
: /* R_OR1K_NONE. */
13345 case EM_PARISC
: /* R_PARISC_NONE. */
13346 case EM_PPC64
: /* R_PPC64_NONE. */
13347 case EM_PPC
: /* R_PPC_NONE. */
13348 case EM_RISCV
: /* R_RISCV_NONE. */
13349 case EM_S390
: /* R_390_NONE. */
13351 case EM_SH
: /* R_SH_NONE. */
13352 case EM_SPARC32PLUS
:
13353 case EM_SPARC
: /* R_SPARC_NONE. */
13355 case EM_TILEGX
: /* R_TILEGX_NONE. */
13356 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13357 case EM_TI_C6000
:/* R_C6000_NONE. */
13358 case EM_X86_64
: /* R_X86_64_NONE. */
13360 case EM_Z80
: /* R_Z80_NONE. */
13361 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13362 return reloc_type
== 0;
13365 return reloc_type
== 0 || reloc_type
== 256;
13368 return (reloc_type
== 0 /* R_AVR_NONE. */
13369 || reloc_type
== 30 /* R_AVR_DIFF8. */
13370 || reloc_type
== 31 /* R_AVR_DIFF16. */
13371 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13373 return reloc_type
== 3; /* R_METAG_NONE. */
13375 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13376 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13377 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13378 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13379 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13381 return (reloc_type
== 0 /* R_PRU_NONE. */
13382 || reloc_type
== 65 /* R_PRU_DIFF8. */
13383 || reloc_type
== 66 /* R_PRU_DIFF16. */
13384 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13385 case EM_XTENSA_OLD
:
13387 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13388 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13389 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13390 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13391 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13392 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13393 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13394 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13395 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13396 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13401 /* Returns TRUE if there is a relocation against
13402 section NAME at OFFSET bytes. */
13405 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13407 Elf_Internal_Rela
* relocs
;
13408 Elf_Internal_Rela
* rp
;
13410 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13413 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13415 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13416 if (rp
->r_offset
== offset
)
13422 /* Apply relocations to a section.
13423 Returns TRUE upon success, FALSE otherwise.
13424 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13425 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13426 will be set to the number of relocs loaded.
13428 Note: So far support has been added only for those relocations
13429 which can be found in debug sections. FIXME: Add support for
13430 more relocations ? */
13433 apply_relocations (Filedata
* filedata
,
13434 const Elf_Internal_Shdr
* section
,
13435 unsigned char * start
,
13436 bfd_size_type size
,
13437 void ** relocs_return
,
13438 unsigned long * num_relocs_return
)
13440 Elf_Internal_Shdr
* relsec
;
13441 unsigned char * end
= start
+ size
;
13443 if (relocs_return
!= NULL
)
13445 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13446 * num_relocs_return
= 0;
13449 if (filedata
->file_header
.e_type
!= ET_REL
)
13450 /* No relocs to apply. */
13453 /* Find the reloc section associated with the section. */
13454 for (relsec
= filedata
->section_headers
;
13455 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13458 bfd_boolean is_rela
;
13459 unsigned long num_relocs
;
13460 Elf_Internal_Rela
* relocs
;
13461 Elf_Internal_Rela
* rp
;
13462 Elf_Internal_Shdr
* symsec
;
13463 Elf_Internal_Sym
* symtab
;
13464 unsigned long num_syms
;
13465 Elf_Internal_Sym
* sym
;
13467 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13468 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13469 || filedata
->section_headers
+ relsec
->sh_info
!= section
13470 || relsec
->sh_size
== 0
13471 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13474 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13475 if (symsec
->sh_type
!= SHT_SYMTAB
13476 && symsec
->sh_type
!= SHT_DYNSYM
)
13479 is_rela
= relsec
->sh_type
== SHT_RELA
;
13483 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13484 relsec
->sh_size
, & relocs
, & num_relocs
))
13489 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13490 relsec
->sh_size
, & relocs
, & num_relocs
))
13494 /* SH uses RELA but uses in place value instead of the addend field. */
13495 if (filedata
->file_header
.e_machine
== EM_SH
)
13498 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13500 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13503 unsigned int reloc_type
;
13504 unsigned int reloc_size
;
13505 bfd_boolean reloc_inplace
= FALSE
;
13506 bfd_boolean reloc_subtract
= FALSE
;
13507 unsigned char * rloc
;
13508 unsigned long sym_index
;
13510 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13512 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13514 else if (is_none_reloc (filedata
, reloc_type
))
13516 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13517 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13519 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13520 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13522 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13524 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13526 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13527 || is_6bit_abs_reloc (filedata
, reloc_type
))
13529 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13531 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13534 reloc_inplace
= TRUE
;
13536 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13538 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13541 reloc_inplace
= TRUE
;
13543 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13545 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13548 reloc_inplace
= TRUE
;
13550 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13552 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13555 reloc_inplace
= TRUE
;
13557 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13561 reloc_inplace
= TRUE
;
13565 static unsigned int prev_reloc
= 0;
13567 if (reloc_type
!= prev_reloc
)
13568 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13569 reloc_type
, printable_section_name (filedata
, section
));
13570 prev_reloc
= reloc_type
;
13574 rloc
= start
+ rp
->r_offset
;
13575 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13577 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13578 (unsigned long) rp
->r_offset
,
13579 printable_section_name (filedata
, section
));
13583 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13584 if (sym_index
>= num_syms
)
13586 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13587 sym_index
, printable_section_name (filedata
, section
));
13590 sym
= symtab
+ sym_index
;
13592 /* If the reloc has a symbol associated with it,
13593 make sure that it is of an appropriate type.
13595 Relocations against symbols without type can happen.
13596 Gcc -feliminate-dwarf2-dups may generate symbols
13597 without type for debug info.
13599 Icc generates relocations against function symbols
13600 instead of local labels.
13602 Relocations against object symbols can happen, eg when
13603 referencing a global array. For an example of this see
13604 the _clz.o binary in libgcc.a. */
13606 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13607 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13609 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13610 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13611 printable_section_name (filedata
, relsec
),
13612 (long int)(rp
- relocs
));
13618 addend
+= rp
->r_addend
;
13619 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13620 partial_inplace. */
13622 || (filedata
->file_header
.e_machine
== EM_XTENSA
13623 && reloc_type
== 1)
13624 || ((filedata
->file_header
.e_machine
== EM_PJ
13625 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13626 && reloc_type
== 1)
13627 || ((filedata
->file_header
.e_machine
== EM_D30V
13628 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13629 && reloc_type
== 12)
13632 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13633 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13635 addend
+= byte_get (rloc
, reloc_size
);
13638 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13639 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13641 /* On HPPA, all pc-relative relocations are biased by 8. */
13642 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13644 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13647 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13648 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13650 if (reloc_subtract
)
13651 addend
-= sym
->st_value
;
13653 addend
+= sym
->st_value
;
13654 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13655 byte_put (rloc
, addend
, reloc_size
);
13657 else if (reloc_subtract
)
13658 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13660 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13664 /* Let the target specific reloc processing code know that
13665 we have finished with these relocs. */
13666 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13670 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13671 * num_relocs_return
= num_relocs
;
13682 #ifdef SUPPORT_DISASSEMBLY
13684 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13686 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13688 /* FIXME: XXX -- to be done --- XXX */
13694 /* Reads in the contents of SECTION from FILE, returning a pointer
13695 to a malloc'ed buffer or NULL if something went wrong. */
13698 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13700 bfd_size_type num_bytes
= section
->sh_size
;
13702 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13704 printf (_("Section '%s' has no data to dump.\n"),
13705 printable_section_name (filedata
, section
));
13709 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13710 _("section contents"));
13713 /* Uncompresses a section that was compressed using zlib, in place. */
13716 uncompress_section_contents (unsigned char ** buffer
,
13717 dwarf_size_type uncompressed_size
,
13718 dwarf_size_type
* size
)
13720 dwarf_size_type compressed_size
= *size
;
13721 unsigned char * compressed_buffer
= *buffer
;
13722 unsigned char * uncompressed_buffer
;
13726 /* It is possible the section consists of several compressed
13727 buffers concatenated together, so we uncompress in a loop. */
13728 /* PR 18313: The state field in the z_stream structure is supposed
13729 to be invisible to the user (ie us), but some compilers will
13730 still complain about it being used without initialisation. So
13731 we first zero the entire z_stream structure and then set the fields
13733 memset (& strm
, 0, sizeof strm
);
13734 strm
.avail_in
= compressed_size
;
13735 strm
.next_in
= (Bytef
*) compressed_buffer
;
13736 strm
.avail_out
= uncompressed_size
;
13737 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13739 rc
= inflateInit (& strm
);
13740 while (strm
.avail_in
> 0)
13744 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13745 + (uncompressed_size
- strm
.avail_out
));
13746 rc
= inflate (&strm
, Z_FINISH
);
13747 if (rc
!= Z_STREAM_END
)
13749 rc
= inflateReset (& strm
);
13751 rc
= inflateEnd (& strm
);
13753 || strm
.avail_out
!= 0)
13756 *buffer
= uncompressed_buffer
;
13757 *size
= uncompressed_size
;
13761 free (uncompressed_buffer
);
13762 /* Indicate decompression failure. */
13768 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13770 Elf_Internal_Shdr
* relsec
;
13771 bfd_size_type num_bytes
;
13772 unsigned char * data
;
13773 unsigned char * end
;
13774 unsigned char * real_start
;
13775 unsigned char * start
;
13776 bfd_boolean some_strings_shown
;
13778 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13780 /* PR 21820: Do not fail if the section was empty. */
13781 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13783 num_bytes
= section
->sh_size
;
13785 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13787 if (decompress_dumps
)
13789 dwarf_size_type new_size
= num_bytes
;
13790 dwarf_size_type uncompressed_size
= 0;
13792 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13794 Elf_Internal_Chdr chdr
;
13795 unsigned int compression_header_size
13796 = get_compression_header (& chdr
, (unsigned char *) start
,
13798 if (compression_header_size
== 0)
13799 /* An error message will have already been generated
13800 by get_compression_header. */
13803 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13805 warn (_("section '%s' has unsupported compress type: %d\n"),
13806 printable_section_name (filedata
, section
), chdr
.ch_type
);
13809 uncompressed_size
= chdr
.ch_size
;
13810 start
+= compression_header_size
;
13811 new_size
-= compression_header_size
;
13813 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13815 /* Read the zlib header. In this case, it should be "ZLIB"
13816 followed by the uncompressed section size, 8 bytes in
13817 big-endian order. */
13818 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13819 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13820 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13821 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13822 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13823 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13824 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13825 uncompressed_size
+= start
[11];
13830 if (uncompressed_size
)
13832 if (uncompress_section_contents (& start
,
13833 uncompressed_size
, & new_size
))
13834 num_bytes
= new_size
;
13837 error (_("Unable to decompress section %s\n"),
13838 printable_section_name (filedata
, section
));
13843 start
= real_start
;
13846 /* If the section being dumped has relocations against it the user might
13847 be expecting these relocations to have been applied. Check for this
13848 case and issue a warning message in order to avoid confusion.
13849 FIXME: Maybe we ought to have an option that dumps a section with
13850 relocs applied ? */
13851 for (relsec
= filedata
->section_headers
;
13852 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13855 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13856 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13857 || filedata
->section_headers
+ relsec
->sh_info
!= section
13858 || relsec
->sh_size
== 0
13859 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13862 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13867 end
= start
+ num_bytes
;
13868 some_strings_shown
= FALSE
;
13870 #ifdef HAVE_MBSTATE_T
13872 /* Initialise the multibyte conversion state. */
13873 memset (& state
, 0, sizeof (state
));
13876 bfd_boolean continuing
= FALSE
;
13880 while (!ISPRINT (* data
))
13881 if (++ data
>= end
)
13886 size_t maxlen
= end
- data
;
13891 continuing
= FALSE
;
13896 /* PR 11128: Use two separate invocations in order to work
13897 around bugs in the Solaris 8 implementation of printf. */
13898 printf (" [%6tx] ", data
- start
);
13900 printf (" [%6Ix] ", (size_t) (data
- start
));
13915 /* PR 25543: Treat new-lines as string-ending characters. */
13924 /* Do not print control characters directly as they can affect terminal
13925 settings. Such characters usually appear in the names generated
13926 by the assembler for local labels. */
13929 printf ("^%c", c
+ 0x40);
13931 else if (ISPRINT (c
))
13938 #ifdef HAVE_MBSTATE_T
13941 /* Let printf do the hard work of displaying multibyte characters. */
13942 printf ("%.1s", data
- 1);
13943 #ifdef HAVE_MBSTATE_T
13944 /* Try to find out how many bytes made up the character that was
13945 just printed. Advance the symbol pointer past the bytes that
13947 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13951 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13961 printf (_("<corrupt>\n"));
13964 some_strings_shown
= TRUE
;
13968 if (! some_strings_shown
)
13969 printf (_(" No strings found in this section."));
13982 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13983 Filedata
* filedata
,
13984 bfd_boolean relocate
)
13986 Elf_Internal_Shdr
* relsec
;
13987 bfd_size_type bytes
;
13988 bfd_size_type section_size
;
13990 unsigned char * data
;
13991 unsigned char * real_start
;
13992 unsigned char * start
;
13994 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13996 /* PR 21820: Do not fail if the section was empty. */
13997 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13999 section_size
= section
->sh_size
;
14001 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
14003 if (decompress_dumps
)
14005 dwarf_size_type new_size
= section_size
;
14006 dwarf_size_type uncompressed_size
= 0;
14008 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14010 Elf_Internal_Chdr chdr
;
14011 unsigned int compression_header_size
14012 = get_compression_header (& chdr
, start
, section_size
);
14014 if (compression_header_size
== 0)
14015 /* An error message will have already been generated
14016 by get_compression_header. */
14019 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14021 warn (_("section '%s' has unsupported compress type: %d\n"),
14022 printable_section_name (filedata
, section
), chdr
.ch_type
);
14025 uncompressed_size
= chdr
.ch_size
;
14026 start
+= compression_header_size
;
14027 new_size
-= compression_header_size
;
14029 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14031 /* Read the zlib header. In this case, it should be "ZLIB"
14032 followed by the uncompressed section size, 8 bytes in
14033 big-endian order. */
14034 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14035 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14036 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14037 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14038 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14039 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14040 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14041 uncompressed_size
+= start
[11];
14046 if (uncompressed_size
)
14048 if (uncompress_section_contents (& start
, uncompressed_size
,
14051 section_size
= new_size
;
14055 error (_("Unable to decompress section %s\n"),
14056 printable_section_name (filedata
, section
));
14057 /* FIXME: Print the section anyway ? */
14062 start
= real_start
;
14067 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14072 /* If the section being dumped has relocations against it the user might
14073 be expecting these relocations to have been applied. Check for this
14074 case and issue a warning message in order to avoid confusion.
14075 FIXME: Maybe we ought to have an option that dumps a section with
14076 relocs applied ? */
14077 for (relsec
= filedata
->section_headers
;
14078 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14081 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14082 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14083 || filedata
->section_headers
+ relsec
->sh_info
!= section
14084 || relsec
->sh_size
== 0
14085 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14088 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14093 addr
= section
->sh_addr
;
14094 bytes
= section_size
;
14103 lbytes
= (bytes
> 16 ? 16 : bytes
);
14105 printf (" 0x%8.8lx ", (unsigned long) addr
);
14107 for (j
= 0; j
< 16; j
++)
14110 printf ("%2.2x", data
[j
]);
14118 for (j
= 0; j
< lbytes
; j
++)
14121 if (k
>= ' ' && k
< 0x7f)
14144 static ctf_sect_t
*
14145 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14147 buf
->cts_name
= SECTION_NAME (shdr
);
14148 buf
->cts_size
= shdr
->sh_size
;
14149 buf
->cts_entsize
= shdr
->sh_entsize
;
14154 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14155 it is passed, or a pointer to newly-allocated storage, in which case
14156 dump_ctf() will free it when it no longer needs it. */
14158 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14159 char *s
, void *arg
)
14161 const char *blanks
= arg
;
14164 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14170 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14172 Elf_Internal_Shdr
* parent_sec
= NULL
;
14173 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14174 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14175 void * data
= NULL
;
14176 void * symdata
= NULL
;
14177 void * strdata
= NULL
;
14178 void * parentdata
= NULL
;
14179 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14180 ctf_sect_t
* symsectp
= NULL
;
14181 ctf_sect_t
* strsectp
= NULL
;
14182 ctf_file_t
* ctf
= NULL
;
14183 ctf_file_t
* parent
= NULL
;
14185 const char *things
[] = {"Header", "Labels", "Data objects",
14186 "Function objects", "Variables", "Types", "Strings",
14188 const char **thing
;
14190 bfd_boolean ret
= FALSE
;
14193 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14194 data
= get_section_contents (section
, filedata
);
14195 ctfsect
.cts_data
= data
;
14197 if (!dump_ctf_symtab_name
)
14198 dump_ctf_symtab_name
= strdup (".symtab");
14200 if (!dump_ctf_strtab_name
)
14201 dump_ctf_strtab_name
= strdup (".strtab");
14203 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14205 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14207 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14210 if ((symdata
= (void *) get_data (NULL
, filedata
,
14211 symtab_sec
->sh_offset
, 1,
14212 symtab_sec
->sh_size
,
14213 _("symbols"))) == NULL
)
14215 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14216 symsect
.cts_data
= symdata
;
14218 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14220 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14222 error (_("No string table section named %s\n"),
14223 dump_ctf_strtab_name
);
14226 if ((strdata
= (void *) get_data (NULL
, filedata
,
14227 strtab_sec
->sh_offset
, 1,
14228 strtab_sec
->sh_size
,
14229 _("strings"))) == NULL
)
14231 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14232 strsect
.cts_data
= strdata
;
14234 if (dump_ctf_parent_name
)
14236 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14238 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14241 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14242 parent_sec
->sh_offset
, 1,
14243 parent_sec
->sh_size
,
14244 _("CTF parent"))) == NULL
)
14246 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14247 parentsect
.cts_data
= parentdata
;
14250 /* Load the CTF file and dump it. */
14252 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14254 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14260 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14262 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14266 ctf_import (ctf
, parent
);
14271 printf (_("\nDump of CTF section '%s':\n"),
14272 printable_section_name (filedata
, section
));
14274 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14276 ctf_dump_state_t
*s
= NULL
;
14279 printf ("\n %s:\n", *thing
);
14280 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14281 (void *) " ")) != NULL
)
14283 printf ("%s\n", item
);
14287 if (ctf_errno (ctf
))
14289 error (_("Iteration failed: %s, %s\n"), *thing
,
14290 ctf_errmsg (ctf_errno (ctf
)));
14296 ctf_file_close (ctf
);
14297 ctf_file_close (parent
);
14306 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14307 const Elf_Internal_Shdr
* sec
,
14310 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14312 Filedata
* filedata
= (Filedata
*) data
;
14314 if (section
->start
!= NULL
)
14316 /* If it is already loaded, do nothing. */
14317 if (streq (section
->filename
, filedata
->file_name
))
14319 free (section
->start
);
14322 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14323 section
->address
= sec
->sh_addr
;
14324 section
->user_data
= NULL
;
14325 section
->filename
= filedata
->file_name
;
14326 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14328 sec
->sh_size
, buf
);
14329 if (section
->start
== NULL
)
14333 unsigned char *start
= section
->start
;
14334 dwarf_size_type size
= sec
->sh_size
;
14335 dwarf_size_type uncompressed_size
= 0;
14337 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14339 Elf_Internal_Chdr chdr
;
14340 unsigned int compression_header_size
;
14342 if (size
< (is_32bit_elf
14343 ? sizeof (Elf32_External_Chdr
)
14344 : sizeof (Elf64_External_Chdr
)))
14346 warn (_("compressed section %s is too small to contain a compression header\n"),
14351 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14352 if (compression_header_size
== 0)
14353 /* An error message will have already been generated
14354 by get_compression_header. */
14357 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14359 warn (_("section '%s' has unsupported compress type: %d\n"),
14360 section
->name
, chdr
.ch_type
);
14363 uncompressed_size
= chdr
.ch_size
;
14364 start
+= compression_header_size
;
14365 size
-= compression_header_size
;
14367 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14369 /* Read the zlib header. In this case, it should be "ZLIB"
14370 followed by the uncompressed section size, 8 bytes in
14371 big-endian order. */
14372 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14373 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14374 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14375 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14376 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14377 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14378 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14379 uncompressed_size
+= start
[11];
14384 if (uncompressed_size
)
14386 if (uncompress_section_contents (&start
, uncompressed_size
,
14389 /* Free the compressed buffer, update the section buffer
14390 and the section size if uncompress is successful. */
14391 free (section
->start
);
14392 section
->start
= start
;
14396 error (_("Unable to decompress section %s\n"),
14397 printable_section_name (filedata
, sec
));
14402 section
->size
= size
;
14405 if (section
->start
== NULL
)
14408 if (debug_displays
[debug
].relocate
)
14410 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14411 & section
->reloc_info
, & section
->num_relocs
))
14416 section
->reloc_info
= NULL
;
14417 section
->num_relocs
= 0;
14423 #if HAVE_LIBDEBUGINFOD
14424 /* Return a hex string representation of the build-id. */
14426 get_build_id (void * data
)
14428 Filedata
* filedata
= (Filedata
*)data
;
14429 Elf_Internal_Shdr
* shdr
;
14432 /* Iterate through notes to find note.gnu.build-id.
14433 FIXME: Only the first note in any note section is examined. */
14434 for (i
= 0, shdr
= filedata
->section_headers
;
14435 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14438 if (shdr
->sh_type
!= SHT_NOTE
)
14443 size_t data_remaining
;
14445 Elf_External_Note
* enote
;
14446 Elf_Internal_Note inote
;
14448 bfd_vma offset
= shdr
->sh_offset
;
14449 bfd_vma align
= shdr
->sh_addralign
;
14450 bfd_vma length
= shdr
->sh_size
;
14452 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14458 else if (align
!= 4 && align
!= 8)
14464 end
= (char *) enote
+ length
;
14465 data_remaining
= end
- (char *) enote
;
14467 if (!is_ia64_vms (filedata
))
14469 min_notesz
= offsetof (Elf_External_Note
, name
);
14470 if (data_remaining
< min_notesz
)
14473 malformed note encountered in section %s whilst scanning for build-id note\n"),
14474 printable_section_name (filedata
, shdr
));
14478 data_remaining
-= min_notesz
;
14480 inote
.type
= BYTE_GET (enote
->type
);
14481 inote
.namesz
= BYTE_GET (enote
->namesz
);
14482 inote
.namedata
= enote
->name
;
14483 inote
.descsz
= BYTE_GET (enote
->descsz
);
14484 inote
.descdata
= ((char *) enote
14485 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14486 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14487 next
= ((char *) enote
14488 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14492 Elf64_External_VMS_Note
*vms_enote
;
14494 /* PR binutils/15191
14495 Make sure that there is enough data to read. */
14496 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14497 if (data_remaining
< min_notesz
)
14500 malformed note encountered in section %s whilst scanning for build-id note\n"),
14501 printable_section_name (filedata
, shdr
));
14505 data_remaining
-= min_notesz
;
14507 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14508 inote
.type
= BYTE_GET (vms_enote
->type
);
14509 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14510 inote
.namedata
= vms_enote
->name
;
14511 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14512 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14513 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14514 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14517 /* Skip malformed notes. */
14518 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14519 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14520 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14521 || ((size_t) (next
- inote
.descdata
)
14522 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14525 malformed note encountered in section %s whilst scanning for build-id note\n"),
14526 printable_section_name (filedata
, shdr
));
14531 /* Check if this is the build-id note. If so then convert the build-id
14532 bytes to a hex string. */
14533 if (inote
.namesz
> 0
14534 && const_strneq (inote
.namedata
, "GNU")
14535 && inote
.type
== NT_GNU_BUILD_ID
)
14540 build_id
= malloc (inote
.descsz
* 2 + 1);
14541 if (build_id
== NULL
)
14547 for (j
= 0; j
< inote
.descsz
; ++j
)
14548 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14549 build_id
[inote
.descsz
* 2] = '\0';
14552 return (unsigned char *) build_id
;
14559 #endif /* HAVE_LIBDEBUGINFOD */
14561 /* If this is not NULL, load_debug_section will only look for sections
14562 within the list of sections given here. */
14563 static unsigned int * section_subset
= NULL
;
14566 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14568 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14569 Elf_Internal_Shdr
* sec
;
14570 Filedata
* filedata
= (Filedata
*) data
;
14572 /* Without section headers we cannot find any sections. */
14573 if (filedata
->section_headers
== NULL
)
14576 if (filedata
->string_table
== NULL
14577 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14578 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14580 Elf_Internal_Shdr
* strs
;
14582 /* Read in the string table, so that we have section names to scan. */
14583 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14585 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14587 filedata
->string_table
14588 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14589 1, strs
->sh_size
, _("string table"));
14591 filedata
->string_table_length
14592 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14596 /* Locate the debug section. */
14597 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14599 section
->name
= section
->uncompressed_name
;
14602 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14604 section
->name
= section
->compressed_name
;
14609 /* If we're loading from a subset of sections, and we've loaded
14610 a section matching this name before, it's likely that it's a
14612 if (section_subset
!= NULL
)
14613 free_debug_section (debug
);
14615 return load_specific_debug_section (debug
, sec
, data
);
14619 free_debug_section (enum dwarf_section_display_enum debug
)
14621 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14623 if (section
->start
== NULL
)
14626 free ((char *) section
->start
);
14627 section
->start
= NULL
;
14628 section
->address
= 0;
14631 if (section
->reloc_info
!= NULL
)
14633 free (section
->reloc_info
);
14634 section
->reloc_info
= NULL
;
14635 section
->num_relocs
= 0;
14640 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14642 char * name
= SECTION_NAME (section
);
14643 const char * print_name
= printable_section_name (filedata
, section
);
14644 bfd_size_type length
;
14645 bfd_boolean result
= TRUE
;
14648 length
= section
->sh_size
;
14651 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14654 if (section
->sh_type
== SHT_NOBITS
)
14656 /* There is no point in dumping the contents of a debugging section
14657 which has the NOBITS type - the bits in the file will be random.
14658 This can happen when a file containing a .eh_frame section is
14659 stripped with the --only-keep-debug command line option. */
14660 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14665 if (const_strneq (name
, ".gnu.linkonce.wi."))
14666 name
= ".debug_info";
14668 /* See if we know how to display the contents of this section. */
14669 for (i
= 0; i
< max
; i
++)
14671 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14672 struct dwarf_section_display
* display
= debug_displays
+ i
;
14673 struct dwarf_section
* sec
= & display
->section
;
14675 if (streq (sec
->uncompressed_name
, name
)
14676 || (id
== line
&& const_strneq (name
, ".debug_line."))
14677 || streq (sec
->compressed_name
, name
))
14679 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14682 free_debug_section (id
);
14684 if (i
== line
&& const_strneq (name
, ".debug_line."))
14686 else if (streq (sec
->uncompressed_name
, name
))
14687 sec
->name
= sec
->uncompressed_name
;
14689 sec
->name
= sec
->compressed_name
;
14691 if (load_specific_debug_section (id
, section
, filedata
))
14693 /* If this debug section is part of a CU/TU set in a .dwp file,
14694 restrict load_debug_section to the sections in that set. */
14695 section_subset
= find_cu_tu_set (filedata
, shndx
);
14697 result
&= display
->display (sec
, filedata
);
14699 section_subset
= NULL
;
14701 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14702 free_debug_section (id
);
14710 printf (_("Unrecognized debug section: %s\n"), print_name
);
14717 /* Set DUMP_SECTS for all sections where dumps were requested
14718 based on section name. */
14721 initialise_dumps_byname (Filedata
* filedata
)
14723 struct dump_list_entry
* cur
;
14725 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14728 bfd_boolean any
= FALSE
;
14730 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14731 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14733 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14738 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14744 process_section_contents (Filedata
* filedata
)
14746 Elf_Internal_Shdr
* section
;
14748 bfd_boolean res
= TRUE
;
14753 initialise_dumps_byname (filedata
);
14755 for (i
= 0, section
= filedata
->section_headers
;
14756 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14759 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14761 #ifdef SUPPORT_DISASSEMBLY
14762 if (dump
& DISASS_DUMP
)
14764 if (! disassemble_section (section
, filedata
))
14768 if (dump
& HEX_DUMP
)
14770 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14774 if (dump
& RELOC_DUMP
)
14776 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14780 if (dump
& STRING_DUMP
)
14782 if (! dump_section_as_strings (section
, filedata
))
14786 if (dump
& DEBUG_DUMP
)
14788 if (! display_debug_section (i
, section
, filedata
))
14792 if (dump
& CTF_DUMP
)
14794 if (! dump_section_as_ctf (section
, filedata
))
14799 /* Check to see if the user requested a
14800 dump of a section that does not exist. */
14801 while (i
< filedata
->dump
.num_dump_sects
)
14803 if (filedata
->dump
.dump_sects
[i
])
14805 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14815 process_mips_fpe_exception (int mask
)
14819 bfd_boolean first
= TRUE
;
14821 if (mask
& OEX_FPU_INEX
)
14822 fputs ("INEX", stdout
), first
= FALSE
;
14823 if (mask
& OEX_FPU_UFLO
)
14824 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14825 if (mask
& OEX_FPU_OFLO
)
14826 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14827 if (mask
& OEX_FPU_DIV0
)
14828 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14829 if (mask
& OEX_FPU_INVAL
)
14830 printf ("%sINVAL", first
? "" : "|");
14833 fputs ("0", stdout
);
14836 /* Display's the value of TAG at location P. If TAG is
14837 greater than 0 it is assumed to be an unknown tag, and
14838 a message is printed to this effect. Otherwise it is
14839 assumed that a message has already been printed.
14841 If the bottom bit of TAG is set it assumed to have a
14842 string value, otherwise it is assumed to have an integer
14845 Returns an updated P pointing to the first unread byte
14846 beyond the end of TAG's value.
14848 Reads at or beyond END will not be made. */
14850 static unsigned char *
14851 display_tag_value (signed int tag
,
14853 const unsigned char * const end
)
14858 printf (" Tag_unknown_%d: ", tag
);
14862 warn (_("<corrupt tag>\n"));
14866 /* PR 17531 file: 027-19978-0.004. */
14867 size_t maxlen
= (end
- p
) - 1;
14872 print_symbol ((int) maxlen
, (const char *) p
);
14873 p
+= strnlen ((char *) p
, maxlen
) + 1;
14877 printf (_("<corrupt string tag>"));
14878 p
= (unsigned char *) end
;
14884 READ_ULEB (val
, p
, end
);
14885 printf ("%ld (0x%lx)\n", val
, val
);
14892 /* ARC ABI attributes section. */
14894 static unsigned char *
14895 display_arc_attribute (unsigned char * p
,
14896 const unsigned char * const end
)
14901 READ_ULEB (tag
, p
, end
);
14905 case Tag_ARC_PCS_config
:
14906 READ_ULEB (val
, p
, end
);
14907 printf (" Tag_ARC_PCS_config: ");
14911 printf (_("Absent/Non standard\n"));
14914 printf (_("Bare metal/mwdt\n"));
14917 printf (_("Bare metal/newlib\n"));
14920 printf (_("Linux/uclibc\n"));
14923 printf (_("Linux/glibc\n"));
14926 printf (_("Unknown\n"));
14931 case Tag_ARC_CPU_base
:
14932 READ_ULEB (val
, p
, end
);
14933 printf (" Tag_ARC_CPU_base: ");
14938 printf (_("Absent\n"));
14940 case TAG_CPU_ARC6xx
:
14941 printf ("ARC6xx\n");
14943 case TAG_CPU_ARC7xx
:
14944 printf ("ARC7xx\n");
14946 case TAG_CPU_ARCEM
:
14947 printf ("ARCEM\n");
14949 case TAG_CPU_ARCHS
:
14950 printf ("ARCHS\n");
14955 case Tag_ARC_CPU_variation
:
14956 READ_ULEB (val
, p
, end
);
14957 printf (" Tag_ARC_CPU_variation: ");
14961 if (val
> 0 && val
< 16)
14962 printf ("Core%d\n", val
);
14964 printf ("Unknown\n");
14968 printf (_("Absent\n"));
14973 case Tag_ARC_CPU_name
:
14974 printf (" Tag_ARC_CPU_name: ");
14975 p
= display_tag_value (-1, p
, end
);
14978 case Tag_ARC_ABI_rf16
:
14979 READ_ULEB (val
, p
, end
);
14980 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14983 case Tag_ARC_ABI_osver
:
14984 READ_ULEB (val
, p
, end
);
14985 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14988 case Tag_ARC_ABI_pic
:
14989 case Tag_ARC_ABI_sda
:
14990 READ_ULEB (val
, p
, end
);
14991 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14992 : " Tag_ARC_ABI_pic: ");
14996 printf (_("Absent\n"));
15005 printf (_("Unknown\n"));
15010 case Tag_ARC_ABI_tls
:
15011 READ_ULEB (val
, p
, end
);
15012 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15015 case Tag_ARC_ABI_enumsize
:
15016 READ_ULEB (val
, p
, end
);
15017 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15021 case Tag_ARC_ABI_exceptions
:
15022 READ_ULEB (val
, p
, end
);
15023 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15027 case Tag_ARC_ABI_double_size
:
15028 READ_ULEB (val
, p
, end
);
15029 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15032 case Tag_ARC_ISA_config
:
15033 printf (" Tag_ARC_ISA_config: ");
15034 p
= display_tag_value (-1, p
, end
);
15037 case Tag_ARC_ISA_apex
:
15038 printf (" Tag_ARC_ISA_apex: ");
15039 p
= display_tag_value (-1, p
, end
);
15042 case Tag_ARC_ISA_mpy_option
:
15043 READ_ULEB (val
, p
, end
);
15044 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15047 case Tag_ARC_ATR_version
:
15048 READ_ULEB (val
, p
, end
);
15049 printf (" Tag_ARC_ATR_version: %d\n", val
);
15053 return display_tag_value (tag
& 1, p
, end
);
15059 /* ARM EABI attributes section. */
15064 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15066 const char ** table
;
15067 } arm_attr_public_tag
;
15069 static const char * arm_attr_tag_CPU_arch
[] =
15070 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15071 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15072 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15073 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15074 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15075 {"No", "Thumb-1", "Thumb-2", "Yes"};
15076 static const char * arm_attr_tag_FP_arch
[] =
15077 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15078 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15079 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15080 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15081 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15082 "NEON for ARMv8.1"};
15083 static const char * arm_attr_tag_PCS_config
[] =
15084 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15085 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15086 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15087 {"V6", "SB", "TLS", "Unused"};
15088 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15089 {"Absolute", "PC-relative", "SB-relative", "None"};
15090 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15091 {"Absolute", "PC-relative", "None"};
15092 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15093 {"None", "direct", "GOT-indirect"};
15094 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15095 {"None", "??? 1", "2", "??? 3", "4"};
15096 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15097 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15098 {"Unused", "Needed", "Sign only"};
15099 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15100 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15101 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15102 {"Unused", "Finite", "RTABI", "IEEE 754"};
15103 static const char * arm_attr_tag_ABI_enum_size
[] =
15104 {"Unused", "small", "int", "forced to int"};
15105 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15106 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15107 static const char * arm_attr_tag_ABI_VFP_args
[] =
15108 {"AAPCS", "VFP registers", "custom", "compatible"};
15109 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15110 {"AAPCS", "WMMX registers", "custom"};
15111 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15112 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15113 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15114 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15115 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15116 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15117 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15118 static const char * arm_attr_tag_FP_HP_extension
[] =
15119 {"Not Allowed", "Allowed"};
15120 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15121 {"None", "IEEE 754", "Alternative Format"};
15122 static const char * arm_attr_tag_DSP_extension
[] =
15123 {"Follow architecture", "Allowed"};
15124 static const char * arm_attr_tag_MPextension_use
[] =
15125 {"Not Allowed", "Allowed"};
15126 static const char * arm_attr_tag_DIV_use
[] =
15127 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15128 "Allowed in v7-A with integer division extension"};
15129 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15130 static const char * arm_attr_tag_Virtualization_use
[] =
15131 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15132 "TrustZone and Virtualization Extensions"};
15133 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15134 {"Not Allowed", "Allowed"};
15136 static const char * arm_attr_tag_MVE_arch
[] =
15137 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15139 #define LOOKUP(id, name) \
15140 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15141 static arm_attr_public_tag arm_attr_public_tags
[] =
15143 {4, "CPU_raw_name", 1, NULL
},
15144 {5, "CPU_name", 1, NULL
},
15145 LOOKUP(6, CPU_arch
),
15146 {7, "CPU_arch_profile", 0, NULL
},
15147 LOOKUP(8, ARM_ISA_use
),
15148 LOOKUP(9, THUMB_ISA_use
),
15149 LOOKUP(10, FP_arch
),
15150 LOOKUP(11, WMMX_arch
),
15151 LOOKUP(12, Advanced_SIMD_arch
),
15152 LOOKUP(13, PCS_config
),
15153 LOOKUP(14, ABI_PCS_R9_use
),
15154 LOOKUP(15, ABI_PCS_RW_data
),
15155 LOOKUP(16, ABI_PCS_RO_data
),
15156 LOOKUP(17, ABI_PCS_GOT_use
),
15157 LOOKUP(18, ABI_PCS_wchar_t
),
15158 LOOKUP(19, ABI_FP_rounding
),
15159 LOOKUP(20, ABI_FP_denormal
),
15160 LOOKUP(21, ABI_FP_exceptions
),
15161 LOOKUP(22, ABI_FP_user_exceptions
),
15162 LOOKUP(23, ABI_FP_number_model
),
15163 {24, "ABI_align_needed", 0, NULL
},
15164 {25, "ABI_align_preserved", 0, NULL
},
15165 LOOKUP(26, ABI_enum_size
),
15166 LOOKUP(27, ABI_HardFP_use
),
15167 LOOKUP(28, ABI_VFP_args
),
15168 LOOKUP(29, ABI_WMMX_args
),
15169 LOOKUP(30, ABI_optimization_goals
),
15170 LOOKUP(31, ABI_FP_optimization_goals
),
15171 {32, "compatibility", 0, NULL
},
15172 LOOKUP(34, CPU_unaligned_access
),
15173 LOOKUP(36, FP_HP_extension
),
15174 LOOKUP(38, ABI_FP_16bit_format
),
15175 LOOKUP(42, MPextension_use
),
15176 LOOKUP(44, DIV_use
),
15177 LOOKUP(46, DSP_extension
),
15178 LOOKUP(48, MVE_arch
),
15179 {64, "nodefaults", 0, NULL
},
15180 {65, "also_compatible_with", 0, NULL
},
15181 LOOKUP(66, T2EE_use
),
15182 {67, "conformance", 1, NULL
},
15183 LOOKUP(68, Virtualization_use
),
15184 LOOKUP(70, MPextension_use_legacy
)
15188 static unsigned char *
15189 display_arm_attribute (unsigned char * p
,
15190 const unsigned char * const end
)
15194 arm_attr_public_tag
* attr
;
15198 READ_ULEB (tag
, p
, end
);
15200 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15202 if (arm_attr_public_tags
[i
].tag
== tag
)
15204 attr
= &arm_attr_public_tags
[i
];
15211 printf (" Tag_%s: ", attr
->name
);
15212 switch (attr
->type
)
15217 case 7: /* Tag_CPU_arch_profile. */
15218 READ_ULEB (val
, p
, end
);
15221 case 0: printf (_("None\n")); break;
15222 case 'A': printf (_("Application\n")); break;
15223 case 'R': printf (_("Realtime\n")); break;
15224 case 'M': printf (_("Microcontroller\n")); break;
15225 case 'S': printf (_("Application or Realtime\n")); break;
15226 default: printf ("??? (%d)\n", val
); break;
15230 case 24: /* Tag_align_needed. */
15231 READ_ULEB (val
, p
, end
);
15234 case 0: printf (_("None\n")); break;
15235 case 1: printf (_("8-byte\n")); break;
15236 case 2: printf (_("4-byte\n")); break;
15237 case 3: printf ("??? 3\n"); break;
15240 printf (_("8-byte and up to %d-byte extended\n"),
15243 printf ("??? (%d)\n", val
);
15248 case 25: /* Tag_align_preserved. */
15249 READ_ULEB (val
, p
, end
);
15252 case 0: printf (_("None\n")); break;
15253 case 1: printf (_("8-byte, except leaf SP\n")); break;
15254 case 2: printf (_("8-byte\n")); break;
15255 case 3: printf ("??? 3\n"); break;
15258 printf (_("8-byte and up to %d-byte extended\n"),
15261 printf ("??? (%d)\n", val
);
15266 case 32: /* Tag_compatibility. */
15268 READ_ULEB (val
, p
, end
);
15269 printf (_("flag = %d, vendor = "), val
);
15272 size_t maxlen
= (end
- p
) - 1;
15274 print_symbol ((int) maxlen
, (const char *) p
);
15275 p
+= strnlen ((char *) p
, maxlen
) + 1;
15279 printf (_("<corrupt>"));
15280 p
= (unsigned char *) end
;
15286 case 64: /* Tag_nodefaults. */
15287 /* PR 17531: file: 001-505008-0.01. */
15290 printf (_("True\n"));
15293 case 65: /* Tag_also_compatible_with. */
15294 READ_ULEB (val
, p
, end
);
15295 if (val
== 6 /* Tag_CPU_arch. */)
15297 READ_ULEB (val
, p
, end
);
15298 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15299 printf ("??? (%d)\n", val
);
15301 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15305 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15310 printf (_("<unknown: %d>\n"), tag
);
15316 return display_tag_value (-1, p
, end
);
15318 return display_tag_value (0, p
, end
);
15321 assert (attr
->type
& 0x80);
15322 READ_ULEB (val
, p
, end
);
15323 type
= attr
->type
& 0x7f;
15325 printf ("??? (%d)\n", val
);
15327 printf ("%s\n", attr
->table
[val
]);
15332 return display_tag_value (tag
, p
, end
);
15335 static unsigned char *
15336 display_gnu_attribute (unsigned char * p
,
15337 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15338 const unsigned char * const end
)
15343 READ_ULEB (tag
, p
, end
);
15345 /* Tag_compatibility is the only generic GNU attribute defined at
15349 READ_ULEB (val
, p
, end
);
15351 printf (_("flag = %d, vendor = "), val
);
15354 printf (_("<corrupt>\n"));
15355 warn (_("corrupt vendor attribute\n"));
15361 size_t maxlen
= (end
- p
) - 1;
15363 print_symbol ((int) maxlen
, (const char *) p
);
15364 p
+= strnlen ((char *) p
, maxlen
) + 1;
15368 printf (_("<corrupt>"));
15369 p
= (unsigned char *) end
;
15376 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15377 return display_proc_gnu_attribute (p
, tag
, end
);
15379 return display_tag_value (tag
, p
, end
);
15382 static unsigned char *
15383 display_power_gnu_attribute (unsigned char * p
,
15385 const unsigned char * const end
)
15389 if (tag
== Tag_GNU_Power_ABI_FP
)
15391 printf (" Tag_GNU_Power_ABI_FP: ");
15394 printf (_("<corrupt>\n"));
15397 READ_ULEB (val
, p
, end
);
15400 printf ("(%#x), ", val
);
15405 printf (_("unspecified hard/soft float, "));
15408 printf (_("hard float, "));
15411 printf (_("soft float, "));
15414 printf (_("single-precision hard float, "));
15421 printf (_("unspecified long double\n"));
15424 printf (_("128-bit IBM long double\n"));
15427 printf (_("64-bit long double\n"));
15430 printf (_("128-bit IEEE long double\n"));
15436 if (tag
== Tag_GNU_Power_ABI_Vector
)
15438 printf (" Tag_GNU_Power_ABI_Vector: ");
15441 printf (_("<corrupt>\n"));
15444 READ_ULEB (val
, p
, end
);
15447 printf ("(%#x), ", val
);
15452 printf (_("unspecified\n"));
15455 printf (_("generic\n"));
15458 printf ("AltiVec\n");
15467 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15469 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15472 printf (_("<corrupt>\n"));
15475 READ_ULEB (val
, p
, end
);
15478 printf ("(%#x), ", val
);
15483 printf (_("unspecified\n"));
15486 printf ("r3/r4\n");
15489 printf (_("memory\n"));
15498 return display_tag_value (tag
& 1, p
, end
);
15501 static unsigned char *
15502 display_s390_gnu_attribute (unsigned char * p
,
15504 const unsigned char * const end
)
15508 if (tag
== Tag_GNU_S390_ABI_Vector
)
15510 printf (" Tag_GNU_S390_ABI_Vector: ");
15511 READ_ULEB (val
, p
, end
);
15516 printf (_("any\n"));
15519 printf (_("software\n"));
15522 printf (_("hardware\n"));
15525 printf ("??? (%d)\n", val
);
15531 return display_tag_value (tag
& 1, p
, end
);
15535 display_sparc_hwcaps (unsigned int mask
)
15539 bfd_boolean first
= TRUE
;
15541 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15542 fputs ("mul32", stdout
), first
= FALSE
;
15543 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15544 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15545 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15546 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15547 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15548 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15549 if (mask
& ELF_SPARC_HWCAP_POPC
)
15550 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15551 if (mask
& ELF_SPARC_HWCAP_VIS
)
15552 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15553 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15554 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15555 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15556 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15557 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15558 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15559 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15560 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15561 if (mask
& ELF_SPARC_HWCAP_HPC
)
15562 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15563 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15564 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15565 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15566 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15567 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15568 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15569 if (mask
& ELF_SPARC_HWCAP_IMA
)
15570 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15571 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15572 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15575 fputc ('0', stdout
);
15576 fputc ('\n', stdout
);
15580 display_sparc_hwcaps2 (unsigned int mask
)
15584 bfd_boolean first
= TRUE
;
15586 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15587 fputs ("fjathplus", stdout
), first
= FALSE
;
15588 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15589 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15590 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15591 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15592 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15593 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15594 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15595 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15596 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15597 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15598 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15599 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15600 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15601 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15602 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15603 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15604 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15605 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15606 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15607 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15610 fputc ('0', stdout
);
15611 fputc ('\n', stdout
);
15614 static unsigned char *
15615 display_sparc_gnu_attribute (unsigned char * p
,
15617 const unsigned char * const end
)
15621 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15623 READ_ULEB (val
, p
, end
);
15624 printf (" Tag_GNU_Sparc_HWCAPS: ");
15625 display_sparc_hwcaps (val
);
15628 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15630 READ_ULEB (val
, p
, end
);
15631 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15632 display_sparc_hwcaps2 (val
);
15636 return display_tag_value (tag
, p
, end
);
15640 print_mips_fp_abi_value (unsigned int val
)
15644 case Val_GNU_MIPS_ABI_FP_ANY
:
15645 printf (_("Hard or soft float\n"));
15647 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15648 printf (_("Hard float (double precision)\n"));
15650 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15651 printf (_("Hard float (single precision)\n"));
15653 case Val_GNU_MIPS_ABI_FP_SOFT
:
15654 printf (_("Soft float\n"));
15656 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15657 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15659 case Val_GNU_MIPS_ABI_FP_XX
:
15660 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15662 case Val_GNU_MIPS_ABI_FP_64
:
15663 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15665 case Val_GNU_MIPS_ABI_FP_64A
:
15666 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15668 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15669 printf (_("NaN 2008 compatibility\n"));
15672 printf ("??? (%d)\n", val
);
15677 static unsigned char *
15678 display_mips_gnu_attribute (unsigned char * p
,
15680 const unsigned char * const end
)
15682 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15686 printf (" Tag_GNU_MIPS_ABI_FP: ");
15687 READ_ULEB (val
, p
, end
);
15688 print_mips_fp_abi_value (val
);
15692 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15696 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15697 READ_ULEB (val
, p
, end
);
15701 case Val_GNU_MIPS_ABI_MSA_ANY
:
15702 printf (_("Any MSA or not\n"));
15704 case Val_GNU_MIPS_ABI_MSA_128
:
15705 printf (_("128-bit MSA\n"));
15708 printf ("??? (%d)\n", val
);
15714 return display_tag_value (tag
& 1, p
, end
);
15717 static unsigned char *
15718 display_tic6x_attribute (unsigned char * p
,
15719 const unsigned char * const end
)
15724 READ_ULEB (tag
, p
, end
);
15729 printf (" Tag_ISA: ");
15730 READ_ULEB (val
, p
, end
);
15734 case C6XABI_Tag_ISA_none
:
15735 printf (_("None\n"));
15737 case C6XABI_Tag_ISA_C62X
:
15740 case C6XABI_Tag_ISA_C67X
:
15743 case C6XABI_Tag_ISA_C67XP
:
15744 printf ("C67x+\n");
15746 case C6XABI_Tag_ISA_C64X
:
15749 case C6XABI_Tag_ISA_C64XP
:
15750 printf ("C64x+\n");
15752 case C6XABI_Tag_ISA_C674X
:
15753 printf ("C674x\n");
15756 printf ("??? (%d)\n", val
);
15761 case Tag_ABI_wchar_t
:
15762 printf (" Tag_ABI_wchar_t: ");
15763 READ_ULEB (val
, p
, end
);
15767 printf (_("Not used\n"));
15770 printf (_("2 bytes\n"));
15773 printf (_("4 bytes\n"));
15776 printf ("??? (%d)\n", val
);
15781 case Tag_ABI_stack_align_needed
:
15782 printf (" Tag_ABI_stack_align_needed: ");
15783 READ_ULEB (val
, p
, end
);
15787 printf (_("8-byte\n"));
15790 printf (_("16-byte\n"));
15793 printf ("??? (%d)\n", val
);
15798 case Tag_ABI_stack_align_preserved
:
15799 READ_ULEB (val
, p
, end
);
15800 printf (" Tag_ABI_stack_align_preserved: ");
15804 printf (_("8-byte\n"));
15807 printf (_("16-byte\n"));
15810 printf ("??? (%d)\n", val
);
15816 READ_ULEB (val
, p
, end
);
15817 printf (" Tag_ABI_DSBT: ");
15821 printf (_("DSBT addressing not used\n"));
15824 printf (_("DSBT addressing used\n"));
15827 printf ("??? (%d)\n", val
);
15833 READ_ULEB (val
, p
, end
);
15834 printf (" Tag_ABI_PID: ");
15838 printf (_("Data addressing position-dependent\n"));
15841 printf (_("Data addressing position-independent, GOT near DP\n"));
15844 printf (_("Data addressing position-independent, GOT far from DP\n"));
15847 printf ("??? (%d)\n", val
);
15853 READ_ULEB (val
, p
, end
);
15854 printf (" Tag_ABI_PIC: ");
15858 printf (_("Code addressing position-dependent\n"));
15861 printf (_("Code addressing position-independent\n"));
15864 printf ("??? (%d)\n", val
);
15869 case Tag_ABI_array_object_alignment
:
15870 READ_ULEB (val
, p
, end
);
15871 printf (" Tag_ABI_array_object_alignment: ");
15875 printf (_("8-byte\n"));
15878 printf (_("4-byte\n"));
15881 printf (_("16-byte\n"));
15884 printf ("??? (%d)\n", val
);
15889 case Tag_ABI_array_object_align_expected
:
15890 READ_ULEB (val
, p
, end
);
15891 printf (" Tag_ABI_array_object_align_expected: ");
15895 printf (_("8-byte\n"));
15898 printf (_("4-byte\n"));
15901 printf (_("16-byte\n"));
15904 printf ("??? (%d)\n", val
);
15909 case Tag_ABI_compatibility
:
15911 READ_ULEB (val
, p
, end
);
15912 printf (" Tag_ABI_compatibility: ");
15913 printf (_("flag = %d, vendor = "), val
);
15916 size_t maxlen
= (end
- p
) - 1;
15918 print_symbol ((int) maxlen
, (const char *) p
);
15919 p
+= strnlen ((char *) p
, maxlen
) + 1;
15923 printf (_("<corrupt>"));
15924 p
= (unsigned char *) end
;
15930 case Tag_ABI_conformance
:
15932 printf (" Tag_ABI_conformance: \"");
15935 size_t maxlen
= (end
- p
) - 1;
15937 print_symbol ((int) maxlen
, (const char *) p
);
15938 p
+= strnlen ((char *) p
, maxlen
) + 1;
15942 printf (_("<corrupt>"));
15943 p
= (unsigned char *) end
;
15950 return display_tag_value (tag
, p
, end
);
15954 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15956 unsigned long addr
= 0;
15957 size_t bytes
= end
- p
;
15964 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15966 printf (" 0x%8.8lx ", addr
);
15968 for (j
= 0; j
< 16; j
++)
15971 printf ("%2.2x", p
[j
]);
15979 for (j
= 0; j
< lbytes
; j
++)
15982 if (k
>= ' ' && k
< 0x7f)
15998 static unsigned char *
15999 display_msp430x_attribute (unsigned char * p
,
16000 const unsigned char * const end
)
16005 READ_ULEB (tag
, p
, end
);
16009 case OFBA_MSPABI_Tag_ISA
:
16010 printf (" Tag_ISA: ");
16011 READ_ULEB (val
, p
, end
);
16014 case 0: printf (_("None\n")); break;
16015 case 1: printf (_("MSP430\n")); break;
16016 case 2: printf (_("MSP430X\n")); break;
16017 default: printf ("??? (%d)\n", val
); break;
16021 case OFBA_MSPABI_Tag_Code_Model
:
16022 printf (" Tag_Code_Model: ");
16023 READ_ULEB (val
, p
, end
);
16026 case 0: printf (_("None\n")); break;
16027 case 1: printf (_("Small\n")); break;
16028 case 2: printf (_("Large\n")); break;
16029 default: printf ("??? (%d)\n", val
); break;
16033 case OFBA_MSPABI_Tag_Data_Model
:
16034 printf (" Tag_Data_Model: ");
16035 READ_ULEB (val
, p
, end
);
16038 case 0: printf (_("None\n")); break;
16039 case 1: printf (_("Small\n")); break;
16040 case 2: printf (_("Large\n")); break;
16041 case 3: printf (_("Restricted Large\n")); break;
16042 default: printf ("??? (%d)\n", val
); break;
16047 printf (_(" <unknown tag %d>: "), tag
);
16054 size_t maxlen
= (end
- p
) - 1;
16056 print_symbol ((int) maxlen
, (const char *) p
);
16057 p
+= strnlen ((char *) p
, maxlen
) + 1;
16061 printf (_("<corrupt>"));
16062 p
= (unsigned char *) end
;
16068 READ_ULEB (val
, p
, end
);
16069 printf ("%d (0x%x)\n", val
, val
);
16078 static unsigned char *
16079 display_msp430_gnu_attribute (unsigned char * p
,
16081 const unsigned char * const end
)
16083 if (tag
== Tag_GNU_MSP430_Data_Region
)
16087 printf (" Tag_GNU_MSP430_Data_Region: ");
16088 READ_ULEB (val
, p
, end
);
16092 case Val_GNU_MSP430_Data_Region_Any
:
16093 printf (_("Any Region\n"));
16095 case Val_GNU_MSP430_Data_Region_Lower
:
16096 printf (_("Lower Region Only\n"));
16099 printf ("??? (%u)\n", val
);
16103 return display_tag_value (tag
& 1, p
, end
);
16106 struct riscv_attr_tag_t
{
16111 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16113 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16116 T(priv_spec_minor
),
16117 T(priv_spec_revision
),
16118 T(unaligned_access
),
16123 static unsigned char *
16124 display_riscv_attribute (unsigned char *p
,
16125 const unsigned char * const end
)
16129 struct riscv_attr_tag_t
*attr
= NULL
;
16132 READ_ULEB (tag
, p
, end
);
16134 /* Find the name of attribute. */
16135 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16137 if (riscv_attr_tag
[i
].tag
== tag
)
16139 attr
= &riscv_attr_tag
[i
];
16145 printf (" %s: ", attr
->name
);
16147 return display_tag_value (tag
, p
, end
);
16151 case Tag_RISCV_priv_spec
:
16152 case Tag_RISCV_priv_spec_minor
:
16153 case Tag_RISCV_priv_spec_revision
:
16154 READ_ULEB (val
, p
, end
);
16155 printf (_("%u\n"), val
);
16157 case Tag_RISCV_unaligned_access
:
16158 READ_ULEB (val
, p
, end
);
16162 printf (_("No unaligned access\n"));
16165 printf (_("Unaligned access\n"));
16169 case Tag_RISCV_stack_align
:
16170 READ_ULEB (val
, p
, end
);
16171 printf (_("%u-bytes\n"), val
);
16173 case Tag_RISCV_arch
:
16174 p
= display_tag_value (-1, p
, end
);
16177 return display_tag_value (tag
, p
, end
);
16184 process_attributes (Filedata
* filedata
,
16185 const char * public_name
,
16186 unsigned int proc_type
,
16187 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16188 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16190 Elf_Internal_Shdr
* sect
;
16192 bfd_boolean res
= TRUE
;
16194 /* Find the section header so that we get the size. */
16195 for (i
= 0, sect
= filedata
->section_headers
;
16196 i
< filedata
->file_header
.e_shnum
;
16199 unsigned char * contents
;
16202 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16205 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16206 sect
->sh_size
, _("attributes"));
16207 if (contents
== NULL
)
16214 /* The first character is the version of the attributes.
16215 Currently only version 1, (aka 'A') is recognised here. */
16218 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16223 bfd_vma section_len
;
16225 section_len
= sect
->sh_size
- 1;
16228 while (section_len
> 0)
16231 unsigned int namelen
;
16232 bfd_boolean public_section
;
16233 bfd_boolean gnu_section
;
16235 if (section_len
<= 4)
16237 error (_("Tag section ends prematurely\n"));
16241 attr_len
= byte_get (p
, 4);
16244 if (attr_len
> section_len
)
16246 error (_("Bad attribute length (%u > %u)\n"),
16247 (unsigned) attr_len
, (unsigned) section_len
);
16248 attr_len
= section_len
;
16251 /* PR 17531: file: 001-101425-0.004 */
16252 else if (attr_len
< 5)
16254 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16259 section_len
-= attr_len
;
16262 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16263 if (namelen
== 0 || namelen
>= attr_len
)
16265 error (_("Corrupt attribute section name\n"));
16270 printf (_("Attribute Section: "));
16271 print_symbol (INT_MAX
, (const char *) p
);
16274 if (public_name
&& streq ((char *) p
, public_name
))
16275 public_section
= TRUE
;
16277 public_section
= FALSE
;
16279 if (streq ((char *) p
, "gnu"))
16280 gnu_section
= TRUE
;
16282 gnu_section
= FALSE
;
16285 attr_len
-= namelen
;
16287 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16292 unsigned char * end
;
16294 /* PR binutils/17531: Safe handling of corrupt files. */
16297 error (_("Unused bytes at end of section\n"));
16304 size
= byte_get (p
, 4);
16305 if (size
> attr_len
)
16307 error (_("Bad subsection length (%u > %u)\n"),
16308 (unsigned) size
, (unsigned) attr_len
);
16312 /* PR binutils/17531: Safe handling of corrupt files. */
16315 error (_("Bad subsection length (%u < 6)\n"),
16323 end
= p
+ size
- 1;
16324 assert (end
<= contents
+ sect
->sh_size
);
16330 printf (_("File Attributes\n"));
16333 printf (_("Section Attributes:"));
16336 printf (_("Symbol Attributes:"));
16337 /* Fall through. */
16341 READ_ULEB (val
, p
, end
);
16344 printf (" %d", val
);
16349 printf (_("Unknown tag: %d\n"), tag
);
16350 public_section
= FALSE
;
16354 if (public_section
&& display_pub_attribute
!= NULL
)
16357 p
= display_pub_attribute (p
, end
);
16360 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16363 p
= display_gnu_attribute (p
,
16364 display_proc_gnu_attribute
,
16370 printf (_(" Unknown attribute:\n"));
16371 display_raw_attribute (p
, end
);
16386 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16387 Print the Address, Access and Initial fields of an entry at VMA ADDR
16388 and return the VMA of the next entry, or -1 if there was a problem.
16389 Does not read from DATA_END or beyond. */
16392 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16393 unsigned char * data_end
)
16396 print_vma (addr
, LONG_HEX
);
16398 if (addr
< pltgot
+ 0xfff0)
16399 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16401 printf ("%10s", "");
16404 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16408 unsigned char * from
= data
+ addr
- pltgot
;
16410 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16412 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16413 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16414 return (bfd_vma
) -1;
16418 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16419 print_vma (entry
, LONG_HEX
);
16422 return addr
+ (is_32bit_elf
? 4 : 8);
16425 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16426 PLTGOT. Print the Address and Initial fields of an entry at VMA
16427 ADDR and return the VMA of the next entry. */
16430 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16433 print_vma (addr
, LONG_HEX
);
16436 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16441 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16442 print_vma (entry
, LONG_HEX
);
16444 return addr
+ (is_32bit_elf
? 4 : 8);
16448 print_mips_ases (unsigned int mask
)
16450 if (mask
& AFL_ASE_DSP
)
16451 fputs ("\n\tDSP ASE", stdout
);
16452 if (mask
& AFL_ASE_DSPR2
)
16453 fputs ("\n\tDSP R2 ASE", stdout
);
16454 if (mask
& AFL_ASE_DSPR3
)
16455 fputs ("\n\tDSP R3 ASE", stdout
);
16456 if (mask
& AFL_ASE_EVA
)
16457 fputs ("\n\tEnhanced VA Scheme", stdout
);
16458 if (mask
& AFL_ASE_MCU
)
16459 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16460 if (mask
& AFL_ASE_MDMX
)
16461 fputs ("\n\tMDMX ASE", stdout
);
16462 if (mask
& AFL_ASE_MIPS3D
)
16463 fputs ("\n\tMIPS-3D ASE", stdout
);
16464 if (mask
& AFL_ASE_MT
)
16465 fputs ("\n\tMT ASE", stdout
);
16466 if (mask
& AFL_ASE_SMARTMIPS
)
16467 fputs ("\n\tSmartMIPS ASE", stdout
);
16468 if (mask
& AFL_ASE_VIRT
)
16469 fputs ("\n\tVZ ASE", stdout
);
16470 if (mask
& AFL_ASE_MSA
)
16471 fputs ("\n\tMSA ASE", stdout
);
16472 if (mask
& AFL_ASE_MIPS16
)
16473 fputs ("\n\tMIPS16 ASE", stdout
);
16474 if (mask
& AFL_ASE_MICROMIPS
)
16475 fputs ("\n\tMICROMIPS ASE", stdout
);
16476 if (mask
& AFL_ASE_XPA
)
16477 fputs ("\n\tXPA ASE", stdout
);
16478 if (mask
& AFL_ASE_MIPS16E2
)
16479 fputs ("\n\tMIPS16e2 ASE", stdout
);
16480 if (mask
& AFL_ASE_CRC
)
16481 fputs ("\n\tCRC ASE", stdout
);
16482 if (mask
& AFL_ASE_GINV
)
16483 fputs ("\n\tGINV ASE", stdout
);
16484 if (mask
& AFL_ASE_LOONGSON_MMI
)
16485 fputs ("\n\tLoongson MMI ASE", stdout
);
16486 if (mask
& AFL_ASE_LOONGSON_CAM
)
16487 fputs ("\n\tLoongson CAM ASE", stdout
);
16488 if (mask
& AFL_ASE_LOONGSON_EXT
)
16489 fputs ("\n\tLoongson EXT ASE", stdout
);
16490 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16491 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16493 fprintf (stdout
, "\n\t%s", _("None"));
16494 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16495 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16499 print_mips_isa_ext (unsigned int isa_ext
)
16504 fputs (_("None"), stdout
);
16507 fputs ("RMI XLR", stdout
);
16509 case AFL_EXT_OCTEON3
:
16510 fputs ("Cavium Networks Octeon3", stdout
);
16512 case AFL_EXT_OCTEON2
:
16513 fputs ("Cavium Networks Octeon2", stdout
);
16515 case AFL_EXT_OCTEONP
:
16516 fputs ("Cavium Networks OcteonP", stdout
);
16518 case AFL_EXT_OCTEON
:
16519 fputs ("Cavium Networks Octeon", stdout
);
16522 fputs ("Toshiba R5900", stdout
);
16525 fputs ("MIPS R4650", stdout
);
16528 fputs ("LSI R4010", stdout
);
16531 fputs ("NEC VR4100", stdout
);
16534 fputs ("Toshiba R3900", stdout
);
16536 case AFL_EXT_10000
:
16537 fputs ("MIPS R10000", stdout
);
16540 fputs ("Broadcom SB-1", stdout
);
16543 fputs ("NEC VR4111/VR4181", stdout
);
16546 fputs ("NEC VR4120", stdout
);
16549 fputs ("NEC VR5400", stdout
);
16552 fputs ("NEC VR5500", stdout
);
16554 case AFL_EXT_LOONGSON_2E
:
16555 fputs ("ST Microelectronics Loongson 2E", stdout
);
16557 case AFL_EXT_LOONGSON_2F
:
16558 fputs ("ST Microelectronics Loongson 2F", stdout
);
16560 case AFL_EXT_INTERAPTIV_MR2
:
16561 fputs ("Imagination interAptiv MR2", stdout
);
16564 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16569 get_mips_reg_size (int reg_size
)
16571 return (reg_size
== AFL_REG_NONE
) ? 0
16572 : (reg_size
== AFL_REG_32
) ? 32
16573 : (reg_size
== AFL_REG_64
) ? 64
16574 : (reg_size
== AFL_REG_128
) ? 128
16579 process_mips_specific (Filedata
* filedata
)
16581 Elf_Internal_Dyn
* entry
;
16582 Elf_Internal_Shdr
*sect
= NULL
;
16583 size_t liblist_offset
= 0;
16584 size_t liblistno
= 0;
16585 size_t conflictsno
= 0;
16586 size_t options_offset
= 0;
16587 size_t conflicts_offset
= 0;
16588 size_t pltrelsz
= 0;
16590 bfd_vma pltgot
= 0;
16591 bfd_vma mips_pltgot
= 0;
16592 bfd_vma jmprel
= 0;
16593 bfd_vma local_gotno
= 0;
16594 bfd_vma gotsym
= 0;
16595 bfd_vma symtabno
= 0;
16596 bfd_boolean res
= TRUE
;
16598 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16599 display_mips_gnu_attribute
))
16602 sect
= find_section (filedata
, ".MIPS.abiflags");
16606 Elf_External_ABIFlags_v0
*abiflags_ext
;
16607 Elf_Internal_ABIFlags_v0 abiflags_in
;
16609 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16611 error (_("Corrupt MIPS ABI Flags section.\n"));
16616 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16617 sect
->sh_size
, _("MIPS ABI Flags section"));
16620 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16621 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16622 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16623 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16624 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16625 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16626 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16627 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16628 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16629 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16630 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16632 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16633 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16634 if (abiflags_in
.isa_rev
> 1)
16635 printf ("r%d", abiflags_in
.isa_rev
);
16636 printf ("\nGPR size: %d",
16637 get_mips_reg_size (abiflags_in
.gpr_size
));
16638 printf ("\nCPR1 size: %d",
16639 get_mips_reg_size (abiflags_in
.cpr1_size
));
16640 printf ("\nCPR2 size: %d",
16641 get_mips_reg_size (abiflags_in
.cpr2_size
));
16642 fputs ("\nFP ABI: ", stdout
);
16643 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16644 fputs ("ISA Extension: ", stdout
);
16645 print_mips_isa_ext (abiflags_in
.isa_ext
);
16646 fputs ("\nASEs:", stdout
);
16647 print_mips_ases (abiflags_in
.ases
);
16648 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16649 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16650 fputc ('\n', stdout
);
16651 free (abiflags_ext
);
16656 /* We have a lot of special sections. Thanks SGI! */
16657 if (filedata
->dynamic_section
== NULL
)
16659 /* No dynamic information available. See if there is static GOT. */
16660 sect
= find_section (filedata
, ".got");
16663 unsigned char *data_end
;
16664 unsigned char *data
;
16668 pltgot
= sect
->sh_addr
;
16671 addr_size
= (is_32bit_elf
? 4 : 8);
16672 end
= pltgot
+ sect
->sh_size
;
16674 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16676 _("Global Offset Table data"));
16677 /* PR 12855: Null data is handled gracefully throughout. */
16678 data_end
= data
+ (end
- pltgot
);
16680 printf (_("\nStatic GOT:\n"));
16681 printf (_(" Canonical gp value: "));
16682 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16685 /* In a dynamic binary GOT[0] is reserved for the dynamic
16686 loader to store the lazy resolver pointer, however in
16687 a static binary it may well have been omitted and GOT
16688 reduced to a table of addresses.
16689 PR 21344: Check for the entry being fully available
16690 before fetching it. */
16692 && data
+ ent
- pltgot
+ addr_size
<= data_end
16693 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16695 printf (_(" Reserved entries:\n"));
16696 printf (_(" %*s %10s %*s\n"),
16697 addr_size
* 2, _("Address"), _("Access"),
16698 addr_size
* 2, _("Value"));
16699 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16701 if (ent
== (bfd_vma
) -1)
16702 goto sgot_print_fail
;
16704 /* Check for the MSB of GOT[1] being set, identifying a
16705 GNU object. This entry will be used by some runtime
16706 loaders, to store the module pointer. Otherwise this
16707 is an ordinary local entry.
16708 PR 21344: Check for the entry being fully available
16709 before fetching it. */
16711 && data
+ ent
- pltgot
+ addr_size
<= data_end
16712 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16713 >> (addr_size
* 8 - 1)) != 0)
16715 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16717 if (ent
== (bfd_vma
) -1)
16718 goto sgot_print_fail
;
16723 if (data
!= NULL
&& ent
< end
)
16725 printf (_(" Local entries:\n"));
16726 printf (" %*s %10s %*s\n",
16727 addr_size
* 2, _("Address"), _("Access"),
16728 addr_size
* 2, _("Value"));
16731 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16733 if (ent
== (bfd_vma
) -1)
16734 goto sgot_print_fail
;
16746 for (entry
= filedata
->dynamic_section
;
16747 /* PR 17531 file: 012-50589-0.004. */
16748 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16749 && entry
->d_tag
!= DT_NULL
);
16751 switch (entry
->d_tag
)
16753 case DT_MIPS_LIBLIST
:
16755 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16756 liblistno
* sizeof (Elf32_External_Lib
));
16758 case DT_MIPS_LIBLISTNO
:
16759 liblistno
= entry
->d_un
.d_val
;
16761 case DT_MIPS_OPTIONS
:
16762 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16764 case DT_MIPS_CONFLICT
:
16766 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16767 conflictsno
* sizeof (Elf32_External_Conflict
));
16769 case DT_MIPS_CONFLICTNO
:
16770 conflictsno
= entry
->d_un
.d_val
;
16773 pltgot
= entry
->d_un
.d_ptr
;
16775 case DT_MIPS_LOCAL_GOTNO
:
16776 local_gotno
= entry
->d_un
.d_val
;
16778 case DT_MIPS_GOTSYM
:
16779 gotsym
= entry
->d_un
.d_val
;
16781 case DT_MIPS_SYMTABNO
:
16782 symtabno
= entry
->d_un
.d_val
;
16784 case DT_MIPS_PLTGOT
:
16785 mips_pltgot
= entry
->d_un
.d_ptr
;
16788 pltrel
= entry
->d_un
.d_val
;
16791 pltrelsz
= entry
->d_un
.d_val
;
16794 jmprel
= entry
->d_un
.d_ptr
;
16800 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16802 Elf32_External_Lib
* elib
;
16805 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16806 sizeof (Elf32_External_Lib
),
16808 _("liblist section data"));
16811 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16812 "\nSection '.liblist' contains %lu entries:\n",
16813 (unsigned long) liblistno
),
16814 (unsigned long) liblistno
);
16815 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16818 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16825 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16826 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16827 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16828 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16829 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16831 tmp
= gmtime (&atime
);
16832 snprintf (timebuf
, sizeof (timebuf
),
16833 "%04u-%02u-%02uT%02u:%02u:%02u",
16834 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16835 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16837 printf ("%3lu: ", (unsigned long) cnt
);
16838 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
16839 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
16841 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16842 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16843 liblist
.l_version
);
16845 if (liblist
.l_flags
== 0)
16849 static const struct
16856 { " EXACT_MATCH", LL_EXACT_MATCH
},
16857 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16858 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16859 { " EXPORTS", LL_EXPORTS
},
16860 { " DELAY_LOAD", LL_DELAY_LOAD
},
16861 { " DELTA", LL_DELTA
}
16863 int flags
= liblist
.l_flags
;
16866 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16867 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16869 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16870 flags
^= l_flags_vals
[fcnt
].bit
;
16873 printf (" %#x", (unsigned int) flags
);
16885 if (options_offset
!= 0)
16887 Elf_External_Options
* eopt
;
16890 sect
= filedata
->section_headers
;
16892 /* Find the section header so that we get the size. */
16893 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16894 /* PR 17533 file: 012-277276-0.004. */
16897 error (_("No MIPS_OPTIONS header found\n"));
16901 if (sect
->sh_size
< sizeof (* eopt
))
16903 error (_("The MIPS options section is too small.\n"));
16907 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16908 sect
->sh_size
, _("options"));
16911 Elf_Internal_Options
* iopt
;
16912 Elf_Internal_Options
* option
;
16913 Elf_Internal_Options
* iopt_end
;
16915 iopt
= (Elf_Internal_Options
*)
16916 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16919 error (_("Out of memory allocating space for MIPS options\n"));
16926 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16928 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16930 Elf_External_Options
* eoption
;
16932 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16934 option
->kind
= BYTE_GET (eoption
->kind
);
16935 option
->size
= BYTE_GET (eoption
->size
);
16936 option
->section
= BYTE_GET (eoption
->section
);
16937 option
->info
= BYTE_GET (eoption
->info
);
16939 /* PR 17531: file: ffa0fa3b. */
16940 if (option
->size
< sizeof (* eopt
)
16941 || offset
+ option
->size
> sect
->sh_size
)
16943 error (_("Invalid size (%u) for MIPS option\n"),
16949 offset
+= option
->size
;
16955 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16956 "\nSection '%s' contains %d entries:\n",
16958 printable_section_name (filedata
, sect
), cnt
);
16967 switch (option
->kind
)
16970 /* This shouldn't happen. */
16971 printf (" NULL %d %lx", option
->section
, option
->info
);
16975 printf (" REGINFO ");
16976 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16978 Elf32_External_RegInfo
* ereg
;
16979 Elf32_RegInfo reginfo
;
16982 if (option
+ 2 > iopt_end
)
16984 printf (_("<corrupt>\n"));
16985 error (_("Truncated MIPS REGINFO option\n"));
16990 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16992 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16993 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16994 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16995 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16996 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16997 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16999 printf ("GPR %08lx GP 0x%lx\n",
17000 reginfo
.ri_gprmask
,
17001 (unsigned long) reginfo
.ri_gp_value
);
17002 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
17003 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17004 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17009 Elf64_External_RegInfo
* ereg
;
17010 Elf64_Internal_RegInfo reginfo
;
17012 if (option
+ 2 > iopt_end
)
17014 printf (_("<corrupt>\n"));
17015 error (_("Truncated MIPS REGINFO option\n"));
17020 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
17021 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17022 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17023 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17024 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17025 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17026 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17028 printf ("GPR %08lx GP 0x",
17029 reginfo
.ri_gprmask
);
17030 printf_vma (reginfo
.ri_gp_value
);
17033 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
17034 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17035 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17040 case ODK_EXCEPTIONS
:
17041 fputs (" EXCEPTIONS fpe_min(", stdout
);
17042 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
17043 fputs (") fpe_max(", stdout
);
17044 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
17045 fputs (")", stdout
);
17047 if (option
->info
& OEX_PAGE0
)
17048 fputs (" PAGE0", stdout
);
17049 if (option
->info
& OEX_SMM
)
17050 fputs (" SMM", stdout
);
17051 if (option
->info
& OEX_FPDBUG
)
17052 fputs (" FPDBUG", stdout
);
17053 if (option
->info
& OEX_DISMISS
)
17054 fputs (" DISMISS", stdout
);
17058 fputs (" PAD ", stdout
);
17059 if (option
->info
& OPAD_PREFIX
)
17060 fputs (" PREFIX", stdout
);
17061 if (option
->info
& OPAD_POSTFIX
)
17062 fputs (" POSTFIX", stdout
);
17063 if (option
->info
& OPAD_SYMBOL
)
17064 fputs (" SYMBOL", stdout
);
17068 fputs (" HWPATCH ", stdout
);
17069 if (option
->info
& OHW_R4KEOP
)
17070 fputs (" R4KEOP", stdout
);
17071 if (option
->info
& OHW_R8KPFETCH
)
17072 fputs (" R8KPFETCH", stdout
);
17073 if (option
->info
& OHW_R5KEOP
)
17074 fputs (" R5KEOP", stdout
);
17075 if (option
->info
& OHW_R5KCVTL
)
17076 fputs (" R5KCVTL", stdout
);
17080 fputs (" FILL ", stdout
);
17081 /* XXX Print content of info word? */
17085 fputs (" TAGS ", stdout
);
17086 /* XXX Print content of info word? */
17090 fputs (" HWAND ", stdout
);
17091 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17092 fputs (" R4KEOP_CHECKED", stdout
);
17093 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17094 fputs (" R4KEOP_CLEAN", stdout
);
17098 fputs (" HWOR ", stdout
);
17099 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17100 fputs (" R4KEOP_CHECKED", stdout
);
17101 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17102 fputs (" R4KEOP_CLEAN", stdout
);
17106 printf (" GP_GROUP %#06lx self-contained %#06lx",
17107 option
->info
& OGP_GROUP
,
17108 (option
->info
& OGP_SELF
) >> 16);
17112 printf (" IDENT %#06lx self-contained %#06lx",
17113 option
->info
& OGP_GROUP
,
17114 (option
->info
& OGP_SELF
) >> 16);
17118 /* This shouldn't happen. */
17119 printf (" %3d ??? %d %lx",
17120 option
->kind
, option
->section
, option
->info
);
17124 len
= sizeof (* eopt
);
17125 while (len
< option
->size
)
17127 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17129 if (ISPRINT (datum
))
17130 printf ("%c", datum
);
17132 printf ("\\%03o", datum
);
17135 fputs ("\n", stdout
);
17137 offset
+= option
->size
;
17147 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17149 Elf32_Conflict
* iconf
;
17152 if (filedata
->dynamic_symbols
== NULL
)
17154 error (_("conflict list found without a dynamic symbol table\n"));
17158 /* PR 21345 - print a slightly more helpful error message
17159 if we are sure that the cmalloc will fail. */
17160 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17162 error (_("Overlarge number of conflicts detected: %lx\n"),
17163 (long) conflictsno
);
17167 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17170 error (_("Out of memory allocating space for dynamic conflicts\n"));
17176 Elf32_External_Conflict
* econf32
;
17178 econf32
= (Elf32_External_Conflict
*)
17179 get_data (NULL
, filedata
, conflicts_offset
,
17180 sizeof (*econf32
), conflictsno
, _("conflict"));
17187 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17188 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17194 Elf64_External_Conflict
* econf64
;
17196 econf64
= (Elf64_External_Conflict
*)
17197 get_data (NULL
, filedata
, conflicts_offset
,
17198 sizeof (*econf64
), conflictsno
, _("conflict"));
17205 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17206 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17211 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17212 "\nSection '.conflict' contains %lu entries:\n",
17213 (unsigned long) conflictsno
),
17214 (unsigned long) conflictsno
);
17215 puts (_(" Num: Index Value Name"));
17217 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17219 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17221 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17222 printf (_("<corrupt symbol index>"));
17225 Elf_Internal_Sym
* psym
;
17227 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17228 print_vma (psym
->st_value
, FULL_HEX
);
17230 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17231 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17233 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17241 if (pltgot
!= 0 && local_gotno
!= 0)
17243 bfd_vma ent
, local_end
, global_end
;
17245 unsigned char * data
;
17246 unsigned char * data_end
;
17250 addr_size
= (is_32bit_elf
? 4 : 8);
17251 local_end
= pltgot
+ local_gotno
* addr_size
;
17253 /* PR binutils/17533 file: 012-111227-0.004 */
17254 if (symtabno
< gotsym
)
17256 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17257 (unsigned long) gotsym
, (unsigned long) symtabno
);
17261 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17262 /* PR 17531: file: 54c91a34. */
17263 if (global_end
< local_end
)
17265 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17269 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17270 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17271 global_end
- pltgot
, 1,
17272 _("Global Offset Table data"));
17273 /* PR 12855: Null data is handled gracefully throughout. */
17274 data_end
= data
+ (global_end
- pltgot
);
17276 printf (_("\nPrimary GOT:\n"));
17277 printf (_(" Canonical gp value: "));
17278 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17281 printf (_(" Reserved entries:\n"));
17282 printf (_(" %*s %10s %*s Purpose\n"),
17283 addr_size
* 2, _("Address"), _("Access"),
17284 addr_size
* 2, _("Initial"));
17285 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17286 printf (_(" Lazy resolver\n"));
17287 if (ent
== (bfd_vma
) -1)
17288 goto got_print_fail
;
17290 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17291 This entry will be used by some runtime loaders, to store the
17292 module pointer. Otherwise this is an ordinary local entry.
17293 PR 21344: Check for the entry being fully available before
17296 && data
+ ent
- pltgot
+ addr_size
<= data_end
17297 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17298 >> (addr_size
* 8 - 1)) != 0)
17300 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17301 printf (_(" Module pointer (GNU extension)\n"));
17302 if (ent
== (bfd_vma
) -1)
17303 goto got_print_fail
;
17307 if (data
!= NULL
&& ent
< local_end
)
17309 printf (_(" Local entries:\n"));
17310 printf (" %*s %10s %*s\n",
17311 addr_size
* 2, _("Address"), _("Access"),
17312 addr_size
* 2, _("Initial"));
17313 while (ent
< local_end
)
17315 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17317 if (ent
== (bfd_vma
) -1)
17318 goto got_print_fail
;
17323 if (data
!= NULL
&& gotsym
< symtabno
)
17327 printf (_(" Global entries:\n"));
17328 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17329 addr_size
* 2, _("Address"),
17331 addr_size
* 2, _("Initial"),
17332 addr_size
* 2, _("Sym.Val."),
17334 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17335 _("Ndx"), _("Name"));
17337 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17339 for (i
= gotsym
; i
< symtabno
; i
++)
17341 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17344 if (filedata
->dynamic_symbols
== NULL
)
17345 printf (_("<no dynamic symbols>"));
17346 else if (i
< filedata
->num_dynamic_syms
)
17348 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17350 print_vma (psym
->st_value
, LONG_HEX
);
17351 printf (" %-7s %3s ",
17352 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17353 get_symbol_index_type (filedata
, psym
->st_shndx
));
17355 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17356 print_symbol (sym_width
,
17357 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17359 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17362 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17363 (unsigned long) i
);
17366 if (ent
== (bfd_vma
) -1)
17377 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17380 size_t offset
, rel_offset
;
17381 unsigned long count
, i
;
17382 unsigned char * data
;
17383 int addr_size
, sym_width
;
17384 Elf_Internal_Rela
* rels
;
17386 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17387 if (pltrel
== DT_RELA
)
17389 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17394 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17399 addr_size
= (is_32bit_elf
? 4 : 8);
17400 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17402 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17403 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17404 1, _("Procedure Linkage Table data"));
17408 printf ("\nPLT GOT:\n\n");
17409 printf (_(" Reserved entries:\n"));
17410 printf (_(" %*s %*s Purpose\n"),
17411 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17412 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17413 printf (_(" PLT lazy resolver\n"));
17414 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17415 printf (_(" Module pointer\n"));
17418 printf (_(" Entries:\n"));
17419 printf (" %*s %*s %*s %-7s %3s %s\n",
17420 addr_size
* 2, _("Address"),
17421 addr_size
* 2, _("Initial"),
17422 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17423 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17424 for (i
= 0; i
< count
; i
++)
17426 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17428 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17431 if (idx
>= filedata
->num_dynamic_syms
)
17432 printf (_("<corrupt symbol index: %lu>"), idx
);
17435 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17437 print_vma (psym
->st_value
, LONG_HEX
);
17438 printf (" %-7s %3s ",
17439 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17440 get_symbol_index_type (filedata
, psym
->st_shndx
));
17441 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17442 print_symbol (sym_width
,
17443 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17445 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17460 process_nds32_specific (Filedata
* filedata
)
17462 Elf_Internal_Shdr
*sect
= NULL
;
17464 sect
= find_section (filedata
, ".nds32_e_flags");
17465 if (sect
!= NULL
&& sect
->sh_size
>= 4)
17467 unsigned char *buf
;
17470 printf ("\nNDS32 elf flags section:\n");
17471 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
17472 _("NDS32 elf flags section"));
17477 flag
= byte_get (buf
, 4);
17479 switch (flag
& 0x3)
17482 printf ("(VEC_SIZE):\tNo entry.\n");
17485 printf ("(VEC_SIZE):\t4 bytes\n");
17488 printf ("(VEC_SIZE):\t16 bytes\n");
17491 printf ("(VEC_SIZE):\treserved\n");
17500 process_gnu_liblist (Filedata
* filedata
)
17502 Elf_Internal_Shdr
* section
;
17503 Elf_Internal_Shdr
* string_sec
;
17504 Elf32_External_Lib
* elib
;
17506 size_t strtab_size
;
17508 unsigned long num_liblist
;
17510 bfd_boolean res
= TRUE
;
17515 for (i
= 0, section
= filedata
->section_headers
;
17516 i
< filedata
->file_header
.e_shnum
;
17519 switch (section
->sh_type
)
17521 case SHT_GNU_LIBLIST
:
17522 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17525 elib
= (Elf32_External_Lib
*)
17526 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17527 _("liblist section data"));
17535 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17536 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17537 string_sec
->sh_size
,
17538 _("liblist string table"));
17540 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17547 strtab_size
= string_sec
->sh_size
;
17549 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17550 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17551 "\nLibrary list section '%s' contains %lu entries:\n",
17553 printable_section_name (filedata
, section
),
17556 puts (_(" Library Time Stamp Checksum Version Flags"));
17558 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17566 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17567 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17568 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17569 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17570 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17572 tmp
= gmtime (&atime
);
17573 snprintf (timebuf
, sizeof (timebuf
),
17574 "%04u-%02u-%02uT%02u:%02u:%02u",
17575 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17576 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17578 printf ("%3lu: ", (unsigned long) cnt
);
17580 printf ("%-20s", liblist
.l_name
< strtab_size
17581 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17583 printf ("%-20.20s", liblist
.l_name
< strtab_size
17584 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17585 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17586 liblist
.l_version
, liblist
.l_flags
);
17597 static const char *
17598 get_note_type (Filedata
* filedata
, unsigned e_type
)
17600 static char buff
[64];
17602 if (filedata
->file_header
.e_type
== ET_CORE
)
17606 return _("NT_AUXV (auxiliary vector)");
17608 return _("NT_PRSTATUS (prstatus structure)");
17610 return _("NT_FPREGSET (floating point registers)");
17612 return _("NT_PRPSINFO (prpsinfo structure)");
17613 case NT_TASKSTRUCT
:
17614 return _("NT_TASKSTRUCT (task structure)");
17616 return _("NT_PRXFPREG (user_xfpregs structure)");
17618 return _("NT_PPC_VMX (ppc Altivec registers)");
17620 return _("NT_PPC_VSX (ppc VSX registers)");
17622 return _("NT_PPC_TAR (ppc TAR register)");
17624 return _("NT_PPC_PPR (ppc PPR register)");
17626 return _("NT_PPC_DSCR (ppc DSCR register)");
17628 return _("NT_PPC_EBB (ppc EBB registers)");
17630 return _("NT_PPC_PMU (ppc PMU registers)");
17631 case NT_PPC_TM_CGPR
:
17632 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17633 case NT_PPC_TM_CFPR
:
17634 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17635 case NT_PPC_TM_CVMX
:
17636 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17637 case NT_PPC_TM_CVSX
:
17638 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17639 case NT_PPC_TM_SPR
:
17640 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17641 case NT_PPC_TM_CTAR
:
17642 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17643 case NT_PPC_TM_CPPR
:
17644 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17645 case NT_PPC_TM_CDSCR
:
17646 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17648 return _("NT_386_TLS (x86 TLS information)");
17649 case NT_386_IOPERM
:
17650 return _("NT_386_IOPERM (x86 I/O permissions)");
17651 case NT_X86_XSTATE
:
17652 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17653 case NT_S390_HIGH_GPRS
:
17654 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17655 case NT_S390_TIMER
:
17656 return _("NT_S390_TIMER (s390 timer register)");
17657 case NT_S390_TODCMP
:
17658 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17659 case NT_S390_TODPREG
:
17660 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17662 return _("NT_S390_CTRS (s390 control registers)");
17663 case NT_S390_PREFIX
:
17664 return _("NT_S390_PREFIX (s390 prefix register)");
17665 case NT_S390_LAST_BREAK
:
17666 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17667 case NT_S390_SYSTEM_CALL
:
17668 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17670 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17671 case NT_S390_VXRS_LOW
:
17672 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17673 case NT_S390_VXRS_HIGH
:
17674 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17675 case NT_S390_GS_CB
:
17676 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17677 case NT_S390_GS_BC
:
17678 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17680 return _("NT_ARM_VFP (arm VFP registers)");
17682 return _("NT_ARM_TLS (AArch TLS registers)");
17683 case NT_ARM_HW_BREAK
:
17684 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17685 case NT_ARM_HW_WATCH
:
17686 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17688 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17690 return _("NT_PSTATUS (pstatus structure)");
17692 return _("NT_FPREGS (floating point registers)");
17694 return _("NT_PSINFO (psinfo structure)");
17696 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17698 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17699 case NT_WIN32PSTATUS
:
17700 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17702 return _("NT_SIGINFO (siginfo_t data)");
17704 return _("NT_FILE (mapped files)");
17712 return _("NT_VERSION (version)");
17714 return _("NT_ARCH (architecture)");
17715 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17717 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17723 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17728 print_core_note (Elf_Internal_Note
*pnote
)
17730 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17731 bfd_vma count
, page_size
;
17732 unsigned char *descdata
, *filenames
, *descend
;
17734 if (pnote
->type
!= NT_FILE
)
17744 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17745 /* Still "successful". */
17750 if (pnote
->descsz
< 2 * addr_size
)
17752 error (_(" Malformed note - too short for header\n"));
17756 descdata
= (unsigned char *) pnote
->descdata
;
17757 descend
= descdata
+ pnote
->descsz
;
17759 if (descdata
[pnote
->descsz
- 1] != '\0')
17761 error (_(" Malformed note - does not end with \\0\n"));
17765 count
= byte_get (descdata
, addr_size
);
17766 descdata
+= addr_size
;
17768 page_size
= byte_get (descdata
, addr_size
);
17769 descdata
+= addr_size
;
17771 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17772 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17774 error (_(" Malformed note - too short for supplied file count\n"));
17778 printf (_(" Page size: "));
17779 print_vma (page_size
, DEC
);
17782 printf (_(" %*s%*s%*s\n"),
17783 (int) (2 + 2 * addr_size
), _("Start"),
17784 (int) (4 + 2 * addr_size
), _("End"),
17785 (int) (4 + 2 * addr_size
), _("Page Offset"));
17786 filenames
= descdata
+ count
* 3 * addr_size
;
17787 while (count
-- > 0)
17789 bfd_vma start
, end
, file_ofs
;
17791 if (filenames
== descend
)
17793 error (_(" Malformed note - filenames end too early\n"));
17797 start
= byte_get (descdata
, addr_size
);
17798 descdata
+= addr_size
;
17799 end
= byte_get (descdata
, addr_size
);
17800 descdata
+= addr_size
;
17801 file_ofs
= byte_get (descdata
, addr_size
);
17802 descdata
+= addr_size
;
17805 print_vma (start
, FULL_HEX
);
17807 print_vma (end
, FULL_HEX
);
17809 print_vma (file_ofs
, FULL_HEX
);
17810 printf ("\n %s\n", filenames
);
17812 filenames
+= 1 + strlen ((char *) filenames
);
17818 static const char *
17819 get_gnu_elf_note_type (unsigned e_type
)
17821 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17824 case NT_GNU_ABI_TAG
:
17825 return _("NT_GNU_ABI_TAG (ABI version tag)");
17827 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17828 case NT_GNU_BUILD_ID
:
17829 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17830 case NT_GNU_GOLD_VERSION
:
17831 return _("NT_GNU_GOLD_VERSION (gold version)");
17832 case NT_GNU_PROPERTY_TYPE_0
:
17833 return _("NT_GNU_PROPERTY_TYPE_0");
17834 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17835 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17836 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17837 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17840 static char buff
[64];
17842 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17849 decode_x86_compat_isa (unsigned int bitmask
)
17853 unsigned int bit
= bitmask
& (- bitmask
);
17858 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17861 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17864 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17867 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17870 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17873 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17876 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17879 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17882 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17885 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17888 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17891 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17892 printf ("AVX512F");
17894 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17895 printf ("AVX512CD");
17897 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17898 printf ("AVX512ER");
17900 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17901 printf ("AVX512PF");
17903 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17904 printf ("AVX512VL");
17906 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17907 printf ("AVX512DQ");
17909 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17910 printf ("AVX512BW");
17913 printf (_("<unknown: %x>"), bit
);
17922 decode_x86_isa (unsigned int bitmask
)
17926 printf (_("<None>"));
17932 unsigned int bit
= bitmask
& (- bitmask
);
17937 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17940 case GNU_PROPERTY_X86_ISA_1_SSE
:
17943 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17946 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17949 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17952 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17955 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17958 case GNU_PROPERTY_X86_ISA_1_AVX
:
17961 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17964 case GNU_PROPERTY_X86_ISA_1_FMA
:
17967 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17968 printf ("AVX512F");
17970 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17971 printf ("AVX512CD");
17973 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17974 printf ("AVX512ER");
17976 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17977 printf ("AVX512PF");
17979 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17980 printf ("AVX512VL");
17982 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17983 printf ("AVX512DQ");
17985 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17986 printf ("AVX512BW");
17988 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17989 printf ("AVX512_4FMAPS");
17991 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17992 printf ("AVX512_4VNNIW");
17994 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17995 printf ("AVX512_BITALG");
17997 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17998 printf ("AVX512_IFMA");
18000 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
18001 printf ("AVX512_VBMI");
18003 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
18004 printf ("AVX512_VBMI2");
18006 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
18007 printf ("AVX512_VNNI");
18009 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
18010 printf ("AVX512_BF16");
18013 printf (_("<unknown: %x>"), bit
);
18022 decode_x86_feature_1 (unsigned int bitmask
)
18026 printf (_("<None>"));
18032 unsigned int bit
= bitmask
& (- bitmask
);
18037 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18040 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18044 printf (_("<unknown: %x>"), bit
);
18053 decode_x86_feature_2 (unsigned int bitmask
)
18057 printf (_("<None>"));
18063 unsigned int bit
= bitmask
& (- bitmask
);
18068 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18071 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18074 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18077 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18080 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18083 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18086 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18089 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18092 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18093 printf ("XSAVEOPT");
18095 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18099 printf (_("<unknown: %x>"), bit
);
18108 decode_aarch64_feature_1_and (unsigned int bitmask
)
18112 unsigned int bit
= bitmask
& (- bitmask
);
18117 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18121 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18126 printf (_("<unknown: %x>"), bit
);
18135 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18137 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18138 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18139 unsigned int size
= is_32bit_elf
? 4 : 8;
18141 printf (_(" Properties: "));
18143 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18145 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18149 while (ptr
< ptr_end
)
18153 unsigned int datasz
;
18155 if ((size_t) (ptr_end
- ptr
) < 8)
18157 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18161 type
= byte_get (ptr
, 4);
18162 datasz
= byte_get (ptr
+ 4, 4);
18166 if (datasz
> (size_t) (ptr_end
- ptr
))
18168 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18173 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18175 if (filedata
->file_header
.e_machine
== EM_X86_64
18176 || filedata
->file_header
.e_machine
== EM_IAMCU
18177 || filedata
->file_header
.e_machine
== EM_386
)
18179 unsigned int bitmask
;
18182 bitmask
= byte_get (ptr
, 4);
18188 case GNU_PROPERTY_X86_ISA_1_USED
:
18190 printf (_("x86 ISA used: <corrupt length: %#x> "),
18194 printf ("x86 ISA used: ");
18195 decode_x86_isa (bitmask
);
18199 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18201 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18205 printf ("x86 ISA needed: ");
18206 decode_x86_isa (bitmask
);
18210 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18212 printf (_("x86 feature: <corrupt length: %#x> "),
18216 printf ("x86 feature: ");
18217 decode_x86_feature_1 (bitmask
);
18221 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18223 printf (_("x86 feature used: <corrupt length: %#x> "),
18227 printf ("x86 feature used: ");
18228 decode_x86_feature_2 (bitmask
);
18232 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18234 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18237 printf ("x86 feature needed: ");
18238 decode_x86_feature_2 (bitmask
);
18242 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18244 printf (_("x86 ISA used: <corrupt length: %#x> "),
18248 printf ("x86 ISA used: ");
18249 decode_x86_compat_isa (bitmask
);
18253 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18255 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18259 printf ("x86 ISA needed: ");
18260 decode_x86_compat_isa (bitmask
);
18268 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18270 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18272 printf ("AArch64 feature: ");
18274 printf (_("<corrupt length: %#x> "), datasz
);
18276 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18285 case GNU_PROPERTY_STACK_SIZE
:
18286 printf (_("stack size: "));
18287 if (datasz
!= size
)
18288 printf (_("<corrupt length: %#x> "), datasz
);
18290 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18293 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18294 printf ("no copy on protected ");
18296 printf (_("<corrupt length: %#x> "), datasz
);
18304 if (type
< GNU_PROPERTY_LOPROC
)
18305 printf (_("<unknown type %#x data: "), type
);
18306 else if (type
< GNU_PROPERTY_LOUSER
)
18307 printf (_("<procesor-specific type %#x data: "), type
);
18309 printf (_("<application-specific type %#x data: "), type
);
18310 for (j
= 0; j
< datasz
; ++j
)
18311 printf ("%02x ", ptr
[j
] & 0xff);
18315 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18316 if (ptr
== ptr_end
)
18329 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18331 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18332 switch (pnote
->type
)
18334 case NT_GNU_BUILD_ID
:
18338 printf (_(" Build ID: "));
18339 for (i
= 0; i
< pnote
->descsz
; ++i
)
18340 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18345 case NT_GNU_ABI_TAG
:
18347 unsigned long os
, major
, minor
, subminor
;
18348 const char *osname
;
18350 /* PR 17531: file: 030-599401-0.004. */
18351 if (pnote
->descsz
< 16)
18353 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18357 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18358 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18359 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18360 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18364 case GNU_ABI_TAG_LINUX
:
18367 case GNU_ABI_TAG_HURD
:
18370 case GNU_ABI_TAG_SOLARIS
:
18371 osname
= "Solaris";
18373 case GNU_ABI_TAG_FREEBSD
:
18374 osname
= "FreeBSD";
18376 case GNU_ABI_TAG_NETBSD
:
18379 case GNU_ABI_TAG_SYLLABLE
:
18380 osname
= "Syllable";
18382 case GNU_ABI_TAG_NACL
:
18386 osname
= "Unknown";
18390 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18391 major
, minor
, subminor
);
18395 case NT_GNU_GOLD_VERSION
:
18399 printf (_(" Version: "));
18400 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18401 printf ("%c", pnote
->descdata
[i
]);
18408 unsigned long num_entries
, mask
;
18410 /* Hardware capabilities information. Word 0 is the number of entries.
18411 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18412 is a series of entries, where each entry is a single byte followed
18413 by a nul terminated string. The byte gives the bit number to test
18414 if enabled in the bitmask. */
18415 printf (_(" Hardware Capabilities: "));
18416 if (pnote
->descsz
< 8)
18418 error (_("<corrupt GNU_HWCAP>\n"));
18421 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18422 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18423 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18424 /* FIXME: Add code to display the entries... */
18428 case NT_GNU_PROPERTY_TYPE_0
:
18429 print_gnu_property_note (filedata
, pnote
);
18433 /* Handle unrecognised types. An error message should have already been
18434 created by get_gnu_elf_note_type(), so all that we need to do is to
18435 display the data. */
18439 printf (_(" Description data: "));
18440 for (i
= 0; i
< pnote
->descsz
; ++i
)
18441 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18450 static const char *
18451 get_v850_elf_note_type (enum v850_notes n_type
)
18453 static char buff
[64];
18457 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18458 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18459 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18460 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18461 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18462 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18464 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18470 print_v850_note (Elf_Internal_Note
* pnote
)
18474 if (pnote
->descsz
!= 4)
18477 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18481 printf (_("not set\n"));
18485 switch (pnote
->type
)
18487 case V850_NOTE_ALIGNMENT
:
18490 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18491 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18495 case V850_NOTE_DATA_SIZE
:
18498 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18499 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18503 case V850_NOTE_FPU_INFO
:
18506 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18507 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18511 case V850_NOTE_MMU_INFO
:
18512 case V850_NOTE_CACHE_INFO
:
18513 case V850_NOTE_SIMD_INFO
:
18514 if (val
== EF_RH850_SIMD
)
18516 printf (_("yes\n"));
18522 /* An 'unknown note type' message will already have been displayed. */
18526 printf (_("unknown value: %x\n"), val
);
18531 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18533 unsigned int version
;
18535 switch (pnote
->type
)
18537 case NT_NETBSD_IDENT
:
18538 if (pnote
->descsz
< 1)
18540 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18541 if ((version
/ 10000) % 100)
18542 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18543 version
, version
/ 100000000, (version
/ 1000000) % 100,
18544 (version
/ 10000) % 100 > 26 ? "Z" : "",
18545 'A' + (version
/ 10000) % 26);
18547 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18548 version
, version
/ 100000000, (version
/ 1000000) % 100,
18549 (version
/ 100) % 100);
18552 case NT_NETBSD_MARCH
:
18553 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18557 #ifdef NT_NETBSD_PAX
18558 case NT_NETBSD_PAX
:
18559 if (pnote
->descsz
< 1)
18561 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18562 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18563 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18564 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18565 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18566 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18567 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18568 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18573 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18574 pnote
->descsz
, pnote
->type
);
18578 static const char *
18579 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18583 case NT_FREEBSD_THRMISC
:
18584 return _("NT_THRMISC (thrmisc structure)");
18585 case NT_FREEBSD_PROCSTAT_PROC
:
18586 return _("NT_PROCSTAT_PROC (proc data)");
18587 case NT_FREEBSD_PROCSTAT_FILES
:
18588 return _("NT_PROCSTAT_FILES (files data)");
18589 case NT_FREEBSD_PROCSTAT_VMMAP
:
18590 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18591 case NT_FREEBSD_PROCSTAT_GROUPS
:
18592 return _("NT_PROCSTAT_GROUPS (groups data)");
18593 case NT_FREEBSD_PROCSTAT_UMASK
:
18594 return _("NT_PROCSTAT_UMASK (umask data)");
18595 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18596 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18597 case NT_FREEBSD_PROCSTAT_OSREL
:
18598 return _("NT_PROCSTAT_OSREL (osreldate data)");
18599 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18600 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18601 case NT_FREEBSD_PROCSTAT_AUXV
:
18602 return _("NT_PROCSTAT_AUXV (auxv data)");
18603 case NT_FREEBSD_PTLWPINFO
:
18604 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18606 return get_note_type (filedata
, e_type
);
18609 static const char *
18610 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18612 static char buff
[64];
18616 case NT_NETBSDCORE_PROCINFO
:
18617 /* NetBSD core "procinfo" structure. */
18618 return _("NetBSD procinfo structure");
18620 #ifdef NT_NETBSDCORE_AUXV
18621 case NT_NETBSDCORE_AUXV
:
18622 return _("NetBSD ELF auxiliary vector data");
18625 #ifdef NT_NETBSDCORE_LWPSTATUS
18626 case NT_NETBSDCORE_LWPSTATUS
:
18627 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18631 /* As of Jan 2020 there are no other machine-independent notes
18632 defined for NetBSD core files. If the note type is less
18633 than the start of the machine-dependent note types, we don't
18636 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18638 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18644 switch (filedata
->file_header
.e_machine
)
18646 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18647 and PT_GETFPREGS == mach+2. */
18652 case EM_SPARC32PLUS
:
18656 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18657 return _("PT_GETREGS (reg structure)");
18658 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18659 return _("PT_GETFPREGS (fpreg structure)");
18665 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18666 There's also old PT___GETREGS40 == mach + 1 for old reg
18667 structure which lacks GBR. */
18671 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18672 return _("PT___GETREGS40 (old reg structure)");
18673 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18674 return _("PT_GETREGS (reg structure)");
18675 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18676 return _("PT_GETFPREGS (fpreg structure)");
18682 /* On all other arch's, PT_GETREGS == mach+1 and
18683 PT_GETFPREGS == mach+3. */
18687 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18688 return _("PT_GETREGS (reg structure)");
18689 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18690 return _("PT_GETFPREGS (fpreg structure)");
18696 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18697 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18701 static const char *
18702 get_stapsdt_note_type (unsigned e_type
)
18704 static char buff
[64];
18709 return _("NT_STAPSDT (SystemTap probe descriptors)");
18715 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18720 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18722 size_t len
, maxlen
;
18723 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18724 char *data
= pnote
->descdata
;
18725 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18726 bfd_vma pc
, base_addr
, semaphore
;
18727 char *provider
, *probe
, *arg_fmt
;
18729 if (pnote
->descsz
< (addr_size
* 3))
18730 goto stapdt_note_too_small
;
18732 pc
= byte_get ((unsigned char *) data
, addr_size
);
18735 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18738 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18741 if (data
>= data_end
)
18742 goto stapdt_note_too_small
;
18743 maxlen
= data_end
- data
;
18744 len
= strnlen (data
, maxlen
);
18751 goto stapdt_note_too_small
;
18753 if (data
>= data_end
)
18754 goto stapdt_note_too_small
;
18755 maxlen
= data_end
- data
;
18756 len
= strnlen (data
, maxlen
);
18763 goto stapdt_note_too_small
;
18765 if (data
>= data_end
)
18766 goto stapdt_note_too_small
;
18767 maxlen
= data_end
- data
;
18768 len
= strnlen (data
, maxlen
);
18775 goto stapdt_note_too_small
;
18777 printf (_(" Provider: %s\n"), provider
);
18778 printf (_(" Name: %s\n"), probe
);
18779 printf (_(" Location: "));
18780 print_vma (pc
, FULL_HEX
);
18781 printf (_(", Base: "));
18782 print_vma (base_addr
, FULL_HEX
);
18783 printf (_(", Semaphore: "));
18784 print_vma (semaphore
, FULL_HEX
);
18786 printf (_(" Arguments: %s\n"), arg_fmt
);
18788 return data
== data_end
;
18790 stapdt_note_too_small
:
18791 printf (_(" <corrupt - note is too small>\n"));
18792 error (_("corrupt stapdt note - the data size is too small\n"));
18796 static const char *
18797 get_ia64_vms_note_type (unsigned e_type
)
18799 static char buff
[64];
18804 return _("NT_VMS_MHD (module header)");
18806 return _("NT_VMS_LNM (language name)");
18808 return _("NT_VMS_SRC (source files)");
18810 return "NT_VMS_TITLE";
18812 return _("NT_VMS_EIDC (consistency check)");
18813 case NT_VMS_FPMODE
:
18814 return _("NT_VMS_FPMODE (FP mode)");
18815 case NT_VMS_LINKTIME
:
18816 return "NT_VMS_LINKTIME";
18817 case NT_VMS_IMGNAM
:
18818 return _("NT_VMS_IMGNAM (image name)");
18820 return _("NT_VMS_IMGID (image id)");
18821 case NT_VMS_LINKID
:
18822 return _("NT_VMS_LINKID (link id)");
18823 case NT_VMS_IMGBID
:
18824 return _("NT_VMS_IMGBID (build id)");
18825 case NT_VMS_GSTNAM
:
18826 return _("NT_VMS_GSTNAM (sym table name)");
18827 case NT_VMS_ORIG_DYN
:
18828 return "NT_VMS_ORIG_DYN";
18829 case NT_VMS_PATCHTIME
:
18830 return "NT_VMS_PATCHTIME";
18832 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18838 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18840 int maxlen
= pnote
->descsz
;
18842 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18843 goto desc_size_fail
;
18845 switch (pnote
->type
)
18849 goto desc_size_fail
;
18851 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18853 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18854 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18855 if (l
+ 34 < maxlen
)
18857 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18858 if (l
+ 35 < maxlen
)
18859 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18861 printf (_(" Module version : <missing>\n"));
18865 printf (_(" Module name : <missing>\n"));
18866 printf (_(" Module version : <missing>\n"));
18871 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18875 case NT_VMS_FPMODE
:
18876 printf (_(" Floating Point mode: "));
18878 goto desc_size_fail
;
18879 /* FIXME: Generate an error if descsz > 8 ? */
18881 printf ("0x%016" BFD_VMA_FMT
"x\n",
18882 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18885 case NT_VMS_LINKTIME
:
18886 printf (_(" Link time: "));
18888 goto desc_size_fail
;
18889 /* FIXME: Generate an error if descsz > 8 ? */
18892 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18896 case NT_VMS_PATCHTIME
:
18897 printf (_(" Patch time: "));
18899 goto desc_size_fail
;
18900 /* FIXME: Generate an error if descsz > 8 ? */
18903 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18907 case NT_VMS_ORIG_DYN
:
18909 goto desc_size_fail
;
18911 printf (_(" Major id: %u, minor id: %u\n"),
18912 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18913 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18914 printf (_(" Last modified : "));
18916 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18917 printf (_("\n Link flags : "));
18918 printf ("0x%016" BFD_VMA_FMT
"x\n",
18919 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18920 printf (_(" Header flags: 0x%08x\n"),
18921 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18922 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18926 case NT_VMS_IMGNAM
:
18927 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18930 case NT_VMS_GSTNAM
:
18931 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18935 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18938 case NT_VMS_LINKID
:
18939 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18949 printf (_(" <corrupt - data size is too small>\n"));
18950 error (_("corrupt IA64 note: data size is too small\n"));
18954 struct build_attr_cache
{
18955 Filedata
*filedata
;
18957 unsigned long strtablen
;
18958 Elf_Internal_Sym
*symtab
;
18959 unsigned long nsyms
;
18962 /* Find the symbol associated with a build attribute that is attached
18963 to address OFFSET. If PNAME is non-NULL then store the name of
18964 the symbol (if found) in the provided pointer, Returns NULL if a
18965 symbol could not be found. */
18967 static Elf_Internal_Sym
*
18968 get_symbol_for_build_attribute (Filedata
* filedata
,
18969 unsigned long offset
,
18970 bfd_boolean is_open_attr
,
18971 const char ** pname
)
18973 Elf_Internal_Sym
*saved_sym
= NULL
;
18974 Elf_Internal_Sym
*sym
;
18976 if (filedata
->section_headers
!= NULL
18977 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18979 Elf_Internal_Shdr
* symsec
;
18981 free (ba_cache
.strtab
);
18982 ba_cache
.strtab
= NULL
;
18983 free (ba_cache
.symtab
);
18984 ba_cache
.symtab
= NULL
;
18986 /* Load the symbol and string sections. */
18987 for (symsec
= filedata
->section_headers
;
18988 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18991 if (symsec
->sh_type
== SHT_SYMTAB
18992 && get_symtab (filedata
, symsec
,
18993 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18994 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18997 ba_cache
.filedata
= filedata
;
19000 if (ba_cache
.symtab
== NULL
)
19003 /* Find a symbol whose value matches offset. */
19004 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19005 if (sym
->st_value
== offset
)
19007 if (sym
->st_name
>= ba_cache
.strtablen
)
19008 /* Huh ? This should not happen. */
19011 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19014 /* The AArch64 and ARM architectures define mapping symbols
19015 (eg $d, $x, $t) which we want to ignore. */
19016 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19017 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19018 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19023 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19024 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19025 FUNC symbols entirely. */
19026 switch (ELF_ST_TYPE (sym
->st_info
))
19033 /* If the symbol has a size associated
19034 with it then we can stop searching. */
19035 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19040 /* Ignore function symbols. */
19047 switch (ELF_ST_BIND (sym
->st_info
))
19050 if (saved_sym
== NULL
19051 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19056 if (saved_sym
== NULL
)
19066 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19074 if (saved_sym
&& pname
)
19075 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19080 /* Returns true iff addr1 and addr2 are in the same section. */
19083 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19085 Elf_Internal_Shdr
* a1
;
19086 Elf_Internal_Shdr
* a2
;
19088 a1
= find_section_by_address (filedata
, addr1
);
19089 a2
= find_section_by_address (filedata
, addr2
);
19091 return a1
== a2
&& a1
!= NULL
;
19095 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19096 Filedata
* filedata
)
19098 static unsigned long global_offset
= 0;
19099 static unsigned long global_end
= 0;
19100 static unsigned long func_offset
= 0;
19101 static unsigned long func_end
= 0;
19103 Elf_Internal_Sym
* sym
;
19105 unsigned long start
;
19107 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19109 switch (pnote
->descsz
)
19112 /* A zero-length description means that the range of
19113 the previous note of the same type should be used. */
19116 if (global_end
> global_offset
)
19117 printf (_(" Applies to region from %#lx to %#lx\n"),
19118 global_offset
, global_end
);
19120 printf (_(" Applies to region from %#lx\n"), global_offset
);
19124 if (func_end
> func_offset
)
19125 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19127 printf (_(" Applies to region from %#lx\n"), func_offset
);
19132 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19139 /* FIXME: We should check that version 3+ notes are being used here... */
19140 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19141 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19145 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19151 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19152 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19156 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19157 printf (_(" <invalid descsz>"));
19162 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19163 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19164 in order to avoid them being confused with the start address of the
19165 first function in the file... */
19166 if (sym
== NULL
&& is_open_attr
)
19167 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19170 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19171 end
= start
+ sym
->st_size
;
19175 /* FIXME: Need to properly allow for section alignment.
19176 16 is just the alignment used on x86_64. */
19178 && start
> BFD_ALIGN (global_end
, 16)
19179 /* Build notes are not guaranteed to be organised in order of
19180 increasing address, but we should find the all of the notes
19181 for one section in the same place. */
19182 && same_section (filedata
, start
, global_end
))
19183 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19184 global_end
+ 1, start
- 1);
19186 printf (_(" Applies to region from %#lx"), start
);
19187 global_offset
= start
;
19191 printf (_(" to %#lx"), end
);
19197 printf (_(" Applies to region from %#lx"), start
);
19198 func_offset
= start
;
19202 printf (_(" to %#lx"), end
);
19208 printf (_(" (%s)"), name
);
19215 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19217 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19218 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19219 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19221 char name_attribute
;
19222 const char * expected_types
;
19223 const char * name
= pnote
->namedata
;
19227 if (name
== NULL
|| pnote
->namesz
< 2)
19229 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19230 print_symbol (-20, _(" <corrupt name>"));
19239 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19240 if (name
[0] == 'G' && name
[1] == 'A')
19242 if (pnote
->namesz
< 4)
19244 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19245 print_symbol (-20, _(" <corrupt name>"));
19254 switch ((name_type
= * name
))
19256 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19257 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19258 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19259 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19260 printf ("%c", * name
);
19264 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19265 print_symbol (-20, _("<unknown name type>"));
19272 switch ((name_attribute
= * name
))
19274 case GNU_BUILD_ATTRIBUTE_VERSION
:
19275 text
= _("<version>");
19276 expected_types
= string_expected
;
19279 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19280 text
= _("<stack prot>");
19281 expected_types
= "!+*";
19284 case GNU_BUILD_ATTRIBUTE_RELRO
:
19285 text
= _("<relro>");
19286 expected_types
= bool_expected
;
19289 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19290 text
= _("<stack size>");
19291 expected_types
= number_expected
;
19294 case GNU_BUILD_ATTRIBUTE_TOOL
:
19295 text
= _("<tool>");
19296 expected_types
= string_expected
;
19299 case GNU_BUILD_ATTRIBUTE_ABI
:
19301 expected_types
= "$*";
19304 case GNU_BUILD_ATTRIBUTE_PIC
:
19306 expected_types
= number_expected
;
19309 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19310 text
= _("<short enum>");
19311 expected_types
= bool_expected
;
19315 if (ISPRINT (* name
))
19317 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19319 if (len
> left
&& ! do_wide
)
19321 printf ("%.*s:", len
, name
);
19327 static char tmpbuf
[128];
19329 error (_("unrecognised byte in name field: %d\n"), * name
);
19330 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19334 expected_types
= "*$!+";
19339 left
-= printf ("%s", text
);
19341 if (strchr (expected_types
, name_type
) == NULL
)
19342 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19344 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19346 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19347 (unsigned long) pnote
->namesz
,
19348 (long) (name
- pnote
->namedata
));
19352 if (left
< 1 && ! do_wide
)
19357 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19359 unsigned int bytes
;
19360 unsigned long long val
= 0;
19361 unsigned int shift
= 0;
19362 char * decoded
= NULL
;
19364 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19366 /* The -1 is because the name field is always 0 terminated, and we
19367 want to be able to ensure that the shift in the while loop below
19368 will not overflow. */
19371 if (bytes
> sizeof (val
))
19373 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19375 bytes
= sizeof (val
);
19377 /* We do not bother to warn if bytes == 0 as this can
19378 happen with some early versions of the gcc plugin. */
19382 unsigned long byte
= (* name
++) & 0xff;
19384 val
|= byte
<< shift
;
19388 switch (name_attribute
)
19390 case GNU_BUILD_ATTRIBUTE_PIC
:
19393 case 0: decoded
= "static"; break;
19394 case 1: decoded
= "pic"; break;
19395 case 2: decoded
= "PIC"; break;
19396 case 3: decoded
= "pie"; break;
19397 case 4: decoded
= "PIE"; break;
19401 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19404 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19405 case 0: decoded
= "off"; break;
19406 case 1: decoded
= "on"; break;
19407 case 2: decoded
= "all"; break;
19408 case 3: decoded
= "strong"; break;
19409 case 4: decoded
= "explicit"; break;
19417 if (decoded
!= NULL
)
19419 print_symbol (-left
, decoded
);
19430 left
-= printf ("0x%llx", val
);
19432 left
-= printf ("0x%-.*llx", left
, val
);
19436 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19437 left
-= print_symbol (- left
, name
);
19439 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19440 left
-= print_symbol (- left
, "true");
19442 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19443 left
-= print_symbol (- left
, "false");
19447 if (do_wide
&& left
> 0)
19448 printf ("%-*s", left
, " ");
19453 /* Note that by the ELF standard, the name field is already null byte
19454 terminated, and namesz includes the terminating null byte.
19455 I.E. the value of namesz for the name "FSF" is 4.
19457 If the value of namesz is zero, there is no name present. */
19460 process_note (Elf_Internal_Note
* pnote
,
19461 Filedata
* filedata
)
19463 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19466 if (pnote
->namesz
== 0)
19467 /* If there is no note name, then use the default set of
19468 note type strings. */
19469 nt
= get_note_type (filedata
, pnote
->type
);
19471 else if (const_strneq (pnote
->namedata
, "GNU"))
19472 /* GNU-specific object file notes. */
19473 nt
= get_gnu_elf_note_type (pnote
->type
);
19475 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19476 /* FreeBSD-specific core file notes. */
19477 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19479 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19480 /* NetBSD-specific core file notes. */
19481 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19483 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19484 /* NetBSD-specific core file notes. */
19485 return process_netbsd_elf_note (pnote
);
19487 else if (const_strneq (pnote
->namedata
, "PaX"))
19488 /* NetBSD-specific core file notes. */
19489 return process_netbsd_elf_note (pnote
);
19491 else if (strneq (pnote
->namedata
, "SPU/", 4))
19493 /* SPU-specific core file notes. */
19494 nt
= pnote
->namedata
+ 4;
19498 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19499 /* VMS/ia64-specific file notes. */
19500 nt
= get_ia64_vms_note_type (pnote
->type
);
19502 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19503 nt
= get_stapsdt_note_type (pnote
->type
);
19506 /* Don't recognize this note name; just use the default set of
19507 note type strings. */
19508 nt
= get_note_type (filedata
, pnote
->type
);
19512 if (((const_strneq (pnote
->namedata
, "GA")
19513 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19514 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19515 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19516 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19517 print_gnu_build_attribute_name (pnote
);
19519 print_symbol (-20, name
);
19522 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19524 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19526 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19527 return print_ia64_vms_note (pnote
);
19528 else if (const_strneq (pnote
->namedata
, "GNU"))
19529 return print_gnu_note (filedata
, pnote
);
19530 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19531 return print_stapsdt_note (pnote
);
19532 else if (const_strneq (pnote
->namedata
, "CORE"))
19533 return print_core_note (pnote
);
19534 else if (((const_strneq (pnote
->namedata
, "GA")
19535 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19536 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19537 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19538 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19539 return print_gnu_build_attribute_description (pnote
, filedata
);
19545 printf (_(" description data: "));
19546 for (i
= 0; i
< pnote
->descsz
; i
++)
19547 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19559 process_notes_at (Filedata
* filedata
,
19560 Elf_Internal_Shdr
* section
,
19565 Elf_External_Note
* pnotes
;
19566 Elf_External_Note
* external
;
19568 bfd_boolean res
= TRUE
;
19575 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19578 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19586 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19589 if (pnotes
== NULL
)
19595 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19597 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19598 (unsigned long) offset
, (unsigned long) length
);
19600 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19601 specifies that notes should be aligned to 4 bytes in 32-bit
19602 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19603 we also support 4 byte alignment in 64-bit objects. If section
19604 alignment is less than 4, we treate alignment as 4 bytes. */
19607 else if (align
!= 4 && align
!= 8)
19609 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19615 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19617 end
= (char *) pnotes
+ length
;
19618 while ((char *) external
< end
)
19620 Elf_Internal_Note inote
;
19623 char * temp
= NULL
;
19624 size_t data_remaining
= end
- (char *) external
;
19626 if (!is_ia64_vms (filedata
))
19628 /* PR binutils/15191
19629 Make sure that there is enough data to read. */
19630 min_notesz
= offsetof (Elf_External_Note
, name
);
19631 if (data_remaining
< min_notesz
)
19633 warn (ngettext ("Corrupt note: only %ld byte remains, "
19634 "not enough for a full note\n",
19635 "Corrupt note: only %ld bytes remain, "
19636 "not enough for a full note\n",
19638 (long) data_remaining
);
19641 data_remaining
-= min_notesz
;
19643 inote
.type
= BYTE_GET (external
->type
);
19644 inote
.namesz
= BYTE_GET (external
->namesz
);
19645 inote
.namedata
= external
->name
;
19646 inote
.descsz
= BYTE_GET (external
->descsz
);
19647 inote
.descdata
= ((char *) external
19648 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19649 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19650 next
= ((char *) external
19651 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19655 Elf64_External_VMS_Note
*vms_external
;
19657 /* PR binutils/15191
19658 Make sure that there is enough data to read. */
19659 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19660 if (data_remaining
< min_notesz
)
19662 warn (ngettext ("Corrupt note: only %ld byte remains, "
19663 "not enough for a full note\n",
19664 "Corrupt note: only %ld bytes remain, "
19665 "not enough for a full note\n",
19667 (long) data_remaining
);
19670 data_remaining
-= min_notesz
;
19672 vms_external
= (Elf64_External_VMS_Note
*) external
;
19673 inote
.type
= BYTE_GET (vms_external
->type
);
19674 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19675 inote
.namedata
= vms_external
->name
;
19676 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19677 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19678 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19679 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19682 /* PR 17531: file: 3443835e. */
19683 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19684 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19685 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19686 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19687 || ((size_t) (next
- inote
.descdata
)
19688 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19690 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19691 (unsigned long) ((char *) external
- (char *) pnotes
));
19692 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19693 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19697 external
= (Elf_External_Note
*) next
;
19699 /* Verify that name is null terminated. It appears that at least
19700 one version of Linux (RedHat 6.0) generates corefiles that don't
19701 comply with the ELF spec by failing to include the null byte in
19703 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19705 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19707 temp
= (char *) malloc (inote
.namesz
+ 1);
19710 error (_("Out of memory allocating space for inote name\n"));
19715 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19716 inote
.namedata
= temp
;
19718 inote
.namedata
[inote
.namesz
] = 0;
19721 if (! process_note (& inote
, filedata
))
19737 process_corefile_note_segments (Filedata
* filedata
)
19739 Elf_Internal_Phdr
* segment
;
19741 bfd_boolean res
= TRUE
;
19743 if (! get_program_headers (filedata
))
19746 for (i
= 0, segment
= filedata
->program_headers
;
19747 i
< filedata
->file_header
.e_phnum
;
19750 if (segment
->p_type
== PT_NOTE
)
19751 if (! process_notes_at (filedata
, NULL
,
19752 (bfd_vma
) segment
->p_offset
,
19753 (bfd_vma
) segment
->p_filesz
,
19754 (bfd_vma
) segment
->p_align
))
19762 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19764 Elf_External_Note
* pnotes
;
19765 Elf_External_Note
* external
;
19767 bfd_boolean res
= TRUE
;
19772 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19774 if (pnotes
== NULL
)
19778 end
= (char*) pnotes
+ length
;
19780 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19781 (unsigned long) offset
, (unsigned long) length
);
19783 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19785 Elf_External_Note
* next
;
19786 Elf_Internal_Note inote
;
19788 inote
.type
= BYTE_GET (external
->type
);
19789 inote
.namesz
= BYTE_GET (external
->namesz
);
19790 inote
.namedata
= external
->name
;
19791 inote
.descsz
= BYTE_GET (external
->descsz
);
19792 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19793 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19795 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19797 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19798 inote
.descdata
= inote
.namedata
;
19802 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19804 if ( ((char *) next
> end
)
19805 || ((char *) next
< (char *) pnotes
))
19807 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19808 (unsigned long) ((char *) external
- (char *) pnotes
));
19809 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19810 inote
.type
, inote
.namesz
, inote
.descsz
);
19816 /* Prevent out-of-bounds indexing. */
19817 if ( inote
.namedata
+ inote
.namesz
> end
19818 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19820 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19821 (unsigned long) ((char *) external
- (char *) pnotes
));
19822 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19823 inote
.type
, inote
.namesz
, inote
.descsz
);
19827 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19829 if (! print_v850_note (& inote
))
19832 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19833 inote
.namesz
, inote
.descsz
);
19843 process_note_sections (Filedata
* filedata
)
19845 Elf_Internal_Shdr
* section
;
19847 unsigned int n
= 0;
19848 bfd_boolean res
= TRUE
;
19850 for (i
= 0, section
= filedata
->section_headers
;
19851 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19854 if (section
->sh_type
== SHT_NOTE
)
19856 if (! process_notes_at (filedata
, section
,
19857 (bfd_vma
) section
->sh_offset
,
19858 (bfd_vma
) section
->sh_size
,
19859 (bfd_vma
) section
->sh_addralign
))
19864 if (( filedata
->file_header
.e_machine
== EM_V800
19865 || filedata
->file_header
.e_machine
== EM_V850
19866 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19867 && section
->sh_type
== SHT_RENESAS_INFO
)
19869 if (! process_v850_notes (filedata
,
19870 (bfd_vma
) section
->sh_offset
,
19871 (bfd_vma
) section
->sh_size
))
19878 /* Try processing NOTE segments instead. */
19879 return process_corefile_note_segments (filedata
);
19885 process_notes (Filedata
* filedata
)
19887 /* If we have not been asked to display the notes then do nothing. */
19891 if (filedata
->file_header
.e_type
!= ET_CORE
)
19892 return process_note_sections (filedata
);
19894 /* No program headers means no NOTE segment. */
19895 if (filedata
->file_header
.e_phnum
> 0)
19896 return process_corefile_note_segments (filedata
);
19898 printf (_("No note segments present in the core file.\n"));
19902 static unsigned char *
19903 display_public_gnu_attributes (unsigned char * start
,
19904 const unsigned char * const end
)
19906 printf (_(" Unknown GNU attribute: %s\n"), start
);
19908 start
+= strnlen ((char *) start
, end
- start
);
19909 display_raw_attribute (start
, end
);
19911 return (unsigned char *) end
;
19914 static unsigned char *
19915 display_generic_attribute (unsigned char * start
,
19917 const unsigned char * const end
)
19920 return (unsigned char *) end
;
19922 return display_tag_value (tag
, start
, end
);
19926 process_arch_specific (Filedata
* filedata
)
19931 switch (filedata
->file_header
.e_machine
)
19934 case EM_ARC_COMPACT
:
19935 case EM_ARC_COMPACT2
:
19936 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19937 display_arc_attribute
,
19938 display_generic_attribute
);
19940 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19941 display_arm_attribute
,
19942 display_generic_attribute
);
19945 case EM_MIPS_RS3_LE
:
19946 return process_mips_specific (filedata
);
19949 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19950 display_msp430x_attribute
,
19951 display_msp430_gnu_attribute
);
19954 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19955 display_riscv_attribute
,
19956 display_generic_attribute
);
19959 return process_nds32_specific (filedata
);
19963 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19964 display_power_gnu_attribute
);
19968 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19969 display_s390_gnu_attribute
);
19972 case EM_SPARC32PLUS
:
19974 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19975 display_sparc_gnu_attribute
);
19978 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19979 display_tic6x_attribute
,
19980 display_generic_attribute
);
19983 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19984 display_public_gnu_attributes
,
19985 display_generic_attribute
);
19990 get_file_header (Filedata
* filedata
)
19992 /* Read in the identity array. */
19993 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19996 /* Determine how to read the rest of the header. */
19997 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20002 byte_get
= byte_get_little_endian
;
20003 byte_put
= byte_put_little_endian
;
20006 byte_get
= byte_get_big_endian
;
20007 byte_put
= byte_put_big_endian
;
20011 /* For now we only support 32 bit and 64 bit ELF files. */
20012 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20014 /* Read in the rest of the header. */
20017 Elf32_External_Ehdr ehdr32
;
20019 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20022 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20023 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20024 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20025 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20026 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20027 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20028 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20029 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20030 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20031 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20032 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20033 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20034 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20038 Elf64_External_Ehdr ehdr64
;
20040 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20041 we will not be able to cope with the 64bit data found in
20042 64 ELF files. Detect this now and abort before we start
20043 overwriting things. */
20044 if (sizeof (bfd_vma
) < 8)
20046 error (_("This instance of readelf has been built without support for a\n\
20047 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20051 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20054 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20055 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20056 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20057 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20058 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20059 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20060 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20061 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20062 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20063 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20064 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20065 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20066 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20069 if (filedata
->file_header
.e_shoff
)
20071 /* There may be some extensions in the first section header. Don't
20072 bomb if we can't read it. */
20074 get_32bit_section_headers (filedata
, TRUE
);
20076 get_64bit_section_headers (filedata
, TRUE
);
20083 close_file (Filedata
* filedata
)
20087 if (filedata
->handle
)
20088 fclose (filedata
->handle
);
20094 close_debug_file (void * data
)
20096 close_file ((Filedata
*) data
);
20100 open_file (const char * pathname
)
20102 struct stat statbuf
;
20103 Filedata
* filedata
= NULL
;
20105 if (stat (pathname
, & statbuf
) < 0
20106 || ! S_ISREG (statbuf
.st_mode
))
20109 filedata
= calloc (1, sizeof * filedata
);
20110 if (filedata
== NULL
)
20113 filedata
->handle
= fopen (pathname
, "rb");
20114 if (filedata
->handle
== NULL
)
20117 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20118 filedata
->file_name
= pathname
;
20120 if (! get_file_header (filedata
))
20123 if (filedata
->file_header
.e_shoff
)
20127 /* Read the section headers again, this time for real. */
20129 res
= get_32bit_section_headers (filedata
, FALSE
);
20131 res
= get_64bit_section_headers (filedata
, FALSE
);
20142 if (filedata
->handle
)
20143 fclose (filedata
->handle
);
20150 open_debug_file (const char * pathname
)
20152 return open_file (pathname
);
20155 /* Process one ELF object file according to the command line options.
20156 This file may actually be stored in an archive. The file is
20157 positioned at the start of the ELF object. Returns TRUE if no
20158 problems were encountered, FALSE otherwise. */
20161 process_object (Filedata
* filedata
)
20163 bfd_boolean have_separate_files
;
20167 if (! get_file_header (filedata
))
20169 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20173 /* Initialise per file variables. */
20174 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20175 filedata
->version_info
[i
] = 0;
20177 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20178 filedata
->dynamic_info
[i
] = 0;
20179 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20180 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20182 /* Process the file. */
20184 printf (_("\nFile: %s\n"), filedata
->file_name
);
20186 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20187 Note we do this even if cmdline_dump_sects is empty because we
20188 must make sure that the dump_sets array is zeroed out before each
20189 object file is processed. */
20190 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20191 memset (filedata
->dump
.dump_sects
, 0,
20192 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20194 if (cmdline
.num_dump_sects
> 0)
20196 if (filedata
->dump
.num_dump_sects
== 0)
20197 /* A sneaky way of allocating the dump_sects array. */
20198 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20200 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20201 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20202 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20205 if (! process_file_header (filedata
))
20208 if (! process_section_headers (filedata
))
20210 /* Without loaded section headers we cannot process lots of things. */
20211 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20213 if (! do_using_dynamic
)
20214 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20217 if (! process_section_groups (filedata
))
20218 /* Without loaded section groups we cannot process unwind. */
20221 res
= process_program_headers (filedata
);
20223 res
= process_dynamic_section (filedata
);
20225 if (! process_relocs (filedata
))
20228 if (! process_unwind (filedata
))
20231 if (! process_symbol_table (filedata
))
20234 if (! process_syminfo (filedata
))
20237 if (! process_version_sections (filedata
))
20240 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20241 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20243 have_separate_files
= FALSE
;
20245 if (! process_section_contents (filedata
))
20248 if (have_separate_files
)
20252 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20254 if (! process_section_headers (d
->handle
))
20256 else if (! process_section_contents (d
->handle
))
20260 /* The file handles are closed by the call to free_debug_memory() below. */
20263 if (! process_notes (filedata
))
20266 if (! process_gnu_liblist (filedata
))
20269 if (! process_arch_specific (filedata
))
20272 free (filedata
->program_headers
);
20273 filedata
->program_headers
= NULL
;
20275 free (filedata
->section_headers
);
20276 filedata
->section_headers
= NULL
;
20278 free (filedata
->string_table
);
20279 filedata
->string_table
= NULL
;
20280 filedata
->string_table_length
= 0;
20282 if (filedata
->dump
.dump_sects
!= NULL
)
20284 free (filedata
->dump
.dump_sects
);
20285 filedata
->dump
.dump_sects
= NULL
;
20286 filedata
->dump
.num_dump_sects
= 0;
20289 if (filedata
->dynamic_strings
)
20291 free (filedata
->dynamic_strings
);
20292 filedata
->dynamic_strings
= NULL
;
20293 filedata
->dynamic_strings_length
= 0;
20296 if (filedata
->dynamic_symbols
)
20298 free (filedata
->dynamic_symbols
);
20299 filedata
->dynamic_symbols
= NULL
;
20300 filedata
->num_dynamic_syms
= 0;
20303 if (filedata
->dynamic_syminfo
)
20305 free (filedata
->dynamic_syminfo
);
20306 filedata
->dynamic_syminfo
= NULL
;
20309 if (filedata
->dynamic_section
)
20311 free (filedata
->dynamic_section
);
20312 filedata
->dynamic_section
= NULL
;
20315 while (filedata
->symtab_shndx_list
!= NULL
)
20317 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20318 free (filedata
->symtab_shndx_list
);
20319 filedata
->symtab_shndx_list
= next
;
20322 if (filedata
->section_headers_groups
)
20324 free (filedata
->section_headers_groups
);
20325 filedata
->section_headers_groups
= NULL
;
20328 if (filedata
->section_groups
)
20330 struct group_list
* g
;
20331 struct group_list
* next
;
20333 for (i
= 0; i
< filedata
->group_count
; i
++)
20335 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20342 free (filedata
->section_groups
);
20343 filedata
->section_groups
= NULL
;
20346 free_debug_memory ();
20351 /* Process an ELF archive.
20352 On entry the file is positioned just after the ARMAG string.
20353 Returns TRUE upon success, FALSE otherwise. */
20356 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20358 struct archive_info arch
;
20359 struct archive_info nested_arch
;
20361 bfd_boolean ret
= TRUE
;
20365 /* The ARCH structure is used to hold information about this archive. */
20366 arch
.file_name
= NULL
;
20368 arch
.index_array
= NULL
;
20369 arch
.sym_table
= NULL
;
20370 arch
.longnames
= NULL
;
20372 /* The NESTED_ARCH structure is used as a single-item cache of information
20373 about a nested archive (when members of a thin archive reside within
20374 another regular archive file). */
20375 nested_arch
.file_name
= NULL
;
20376 nested_arch
.file
= NULL
;
20377 nested_arch
.index_array
= NULL
;
20378 nested_arch
.sym_table
= NULL
;
20379 nested_arch
.longnames
= NULL
;
20381 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20382 filedata
->file_size
, is_thin_archive
,
20383 do_archive_index
) != 0)
20389 if (do_archive_index
)
20391 if (arch
.sym_table
== NULL
)
20392 error (_("%s: unable to dump the index as none was found\n"),
20393 filedata
->file_name
);
20396 unsigned long i
, l
;
20397 unsigned long current_pos
;
20399 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20400 "in the symbol table)\n"),
20401 filedata
->file_name
, (unsigned long) arch
.index_num
,
20404 current_pos
= ftell (filedata
->handle
);
20406 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20409 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20412 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20415 if (member_name
!= NULL
)
20417 char * qualified_name
20418 = make_qualified_name (&arch
, &nested_arch
,
20421 if (qualified_name
!= NULL
)
20423 printf (_("Contents of binary %s at offset "),
20425 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20427 free (qualified_name
);
20429 free (member_name
);
20433 if (l
>= arch
.sym_size
)
20435 error (_("%s: end of the symbol table reached "
20436 "before the end of the index\n"),
20437 filedata
->file_name
);
20441 /* PR 17531: file: 0b6630b2. */
20442 printf ("\t%.*s\n",
20443 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20444 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20447 if (arch
.uses_64bit_indices
)
20452 if (l
< arch
.sym_size
)
20454 error (ngettext ("%s: %ld byte remains in the symbol table, "
20455 "but without corresponding entries in "
20456 "the index table\n",
20457 "%s: %ld bytes remain in the symbol table, "
20458 "but without corresponding entries in "
20459 "the index table\n",
20460 arch
.sym_size
- l
),
20461 filedata
->file_name
, arch
.sym_size
- l
);
20465 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20467 error (_("%s: failed to seek back to start of object files "
20468 "in the archive\n"),
20469 filedata
->file_name
);
20475 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20476 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20477 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20478 && !do_section_groups
&& !do_dyn_syms
)
20480 ret
= TRUE
; /* Archive index only. */
20489 char * qualified_name
;
20491 /* Read the next archive header. */
20492 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20494 error (_("%s: failed to seek to next archive header\n"),
20499 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20500 if (got
!= sizeof arch
.arhdr
)
20504 /* PR 24049 - we cannot use filedata->file_name as this will
20505 have already been freed. */
20506 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20511 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20513 error (_("%s: did not find a valid archive header\n"),
20519 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20521 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20522 if (filedata
->archive_file_size
& 01)
20523 ++filedata
->archive_file_size
;
20525 name
= get_archive_member_name (&arch
, &nested_arch
);
20528 error (_("%s: bad archive file name\n"), arch
.file_name
);
20532 namelen
= strlen (name
);
20534 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20535 if (qualified_name
== NULL
)
20537 error (_("%s: bad archive file name\n"), arch
.file_name
);
20543 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20545 /* This is a proxy for an external member of a thin archive. */
20546 Filedata
* member_filedata
;
20547 char * member_file_name
= adjust_relative_path
20548 (filedata
->file_name
, name
, namelen
);
20551 if (member_file_name
== NULL
)
20553 free (qualified_name
);
20558 member_filedata
= open_file (member_file_name
);
20559 if (member_filedata
== NULL
)
20561 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20562 free (member_file_name
);
20563 free (qualified_name
);
20568 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20569 member_filedata
->file_name
= qualified_name
;
20571 if (! process_object (member_filedata
))
20574 close_file (member_filedata
);
20575 free (member_file_name
);
20577 else if (is_thin_archive
)
20579 Filedata thin_filedata
;
20581 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20583 /* PR 15140: Allow for corrupt thin archives. */
20584 if (nested_arch
.file
== NULL
)
20586 error (_("%s: contains corrupt thin archive: %s\n"),
20587 qualified_name
, name
);
20588 free (qualified_name
);
20595 /* This is a proxy for a member of a nested archive. */
20596 filedata
->archive_file_offset
20597 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20599 /* The nested archive file will have been opened and setup by
20600 get_archive_member_name. */
20601 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20604 error (_("%s: failed to seek to archive member.\n"),
20605 nested_arch
.file_name
);
20606 free (qualified_name
);
20611 thin_filedata
.handle
= nested_arch
.file
;
20612 thin_filedata
.file_name
= qualified_name
;
20614 if (! process_object (& thin_filedata
))
20620 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20621 filedata
->file_name
= qualified_name
;
20622 if (! process_object (filedata
))
20624 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20625 /* Stop looping with "negative" archive_file_size. */
20626 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20627 arch
.next_arhdr_offset
= -1ul;
20630 free (qualified_name
);
20634 if (nested_arch
.file
!= NULL
)
20635 fclose (nested_arch
.file
);
20636 release_archive (&nested_arch
);
20637 release_archive (&arch
);
20643 process_file (char * file_name
)
20645 Filedata
* filedata
= NULL
;
20646 struct stat statbuf
;
20647 char armag
[SARMAG
];
20648 bfd_boolean ret
= TRUE
;
20650 if (stat (file_name
, &statbuf
) < 0)
20652 if (errno
== ENOENT
)
20653 error (_("'%s': No such file\n"), file_name
);
20655 error (_("Could not locate '%s'. System error message: %s\n"),
20656 file_name
, strerror (errno
));
20660 if (! S_ISREG (statbuf
.st_mode
))
20662 error (_("'%s' is not an ordinary file\n"), file_name
);
20666 filedata
= calloc (1, sizeof * filedata
);
20667 if (filedata
== NULL
)
20669 error (_("Out of memory allocating file data structure\n"));
20673 filedata
->file_name
= file_name
;
20674 filedata
->handle
= fopen (file_name
, "rb");
20675 if (filedata
->handle
== NULL
)
20677 error (_("Input file '%s' is not readable.\n"), file_name
);
20682 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20684 error (_("%s: Failed to read file's magic number\n"), file_name
);
20685 fclose (filedata
->handle
);
20690 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20692 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20694 if (! process_archive (filedata
, FALSE
))
20697 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20699 if ( ! process_archive (filedata
, TRUE
))
20704 if (do_archive_index
&& !check_all
)
20705 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20708 rewind (filedata
->handle
);
20709 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20711 if (! process_object (filedata
))
20715 fclose (filedata
->handle
);
20716 free (filedata
->section_headers
);
20717 free (filedata
->program_headers
);
20718 free (filedata
->string_table
);
20719 free (filedata
->dump
.dump_sects
);
20722 free (ba_cache
.strtab
);
20723 ba_cache
.strtab
= NULL
;
20724 free (ba_cache
.symtab
);
20725 ba_cache
.symtab
= NULL
;
20726 ba_cache
.filedata
= NULL
;
20731 #ifdef SUPPORT_DISASSEMBLY
20732 /* Needed by the i386 disassembler. For extra credit, someone could
20733 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20737 print_address (unsigned int addr
, FILE * outfile
)
20739 fprintf (outfile
,"0x%8.8x", addr
);
20742 /* Needed by the i386 disassembler. */
20745 db_task_printsym (unsigned int addr
)
20747 print_address (addr
, stderr
);
20752 main (int argc
, char ** argv
)
20756 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20757 setlocale (LC_MESSAGES
, "");
20759 #if defined (HAVE_SETLOCALE)
20760 setlocale (LC_CTYPE
, "");
20762 bindtextdomain (PACKAGE
, LOCALEDIR
);
20763 textdomain (PACKAGE
);
20765 expandargv (&argc
, &argv
);
20767 parse_args (& cmdline
, argc
, argv
);
20769 if (optind
< (argc
- 1))
20770 /* When displaying information for more than one file,
20771 prefix the information with the file name. */
20773 else if (optind
>= argc
)
20775 /* Ensure that the warning is always displayed. */
20778 warn (_("Nothing to do.\n"));
20783 while (optind
< argc
)
20784 if (! process_file (argv
[optind
++]))
20787 if (cmdline
.dump_sects
!= NULL
)
20788 free (cmdline
.dump_sects
);
20790 free (dump_ctf_symtab_name
);
20791 free (dump_ctf_strtab_name
);
20792 free (dump_ctf_parent_name
);
20794 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;