1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/csky.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
107 #include "elf/epiphany.h"
108 #include "elf/fr30.h"
110 #include "elf/ft32.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/s12z.h"
126 #include "elf/mcore.h"
128 #include "elf/metag.h"
129 #include "elf/microblaze.h"
130 #include "elf/mips.h"
131 #include "elf/mmix.h"
132 #include "elf/mn10200.h"
133 #include "elf/mn10300.h"
134 #include "elf/moxie.h"
136 #include "elf/msp430.h"
137 #include "elf/nds32.h"
139 #include "elf/nios2.h"
140 #include "elf/or1k.h"
143 #include "elf/ppc64.h"
145 #include "elf/riscv.h"
146 #include "elf/rl78.h"
148 #include "elf/s390.h"
149 #include "elf/score.h"
151 #include "elf/sparc.h"
153 #include "elf/tic6x.h"
154 #include "elf/tilegx.h"
155 #include "elf/tilepro.h"
156 #include "elf/v850.h"
158 #include "elf/visium.h"
159 #include "elf/wasm32.h"
160 #include "elf/x86-64.h"
161 #include "elf/xc16x.h"
162 #include "elf/xgate.h"
163 #include "elf/xstormy16.h"
164 #include "elf/xtensa.h"
168 #include "libiberty.h"
169 #include "safe-ctype.h"
170 #include "filenames.h"
173 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
176 typedef struct elf_section_list
178 Elf_Internal_Shdr
* hdr
;
179 struct elf_section_list
* next
;
182 /* Flag bits indicating particular types of dump. */
183 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
184 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
187 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
190 typedef unsigned char dump_type
;
192 /* A linked list of the section names for which dumps were requested. */
193 struct dump_list_entry
197 struct dump_list_entry
* next
;
200 /* A dynamic array of flags indicating for which sections a dump
201 has been requested via command line switches. */
203 dump_type
* dump_sects
;
204 unsigned int num_dump_sects
;
207 static struct dump_data cmdline
;
209 static struct dump_list_entry
* dump_sects_byname
;
211 char * program_name
= "readelf";
213 static bfd_boolean show_name
= FALSE
;
214 static bfd_boolean do_dynamic
= FALSE
;
215 static bfd_boolean do_syms
= FALSE
;
216 static bfd_boolean do_dyn_syms
= FALSE
;
217 static bfd_boolean do_reloc
= FALSE
;
218 static bfd_boolean do_sections
= FALSE
;
219 static bfd_boolean do_section_groups
= FALSE
;
220 static bfd_boolean do_section_details
= FALSE
;
221 static bfd_boolean do_segments
= FALSE
;
222 static bfd_boolean do_unwind
= FALSE
;
223 static bfd_boolean do_using_dynamic
= FALSE
;
224 static bfd_boolean do_header
= FALSE
;
225 static bfd_boolean do_dump
= FALSE
;
226 static bfd_boolean do_version
= FALSE
;
227 static bfd_boolean do_histogram
= FALSE
;
228 static bfd_boolean do_debugging
= FALSE
;
229 static bfd_boolean do_ctf
= FALSE
;
230 static bfd_boolean do_arch
= FALSE
;
231 static bfd_boolean do_notes
= FALSE
;
232 static bfd_boolean do_archive_index
= FALSE
;
233 static bfd_boolean is_32bit_elf
= FALSE
;
234 static bfd_boolean decompress_dumps
= FALSE
;
236 static char *dump_ctf_parent_name
;
237 static char *dump_ctf_symtab_name
;
238 static char *dump_ctf_strtab_name
;
242 struct group_list
* next
;
243 unsigned int section_index
;
248 struct group_list
* root
;
249 unsigned int group_index
;
252 typedef struct filedata
254 const char * file_name
;
256 bfd_size_type file_size
;
257 Elf_Internal_Ehdr file_header
;
258 Elf_Internal_Shdr
* section_headers
;
259 Elf_Internal_Phdr
* program_headers
;
261 unsigned long string_table_length
;
262 unsigned long archive_file_offset
;
263 unsigned long archive_file_size
;
264 unsigned long dynamic_addr
;
265 bfd_size_type dynamic_size
;
267 Elf_Internal_Dyn
* dynamic_section
;
268 char * dynamic_strings
;
269 unsigned long dynamic_strings_length
;
270 unsigned long num_dynamic_syms
;
271 Elf_Internal_Sym
* dynamic_symbols
;
272 bfd_vma version_info
[16];
273 unsigned int dynamic_syminfo_nent
;
274 Elf_Internal_Syminfo
* dynamic_syminfo
;
275 unsigned long dynamic_syminfo_offset
;
276 bfd_size_type nbuckets
;
277 bfd_size_type nchains
;
280 bfd_size_type ngnubuckets
;
281 bfd_size_type ngnuchains
;
282 bfd_vma
* gnubuckets
;
286 char program_interpreter
[PATH_MAX
];
287 bfd_vma dynamic_info
[DT_ENCODING
];
288 bfd_vma dynamic_info_DT_GNU_HASH
;
289 bfd_vma dynamic_info_DT_MIPS_XHASH
;
290 elf_section_list
* symtab_shndx_list
;
292 struct group
* section_groups
;
293 struct group
** section_headers_groups
;
294 /* A dynamic array of flags indicating for which sections a dump of
295 some kind has been requested. It is reset on a per-object file
296 basis and then initialised from the cmdline_dump_sects array,
297 the results of interpreting the -w switch, and the
298 dump_sects_byname list. */
299 struct dump_data dump
;
302 /* How to print a vma value. */
303 typedef enum print_mode
315 /* Versioned symbol info. */
316 enum versioned_symbol_info
323 static const char * get_symbol_version_string
324 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
325 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
329 #define SECTION_NAME(X) \
330 ((X) == NULL ? _("<none>") \
331 : filedata->string_table == NULL ? _("<no-strings>") \
332 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
333 : filedata->string_table + (X)->sh_name))
335 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
337 #define GET_ELF_SYMBOLS(file, section, sym_count) \
338 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
339 : get_64bit_elf_symbols (file, section, sym_count))
341 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
342 (strtab != NULL && offset < strtab_size)
343 #define VALID_DYNAMIC_NAME(filedata, offset) \
344 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
345 filedata->dynamic_strings_length, offset)
346 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
347 already been called and verified that the string exists. */
348 #define GET_DYNAMIC_NAME(filedata, offset) \
349 (filedata->dynamic_strings + offset)
351 #define REMOVE_ARCH_BITS(ADDR) \
354 if (filedata->file_header.e_machine == EM_ARM) \
359 /* Get the correct GNU hash section name. */
360 #define GNU_HASH_SECTION_NAME(filedata) \
361 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
363 /* Print a BFD_VMA to an internal buffer, for use in error messages.
364 BFD_FMA_FMT can't be used in translated strings. */
367 bfd_vmatoa (char *fmtch
, bfd_vma value
)
369 /* bfd_vmatoa is used more then once in a printf call for output.
370 Cycle through an array of buffers. */
371 static int buf_pos
= 0;
372 static struct bfd_vmatoa_buf
379 ret
= buf
[buf_pos
++].place
;
380 buf_pos
%= ARRAY_SIZE (buf
);
382 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
383 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
387 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
388 OFFSET + the offset of the current archive member, if we are examining an
389 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
390 allocate a buffer using malloc and fill that. In either case return the
391 pointer to the start of the retrieved data or NULL if something went wrong.
392 If something does go wrong and REASON is not NULL then emit an error
393 message using REASON as part of the context. */
396 get_data (void * var
,
398 unsigned long offset
,
404 bfd_size_type amt
= size
* nmemb
;
406 if (size
== 0 || nmemb
== 0)
409 /* If the size_t type is smaller than the bfd_size_type, eg because
410 you are building a 32-bit tool on a 64-bit host, then make sure
411 that when the sizes are cast to (size_t) no information is lost. */
412 if ((size_t) size
!= size
413 || (size_t) nmemb
!= nmemb
414 || (size_t) amt
!= amt
)
417 error (_("Size truncation prevents reading %s"
418 " elements of size %s for %s\n"),
419 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
423 /* Check for size overflow. */
424 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
427 error (_("Size overflow prevents reading %s"
428 " elements of size %s for %s\n"),
429 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
433 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
434 attempting to allocate memory when the read is bound to fail. */
435 if (filedata
->archive_file_offset
> filedata
->file_size
436 || offset
> filedata
->file_size
- filedata
->archive_file_offset
437 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
440 error (_("Reading %s bytes extends past end of file for %s\n"),
441 bfd_vmatoa ("u", amt
), reason
);
445 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
449 error (_("Unable to seek to 0x%lx for %s\n"),
450 filedata
->archive_file_offset
+ offset
, reason
);
457 /* + 1 so that we can '\0' terminate invalid string table sections. */
458 mvar
= malloc ((size_t) amt
+ 1);
463 error (_("Out of memory allocating %s bytes for %s\n"),
464 bfd_vmatoa ("u", amt
), reason
);
468 ((char *) mvar
)[amt
] = '\0';
471 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
474 error (_("Unable to read in %s bytes of %s\n"),
475 bfd_vmatoa ("u", amt
), reason
);
484 /* Print a VMA value in the MODE specified.
485 Returns the number of characters displayed. */
488 print_vma (bfd_vma vma
, print_mode mode
)
500 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
507 return printf ("%5" BFD_VMA_FMT
"d", vma
);
513 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
516 return printf ("%" BFD_VMA_FMT
"d", vma
);
519 return printf ("%" BFD_VMA_FMT
"u", vma
);
522 /* FIXME: Report unrecognised mode ? */
527 /* Display a symbol on stdout. Handles the display of control characters and
528 multibye characters (assuming the host environment supports them).
530 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
532 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
533 padding as necessary.
535 Returns the number of emitted characters. */
538 print_symbol (signed int width
, const char *symbol
)
540 bfd_boolean extra_padding
= FALSE
;
541 signed int num_printed
= 0;
542 #ifdef HAVE_MBSTATE_T
545 unsigned int width_remaining
;
549 /* Keep the width positive. This helps the code below. */
551 extra_padding
= TRUE
;
557 /* Set the remaining width to a very large value.
558 This simplifies the code below. */
559 width_remaining
= INT_MAX
;
561 width_remaining
= width
;
563 #ifdef HAVE_MBSTATE_T
564 /* Initialise the multibyte conversion state. */
565 memset (& state
, 0, sizeof (state
));
568 while (width_remaining
)
571 const char c
= *symbol
++;
576 /* Do not print control characters directly as they can affect terminal
577 settings. Such characters usually appear in the names generated
578 by the assembler for local labels. */
581 if (width_remaining
< 2)
584 printf ("^%c", c
+ 0x40);
585 width_remaining
-= 2;
588 else if (ISPRINT (c
))
596 #ifdef HAVE_MBSTATE_T
599 /* Let printf do the hard work of displaying multibyte characters. */
600 printf ("%.1s", symbol
- 1);
604 #ifdef HAVE_MBSTATE_T
605 /* Try to find out how many bytes made up the character that was
606 just printed. Advance the symbol pointer past the bytes that
608 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
612 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
617 if (extra_padding
&& num_printed
< width
)
619 /* Fill in the remaining spaces. */
620 printf ("%-*s", width
- num_printed
, " ");
627 /* Returns a pointer to a static buffer containing a printable version of
628 the given section's name. Like print_symbol, except that it does not try
629 to print multibyte characters, it just interprets them as hex values. */
632 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
634 #define MAX_PRINT_SEC_NAME_LEN 128
635 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
636 const char * name
= SECTION_NAME (sec
);
637 char * buf
= sec_name_buf
;
639 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
641 while ((c
= * name
++) != 0)
652 else if (ISPRINT (c
))
659 static char hex
[17] = "0123456789ABCDEF";
664 * buf
++ = hex
[(c
& 0xf0) >> 4];
665 * buf
++ = hex
[c
& 0x0f];
679 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
681 if (ndx
>= filedata
->file_header
.e_shnum
)
682 return _("<corrupt>");
684 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
687 /* Return a pointer to section NAME, or NULL if no such section exists. */
689 static Elf_Internal_Shdr
*
690 find_section (Filedata
* filedata
, const char * name
)
694 if (filedata
->section_headers
== NULL
)
697 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
698 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
699 return filedata
->section_headers
+ i
;
704 /* Return a pointer to a section containing ADDR, or NULL if no such
707 static Elf_Internal_Shdr
*
708 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
712 if (filedata
->section_headers
== NULL
)
715 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
717 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
719 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
726 static Elf_Internal_Shdr
*
727 find_section_by_type (Filedata
* filedata
, unsigned int type
)
731 if (filedata
->section_headers
== NULL
)
734 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
736 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
738 if (sec
->sh_type
== type
)
745 /* Return a pointer to section NAME, or NULL if no such section exists,
746 restricted to the list of sections given in SET. */
748 static Elf_Internal_Shdr
*
749 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
753 if (filedata
->section_headers
== NULL
)
758 while ((i
= *set
++) > 0)
760 /* See PR 21156 for a reproducer. */
761 if (i
>= filedata
->file_header
.e_shnum
)
762 continue; /* FIXME: Should we issue an error message ? */
764 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
765 return filedata
->section_headers
+ i
;
769 return find_section (filedata
, name
);
772 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
773 This OS has so many departures from the ELF standard that we test it at
776 static inline bfd_boolean
777 is_ia64_vms (Filedata
* filedata
)
779 return filedata
->file_header
.e_machine
== EM_IA_64
780 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
783 /* Guess the relocation size commonly used by the specific machines. */
786 guess_is_rela (unsigned int e_machine
)
790 /* Targets that use REL relocations. */
807 /* Targets that use RELA relocations. */
811 case EM_ADAPTEVA_EPIPHANY
:
813 case EM_ALTERA_NIOS2
:
816 case EM_ARC_COMPACT2
:
837 case EM_LATTICEMICO32
:
846 case EM_CYGNUS_MN10200
:
848 case EM_CYGNUS_MN10300
:
884 case EM_MICROBLAZE_OLD
:
906 warn (_("Don't know about relocations on this machine architecture\n"));
911 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
912 Returns TRUE upon success, FALSE otherwise. If successful then a
913 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
914 and the number of relocs loaded is placed in *NRELASP. It is the caller's
915 responsibility to free the allocated buffer. */
918 slurp_rela_relocs (Filedata
* filedata
,
919 unsigned long rel_offset
,
920 unsigned long rel_size
,
921 Elf_Internal_Rela
** relasp
,
922 unsigned long * nrelasp
)
924 Elf_Internal_Rela
* relas
;
930 Elf32_External_Rela
* erelas
;
932 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
933 rel_size
, _("32-bit relocation data"));
937 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
939 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
940 sizeof (Elf_Internal_Rela
));
945 error (_("out of memory parsing relocs\n"));
949 for (i
= 0; i
< nrelas
; i
++)
951 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
952 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
953 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
960 Elf64_External_Rela
* erelas
;
962 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
963 rel_size
, _("64-bit relocation data"));
967 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
969 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
970 sizeof (Elf_Internal_Rela
));
975 error (_("out of memory parsing relocs\n"));
979 for (i
= 0; i
< nrelas
; i
++)
981 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
982 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
983 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
985 /* The #ifdef BFD64 below is to prevent a compile time
986 warning. We know that if we do not have a 64 bit data
987 type that we will never execute this code anyway. */
989 if (filedata
->file_header
.e_machine
== EM_MIPS
990 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
992 /* In little-endian objects, r_info isn't really a
993 64-bit little-endian value: it has a 32-bit
994 little-endian symbol index followed by four
995 individual byte fields. Reorder INFO
997 bfd_vma inf
= relas
[i
].r_info
;
998 inf
= (((inf
& 0xffffffff) << 32)
999 | ((inf
>> 56) & 0xff)
1000 | ((inf
>> 40) & 0xff00)
1001 | ((inf
>> 24) & 0xff0000)
1002 | ((inf
>> 8) & 0xff000000));
1003 relas
[i
].r_info
= inf
;
1016 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1017 Returns TRUE upon success, FALSE otherwise. If successful then a
1018 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1019 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1020 responsibility to free the allocated buffer. */
1023 slurp_rel_relocs (Filedata
* filedata
,
1024 unsigned long rel_offset
,
1025 unsigned long rel_size
,
1026 Elf_Internal_Rela
** relsp
,
1027 unsigned long * nrelsp
)
1029 Elf_Internal_Rela
* rels
;
1035 Elf32_External_Rel
* erels
;
1037 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1038 rel_size
, _("32-bit relocation data"));
1042 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1044 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1049 error (_("out of memory parsing relocs\n"));
1053 for (i
= 0; i
< nrels
; i
++)
1055 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1056 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1057 rels
[i
].r_addend
= 0;
1064 Elf64_External_Rel
* erels
;
1066 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1067 rel_size
, _("64-bit relocation data"));
1071 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1073 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1078 error (_("out of memory parsing relocs\n"));
1082 for (i
= 0; i
< nrels
; i
++)
1084 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1085 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1086 rels
[i
].r_addend
= 0;
1088 /* The #ifdef BFD64 below is to prevent a compile time
1089 warning. We know that if we do not have a 64 bit data
1090 type that we will never execute this code anyway. */
1092 if (filedata
->file_header
.e_machine
== EM_MIPS
1093 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1095 /* In little-endian objects, r_info isn't really a
1096 64-bit little-endian value: it has a 32-bit
1097 little-endian symbol index followed by four
1098 individual byte fields. Reorder INFO
1100 bfd_vma inf
= rels
[i
].r_info
;
1101 inf
= (((inf
& 0xffffffff) << 32)
1102 | ((inf
>> 56) & 0xff)
1103 | ((inf
>> 40) & 0xff00)
1104 | ((inf
>> 24) & 0xff0000)
1105 | ((inf
>> 8) & 0xff000000));
1106 rels
[i
].r_info
= inf
;
1119 /* Returns the reloc type extracted from the reloc info field. */
1122 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1125 return ELF32_R_TYPE (reloc_info
);
1127 switch (filedata
->file_header
.e_machine
)
1130 /* Note: We assume that reloc_info has already been adjusted for us. */
1131 return ELF64_MIPS_R_TYPE (reloc_info
);
1134 return ELF64_R_TYPE_ID (reloc_info
);
1137 return ELF64_R_TYPE (reloc_info
);
1141 /* Return the symbol index extracted from the reloc info field. */
1144 get_reloc_symindex (bfd_vma reloc_info
)
1146 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1149 static inline bfd_boolean
1150 uses_msp430x_relocs (Filedata
* filedata
)
1153 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1154 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1155 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1156 /* TI compiler uses ELFOSABI_NONE. */
1157 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1160 /* Display the contents of the relocation data found at the specified
1164 dump_relocations (Filedata
* filedata
,
1165 unsigned long rel_offset
,
1166 unsigned long rel_size
,
1167 Elf_Internal_Sym
* symtab
,
1168 unsigned long nsyms
,
1170 unsigned long strtablen
,
1172 bfd_boolean is_dynsym
)
1175 Elf_Internal_Rela
* rels
;
1176 bfd_boolean res
= TRUE
;
1178 if (is_rela
== UNKNOWN
)
1179 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1183 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1188 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1197 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1199 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1204 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1206 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1214 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1216 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1221 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1223 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1227 for (i
= 0; i
< rel_size
; i
++)
1232 bfd_vma symtab_index
;
1235 offset
= rels
[i
].r_offset
;
1236 inf
= rels
[i
].r_info
;
1238 type
= get_reloc_type (filedata
, inf
);
1239 symtab_index
= get_reloc_symindex (inf
);
1243 printf ("%8.8lx %8.8lx ",
1244 (unsigned long) offset
& 0xffffffff,
1245 (unsigned long) inf
& 0xffffffff);
1249 #if BFD_HOST_64BIT_LONG
1251 ? "%16.16lx %16.16lx "
1252 : "%12.12lx %12.12lx ",
1254 #elif BFD_HOST_64BIT_LONG_LONG
1257 ? "%16.16llx %16.16llx "
1258 : "%12.12llx %12.12llx ",
1262 ? "%16.16I64x %16.16I64x "
1263 : "%12.12I64x %12.12I64x ",
1268 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1269 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1270 _bfd_int64_high (offset
),
1271 _bfd_int64_low (offset
),
1272 _bfd_int64_high (inf
),
1273 _bfd_int64_low (inf
));
1277 switch (filedata
->file_header
.e_machine
)
1284 rtype
= elf_aarch64_reloc_type (type
);
1288 case EM_CYGNUS_M32R
:
1289 rtype
= elf_m32r_reloc_type (type
);
1294 rtype
= elf_i386_reloc_type (type
);
1299 rtype
= elf_m68hc11_reloc_type (type
);
1303 rtype
= elf_s12z_reloc_type (type
);
1307 rtype
= elf_m68k_reloc_type (type
);
1311 rtype
= elf_i960_reloc_type (type
);
1316 rtype
= elf_avr_reloc_type (type
);
1319 case EM_OLD_SPARCV9
:
1320 case EM_SPARC32PLUS
:
1323 rtype
= elf_sparc_reloc_type (type
);
1327 rtype
= elf_spu_reloc_type (type
);
1331 rtype
= v800_reloc_type (type
);
1334 case EM_CYGNUS_V850
:
1335 rtype
= v850_reloc_type (type
);
1339 case EM_CYGNUS_D10V
:
1340 rtype
= elf_d10v_reloc_type (type
);
1344 case EM_CYGNUS_D30V
:
1345 rtype
= elf_d30v_reloc_type (type
);
1349 rtype
= elf_dlx_reloc_type (type
);
1353 rtype
= elf_sh_reloc_type (type
);
1357 case EM_CYGNUS_MN10300
:
1358 rtype
= elf_mn10300_reloc_type (type
);
1362 case EM_CYGNUS_MN10200
:
1363 rtype
= elf_mn10200_reloc_type (type
);
1367 case EM_CYGNUS_FR30
:
1368 rtype
= elf_fr30_reloc_type (type
);
1372 rtype
= elf_frv_reloc_type (type
);
1376 rtype
= elf_csky_reloc_type (type
);
1380 rtype
= elf_ft32_reloc_type (type
);
1384 rtype
= elf_mcore_reloc_type (type
);
1388 rtype
= elf_mmix_reloc_type (type
);
1392 rtype
= elf_moxie_reloc_type (type
);
1396 if (uses_msp430x_relocs (filedata
))
1398 rtype
= elf_msp430x_reloc_type (type
);
1403 rtype
= elf_msp430_reloc_type (type
);
1407 rtype
= elf_nds32_reloc_type (type
);
1411 rtype
= elf_ppc_reloc_type (type
);
1415 rtype
= elf_ppc64_reloc_type (type
);
1419 case EM_MIPS_RS3_LE
:
1420 rtype
= elf_mips_reloc_type (type
);
1424 rtype
= elf_riscv_reloc_type (type
);
1428 rtype
= elf_alpha_reloc_type (type
);
1432 rtype
= elf_arm_reloc_type (type
);
1436 case EM_ARC_COMPACT
:
1437 case EM_ARC_COMPACT2
:
1438 rtype
= elf_arc_reloc_type (type
);
1442 rtype
= elf_hppa_reloc_type (type
);
1448 rtype
= elf_h8_reloc_type (type
);
1452 rtype
= elf_or1k_reloc_type (type
);
1457 rtype
= elf_pj_reloc_type (type
);
1460 rtype
= elf_ia64_reloc_type (type
);
1464 rtype
= elf_cris_reloc_type (type
);
1468 rtype
= elf_i860_reloc_type (type
);
1474 rtype
= elf_x86_64_reloc_type (type
);
1478 rtype
= i370_reloc_type (type
);
1483 rtype
= elf_s390_reloc_type (type
);
1487 rtype
= elf_score_reloc_type (type
);
1491 rtype
= elf_xstormy16_reloc_type (type
);
1495 rtype
= elf_crx_reloc_type (type
);
1499 rtype
= elf_vax_reloc_type (type
);
1503 rtype
= elf_visium_reloc_type (type
);
1507 rtype
= elf_bpf_reloc_type (type
);
1510 case EM_ADAPTEVA_EPIPHANY
:
1511 rtype
= elf_epiphany_reloc_type (type
);
1516 rtype
= elf_ip2k_reloc_type (type
);
1520 rtype
= elf_iq2000_reloc_type (type
);
1525 rtype
= elf_xtensa_reloc_type (type
);
1528 case EM_LATTICEMICO32
:
1529 rtype
= elf_lm32_reloc_type (type
);
1534 rtype
= elf_m32c_reloc_type (type
);
1538 rtype
= elf_mt_reloc_type (type
);
1542 rtype
= elf_bfin_reloc_type (type
);
1546 rtype
= elf_mep_reloc_type (type
);
1550 rtype
= elf_cr16_reloc_type (type
);
1554 case EM_MICROBLAZE_OLD
:
1555 rtype
= elf_microblaze_reloc_type (type
);
1559 rtype
= elf_rl78_reloc_type (type
);
1563 rtype
= elf_rx_reloc_type (type
);
1567 rtype
= elf_metag_reloc_type (type
);
1572 rtype
= elf_xc16x_reloc_type (type
);
1576 rtype
= elf_tic6x_reloc_type (type
);
1580 rtype
= elf_tilegx_reloc_type (type
);
1584 rtype
= elf_tilepro_reloc_type (type
);
1587 case EM_WEBASSEMBLY
:
1588 rtype
= elf_wasm32_reloc_type (type
);
1592 rtype
= elf_xgate_reloc_type (type
);
1595 case EM_ALTERA_NIOS2
:
1596 rtype
= elf_nios2_reloc_type (type
);
1600 rtype
= elf_pru_reloc_type (type
);
1604 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1605 rtype
= elf_nfp3200_reloc_type (type
);
1607 rtype
= elf_nfp_reloc_type (type
);
1611 rtype
= elf_z80_reloc_type (type
);
1616 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1618 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1620 if (filedata
->file_header
.e_machine
== EM_ALPHA
1622 && streq (rtype
, "R_ALPHA_LITUSE")
1625 switch (rels
[i
].r_addend
)
1627 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1628 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1629 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1630 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1631 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1632 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1633 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1634 default: rtype
= NULL
;
1638 printf (" (%s)", rtype
);
1642 printf (_("<unknown addend: %lx>"),
1643 (unsigned long) rels
[i
].r_addend
);
1647 else if (symtab_index
)
1649 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1651 error (_(" bad symbol index: %08lx in reloc\n"),
1652 (unsigned long) symtab_index
);
1657 Elf_Internal_Sym
* psym
;
1658 const char * version_string
;
1659 enum versioned_symbol_info sym_info
;
1660 unsigned short vna_other
;
1662 psym
= symtab
+ symtab_index
;
1665 = get_symbol_version_string (filedata
, is_dynsym
,
1674 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1678 unsigned int width
= is_32bit_elf
? 8 : 14;
1680 /* Relocations against GNU_IFUNC symbols do not use the value
1681 of the symbol as the address to relocate against. Instead
1682 they invoke the function named by the symbol and use its
1683 result as the address for relocation.
1685 To indicate this to the user, do not display the value of
1686 the symbol in the "Symbols's Value" field. Instead show
1687 its name followed by () as a hint that the symbol is
1691 || psym
->st_name
== 0
1692 || psym
->st_name
>= strtablen
)
1695 name
= strtab
+ psym
->st_name
;
1697 len
= print_symbol (width
, name
);
1699 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1701 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1705 print_vma (psym
->st_value
, LONG_HEX
);
1707 printf (is_32bit_elf
? " " : " ");
1710 if (psym
->st_name
== 0)
1712 const char * sec_name
= "<null>";
1715 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1717 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1718 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1719 else if (psym
->st_shndx
== SHN_ABS
)
1721 else if (psym
->st_shndx
== SHN_COMMON
)
1722 sec_name
= "COMMON";
1723 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1724 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1725 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1726 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1727 sec_name
= "SCOMMON";
1728 else if (filedata
->file_header
.e_machine
== EM_MIPS
1729 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1730 sec_name
= "SUNDEF";
1731 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1732 || filedata
->file_header
.e_machine
== EM_L1OM
1733 || filedata
->file_header
.e_machine
== EM_K1OM
)
1734 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1735 sec_name
= "LARGE_COMMON";
1736 else if (filedata
->file_header
.e_machine
== EM_IA_64
1737 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1738 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1739 sec_name
= "ANSI_COM";
1740 else if (is_ia64_vms (filedata
)
1741 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1742 sec_name
= "VMS_SYMVEC";
1745 sprintf (name_buf
, "<section 0x%x>",
1746 (unsigned int) psym
->st_shndx
);
1747 sec_name
= name_buf
;
1750 print_symbol (22, sec_name
);
1752 else if (strtab
== NULL
)
1753 printf (_("<string table index: %3ld>"), psym
->st_name
);
1754 else if (psym
->st_name
>= strtablen
)
1756 error (_("<corrupt string table index: %3ld>\n"),
1762 print_symbol (22, strtab
+ psym
->st_name
);
1764 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1770 bfd_vma off
= rels
[i
].r_addend
;
1772 if ((bfd_signed_vma
) off
< 0)
1773 printf (" - %" BFD_VMA_FMT
"x", - off
);
1775 printf (" + %" BFD_VMA_FMT
"x", off
);
1781 bfd_vma off
= rels
[i
].r_addend
;
1783 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1784 if ((bfd_signed_vma
) off
< 0)
1785 printf ("-%" BFD_VMA_FMT
"x", - off
);
1787 printf ("%" BFD_VMA_FMT
"x", off
);
1790 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1792 && streq (rtype
, "R_SPARC_OLO10"))
1793 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1798 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1800 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1801 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1802 const char * rtype2
= elf_mips_reloc_type (type2
);
1803 const char * rtype3
= elf_mips_reloc_type (type3
);
1805 printf (" Type2: ");
1808 printf (_("unrecognized: %-7lx"),
1809 (unsigned long) type2
& 0xffffffff);
1811 printf ("%-17.17s", rtype2
);
1813 printf ("\n Type3: ");
1816 printf (_("unrecognized: %-7lx"),
1817 (unsigned long) type3
& 0xffffffff);
1819 printf ("%-17.17s", rtype3
);
1832 get_aarch64_dynamic_type (unsigned long type
)
1836 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1837 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1838 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1845 get_mips_dynamic_type (unsigned long type
)
1849 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1850 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1851 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1852 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1853 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1854 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1855 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1856 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1857 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1858 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1859 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1860 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1861 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1862 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1863 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1864 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1865 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1866 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1867 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1868 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1869 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1870 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1871 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1872 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1873 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1874 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1875 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1876 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1877 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1878 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1879 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1880 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1881 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1882 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1883 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1884 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1885 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1886 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1887 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1888 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1889 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1890 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1891 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1892 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1893 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1894 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1895 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1902 get_sparc64_dynamic_type (unsigned long type
)
1906 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1913 get_ppc_dynamic_type (unsigned long type
)
1917 case DT_PPC_GOT
: return "PPC_GOT";
1918 case DT_PPC_OPT
: return "PPC_OPT";
1925 get_ppc64_dynamic_type (unsigned long type
)
1929 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1930 case DT_PPC64_OPD
: return "PPC64_OPD";
1931 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1932 case DT_PPC64_OPT
: return "PPC64_OPT";
1939 get_parisc_dynamic_type (unsigned long type
)
1943 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1944 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1945 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1946 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1947 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1948 case DT_HP_PREINIT
: return "HP_PREINIT";
1949 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1950 case DT_HP_NEEDED
: return "HP_NEEDED";
1951 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1952 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1953 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1954 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1955 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1956 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1957 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1958 case DT_HP_FILTERED
: return "HP_FILTERED";
1959 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1960 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1961 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1962 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1963 case DT_PLT
: return "PLT";
1964 case DT_PLT_SIZE
: return "PLT_SIZE";
1965 case DT_DLT
: return "DLT";
1966 case DT_DLT_SIZE
: return "DLT_SIZE";
1973 get_ia64_dynamic_type (unsigned long type
)
1977 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1978 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1979 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1980 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1981 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1982 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1983 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1984 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1985 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1986 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1987 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1988 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1989 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1990 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1991 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1992 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1993 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1994 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1995 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1996 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1997 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1998 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1999 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2000 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2001 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2002 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2003 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2004 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2005 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2006 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2007 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2014 get_solaris_section_type (unsigned long type
)
2018 case 0x6fffffee: return "SUNW_ancillary";
2019 case 0x6fffffef: return "SUNW_capchain";
2020 case 0x6ffffff0: return "SUNW_capinfo";
2021 case 0x6ffffff1: return "SUNW_symsort";
2022 case 0x6ffffff2: return "SUNW_tlssort";
2023 case 0x6ffffff3: return "SUNW_LDYNSYM";
2024 case 0x6ffffff4: return "SUNW_dof";
2025 case 0x6ffffff5: return "SUNW_cap";
2026 case 0x6ffffff6: return "SUNW_SIGNATURE";
2027 case 0x6ffffff7: return "SUNW_ANNOTATE";
2028 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2029 case 0x6ffffff9: return "SUNW_DEBUG";
2030 case 0x6ffffffa: return "SUNW_move";
2031 case 0x6ffffffb: return "SUNW_COMDAT";
2032 case 0x6ffffffc: return "SUNW_syminfo";
2033 case 0x6ffffffd: return "SUNW_verdef";
2034 case 0x6ffffffe: return "SUNW_verneed";
2035 case 0x6fffffff: return "SUNW_versym";
2036 case 0x70000000: return "SPARC_GOTDATA";
2037 default: return NULL
;
2042 get_alpha_dynamic_type (unsigned long type
)
2046 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2047 default: return NULL
;
2052 get_score_dynamic_type (unsigned long type
)
2056 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2057 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2058 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2059 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2060 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2061 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2062 default: return NULL
;
2067 get_tic6x_dynamic_type (unsigned long type
)
2071 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2072 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2073 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2074 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2075 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2076 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2077 default: return NULL
;
2082 get_nios2_dynamic_type (unsigned long type
)
2086 case DT_NIOS2_GP
: return "NIOS2_GP";
2087 default: return NULL
;
2092 get_solaris_dynamic_type (unsigned long type
)
2096 case 0x6000000d: return "SUNW_AUXILIARY";
2097 case 0x6000000e: return "SUNW_RTLDINF";
2098 case 0x6000000f: return "SUNW_FILTER";
2099 case 0x60000010: return "SUNW_CAP";
2100 case 0x60000011: return "SUNW_SYMTAB";
2101 case 0x60000012: return "SUNW_SYMSZ";
2102 case 0x60000013: return "SUNW_SORTENT";
2103 case 0x60000014: return "SUNW_SYMSORT";
2104 case 0x60000015: return "SUNW_SYMSORTSZ";
2105 case 0x60000016: return "SUNW_TLSSORT";
2106 case 0x60000017: return "SUNW_TLSSORTSZ";
2107 case 0x60000018: return "SUNW_CAPINFO";
2108 case 0x60000019: return "SUNW_STRPAD";
2109 case 0x6000001a: return "SUNW_CAPCHAIN";
2110 case 0x6000001b: return "SUNW_LDMACH";
2111 case 0x6000001d: return "SUNW_CAPCHAINENT";
2112 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2113 case 0x60000021: return "SUNW_PARENT";
2114 case 0x60000023: return "SUNW_ASLR";
2115 case 0x60000025: return "SUNW_RELAX";
2116 case 0x60000029: return "SUNW_NXHEAP";
2117 case 0x6000002b: return "SUNW_NXSTACK";
2119 case 0x70000001: return "SPARC_REGISTER";
2120 case 0x7ffffffd: return "AUXILIARY";
2121 case 0x7ffffffe: return "USED";
2122 case 0x7fffffff: return "FILTER";
2124 default: return NULL
;
2129 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2131 static char buff
[64];
2135 case DT_NULL
: return "NULL";
2136 case DT_NEEDED
: return "NEEDED";
2137 case DT_PLTRELSZ
: return "PLTRELSZ";
2138 case DT_PLTGOT
: return "PLTGOT";
2139 case DT_HASH
: return "HASH";
2140 case DT_STRTAB
: return "STRTAB";
2141 case DT_SYMTAB
: return "SYMTAB";
2142 case DT_RELA
: return "RELA";
2143 case DT_RELASZ
: return "RELASZ";
2144 case DT_RELAENT
: return "RELAENT";
2145 case DT_STRSZ
: return "STRSZ";
2146 case DT_SYMENT
: return "SYMENT";
2147 case DT_INIT
: return "INIT";
2148 case DT_FINI
: return "FINI";
2149 case DT_SONAME
: return "SONAME";
2150 case DT_RPATH
: return "RPATH";
2151 case DT_SYMBOLIC
: return "SYMBOLIC";
2152 case DT_REL
: return "REL";
2153 case DT_RELSZ
: return "RELSZ";
2154 case DT_RELENT
: return "RELENT";
2155 case DT_PLTREL
: return "PLTREL";
2156 case DT_DEBUG
: return "DEBUG";
2157 case DT_TEXTREL
: return "TEXTREL";
2158 case DT_JMPREL
: return "JMPREL";
2159 case DT_BIND_NOW
: return "BIND_NOW";
2160 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2161 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2162 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2163 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2164 case DT_RUNPATH
: return "RUNPATH";
2165 case DT_FLAGS
: return "FLAGS";
2167 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2168 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2169 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2171 case DT_CHECKSUM
: return "CHECKSUM";
2172 case DT_PLTPADSZ
: return "PLTPADSZ";
2173 case DT_MOVEENT
: return "MOVEENT";
2174 case DT_MOVESZ
: return "MOVESZ";
2175 case DT_FEATURE
: return "FEATURE";
2176 case DT_POSFLAG_1
: return "POSFLAG_1";
2177 case DT_SYMINSZ
: return "SYMINSZ";
2178 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2180 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2181 case DT_CONFIG
: return "CONFIG";
2182 case DT_DEPAUDIT
: return "DEPAUDIT";
2183 case DT_AUDIT
: return "AUDIT";
2184 case DT_PLTPAD
: return "PLTPAD";
2185 case DT_MOVETAB
: return "MOVETAB";
2186 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2188 case DT_VERSYM
: return "VERSYM";
2190 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2191 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2192 case DT_RELACOUNT
: return "RELACOUNT";
2193 case DT_RELCOUNT
: return "RELCOUNT";
2194 case DT_FLAGS_1
: return "FLAGS_1";
2195 case DT_VERDEF
: return "VERDEF";
2196 case DT_VERDEFNUM
: return "VERDEFNUM";
2197 case DT_VERNEED
: return "VERNEED";
2198 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2200 case DT_AUXILIARY
: return "AUXILIARY";
2201 case DT_USED
: return "USED";
2202 case DT_FILTER
: return "FILTER";
2204 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2205 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2206 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2207 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2208 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2209 case DT_GNU_HASH
: return "GNU_HASH";
2212 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2214 const char * result
;
2216 switch (filedata
->file_header
.e_machine
)
2219 result
= get_aarch64_dynamic_type (type
);
2222 case EM_MIPS_RS3_LE
:
2223 result
= get_mips_dynamic_type (type
);
2226 result
= get_sparc64_dynamic_type (type
);
2229 result
= get_ppc_dynamic_type (type
);
2232 result
= get_ppc64_dynamic_type (type
);
2235 result
= get_ia64_dynamic_type (type
);
2238 result
= get_alpha_dynamic_type (type
);
2241 result
= get_score_dynamic_type (type
);
2244 result
= get_tic6x_dynamic_type (type
);
2246 case EM_ALTERA_NIOS2
:
2247 result
= get_nios2_dynamic_type (type
);
2250 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2251 result
= get_solaris_dynamic_type (type
);
2260 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2262 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2263 || (filedata
->file_header
.e_machine
== EM_PARISC
2264 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2266 const char * result
;
2268 switch (filedata
->file_header
.e_machine
)
2271 result
= get_parisc_dynamic_type (type
);
2274 result
= get_ia64_dynamic_type (type
);
2277 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2278 result
= get_solaris_dynamic_type (type
);
2287 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2291 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2298 get_file_type (unsigned e_type
)
2300 static char buff
[64];
2304 case ET_NONE
: return _("NONE (None)");
2305 case ET_REL
: return _("REL (Relocatable file)");
2306 case ET_EXEC
: return _("EXEC (Executable file)");
2307 case ET_DYN
: return _("DYN (Shared object file)");
2308 case ET_CORE
: return _("CORE (Core file)");
2311 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2312 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2313 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2314 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2316 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2322 get_machine_name (unsigned e_machine
)
2324 static char buff
[64]; /* XXX */
2328 /* Please keep this switch table sorted by increasing EM_ value. */
2330 case EM_NONE
: return _("None");
2331 case EM_M32
: return "WE32100";
2332 case EM_SPARC
: return "Sparc";
2333 case EM_386
: return "Intel 80386";
2334 case EM_68K
: return "MC68000";
2335 case EM_88K
: return "MC88000";
2336 case EM_IAMCU
: return "Intel MCU";
2337 case EM_860
: return "Intel 80860";
2338 case EM_MIPS
: return "MIPS R3000";
2339 case EM_S370
: return "IBM System/370";
2341 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2342 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2343 case EM_PARISC
: return "HPPA";
2344 case EM_VPP550
: return "Fujitsu VPP500";
2345 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2346 case EM_960
: return "Intel 80960";
2347 case EM_PPC
: return "PowerPC";
2349 case EM_PPC64
: return "PowerPC64";
2351 case EM_S390
: return "IBM S/390";
2352 case EM_SPU
: return "SPU";
2354 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2355 case EM_FR20
: return "Fujitsu FR20";
2356 case EM_RH32
: return "TRW RH32";
2357 case EM_MCORE
: return "MCORE";
2359 case EM_ARM
: return "ARM";
2360 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2361 case EM_SH
: return "Renesas / SuperH SH";
2362 case EM_SPARCV9
: return "Sparc v9";
2363 case EM_TRICORE
: return "Siemens Tricore";
2364 case EM_ARC
: return "ARC";
2365 case EM_H8_300
: return "Renesas H8/300";
2366 case EM_H8_300H
: return "Renesas H8/300H";
2367 case EM_H8S
: return "Renesas H8S";
2368 case EM_H8_500
: return "Renesas H8/500";
2370 case EM_IA_64
: return "Intel IA-64";
2371 case EM_MIPS_X
: return "Stanford MIPS-X";
2372 case EM_COLDFIRE
: return "Motorola Coldfire";
2373 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2374 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2375 case EM_PCP
: return "Siemens PCP";
2376 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2377 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2378 case EM_STARCORE
: return "Motorola Star*Core processor";
2379 case EM_ME16
: return "Toyota ME16 processor";
2381 case EM_ST100
: return "STMicroelectronics ST100 processor";
2382 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2383 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2384 case EM_PDSP
: return "Sony DSP processor";
2385 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2386 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2387 case EM_FX66
: return "Siemens FX66 microcontroller";
2388 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2389 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2390 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2392 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2393 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2394 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2395 case EM_SVX
: return "Silicon Graphics SVx";
2396 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2397 case EM_VAX
: return "Digital VAX";
2398 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2399 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2400 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2401 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2403 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2404 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2405 case EM_PRISM
: return "Vitesse Prism";
2407 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2408 case EM_CYGNUS_FR30
:
2409 case EM_FR30
: return "Fujitsu FR30";
2410 case EM_CYGNUS_D10V
:
2411 case EM_D10V
: return "d10v";
2412 case EM_CYGNUS_D30V
:
2413 case EM_D30V
: return "d30v";
2414 case EM_CYGNUS_V850
:
2415 case EM_V850
: return "Renesas V850";
2416 case EM_CYGNUS_M32R
:
2417 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2418 case EM_CYGNUS_MN10300
:
2419 case EM_MN10300
: return "mn10300";
2421 case EM_CYGNUS_MN10200
:
2422 case EM_MN10200
: return "mn10200";
2423 case EM_PJ
: return "picoJava";
2424 case EM_OR1K
: return "OpenRISC 1000";
2425 case EM_ARC_COMPACT
: return "ARCompact";
2427 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2428 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2429 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2430 case EM_NS32K
: return "National Semiconductor 32000 series";
2431 case EM_TPC
: return "Tenor Network TPC processor";
2432 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2434 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2436 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2437 case EM_MAX
: return "MAX Processor";
2438 case EM_CR
: return "National Semiconductor CompactRISC";
2439 case EM_F2MC16
: return "Fujitsu F2MC16";
2440 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2441 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2442 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2443 case EM_SEP
: return "Sharp embedded microprocessor";
2444 case EM_ARCA
: return "Arca RISC microprocessor";
2446 case EM_UNICORE
: return "Unicore";
2447 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2448 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2449 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2450 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2451 case EM_XGATE
: return "Motorola XGATE embedded processor";
2453 case EM_XC16X
: return "Infineon Technologies xc16x";
2454 case EM_M16C
: return "Renesas M16C series microprocessors";
2455 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2456 case EM_CE
: return "Freescale Communication Engine RISC core";
2458 case EM_M32C
: return "Renesas M32c";
2460 case EM_TSK3000
: return "Altium TSK3000 core";
2461 case EM_RS08
: return "Freescale RS08 embedded processor";
2462 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2463 case EM_SCORE
: return "SUNPLUS S+Core";
2464 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2465 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2466 case EM_LATTICEMICO32
: return "Lattice Mico32";
2467 case EM_SE_C17
: return "Seiko Epson C17 family";
2469 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2470 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2471 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2472 case EM_TI_PRU
: return "TI PRU I/O processor";
2474 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2475 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2476 case EM_R32C
: return "Renesas R32C series microprocessors";
2477 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2478 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2479 case EM_8051
: return "Intel 8051 and variants";
2480 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2481 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2482 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2483 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2485 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2486 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2487 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2488 case EM_RX
: return "Renesas RX";
2489 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2490 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2491 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2494 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2495 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2496 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2498 case EM_L1OM
: return "Intel L1OM";
2499 case EM_K1OM
: return "Intel K1OM";
2500 case EM_INTEL182
: return "Intel (reserved)";
2501 case EM_AARCH64
: return "AArch64";
2502 case EM_ARM184
: return "ARM (reserved)";
2503 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2504 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2505 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2506 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2508 case EM_CUDA
: return "NVIDIA CUDA architecture";
2509 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2510 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2511 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2512 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2513 case EM_ARC_COMPACT2
: return "ARCv2";
2514 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2515 case EM_RL78
: return "Renesas RL78";
2516 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2517 case EM_78K0R
: return "Renesas 78K0R";
2519 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2520 case EM_BA1
: return "Beyond BA1 CPU architecture";
2521 case EM_BA2
: return "Beyond BA2 CPU architecture";
2522 case EM_XCORE
: return "XMOS xCORE processor family";
2523 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2525 case EM_KM32
: return "KM211 KM32 32-bit processor";
2526 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2527 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2528 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2529 case EM_KVARC
: return "KM211 KVARC processor";
2530 case EM_CDP
: return "Paneve CDP architecture family";
2531 case EM_COGE
: return "Cognitive Smart Memory Processor";
2532 case EM_COOL
: return "Bluechip Systems CoolEngine";
2533 case EM_NORC
: return "Nanoradio Optimized RISC";
2534 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2536 case EM_Z80
: return "Zilog Z80";
2537 case EM_VISIUM
: return "CDS VISIUMcore processor";
2538 case EM_FT32
: return "FTDI Chip FT32";
2539 case EM_MOXIE
: return "Moxie";
2540 case EM_AMDGPU
: return "AMD GPU";
2541 case EM_RISCV
: return "RISC-V";
2542 case EM_LANAI
: return "Lanai 32-bit processor";
2543 case EM_BPF
: return "Linux BPF";
2544 case EM_NFP
: return "Netronome Flow Processor";
2546 /* Large numbers... */
2547 case EM_MT
: return "Morpho Techologies MT processor";
2548 case EM_ALPHA
: return "Alpha";
2549 case EM_WEBASSEMBLY
: return "Web Assembly";
2550 case EM_DLX
: return "OpenDLX";
2551 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2552 case EM_IQ2000
: return "Vitesse IQ2000";
2554 case EM_NIOS32
: return "Altera Nios";
2555 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2556 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2557 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2558 case EM_S12Z
: return "Freescale S12Z";
2559 case EM_CSKY
: return "C-SKY";
2562 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2568 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2570 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2571 other compilers don't a specific architecture type in the e_flags, and
2572 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2573 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2576 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2577 but also sets a specific architecture type in the e_flags field.
2579 However, when decoding the flags we don't worry if we see an
2580 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2581 ARCEM architecture type. */
2583 switch (e_flags
& EF_ARC_MACH_MSK
)
2585 /* We only expect these to occur for EM_ARC_COMPACT2. */
2586 case EF_ARC_CPU_ARCV2EM
:
2587 strcat (buf
, ", ARC EM");
2589 case EF_ARC_CPU_ARCV2HS
:
2590 strcat (buf
, ", ARC HS");
2593 /* We only expect these to occur for EM_ARC_COMPACT. */
2594 case E_ARC_MACH_ARC600
:
2595 strcat (buf
, ", ARC600");
2597 case E_ARC_MACH_ARC601
:
2598 strcat (buf
, ", ARC601");
2600 case E_ARC_MACH_ARC700
:
2601 strcat (buf
, ", ARC700");
2604 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2605 new ELF with new architecture being read by an old version of
2606 readelf, or (c) An ELF built with non-GNU compiler that does not
2607 set the architecture in the e_flags. */
2609 if (e_machine
== EM_ARC_COMPACT
)
2610 strcat (buf
, ", Unknown ARCompact");
2612 strcat (buf
, ", Unknown ARC");
2616 switch (e_flags
& EF_ARC_OSABI_MSK
)
2618 case E_ARC_OSABI_ORIG
:
2619 strcat (buf
, ", (ABI:legacy)");
2621 case E_ARC_OSABI_V2
:
2622 strcat (buf
, ", (ABI:v2)");
2624 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2625 case E_ARC_OSABI_V3
:
2626 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2628 case E_ARC_OSABI_V4
:
2629 strcat (buf
, ", v4 ABI");
2632 strcat (buf
, ", unrecognised ARC OSABI flag");
2638 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2641 bfd_boolean unknown
= FALSE
;
2643 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2644 e_flags
&= ~ EF_ARM_EABIMASK
;
2646 /* Handle "generic" ARM flags. */
2647 if (e_flags
& EF_ARM_RELEXEC
)
2649 strcat (buf
, ", relocatable executable");
2650 e_flags
&= ~ EF_ARM_RELEXEC
;
2653 if (e_flags
& EF_ARM_PIC
)
2655 strcat (buf
, ", position independent");
2656 e_flags
&= ~ EF_ARM_PIC
;
2659 /* Now handle EABI specific flags. */
2663 strcat (buf
, ", <unrecognized EABI>");
2668 case EF_ARM_EABI_VER1
:
2669 strcat (buf
, ", Version1 EABI");
2674 /* Process flags one bit at a time. */
2675 flag
= e_flags
& - e_flags
;
2680 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2681 strcat (buf
, ", sorted symbol tables");
2691 case EF_ARM_EABI_VER2
:
2692 strcat (buf
, ", Version2 EABI");
2697 /* Process flags one bit at a time. */
2698 flag
= e_flags
& - e_flags
;
2703 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2704 strcat (buf
, ", sorted symbol tables");
2707 case EF_ARM_DYNSYMSUSESEGIDX
:
2708 strcat (buf
, ", dynamic symbols use segment index");
2711 case EF_ARM_MAPSYMSFIRST
:
2712 strcat (buf
, ", mapping symbols precede others");
2722 case EF_ARM_EABI_VER3
:
2723 strcat (buf
, ", Version3 EABI");
2726 case EF_ARM_EABI_VER4
:
2727 strcat (buf
, ", Version4 EABI");
2732 /* Process flags one bit at a time. */
2733 flag
= e_flags
& - e_flags
;
2739 strcat (buf
, ", BE8");
2743 strcat (buf
, ", LE8");
2753 case EF_ARM_EABI_VER5
:
2754 strcat (buf
, ", Version5 EABI");
2759 /* Process flags one bit at a time. */
2760 flag
= e_flags
& - e_flags
;
2766 strcat (buf
, ", BE8");
2770 strcat (buf
, ", LE8");
2773 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2774 strcat (buf
, ", soft-float ABI");
2777 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2778 strcat (buf
, ", hard-float ABI");
2788 case EF_ARM_EABI_UNKNOWN
:
2789 strcat (buf
, ", GNU EABI");
2794 /* Process flags one bit at a time. */
2795 flag
= e_flags
& - e_flags
;
2800 case EF_ARM_INTERWORK
:
2801 strcat (buf
, ", interworking enabled");
2804 case EF_ARM_APCS_26
:
2805 strcat (buf
, ", uses APCS/26");
2808 case EF_ARM_APCS_FLOAT
:
2809 strcat (buf
, ", uses APCS/float");
2813 strcat (buf
, ", position independent");
2817 strcat (buf
, ", 8 bit structure alignment");
2820 case EF_ARM_NEW_ABI
:
2821 strcat (buf
, ", uses new ABI");
2824 case EF_ARM_OLD_ABI
:
2825 strcat (buf
, ", uses old ABI");
2828 case EF_ARM_SOFT_FLOAT
:
2829 strcat (buf
, ", software FP");
2832 case EF_ARM_VFP_FLOAT
:
2833 strcat (buf
, ", VFP");
2836 case EF_ARM_MAVERICK_FLOAT
:
2837 strcat (buf
, ", Maverick FP");
2848 strcat (buf
,_(", <unknown>"));
2852 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2854 --size
; /* Leave space for null terminator. */
2856 switch (e_flags
& EF_AVR_MACH
)
2858 case E_AVR_MACH_AVR1
:
2859 strncat (buf
, ", avr:1", size
);
2861 case E_AVR_MACH_AVR2
:
2862 strncat (buf
, ", avr:2", size
);
2864 case E_AVR_MACH_AVR25
:
2865 strncat (buf
, ", avr:25", size
);
2867 case E_AVR_MACH_AVR3
:
2868 strncat (buf
, ", avr:3", size
);
2870 case E_AVR_MACH_AVR31
:
2871 strncat (buf
, ", avr:31", size
);
2873 case E_AVR_MACH_AVR35
:
2874 strncat (buf
, ", avr:35", size
);
2876 case E_AVR_MACH_AVR4
:
2877 strncat (buf
, ", avr:4", size
);
2879 case E_AVR_MACH_AVR5
:
2880 strncat (buf
, ", avr:5", size
);
2882 case E_AVR_MACH_AVR51
:
2883 strncat (buf
, ", avr:51", size
);
2885 case E_AVR_MACH_AVR6
:
2886 strncat (buf
, ", avr:6", size
);
2888 case E_AVR_MACH_AVRTINY
:
2889 strncat (buf
, ", avr:100", size
);
2891 case E_AVR_MACH_XMEGA1
:
2892 strncat (buf
, ", avr:101", size
);
2894 case E_AVR_MACH_XMEGA2
:
2895 strncat (buf
, ", avr:102", size
);
2897 case E_AVR_MACH_XMEGA3
:
2898 strncat (buf
, ", avr:103", size
);
2900 case E_AVR_MACH_XMEGA4
:
2901 strncat (buf
, ", avr:104", size
);
2903 case E_AVR_MACH_XMEGA5
:
2904 strncat (buf
, ", avr:105", size
);
2906 case E_AVR_MACH_XMEGA6
:
2907 strncat (buf
, ", avr:106", size
);
2909 case E_AVR_MACH_XMEGA7
:
2910 strncat (buf
, ", avr:107", size
);
2913 strncat (buf
, ", avr:<unknown>", size
);
2917 size
-= strlen (buf
);
2918 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2919 strncat (buf
, ", link-relax", size
);
2923 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2929 bfd_boolean has_fpu
= FALSE
;
2932 static const char *ABI_STRINGS
[] =
2934 "ABI v0", /* use r5 as return register; only used in N1213HC */
2935 "ABI v1", /* use r0 as return register */
2936 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2937 "ABI v2fp", /* for FPU */
2941 static const char *VER_STRINGS
[] =
2943 "Andes ELF V1.3 or older",
2947 static const char *ARCH_STRINGS
[] =
2956 abi
= EF_NDS_ABI
& e_flags
;
2957 arch
= EF_NDS_ARCH
& e_flags
;
2958 config
= EF_NDS_INST
& e_flags
;
2959 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2961 memset (buf
, 0, size
);
2968 case E_NDS_ABI_V2FP
:
2969 case E_NDS_ABI_AABI
:
2970 case E_NDS_ABI_V2FP_PLUS
:
2971 /* In case there are holes in the array. */
2972 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2976 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2982 case E_NDS32_ELF_VER_1_2
:
2983 case E_NDS32_ELF_VER_1_3
:
2984 case E_NDS32_ELF_VER_1_4
:
2985 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2989 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2993 if (E_NDS_ABI_V0
== abi
)
2995 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2996 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2997 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2998 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3004 case E_NDS_ARCH_STAR_V1_0
:
3005 case E_NDS_ARCH_STAR_V2_0
:
3006 case E_NDS_ARCH_STAR_V3_0
:
3007 case E_NDS_ARCH_STAR_V3_M
:
3008 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3012 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3013 /* ARCH version determines how the e_flags are interpreted.
3014 If it is unknown, we cannot proceed. */
3018 /* Newer ABI; Now handle architecture specific flags. */
3019 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3021 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3022 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3024 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3025 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3027 if (config
& E_NDS32_HAS_DIV_INST
)
3028 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3030 if (config
& E_NDS32_HAS_16BIT_INST
)
3031 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3035 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3037 if (version
<= E_NDS32_ELF_VER_1_3
)
3038 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3040 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3043 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3044 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3046 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3047 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3049 if (config
& E_NDS32_HAS_16BIT_INST
)
3051 if (version
<= E_NDS32_ELF_VER_1_3
)
3052 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3054 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3058 if (config
& E_NDS32_HAS_EXT_INST
)
3059 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3061 if (config
& E_NDS32_HAS_EXT2_INST
)
3062 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3064 if (config
& E_NDS32_HAS_FPU_INST
)
3067 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3070 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3073 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3076 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3079 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3084 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3086 case E_NDS32_FPU_REG_8SP_4DP
:
3087 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3089 case E_NDS32_FPU_REG_16SP_8DP
:
3090 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3092 case E_NDS32_FPU_REG_32SP_16DP
:
3093 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3095 case E_NDS32_FPU_REG_32SP_32DP
:
3096 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3101 if (config
& E_NDS32_HAS_AUDIO_INST
)
3102 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3104 if (config
& E_NDS32_HAS_STRING_INST
)
3105 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3107 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3108 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3110 if (config
& E_NDS32_HAS_VIDEO_INST
)
3112 if (version
<= E_NDS32_ELF_VER_1_3
)
3113 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3115 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3118 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3119 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3121 if (config
& E_NDS32_HAS_L2C_INST
)
3122 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3126 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3128 static char buf
[1024];
3139 case EM_ARC_COMPACT2
:
3140 case EM_ARC_COMPACT
:
3141 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3145 decode_ARM_machine_flags (e_flags
, buf
);
3149 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3153 if (e_flags
& EF_BFIN_PIC
)
3154 strcat (buf
, ", PIC");
3156 if (e_flags
& EF_BFIN_FDPIC
)
3157 strcat (buf
, ", FDPIC");
3159 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3160 strcat (buf
, ", code in L1");
3162 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3163 strcat (buf
, ", data in L1");
3168 switch (e_flags
& EF_FRV_CPU_MASK
)
3170 case EF_FRV_CPU_GENERIC
:
3174 strcat (buf
, ", fr???");
3177 case EF_FRV_CPU_FR300
:
3178 strcat (buf
, ", fr300");
3181 case EF_FRV_CPU_FR400
:
3182 strcat (buf
, ", fr400");
3184 case EF_FRV_CPU_FR405
:
3185 strcat (buf
, ", fr405");
3188 case EF_FRV_CPU_FR450
:
3189 strcat (buf
, ", fr450");
3192 case EF_FRV_CPU_FR500
:
3193 strcat (buf
, ", fr500");
3195 case EF_FRV_CPU_FR550
:
3196 strcat (buf
, ", fr550");
3199 case EF_FRV_CPU_SIMPLE
:
3200 strcat (buf
, ", simple");
3202 case EF_FRV_CPU_TOMCAT
:
3203 strcat (buf
, ", tomcat");
3209 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3210 strcat (buf
, ", m68000");
3211 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3212 strcat (buf
, ", cpu32");
3213 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3214 strcat (buf
, ", fido_a");
3217 char const * isa
= _("unknown");
3218 char const * mac
= _("unknown mac");
3219 char const * additional
= NULL
;
3221 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3223 case EF_M68K_CF_ISA_A_NODIV
:
3225 additional
= ", nodiv";
3227 case EF_M68K_CF_ISA_A
:
3230 case EF_M68K_CF_ISA_A_PLUS
:
3233 case EF_M68K_CF_ISA_B_NOUSP
:
3235 additional
= ", nousp";
3237 case EF_M68K_CF_ISA_B
:
3240 case EF_M68K_CF_ISA_C
:
3243 case EF_M68K_CF_ISA_C_NODIV
:
3245 additional
= ", nodiv";
3248 strcat (buf
, ", cf, isa ");
3251 strcat (buf
, additional
);
3252 if (e_flags
& EF_M68K_CF_FLOAT
)
3253 strcat (buf
, ", float");
3254 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3259 case EF_M68K_CF_MAC
:
3262 case EF_M68K_CF_EMAC
:
3265 case EF_M68K_CF_EMAC_B
:
3278 switch (e_flags
& EF_MEP_CPU_MASK
)
3280 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3281 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3282 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3283 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3284 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3285 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3286 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3289 switch (e_flags
& EF_MEP_COP_MASK
)
3291 case EF_MEP_COP_NONE
: break;
3292 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3293 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3294 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3295 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3296 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3299 if (e_flags
& EF_MEP_LIBRARY
)
3300 strcat (buf
, ", Built for Library");
3302 if (e_flags
& EF_MEP_INDEX_MASK
)
3303 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3304 e_flags
& EF_MEP_INDEX_MASK
);
3306 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3307 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3308 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3312 if (e_flags
& EF_PPC_EMB
)
3313 strcat (buf
, ", emb");
3315 if (e_flags
& EF_PPC_RELOCATABLE
)
3316 strcat (buf
, _(", relocatable"));
3318 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3319 strcat (buf
, _(", relocatable-lib"));
3323 if (e_flags
& EF_PPC64_ABI
)
3325 char abi
[] = ", abiv0";
3327 abi
[6] += e_flags
& EF_PPC64_ABI
;
3333 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3334 strcat (buf
, ", RH850 ABI");
3336 if (e_flags
& EF_V800_850E3
)
3337 strcat (buf
, ", V3 architecture");
3339 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3340 strcat (buf
, ", FPU not used");
3342 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3343 strcat (buf
, ", regmode: COMMON");
3345 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3346 strcat (buf
, ", r4 not used");
3348 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3349 strcat (buf
, ", r30 not used");
3351 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3352 strcat (buf
, ", r5 not used");
3354 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3355 strcat (buf
, ", r2 not used");
3357 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3359 switch (e_flags
& - e_flags
)
3361 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3362 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3363 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3364 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3365 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3366 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3367 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3368 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3369 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3370 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3371 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3372 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3379 case EM_CYGNUS_V850
:
3380 switch (e_flags
& EF_V850_ARCH
)
3382 case E_V850E3V5_ARCH
:
3383 strcat (buf
, ", v850e3v5");
3385 case E_V850E2V3_ARCH
:
3386 strcat (buf
, ", v850e2v3");
3389 strcat (buf
, ", v850e2");
3392 strcat (buf
, ", v850e1");
3395 strcat (buf
, ", v850e");
3398 strcat (buf
, ", v850");
3401 strcat (buf
, _(", unknown v850 architecture variant"));
3407 case EM_CYGNUS_M32R
:
3408 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3409 strcat (buf
, ", m32r");
3413 case EM_MIPS_RS3_LE
:
3414 if (e_flags
& EF_MIPS_NOREORDER
)
3415 strcat (buf
, ", noreorder");
3417 if (e_flags
& EF_MIPS_PIC
)
3418 strcat (buf
, ", pic");
3420 if (e_flags
& EF_MIPS_CPIC
)
3421 strcat (buf
, ", cpic");
3423 if (e_flags
& EF_MIPS_UCODE
)
3424 strcat (buf
, ", ugen_reserved");
3426 if (e_flags
& EF_MIPS_ABI2
)
3427 strcat (buf
, ", abi2");
3429 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3430 strcat (buf
, ", odk first");
3432 if (e_flags
& EF_MIPS_32BITMODE
)
3433 strcat (buf
, ", 32bitmode");
3435 if (e_flags
& EF_MIPS_NAN2008
)
3436 strcat (buf
, ", nan2008");
3438 if (e_flags
& EF_MIPS_FP64
)
3439 strcat (buf
, ", fp64");
3441 switch ((e_flags
& EF_MIPS_MACH
))
3443 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3444 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3445 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3446 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3447 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3448 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3449 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3450 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3451 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3452 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3453 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3454 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3455 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3456 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3457 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3458 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3459 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3460 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3461 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3462 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3463 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3465 /* We simply ignore the field in this case to avoid confusion:
3466 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3469 default: strcat (buf
, _(", unknown CPU")); break;
3472 switch ((e_flags
& EF_MIPS_ABI
))
3474 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3475 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3476 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3477 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3479 /* We simply ignore the field in this case to avoid confusion:
3480 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3481 This means it is likely to be an o32 file, but not for
3484 default: strcat (buf
, _(", unknown ABI")); break;
3487 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3488 strcat (buf
, ", mdmx");
3490 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3491 strcat (buf
, ", mips16");
3493 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3494 strcat (buf
, ", micromips");
3496 switch ((e_flags
& EF_MIPS_ARCH
))
3498 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3499 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3500 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3501 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3502 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3503 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3504 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3505 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3506 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3507 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3508 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3509 default: strcat (buf
, _(", unknown ISA")); break;
3514 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3518 switch (EF_NFP_MACH (e_flags
))
3520 case E_NFP_MACH_3200
:
3521 strcat (buf
, ", NFP-32xx");
3523 case E_NFP_MACH_6000
:
3524 strcat (buf
, ", NFP-6xxx");
3530 if (e_flags
& EF_RISCV_RVC
)
3531 strcat (buf
, ", RVC");
3533 if (e_flags
& EF_RISCV_RVE
)
3534 strcat (buf
, ", RVE");
3536 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3538 case EF_RISCV_FLOAT_ABI_SOFT
:
3539 strcat (buf
, ", soft-float ABI");
3542 case EF_RISCV_FLOAT_ABI_SINGLE
:
3543 strcat (buf
, ", single-float ABI");
3546 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3547 strcat (buf
, ", double-float ABI");
3550 case EF_RISCV_FLOAT_ABI_QUAD
:
3551 strcat (buf
, ", quad-float ABI");
3557 switch ((e_flags
& EF_SH_MACH_MASK
))
3559 case EF_SH1
: strcat (buf
, ", sh1"); break;
3560 case EF_SH2
: strcat (buf
, ", sh2"); break;
3561 case EF_SH3
: strcat (buf
, ", sh3"); break;
3562 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3563 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3564 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3565 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3566 case EF_SH4
: strcat (buf
, ", sh4"); break;
3567 case EF_SH5
: strcat (buf
, ", sh5"); break;
3568 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3569 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3570 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3571 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3572 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3573 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3574 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3575 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3576 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3577 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3578 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3579 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3580 default: strcat (buf
, _(", unknown ISA")); break;
3583 if (e_flags
& EF_SH_PIC
)
3584 strcat (buf
, ", pic");
3586 if (e_flags
& EF_SH_FDPIC
)
3587 strcat (buf
, ", fdpic");
3591 if (e_flags
& EF_OR1K_NODELAY
)
3592 strcat (buf
, ", no delay");
3596 if (e_flags
& EF_SPARC_32PLUS
)
3597 strcat (buf
, ", v8+");
3599 if (e_flags
& EF_SPARC_SUN_US1
)
3600 strcat (buf
, ", ultrasparcI");
3602 if (e_flags
& EF_SPARC_SUN_US3
)
3603 strcat (buf
, ", ultrasparcIII");
3605 if (e_flags
& EF_SPARC_HAL_R1
)
3606 strcat (buf
, ", halr1");
3608 if (e_flags
& EF_SPARC_LEDATA
)
3609 strcat (buf
, ", ledata");
3611 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3612 strcat (buf
, ", tso");
3614 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3615 strcat (buf
, ", pso");
3617 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3618 strcat (buf
, ", rmo");
3622 switch (e_flags
& EF_PARISC_ARCH
)
3624 case EFA_PARISC_1_0
:
3625 strcpy (buf
, ", PA-RISC 1.0");
3627 case EFA_PARISC_1_1
:
3628 strcpy (buf
, ", PA-RISC 1.1");
3630 case EFA_PARISC_2_0
:
3631 strcpy (buf
, ", PA-RISC 2.0");
3636 if (e_flags
& EF_PARISC_TRAPNIL
)
3637 strcat (buf
, ", trapnil");
3638 if (e_flags
& EF_PARISC_EXT
)
3639 strcat (buf
, ", ext");
3640 if (e_flags
& EF_PARISC_LSB
)
3641 strcat (buf
, ", lsb");
3642 if (e_flags
& EF_PARISC_WIDE
)
3643 strcat (buf
, ", wide");
3644 if (e_flags
& EF_PARISC_NO_KABP
)
3645 strcat (buf
, ", no kabp");
3646 if (e_flags
& EF_PARISC_LAZYSWAP
)
3647 strcat (buf
, ", lazyswap");
3652 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3653 strcat (buf
, ", new calling convention");
3655 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3656 strcat (buf
, ", gnu calling convention");
3660 if ((e_flags
& EF_IA_64_ABI64
))
3661 strcat (buf
, ", 64-bit");
3663 strcat (buf
, ", 32-bit");
3664 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3665 strcat (buf
, ", reduced fp model");
3666 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3667 strcat (buf
, ", no function descriptors, constant gp");
3668 else if ((e_flags
& EF_IA_64_CONS_GP
))
3669 strcat (buf
, ", constant gp");
3670 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3671 strcat (buf
, ", absolute");
3672 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3674 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3675 strcat (buf
, ", vms_linkages");
3676 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3678 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3680 case EF_IA_64_VMS_COMCOD_WARNING
:
3681 strcat (buf
, ", warning");
3683 case EF_IA_64_VMS_COMCOD_ERROR
:
3684 strcat (buf
, ", error");
3686 case EF_IA_64_VMS_COMCOD_ABORT
:
3687 strcat (buf
, ", abort");
3690 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3691 e_flags
& EF_IA_64_VMS_COMCOD
);
3692 strcat (buf
, ", <unknown>");
3698 if ((e_flags
& EF_VAX_NONPIC
))
3699 strcat (buf
, ", non-PIC");
3700 if ((e_flags
& EF_VAX_DFLOAT
))
3701 strcat (buf
, ", D-Float");
3702 if ((e_flags
& EF_VAX_GFLOAT
))
3703 strcat (buf
, ", G-Float");
3707 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3708 strcat (buf
, ", mcm");
3709 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3710 strcat (buf
, ", mcm24");
3711 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3712 strcat (buf
, ", gr6");
3716 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3718 case E_FLAG_RL78_ANY_CPU
: break;
3719 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3720 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3721 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3723 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3724 strcat (buf
, ", 64-bit doubles");
3728 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3729 strcat (buf
, ", 64-bit doubles");
3730 if (e_flags
& E_FLAG_RX_DSP
)
3731 strcat (buf
, ", dsp");
3732 if (e_flags
& E_FLAG_RX_PID
)
3733 strcat (buf
, ", pid");
3734 if (e_flags
& E_FLAG_RX_ABI
)
3735 strcat (buf
, ", RX ABI");
3736 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3737 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3738 ? ", uses String instructions" : ", bans String instructions");
3739 if (e_flags
& E_FLAG_RX_V2
)
3740 strcat (buf
, ", V2");
3741 if (e_flags
& E_FLAG_RX_V3
)
3742 strcat (buf
, ", V3");
3746 if (e_flags
& EF_S390_HIGH_GPRS
)
3747 strcat (buf
, ", highgprs");
3751 if ((e_flags
& EF_C6000_REL
))
3752 strcat (buf
, ", relocatable module");
3756 strcat (buf
, _(": architecture variant: "));
3757 switch (e_flags
& EF_MSP430_MACH
)
3759 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3760 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3761 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3762 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3763 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3764 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3765 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3766 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3767 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3768 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3769 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3770 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3771 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3772 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3773 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3775 strcat (buf
, _(": unknown")); break;
3778 if (e_flags
& ~ EF_MSP430_MACH
)
3779 strcat (buf
, _(": unknown extra flag bits also present"));
3783 switch (e_flags
& EF_Z80_MACH_MSK
)
3785 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3786 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3787 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3788 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3789 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3790 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3791 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3793 strcat (buf
, _(", unknown")); break;
3803 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3805 static char buff
[32];
3809 case ELFOSABI_NONE
: return "UNIX - System V";
3810 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3811 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3812 case ELFOSABI_GNU
: return "UNIX - GNU";
3813 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3814 case ELFOSABI_AIX
: return "UNIX - AIX";
3815 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3816 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3817 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3818 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3819 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3820 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3821 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3822 case ELFOSABI_AROS
: return "AROS";
3823 case ELFOSABI_FENIXOS
: return "FenixOS";
3824 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3825 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3828 switch (filedata
->file_header
.e_machine
)
3833 case ELFOSABI_ARM
: return "ARM";
3834 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3845 case ELFOSABI_STANDALONE
: return _("Standalone App");
3854 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3855 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3864 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3870 get_aarch64_segment_type (unsigned long type
)
3874 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3875 default: return NULL
;
3880 get_arm_segment_type (unsigned long type
)
3884 case PT_ARM_EXIDX
: return "EXIDX";
3885 default: return NULL
;
3890 get_s390_segment_type (unsigned long type
)
3894 case PT_S390_PGSTE
: return "S390_PGSTE";
3895 default: return NULL
;
3900 get_mips_segment_type (unsigned long type
)
3904 case PT_MIPS_REGINFO
: return "REGINFO";
3905 case PT_MIPS_RTPROC
: return "RTPROC";
3906 case PT_MIPS_OPTIONS
: return "OPTIONS";
3907 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3908 default: return NULL
;
3913 get_parisc_segment_type (unsigned long type
)
3917 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3918 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3919 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3920 default: return NULL
;
3925 get_ia64_segment_type (unsigned long type
)
3929 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3930 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3931 default: return NULL
;
3936 get_tic6x_segment_type (unsigned long type
)
3940 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3941 default: return NULL
;
3946 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3948 if (e_machine
== EM_PARISC
)
3951 case PT_HP_TLS
: return "HP_TLS";
3952 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3953 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3954 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3955 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3956 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3957 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3958 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3959 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3960 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3961 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3962 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3963 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3964 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3965 case PT_HP_STACK
: return "HP_STACK";
3966 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3967 default: return NULL
;
3970 if (e_machine
== EM_IA_64
)
3973 case PT_HP_TLS
: return "HP_TLS";
3974 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3975 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3976 case PT_IA_64_HP_STACK
: return "HP_STACK";
3977 default: return NULL
;
3984 get_solaris_segment_type (unsigned long type
)
3988 case 0x6464e550: return "PT_SUNW_UNWIND";
3989 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3990 case 0x6ffffff7: return "PT_LOSUNW";
3991 case 0x6ffffffa: return "PT_SUNWBSS";
3992 case 0x6ffffffb: return "PT_SUNWSTACK";
3993 case 0x6ffffffc: return "PT_SUNWDTRACE";
3994 case 0x6ffffffd: return "PT_SUNWCAP";
3995 case 0x6fffffff: return "PT_HISUNW";
3996 default: return NULL
;
4001 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4003 static char buff
[32];
4007 case PT_NULL
: return "NULL";
4008 case PT_LOAD
: return "LOAD";
4009 case PT_DYNAMIC
: return "DYNAMIC";
4010 case PT_INTERP
: return "INTERP";
4011 case PT_NOTE
: return "NOTE";
4012 case PT_SHLIB
: return "SHLIB";
4013 case PT_PHDR
: return "PHDR";
4014 case PT_TLS
: return "TLS";
4015 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4016 case PT_GNU_STACK
: return "GNU_STACK";
4017 case PT_GNU_RELRO
: return "GNU_RELRO";
4018 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4021 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4023 const char * result
;
4025 switch (filedata
->file_header
.e_machine
)
4028 result
= get_aarch64_segment_type (p_type
);
4031 result
= get_arm_segment_type (p_type
);
4034 case EM_MIPS_RS3_LE
:
4035 result
= get_mips_segment_type (p_type
);
4038 result
= get_parisc_segment_type (p_type
);
4041 result
= get_ia64_segment_type (p_type
);
4044 result
= get_tic6x_segment_type (p_type
);
4048 result
= get_s390_segment_type (p_type
);
4058 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4060 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4062 const char * result
= NULL
;
4064 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4067 case ELFOSABI_FREEBSD
:
4068 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4070 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4075 result
= get_hpux_segment_type (p_type
,
4076 filedata
->file_header
.e_machine
);
4078 case ELFOSABI_SOLARIS
:
4079 result
= get_solaris_segment_type (p_type
);
4087 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4090 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4097 get_arc_section_type_name (unsigned int sh_type
)
4101 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4109 get_mips_section_type_name (unsigned int sh_type
)
4113 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4114 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4115 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4116 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4117 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4118 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4119 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4120 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4121 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4122 case SHT_MIPS_RELD
: return "MIPS_RELD";
4123 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4124 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4125 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4126 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4127 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4128 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4129 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4130 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4131 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4132 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4133 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4134 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4135 case SHT_MIPS_LINE
: return "MIPS_LINE";
4136 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4137 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4138 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4139 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4140 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4141 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4142 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4143 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4144 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4145 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4146 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4147 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4148 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4149 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4150 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4151 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4152 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4153 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4161 get_parisc_section_type_name (unsigned int sh_type
)
4165 case SHT_PARISC_EXT
: return "PARISC_EXT";
4166 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4167 case SHT_PARISC_DOC
: return "PARISC_DOC";
4168 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4169 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4170 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4171 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4172 default: return NULL
;
4177 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4179 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4180 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4181 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4185 case SHT_IA_64_EXT
: return "IA_64_EXT";
4186 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4187 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4188 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4189 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4190 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4191 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4192 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4193 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4194 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4202 get_x86_64_section_type_name (unsigned int sh_type
)
4206 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4207 default: return NULL
;
4212 get_aarch64_section_type_name (unsigned int sh_type
)
4216 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4217 default: return NULL
;
4222 get_arm_section_type_name (unsigned int sh_type
)
4226 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4227 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4228 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4229 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4230 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4231 default: return NULL
;
4236 get_tic6x_section_type_name (unsigned int sh_type
)
4240 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4241 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4242 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4243 case SHT_TI_ICODE
: return "TI_ICODE";
4244 case SHT_TI_XREF
: return "TI_XREF";
4245 case SHT_TI_HANDLER
: return "TI_HANDLER";
4246 case SHT_TI_INITINFO
: return "TI_INITINFO";
4247 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4248 default: return NULL
;
4253 get_msp430x_section_type_name (unsigned int sh_type
)
4257 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4258 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4259 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4260 default: return NULL
;
4265 get_nfp_section_type_name (unsigned int sh_type
)
4269 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4270 case SHT_NFP_INITREG
: return "NFP_INITREG";
4271 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4272 default: return NULL
;
4277 get_v850_section_type_name (unsigned int sh_type
)
4281 case SHT_V850_SCOMMON
: return "V850 Small Common";
4282 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4283 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4284 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4285 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4286 default: return NULL
;
4291 get_riscv_section_type_name (unsigned int sh_type
)
4295 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4296 default: return NULL
;
4301 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4303 static char buff
[32];
4304 const char * result
;
4308 case SHT_NULL
: return "NULL";
4309 case SHT_PROGBITS
: return "PROGBITS";
4310 case SHT_SYMTAB
: return "SYMTAB";
4311 case SHT_STRTAB
: return "STRTAB";
4312 case SHT_RELA
: return "RELA";
4313 case SHT_HASH
: return "HASH";
4314 case SHT_DYNAMIC
: return "DYNAMIC";
4315 case SHT_NOTE
: return "NOTE";
4316 case SHT_NOBITS
: return "NOBITS";
4317 case SHT_REL
: return "REL";
4318 case SHT_SHLIB
: return "SHLIB";
4319 case SHT_DYNSYM
: return "DYNSYM";
4320 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4321 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4322 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4323 case SHT_GNU_HASH
: return "GNU_HASH";
4324 case SHT_GROUP
: return "GROUP";
4325 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4326 case SHT_GNU_verdef
: return "VERDEF";
4327 case SHT_GNU_verneed
: return "VERNEED";
4328 case SHT_GNU_versym
: return "VERSYM";
4329 case 0x6ffffff0: return "VERSYM";
4330 case 0x6ffffffc: return "VERDEF";
4331 case 0x7ffffffd: return "AUXILIARY";
4332 case 0x7fffffff: return "FILTER";
4333 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4336 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4338 switch (filedata
->file_header
.e_machine
)
4341 case EM_ARC_COMPACT
:
4342 case EM_ARC_COMPACT2
:
4343 result
= get_arc_section_type_name (sh_type
);
4346 case EM_MIPS_RS3_LE
:
4347 result
= get_mips_section_type_name (sh_type
);
4350 result
= get_parisc_section_type_name (sh_type
);
4353 result
= get_ia64_section_type_name (filedata
, sh_type
);
4358 result
= get_x86_64_section_type_name (sh_type
);
4361 result
= get_aarch64_section_type_name (sh_type
);
4364 result
= get_arm_section_type_name (sh_type
);
4367 result
= get_tic6x_section_type_name (sh_type
);
4370 result
= get_msp430x_section_type_name (sh_type
);
4373 result
= get_nfp_section_type_name (sh_type
);
4377 case EM_CYGNUS_V850
:
4378 result
= get_v850_section_type_name (sh_type
);
4381 result
= get_riscv_section_type_name (sh_type
);
4391 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4393 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4395 switch (filedata
->file_header
.e_machine
)
4398 result
= get_ia64_section_type_name (filedata
, sh_type
);
4401 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4402 result
= get_solaris_section_type (sh_type
);
4407 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4408 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4409 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4410 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4422 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4424 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4426 switch (filedata
->file_header
.e_machine
)
4430 case EM_CYGNUS_V850
:
4431 result
= get_v850_section_type_name (sh_type
);
4441 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4444 /* This message is probably going to be displayed in a 15
4445 character wide field, so put the hex value first. */
4446 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4452 #define OPTION_DEBUG_DUMP 512
4453 #define OPTION_DYN_SYMS 513
4454 #define OPTION_DWARF_DEPTH 514
4455 #define OPTION_DWARF_START 515
4456 #define OPTION_DWARF_CHECK 516
4457 #define OPTION_CTF_DUMP 517
4458 #define OPTION_CTF_PARENT 518
4459 #define OPTION_CTF_SYMBOLS 519
4460 #define OPTION_CTF_STRINGS 520
4462 static struct option options
[] =
4464 {"all", no_argument
, 0, 'a'},
4465 {"file-header", no_argument
, 0, 'h'},
4466 {"program-headers", no_argument
, 0, 'l'},
4467 {"headers", no_argument
, 0, 'e'},
4468 {"histogram", no_argument
, 0, 'I'},
4469 {"segments", no_argument
, 0, 'l'},
4470 {"sections", no_argument
, 0, 'S'},
4471 {"section-headers", no_argument
, 0, 'S'},
4472 {"section-groups", no_argument
, 0, 'g'},
4473 {"section-details", no_argument
, 0, 't'},
4474 {"full-section-name",no_argument
, 0, 'N'},
4475 {"symbols", no_argument
, 0, 's'},
4476 {"syms", no_argument
, 0, 's'},
4477 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4478 {"relocs", no_argument
, 0, 'r'},
4479 {"notes", no_argument
, 0, 'n'},
4480 {"dynamic", no_argument
, 0, 'd'},
4481 {"arch-specific", no_argument
, 0, 'A'},
4482 {"version-info", no_argument
, 0, 'V'},
4483 {"use-dynamic", no_argument
, 0, 'D'},
4484 {"unwind", no_argument
, 0, 'u'},
4485 {"archive-index", no_argument
, 0, 'c'},
4486 {"hex-dump", required_argument
, 0, 'x'},
4487 {"relocated-dump", required_argument
, 0, 'R'},
4488 {"string-dump", required_argument
, 0, 'p'},
4489 {"decompress", no_argument
, 0, 'z'},
4490 #ifdef SUPPORT_DISASSEMBLY
4491 {"instruction-dump", required_argument
, 0, 'i'},
4493 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4495 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4496 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4497 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4499 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4501 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4502 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4503 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4505 {"version", no_argument
, 0, 'v'},
4506 {"wide", no_argument
, 0, 'W'},
4507 {"help", no_argument
, 0, 'H'},
4508 {0, no_argument
, 0, 0}
4512 usage (FILE * stream
)
4514 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4515 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4516 fprintf (stream
, _(" Options are:\n\
4517 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4518 -h --file-header Display the ELF file header\n\
4519 -l --program-headers Display the program headers\n\
4520 --segments An alias for --program-headers\n\
4521 -S --section-headers Display the sections' header\n\
4522 --sections An alias for --section-headers\n\
4523 -g --section-groups Display the section groups\n\
4524 -t --section-details Display the section details\n\
4525 -e --headers Equivalent to: -h -l -S\n\
4526 -s --syms Display the symbol table\n\
4527 --symbols An alias for --syms\n\
4528 --dyn-syms Display the dynamic symbol table\n\
4529 -n --notes Display the core notes (if present)\n\
4530 -r --relocs Display the relocations (if present)\n\
4531 -u --unwind Display the unwind info (if present)\n\
4532 -d --dynamic Display the dynamic section (if present)\n\
4533 -V --version-info Display the version sections (if present)\n\
4534 -A --arch-specific Display architecture specific information (if any)\n\
4535 -c --archive-index Display the symbol/file index in an archive\n\
4536 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4537 -x --hex-dump=<number|name>\n\
4538 Dump the contents of section <number|name> as bytes\n\
4539 -p --string-dump=<number|name>\n\
4540 Dump the contents of section <number|name> as strings\n\
4541 -R --relocated-dump=<number|name>\n\
4542 Dump the contents of section <number|name> as relocated bytes\n\
4543 -z --decompress Decompress section before dumping it\n\
4544 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4545 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4546 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4547 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4548 =addr,=cu_index,=links,=follow-links]\n\
4549 Display the contents of DWARF debug sections\n"));
4550 fprintf (stream
, _("\
4551 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4552 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4554 fprintf (stream
, _("\
4555 --ctf=<number|name> Display CTF info from section <number|name>\n\
4556 --ctf-parent=<number|name>\n\
4557 Use section <number|name> as the CTF parent\n\n\
4558 --ctf-symbols=<number|name>\n\
4559 Use section <number|name> as the CTF external symtab\n\n\
4560 --ctf-strings=<number|name>\n\
4561 Use section <number|name> as the CTF external strtab\n\n"));
4563 #ifdef SUPPORT_DISASSEMBLY
4564 fprintf (stream
, _("\
4565 -i --instruction-dump=<number|name>\n\
4566 Disassemble the contents of section <number|name>\n"));
4568 fprintf (stream
, _("\
4569 -I --histogram Display histogram of bucket list lengths\n\
4570 -W --wide Allow output width to exceed 80 characters\n\
4571 @<file> Read options from <file>\n\
4572 -H --help Display this information\n\
4573 -v --version Display the version number of readelf\n"));
4575 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4576 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4578 exit (stream
== stdout
? 0 : 1);
4581 /* Record the fact that the user wants the contents of section number
4582 SECTION to be displayed using the method(s) encoded as flags bits
4583 in TYPE. Note, TYPE can be zero if we are creating the array for
4587 request_dump_bynumber (struct dump_data
*dumpdata
,
4588 unsigned int section
, dump_type type
)
4590 if (section
>= dumpdata
->num_dump_sects
)
4592 dump_type
* new_dump_sects
;
4594 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4595 sizeof (* new_dump_sects
));
4597 if (new_dump_sects
== NULL
)
4598 error (_("Out of memory allocating dump request table.\n"));
4601 if (dumpdata
->dump_sects
)
4603 /* Copy current flag settings. */
4604 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4605 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4607 free (dumpdata
->dump_sects
);
4610 dumpdata
->dump_sects
= new_dump_sects
;
4611 dumpdata
->num_dump_sects
= section
+ 1;
4615 if (dumpdata
->dump_sects
)
4616 dumpdata
->dump_sects
[section
] |= type
;
4619 /* Request a dump by section name. */
4622 request_dump_byname (const char * section
, dump_type type
)
4624 struct dump_list_entry
* new_request
;
4626 new_request
= (struct dump_list_entry
*)
4627 malloc (sizeof (struct dump_list_entry
));
4629 error (_("Out of memory allocating dump request table.\n"));
4631 new_request
->name
= strdup (section
);
4632 if (!new_request
->name
)
4633 error (_("Out of memory allocating dump request table.\n"));
4635 new_request
->type
= type
;
4637 new_request
->next
= dump_sects_byname
;
4638 dump_sects_byname
= new_request
;
4642 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4648 section
= strtoul (optarg
, & cp
, 0);
4650 if (! *cp
&& section
>= 0)
4651 request_dump_bynumber (dumpdata
, section
, type
);
4653 request_dump_byname (optarg
, type
);
4657 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4664 while ((c
= getopt_long
4665 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4683 do_section_groups
= TRUE
;
4686 do_histogram
= TRUE
;
4691 do_section_groups
= TRUE
;
4696 do_section_details
= TRUE
;
4707 do_using_dynamic
= TRUE
;
4731 do_histogram
= TRUE
;
4737 do_archive_index
= TRUE
;
4740 request_dump (dumpdata
, HEX_DUMP
);
4743 request_dump (dumpdata
, STRING_DUMP
);
4746 request_dump (dumpdata
, RELOC_DUMP
);
4749 decompress_dumps
= TRUE
;
4755 do_debugging
= TRUE
;
4756 dwarf_select_sections_all ();
4760 do_debugging
= FALSE
;
4761 dwarf_select_sections_by_letters (optarg
);
4764 case OPTION_DEBUG_DUMP
:
4767 do_debugging
= TRUE
;
4770 do_debugging
= FALSE
;
4771 dwarf_select_sections_by_names (optarg
);
4774 case OPTION_DWARF_DEPTH
:
4778 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4781 case OPTION_DWARF_START
:
4785 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4788 case OPTION_DWARF_CHECK
:
4791 case OPTION_CTF_DUMP
:
4793 request_dump (dumpdata
, CTF_DUMP
);
4795 case OPTION_CTF_SYMBOLS
:
4796 dump_ctf_symtab_name
= strdup (optarg
);
4798 case OPTION_CTF_STRINGS
:
4799 dump_ctf_strtab_name
= strdup (optarg
);
4801 case OPTION_CTF_PARENT
:
4802 dump_ctf_parent_name
= strdup (optarg
);
4804 case OPTION_DYN_SYMS
:
4807 #ifdef SUPPORT_DISASSEMBLY
4809 request_dump (dumpdata
, DISASS_DUMP
);
4813 print_version (program_name
);
4822 /* xgettext:c-format */
4823 error (_("Invalid option '-%c'\n"), c
);
4830 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4831 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4832 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4833 && !do_section_groups
&& !do_archive_index
4839 get_elf_class (unsigned int elf_class
)
4841 static char buff
[32];
4845 case ELFCLASSNONE
: return _("none");
4846 case ELFCLASS32
: return "ELF32";
4847 case ELFCLASS64
: return "ELF64";
4849 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4855 get_data_encoding (unsigned int encoding
)
4857 static char buff
[32];
4861 case ELFDATANONE
: return _("none");
4862 case ELFDATA2LSB
: return _("2's complement, little endian");
4863 case ELFDATA2MSB
: return _("2's complement, big endian");
4865 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4870 /* Decode the data held in 'filedata->file_header'. */
4873 process_file_header (Filedata
* filedata
)
4875 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4877 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4878 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4879 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4880 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4883 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4887 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4893 printf (_("ELF Header:\n"));
4894 printf (_(" Magic: "));
4895 for (i
= 0; i
< EI_NIDENT
; i
++)
4896 printf ("%2.2x ", header
->e_ident
[i
]);
4898 printf (_(" Class: %s\n"),
4899 get_elf_class (header
->e_ident
[EI_CLASS
]));
4900 printf (_(" Data: %s\n"),
4901 get_data_encoding (header
->e_ident
[EI_DATA
]));
4902 printf (_(" Version: %d%s\n"),
4903 header
->e_ident
[EI_VERSION
],
4904 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4906 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4909 printf (_(" OS/ABI: %s\n"),
4910 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4911 printf (_(" ABI Version: %d\n"),
4912 header
->e_ident
[EI_ABIVERSION
]);
4913 printf (_(" Type: %s\n"),
4914 get_file_type (header
->e_type
));
4915 printf (_(" Machine: %s\n"),
4916 get_machine_name (header
->e_machine
));
4917 printf (_(" Version: 0x%lx\n"),
4920 printf (_(" Entry point address: "));
4921 print_vma (header
->e_entry
, PREFIX_HEX
);
4922 printf (_("\n Start of program headers: "));
4923 print_vma (header
->e_phoff
, DEC
);
4924 printf (_(" (bytes into file)\n Start of section headers: "));
4925 print_vma (header
->e_shoff
, DEC
);
4926 printf (_(" (bytes into file)\n"));
4928 printf (_(" Flags: 0x%lx%s\n"),
4930 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4931 printf (_(" Size of this header: %u (bytes)\n"),
4933 printf (_(" Size of program headers: %u (bytes)\n"),
4934 header
->e_phentsize
);
4935 printf (_(" Number of program headers: %u"),
4937 if (filedata
->section_headers
!= NULL
4938 && header
->e_phnum
== PN_XNUM
4939 && filedata
->section_headers
[0].sh_info
!= 0)
4941 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4942 printf (" (%u)", header
->e_phnum
);
4944 putc ('\n', stdout
);
4945 printf (_(" Size of section headers: %u (bytes)\n"),
4946 header
->e_shentsize
);
4947 printf (_(" Number of section headers: %u"),
4949 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4951 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4952 printf (" (%u)", header
->e_shnum
);
4954 putc ('\n', stdout
);
4955 printf (_(" Section header string table index: %u"),
4956 header
->e_shstrndx
);
4957 if (filedata
->section_headers
!= NULL
4958 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4960 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4961 printf (" (%u)", header
->e_shstrndx
);
4963 if (header
->e_shstrndx
!= SHN_UNDEF
4964 && header
->e_shstrndx
>= header
->e_shnum
)
4966 header
->e_shstrndx
= SHN_UNDEF
;
4967 printf (_(" <corrupt: out of range>"));
4969 putc ('\n', stdout
);
4972 if (filedata
->section_headers
!= NULL
)
4974 if (header
->e_phnum
== PN_XNUM
4975 && filedata
->section_headers
[0].sh_info
!= 0)
4976 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4977 if (header
->e_shnum
== SHN_UNDEF
)
4978 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4979 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4980 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4981 if (header
->e_shstrndx
>= header
->e_shnum
)
4982 header
->e_shstrndx
= SHN_UNDEF
;
4983 free (filedata
->section_headers
);
4984 filedata
->section_headers
= NULL
;
4990 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4991 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4994 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4996 Elf32_External_Phdr
* phdrs
;
4997 Elf32_External_Phdr
* external
;
4998 Elf_Internal_Phdr
* internal
;
5000 unsigned int size
= filedata
->file_header
.e_phentsize
;
5001 unsigned int num
= filedata
->file_header
.e_phnum
;
5003 /* PR binutils/17531: Cope with unexpected section header sizes. */
5004 if (size
== 0 || num
== 0)
5006 if (size
< sizeof * phdrs
)
5008 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5011 if (size
> sizeof * phdrs
)
5012 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5014 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5015 size
, num
, _("program headers"));
5019 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5020 i
< filedata
->file_header
.e_phnum
;
5021 i
++, internal
++, external
++)
5023 internal
->p_type
= BYTE_GET (external
->p_type
);
5024 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5025 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5026 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5027 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5028 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5029 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5030 internal
->p_align
= BYTE_GET (external
->p_align
);
5037 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5038 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5041 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5043 Elf64_External_Phdr
* phdrs
;
5044 Elf64_External_Phdr
* external
;
5045 Elf_Internal_Phdr
* internal
;
5047 unsigned int size
= filedata
->file_header
.e_phentsize
;
5048 unsigned int num
= filedata
->file_header
.e_phnum
;
5050 /* PR binutils/17531: Cope with unexpected section header sizes. */
5051 if (size
== 0 || num
== 0)
5053 if (size
< sizeof * phdrs
)
5055 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5058 if (size
> sizeof * phdrs
)
5059 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5061 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5062 size
, num
, _("program headers"));
5066 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5067 i
< filedata
->file_header
.e_phnum
;
5068 i
++, internal
++, external
++)
5070 internal
->p_type
= BYTE_GET (external
->p_type
);
5071 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5072 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5073 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5074 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5075 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5076 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5077 internal
->p_align
= BYTE_GET (external
->p_align
);
5084 /* Returns TRUE if the program headers were read into `program_headers'. */
5087 get_program_headers (Filedata
* filedata
)
5089 Elf_Internal_Phdr
* phdrs
;
5091 /* Check cache of prior read. */
5092 if (filedata
->program_headers
!= NULL
)
5095 /* Be kind to memory checkers by looking for
5096 e_phnum values which we know must be invalid. */
5097 if (filedata
->file_header
.e_phnum
5098 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5099 >= filedata
->file_size
)
5101 error (_("Too many program headers - %#x - the file is not that big\n"),
5102 filedata
->file_header
.e_phnum
);
5106 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5107 sizeof (Elf_Internal_Phdr
));
5110 error (_("Out of memory reading %u program headers\n"),
5111 filedata
->file_header
.e_phnum
);
5116 ? get_32bit_program_headers (filedata
, phdrs
)
5117 : get_64bit_program_headers (filedata
, phdrs
))
5119 filedata
->program_headers
= phdrs
;
5127 /* Returns TRUE if the program headers were loaded. */
5130 process_program_headers (Filedata
* filedata
)
5132 Elf_Internal_Phdr
* segment
;
5134 Elf_Internal_Phdr
* previous_load
= NULL
;
5136 filedata
->dynamic_addr
= 0;
5137 filedata
->dynamic_size
= 0;
5139 if (filedata
->file_header
.e_phnum
== 0)
5141 /* PR binutils/12467. */
5142 if (filedata
->file_header
.e_phoff
!= 0)
5144 warn (_("possibly corrupt ELF header - it has a non-zero program"
5145 " header offset, but no program headers\n"));
5148 else if (do_segments
)
5149 printf (_("\nThere are no program headers in this file.\n"));
5153 if (do_segments
&& !do_header
)
5155 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5156 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5157 printf (ngettext ("There is %d program header, starting at offset %s\n",
5158 "There are %d program headers, starting at offset %s\n",
5159 filedata
->file_header
.e_phnum
),
5160 filedata
->file_header
.e_phnum
,
5161 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5164 if (! get_program_headers (filedata
))
5169 if (filedata
->file_header
.e_phnum
> 1)
5170 printf (_("\nProgram Headers:\n"));
5172 printf (_("\nProgram Headers:\n"));
5176 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5179 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5183 (_(" Type Offset VirtAddr PhysAddr\n"));
5185 (_(" FileSiz MemSiz Flags Align\n"));
5189 for (i
= 0, segment
= filedata
->program_headers
;
5190 i
< filedata
->file_header
.e_phnum
;
5195 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5199 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5200 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5201 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5202 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5203 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5205 (segment
->p_flags
& PF_R
? 'R' : ' '),
5206 (segment
->p_flags
& PF_W
? 'W' : ' '),
5207 (segment
->p_flags
& PF_X
? 'E' : ' '));
5208 printf ("%#lx", (unsigned long) segment
->p_align
);
5212 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5213 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5216 print_vma (segment
->p_offset
, FULL_HEX
);
5220 print_vma (segment
->p_vaddr
, FULL_HEX
);
5222 print_vma (segment
->p_paddr
, FULL_HEX
);
5225 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5226 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5229 print_vma (segment
->p_filesz
, FULL_HEX
);
5233 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5234 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5237 print_vma (segment
->p_memsz
, FULL_HEX
);
5241 (segment
->p_flags
& PF_R
? 'R' : ' '),
5242 (segment
->p_flags
& PF_W
? 'W' : ' '),
5243 (segment
->p_flags
& PF_X
? 'E' : ' '));
5245 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5246 printf ("%#lx", (unsigned long) segment
->p_align
);
5249 print_vma (segment
->p_align
, PREFIX_HEX
);
5254 print_vma (segment
->p_offset
, FULL_HEX
);
5256 print_vma (segment
->p_vaddr
, FULL_HEX
);
5258 print_vma (segment
->p_paddr
, FULL_HEX
);
5260 print_vma (segment
->p_filesz
, FULL_HEX
);
5262 print_vma (segment
->p_memsz
, FULL_HEX
);
5264 (segment
->p_flags
& PF_R
? 'R' : ' '),
5265 (segment
->p_flags
& PF_W
? 'W' : ' '),
5266 (segment
->p_flags
& PF_X
? 'E' : ' '));
5267 print_vma (segment
->p_align
, PREFIX_HEX
);
5270 putc ('\n', stdout
);
5273 switch (segment
->p_type
)
5276 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5277 required by the ELF standard, several programs, including the Linux
5278 kernel, make use of non-ordered segments. */
5280 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5281 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5283 if (segment
->p_memsz
< segment
->p_filesz
)
5284 error (_("the segment's file size is larger than its memory size\n"));
5285 previous_load
= segment
;
5289 /* PR 20815 - Verify that the program header is loaded into memory. */
5290 if (i
> 0 && previous_load
!= NULL
)
5291 error (_("the PHDR segment must occur before any LOAD segment\n"));
5292 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5296 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5298 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5299 if (load
->p_type
== PT_LOAD
5300 && load
->p_offset
<= segment
->p_offset
5301 && (load
->p_offset
+ load
->p_filesz
5302 >= segment
->p_offset
+ segment
->p_filesz
)
5303 && load
->p_vaddr
<= segment
->p_vaddr
5304 && (load
->p_vaddr
+ load
->p_filesz
5305 >= segment
->p_vaddr
+ segment
->p_filesz
))
5308 if (j
== filedata
->file_header
.e_phnum
)
5309 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5314 if (filedata
->dynamic_addr
)
5315 error (_("more than one dynamic segment\n"));
5317 /* By default, assume that the .dynamic section is the first
5318 section in the DYNAMIC segment. */
5319 filedata
->dynamic_addr
= segment
->p_offset
;
5320 filedata
->dynamic_size
= segment
->p_filesz
;
5322 /* Try to locate the .dynamic section. If there is
5323 a section header table, we can easily locate it. */
5324 if (filedata
->section_headers
!= NULL
)
5326 Elf_Internal_Shdr
* sec
;
5328 sec
= find_section (filedata
, ".dynamic");
5329 if (sec
== NULL
|| sec
->sh_size
== 0)
5331 /* A corresponding .dynamic section is expected, but on
5332 IA-64/OpenVMS it is OK for it to be missing. */
5333 if (!is_ia64_vms (filedata
))
5334 error (_("no .dynamic section in the dynamic segment\n"));
5338 if (sec
->sh_type
== SHT_NOBITS
)
5340 filedata
->dynamic_size
= 0;
5344 filedata
->dynamic_addr
= sec
->sh_offset
;
5345 filedata
->dynamic_size
= sec
->sh_size
;
5347 if (filedata
->dynamic_addr
< segment
->p_offset
5348 || filedata
->dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5349 warn (_("the .dynamic section is not contained"
5350 " within the dynamic segment\n"));
5351 else if (filedata
->dynamic_addr
> segment
->p_offset
)
5352 warn (_("the .dynamic section is not the first section"
5353 " in the dynamic segment.\n"));
5356 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5357 segment. Check this after matching against the section headers
5358 so we don't warn on debuginfo file (which have NOBITS .dynamic
5360 if (filedata
->dynamic_addr
> filedata
->file_size
5361 || (filedata
->dynamic_size
5362 > filedata
->file_size
- filedata
->dynamic_addr
))
5364 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5365 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5370 if (fseek (filedata
->handle
,
5371 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5373 error (_("Unable to find program interpreter name\n"));
5377 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5379 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5380 error (_("Internal error: failed to create format string to display program interpreter\n"));
5382 filedata
->program_interpreter
[0] = 0;
5383 if (fscanf (filedata
->handle
, fmt
,
5384 filedata
->program_interpreter
) <= 0)
5385 error (_("Unable to read program interpreter name\n"));
5388 printf (_(" [Requesting program interpreter: %s]\n"),
5389 filedata
->program_interpreter
);
5396 && filedata
->section_headers
!= NULL
5397 && filedata
->string_table
!= NULL
)
5399 printf (_("\n Section to Segment mapping:\n"));
5400 printf (_(" Segment Sections...\n"));
5402 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5405 Elf_Internal_Shdr
* section
;
5407 segment
= filedata
->program_headers
+ i
;
5408 section
= filedata
->section_headers
+ 1;
5410 printf (" %2.2d ", i
);
5412 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5414 if (!ELF_TBSS_SPECIAL (section
, segment
)
5415 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5416 printf ("%s ", printable_section_name (filedata
, section
));
5427 /* Find the file offset corresponding to VMA by using the program headers. */
5430 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5432 Elf_Internal_Phdr
* seg
;
5434 if (! get_program_headers (filedata
))
5436 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5440 for (seg
= filedata
->program_headers
;
5441 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5444 if (seg
->p_type
!= PT_LOAD
)
5447 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5448 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5449 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5452 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5453 (unsigned long) vma
);
5458 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5459 If PROBE is true, this is just a probe and we do not generate any error
5460 messages if the load fails. */
5463 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5465 Elf32_External_Shdr
* shdrs
;
5466 Elf_Internal_Shdr
* internal
;
5468 unsigned int size
= filedata
->file_header
.e_shentsize
;
5469 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5471 /* PR binutils/17531: Cope with unexpected section header sizes. */
5472 if (size
== 0 || num
== 0)
5474 if (size
< sizeof * shdrs
)
5477 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5480 if (!probe
&& size
> sizeof * shdrs
)
5481 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5483 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5485 probe
? NULL
: _("section headers"));
5489 free (filedata
->section_headers
);
5490 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5491 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5492 if (filedata
->section_headers
== NULL
)
5495 error (_("Out of memory reading %u section headers\n"), num
);
5500 for (i
= 0, internal
= filedata
->section_headers
;
5504 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5505 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5506 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5507 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5508 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5509 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5510 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5511 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5512 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5513 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5514 if (!probe
&& internal
->sh_link
> num
)
5515 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5516 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5517 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5524 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5527 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5529 Elf64_External_Shdr
* shdrs
;
5530 Elf_Internal_Shdr
* internal
;
5532 unsigned int size
= filedata
->file_header
.e_shentsize
;
5533 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5535 /* PR binutils/17531: Cope with unexpected section header sizes. */
5536 if (size
== 0 || num
== 0)
5539 if (size
< sizeof * shdrs
)
5542 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5546 if (! probe
&& size
> sizeof * shdrs
)
5547 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5549 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5550 filedata
->file_header
.e_shoff
,
5552 probe
? NULL
: _("section headers"));
5556 free (filedata
->section_headers
);
5557 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5558 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5559 if (filedata
->section_headers
== NULL
)
5562 error (_("Out of memory reading %u section headers\n"), num
);
5567 for (i
= 0, internal
= filedata
->section_headers
;
5571 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5572 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5573 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5574 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5575 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5576 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5577 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5578 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5579 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5580 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5581 if (!probe
&& internal
->sh_link
> num
)
5582 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5583 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5584 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5591 static Elf_Internal_Sym
*
5592 get_32bit_elf_symbols (Filedata
* filedata
,
5593 Elf_Internal_Shdr
* section
,
5594 unsigned long * num_syms_return
)
5596 unsigned long number
= 0;
5597 Elf32_External_Sym
* esyms
= NULL
;
5598 Elf_External_Sym_Shndx
* shndx
= NULL
;
5599 Elf_Internal_Sym
* isyms
= NULL
;
5600 Elf_Internal_Sym
* psym
;
5602 elf_section_list
* entry
;
5604 if (section
->sh_size
== 0)
5606 if (num_syms_return
!= NULL
)
5607 * num_syms_return
= 0;
5611 /* Run some sanity checks first. */
5612 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5614 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5615 printable_section_name (filedata
, section
),
5616 (unsigned long) section
->sh_entsize
);
5620 if (section
->sh_size
> filedata
->file_size
)
5622 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5623 printable_section_name (filedata
, section
),
5624 (unsigned long) section
->sh_size
);
5628 number
= section
->sh_size
/ section
->sh_entsize
;
5630 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5632 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5633 (unsigned long) section
->sh_size
,
5634 printable_section_name (filedata
, section
),
5635 (unsigned long) section
->sh_entsize
);
5639 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5640 section
->sh_size
, _("symbols"));
5645 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5647 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5652 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5656 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5657 entry
->hdr
->sh_offset
,
5658 1, entry
->hdr
->sh_size
,
5659 _("symbol table section indices"));
5663 /* PR17531: file: heap-buffer-overflow */
5664 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5666 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5667 printable_section_name (filedata
, entry
->hdr
),
5668 (unsigned long) entry
->hdr
->sh_size
,
5669 (unsigned long) section
->sh_size
);
5674 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5678 error (_("Out of memory reading %lu symbols\n"),
5679 (unsigned long) number
);
5683 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5685 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5686 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5687 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5688 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5689 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5691 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5692 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5693 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5694 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5695 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5702 if (num_syms_return
!= NULL
)
5703 * num_syms_return
= isyms
== NULL
? 0 : number
;
5708 static Elf_Internal_Sym
*
5709 get_64bit_elf_symbols (Filedata
* filedata
,
5710 Elf_Internal_Shdr
* section
,
5711 unsigned long * num_syms_return
)
5713 unsigned long number
= 0;
5714 Elf64_External_Sym
* esyms
= NULL
;
5715 Elf_External_Sym_Shndx
* shndx
= NULL
;
5716 Elf_Internal_Sym
* isyms
= NULL
;
5717 Elf_Internal_Sym
* psym
;
5719 elf_section_list
* entry
;
5721 if (section
->sh_size
== 0)
5723 if (num_syms_return
!= NULL
)
5724 * num_syms_return
= 0;
5728 /* Run some sanity checks first. */
5729 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5731 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5732 printable_section_name (filedata
, section
),
5733 (unsigned long) section
->sh_entsize
);
5737 if (section
->sh_size
> filedata
->file_size
)
5739 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5740 printable_section_name (filedata
, section
),
5741 (unsigned long) section
->sh_size
);
5745 number
= section
->sh_size
/ section
->sh_entsize
;
5747 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5749 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5750 (unsigned long) section
->sh_size
,
5751 printable_section_name (filedata
, section
),
5752 (unsigned long) section
->sh_entsize
);
5756 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5757 section
->sh_size
, _("symbols"));
5762 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5764 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5769 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5773 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5774 entry
->hdr
->sh_offset
,
5775 1, entry
->hdr
->sh_size
,
5776 _("symbol table section indices"));
5780 /* PR17531: file: heap-buffer-overflow */
5781 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5783 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5784 printable_section_name (filedata
, entry
->hdr
),
5785 (unsigned long) entry
->hdr
->sh_size
,
5786 (unsigned long) section
->sh_size
);
5791 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5795 error (_("Out of memory reading %lu symbols\n"),
5796 (unsigned long) number
);
5800 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5802 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5803 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5804 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5805 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5807 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5809 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5810 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5811 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5813 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5814 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5821 if (num_syms_return
!= NULL
)
5822 * num_syms_return
= isyms
== NULL
? 0 : number
;
5828 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5830 static char buff
[1024];
5832 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5834 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5835 bfd_vma os_flags
= 0;
5836 bfd_vma proc_flags
= 0;
5837 bfd_vma unknown_flags
= 0;
5845 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5846 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5847 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5848 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5849 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5850 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5851 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5852 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5853 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5854 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5855 /* IA-64 specific. */
5856 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5857 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5858 /* IA-64 OpenVMS specific. */
5859 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5860 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5861 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5862 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5863 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5864 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5866 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5867 /* SPARC specific. */
5868 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5869 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5871 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5872 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5873 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5875 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5877 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5880 if (do_section_details
)
5882 sprintf (buff
, "[%*.*lx]: ",
5883 field_size
, field_size
, (unsigned long) sh_flags
);
5884 p
+= field_size
+ 4;
5891 flag
= sh_flags
& - sh_flags
;
5894 if (do_section_details
)
5898 case SHF_WRITE
: sindex
= 0; break;
5899 case SHF_ALLOC
: sindex
= 1; break;
5900 case SHF_EXECINSTR
: sindex
= 2; break;
5901 case SHF_MERGE
: sindex
= 3; break;
5902 case SHF_STRINGS
: sindex
= 4; break;
5903 case SHF_INFO_LINK
: sindex
= 5; break;
5904 case SHF_LINK_ORDER
: sindex
= 6; break;
5905 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5906 case SHF_GROUP
: sindex
= 8; break;
5907 case SHF_TLS
: sindex
= 9; break;
5908 case SHF_EXCLUDE
: sindex
= 18; break;
5909 case SHF_COMPRESSED
: sindex
= 20; break;
5910 case SHF_GNU_MBIND
: sindex
= 24; break;
5914 switch (filedata
->file_header
.e_machine
)
5917 if (flag
== SHF_IA_64_SHORT
)
5919 else if (flag
== SHF_IA_64_NORECOV
)
5922 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5925 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5926 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5927 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5928 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5929 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5930 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5941 case EM_OLD_SPARCV9
:
5942 case EM_SPARC32PLUS
:
5945 if (flag
== SHF_ORDERED
)
5952 case SHF_ENTRYSECT
: sindex
= 21; break;
5953 case SHF_ARM_PURECODE
: sindex
= 22; break;
5954 case SHF_COMDEF
: sindex
= 23; break;
5959 if (flag
== SHF_PPC_VLE
)
5970 if (p
!= buff
+ field_size
+ 4)
5972 if (size
< (10 + 2))
5974 warn (_("Internal error: not enough buffer room for section flag info"));
5975 return _("<unknown>");
5982 size
-= flags
[sindex
].len
;
5983 p
= stpcpy (p
, flags
[sindex
].str
);
5985 else if (flag
& SHF_MASKOS
)
5987 else if (flag
& SHF_MASKPROC
)
5990 unknown_flags
|= flag
;
5996 case SHF_WRITE
: *p
= 'W'; break;
5997 case SHF_ALLOC
: *p
= 'A'; break;
5998 case SHF_EXECINSTR
: *p
= 'X'; break;
5999 case SHF_MERGE
: *p
= 'M'; break;
6000 case SHF_STRINGS
: *p
= 'S'; break;
6001 case SHF_INFO_LINK
: *p
= 'I'; break;
6002 case SHF_LINK_ORDER
: *p
= 'L'; break;
6003 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6004 case SHF_GROUP
: *p
= 'G'; break;
6005 case SHF_TLS
: *p
= 'T'; break;
6006 case SHF_EXCLUDE
: *p
= 'E'; break;
6007 case SHF_COMPRESSED
: *p
= 'C'; break;
6008 case SHF_GNU_MBIND
: *p
= 'D'; break;
6011 if ((filedata
->file_header
.e_machine
== EM_X86_64
6012 || filedata
->file_header
.e_machine
== EM_L1OM
6013 || filedata
->file_header
.e_machine
== EM_K1OM
)
6014 && flag
== SHF_X86_64_LARGE
)
6016 else if (filedata
->file_header
.e_machine
== EM_ARM
6017 && flag
== SHF_ARM_PURECODE
)
6019 else if (filedata
->file_header
.e_machine
== EM_PPC
6020 && flag
== SHF_PPC_VLE
)
6022 else if (flag
& SHF_MASKOS
)
6025 sh_flags
&= ~ SHF_MASKOS
;
6027 else if (flag
& SHF_MASKPROC
)
6030 sh_flags
&= ~ SHF_MASKPROC
;
6040 if (do_section_details
)
6044 size
-= 5 + field_size
;
6045 if (p
!= buff
+ field_size
+ 4)
6049 warn (_("Internal error: not enough buffer room for section flag info"));
6050 return _("<unknown>");
6056 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6057 (unsigned long) os_flags
);
6058 p
+= 5 + field_size
;
6062 size
-= 7 + field_size
;
6063 if (p
!= buff
+ field_size
+ 4)
6067 warn (_("Internal error: not enough buffer room for section flag info"));
6068 return _("<unknown>");
6074 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6075 (unsigned long) proc_flags
);
6076 p
+= 7 + field_size
;
6080 size
-= 10 + field_size
;
6081 if (p
!= buff
+ field_size
+ 4)
6085 warn (_("Internal error: not enough buffer room for section flag info"));
6086 return _("<unknown>");
6092 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6093 (unsigned long) unknown_flags
);
6094 p
+= 10 + field_size
;
6102 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6103 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6107 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6109 if (size
< sizeof (* echdr
))
6111 error (_("Compressed section is too small even for a compression header\n"));
6115 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6116 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6117 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6118 return sizeof (*echdr
);
6122 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6124 if (size
< sizeof (* echdr
))
6126 error (_("Compressed section is too small even for a compression header\n"));
6130 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6131 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6132 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6133 return sizeof (*echdr
);
6138 process_section_headers (Filedata
* filedata
)
6140 Elf_Internal_Shdr
* section
;
6143 free (filedata
->section_headers
);
6144 filedata
->section_headers
= NULL
;
6145 free (filedata
->dynamic_symbols
);
6146 filedata
->dynamic_symbols
= NULL
;
6147 filedata
->num_dynamic_syms
= 0;
6148 free (filedata
->dynamic_strings
);
6149 filedata
->dynamic_strings
= NULL
;
6150 filedata
->dynamic_strings_length
= 0;
6151 free (filedata
->dynamic_syminfo
);
6152 filedata
->dynamic_syminfo
= NULL
;
6153 while (filedata
->symtab_shndx_list
!= NULL
)
6155 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6156 free (filedata
->symtab_shndx_list
);
6157 filedata
->symtab_shndx_list
= next
;
6160 if (filedata
->file_header
.e_shnum
== 0)
6162 /* PR binutils/12467. */
6163 if (filedata
->file_header
.e_shoff
!= 0)
6165 warn (_("possibly corrupt ELF file header - it has a non-zero"
6166 " section header offset, but no section headers\n"));
6169 else if (do_sections
)
6170 printf (_("\nThere are no sections in this file.\n"));
6175 if (do_sections
&& !do_header
)
6176 printf (ngettext ("There is %d section header, "
6177 "starting at offset 0x%lx:\n",
6178 "There are %d section headers, "
6179 "starting at offset 0x%lx:\n",
6180 filedata
->file_header
.e_shnum
),
6181 filedata
->file_header
.e_shnum
,
6182 (unsigned long) filedata
->file_header
.e_shoff
);
6186 if (! get_32bit_section_headers (filedata
, FALSE
))
6191 if (! get_64bit_section_headers (filedata
, FALSE
))
6195 /* Read in the string table, so that we have names to display. */
6196 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6197 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6199 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6201 if (section
->sh_size
!= 0)
6203 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6204 1, section
->sh_size
,
6207 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6211 /* Scan the sections for the dynamic symbol table
6212 and dynamic string table and debug sections. */
6213 eh_addr_size
= is_32bit_elf
? 4 : 8;
6214 switch (filedata
->file_header
.e_machine
)
6217 case EM_MIPS_RS3_LE
:
6218 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6219 FDE addresses. However, the ABI also has a semi-official ILP32
6220 variant for which the normal FDE address size rules apply.
6222 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6223 section, where XX is the size of longs in bits. Unfortunately,
6224 earlier compilers provided no way of distinguishing ILP32 objects
6225 from LP64 objects, so if there's any doubt, we should assume that
6226 the official LP64 form is being used. */
6227 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6228 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6234 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6236 case E_H8_MACH_H8300
:
6237 case E_H8_MACH_H8300HN
:
6238 case E_H8_MACH_H8300SN
:
6239 case E_H8_MACH_H8300SXN
:
6242 case E_H8_MACH_H8300H
:
6243 case E_H8_MACH_H8300S
:
6244 case E_H8_MACH_H8300SX
:
6252 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6254 case EF_M32C_CPU_M16C
:
6261 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6264 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6265 if (section->sh_entsize != expected_entsize) \
6268 sprintf_vma (buf, section->sh_entsize); \
6269 /* Note: coded this way so that there is a single string for \
6271 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6272 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6273 (unsigned) expected_entsize); \
6274 section->sh_entsize = expected_entsize; \
6279 #define CHECK_ENTSIZE(section, i, type) \
6280 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6281 sizeof (Elf64_External_##type))
6283 for (i
= 0, section
= filedata
->section_headers
;
6284 i
< filedata
->file_header
.e_shnum
;
6287 char * name
= SECTION_NAME (section
);
6289 if (section
->sh_type
== SHT_DYNSYM
)
6291 if (filedata
->dynamic_symbols
!= NULL
)
6293 error (_("File contains multiple dynamic symbol tables\n"));
6297 CHECK_ENTSIZE (section
, i
, Sym
);
6298 filedata
->dynamic_symbols
6299 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6301 else if (section
->sh_type
== SHT_STRTAB
6302 && streq (name
, ".dynstr"))
6304 if (filedata
->dynamic_strings
!= NULL
)
6306 error (_("File contains multiple dynamic string tables\n"));
6310 filedata
->dynamic_strings
6311 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6312 1, section
->sh_size
, _("dynamic strings"));
6313 filedata
->dynamic_strings_length
6314 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6316 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6318 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6320 entry
->hdr
= section
;
6321 entry
->next
= filedata
->symtab_shndx_list
;
6322 filedata
->symtab_shndx_list
= entry
;
6324 else if (section
->sh_type
== SHT_SYMTAB
)
6325 CHECK_ENTSIZE (section
, i
, Sym
);
6326 else if (section
->sh_type
== SHT_GROUP
)
6327 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6328 else if (section
->sh_type
== SHT_REL
)
6329 CHECK_ENTSIZE (section
, i
, Rel
);
6330 else if (section
->sh_type
== SHT_RELA
)
6331 CHECK_ENTSIZE (section
, i
, Rela
);
6332 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6333 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6334 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6335 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6336 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6337 && (const_strneq (name
, ".debug_")
6338 || const_strneq (name
, ".zdebug_")))
6341 name
+= sizeof (".zdebug_") - 1;
6343 name
+= sizeof (".debug_") - 1;
6346 || (do_debug_info
&& const_strneq (name
, "info"))
6347 || (do_debug_info
&& const_strneq (name
, "types"))
6348 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6349 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6350 || (do_debug_lines
&& const_strneq (name
, "line."))
6351 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6352 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6353 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6354 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6355 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6356 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6357 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6358 || (do_debug_frames
&& const_strneq (name
, "frame"))
6359 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6360 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6361 || (do_debug_str
&& const_strneq (name
, "str"))
6362 || (do_debug_loc
&& const_strneq (name
, "loc"))
6363 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6364 || (do_debug_addr
&& const_strneq (name
, "addr"))
6365 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6366 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6368 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6370 /* Linkonce section to be combined with .debug_info at link time. */
6371 else if ((do_debugging
|| do_debug_info
)
6372 && const_strneq (name
, ".gnu.linkonce.wi."))
6373 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6374 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6375 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6376 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6377 || streq (name
, ".debug_names")))
6378 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6379 /* Trace sections for Itanium VMS. */
6380 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6381 || do_trace_aranges
)
6382 && const_strneq (name
, ".trace_"))
6384 name
+= sizeof (".trace_") - 1;
6387 || (do_trace_info
&& streq (name
, "info"))
6388 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6389 || (do_trace_aranges
&& streq (name
, "aranges"))
6391 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6393 else if ((do_debugging
|| do_debug_links
)
6394 && (const_strneq (name
, ".gnu_debuglink")
6395 || const_strneq (name
, ".gnu_debugaltlink")))
6396 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6402 if (filedata
->file_header
.e_shnum
> 1)
6403 printf (_("\nSection Headers:\n"));
6405 printf (_("\nSection Header:\n"));
6409 if (do_section_details
)
6411 printf (_(" [Nr] Name\n"));
6412 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6416 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6420 if (do_section_details
)
6422 printf (_(" [Nr] Name\n"));
6423 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6427 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6431 if (do_section_details
)
6433 printf (_(" [Nr] Name\n"));
6434 printf (_(" Type Address Offset Link\n"));
6435 printf (_(" Size EntSize Info Align\n"));
6439 printf (_(" [Nr] Name Type Address Offset\n"));
6440 printf (_(" Size EntSize Flags Link Info Align\n"));
6444 if (do_section_details
)
6445 printf (_(" Flags\n"));
6447 for (i
= 0, section
= filedata
->section_headers
;
6448 i
< filedata
->file_header
.e_shnum
;
6451 /* Run some sanity checks on the section header. */
6453 /* Check the sh_link field. */
6454 switch (section
->sh_type
)
6458 if (section
->sh_link
== 0
6459 && (filedata
->file_header
.e_type
== ET_EXEC
6460 || filedata
->file_header
.e_type
== ET_DYN
))
6461 /* A dynamic relocation section where all entries use a
6462 zero symbol index need not specify a symtab section. */
6465 case SHT_SYMTAB_SHNDX
:
6469 case SHT_GNU_versym
:
6470 if (section
->sh_link
== 0
6471 || section
->sh_link
>= filedata
->file_header
.e_shnum
6472 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6473 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6474 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6475 i
, section
->sh_link
);
6481 case SHT_GNU_verneed
:
6482 case SHT_GNU_verdef
:
6483 case SHT_GNU_LIBLIST
:
6484 if (section
->sh_link
== 0
6485 || section
->sh_link
>= filedata
->file_header
.e_shnum
6486 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6487 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6488 i
, section
->sh_link
);
6491 case SHT_INIT_ARRAY
:
6492 case SHT_FINI_ARRAY
:
6493 case SHT_PREINIT_ARRAY
:
6494 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6495 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6496 i
, section
->sh_link
);
6500 /* FIXME: Add support for target specific section types. */
6501 #if 0 /* Currently we do not check other section types as there are too
6502 many special cases. Stab sections for example have a type
6503 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6505 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6506 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6507 i
, section
->sh_link
);
6512 /* Check the sh_info field. */
6513 switch (section
->sh_type
)
6517 if (section
->sh_info
== 0
6518 && (filedata
->file_header
.e_type
== ET_EXEC
6519 || filedata
->file_header
.e_type
== ET_DYN
))
6520 /* Dynamic relocations apply to segments, so they do not
6521 need to specify the section they relocate. */
6523 if (section
->sh_info
== 0
6524 || section
->sh_info
>= filedata
->file_header
.e_shnum
6525 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6526 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6527 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6528 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6529 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6530 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6531 /* FIXME: Are other section types valid ? */
6532 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6533 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6534 i
, section
->sh_info
);
6539 case SHT_SYMTAB_SHNDX
:
6540 case SHT_INIT_ARRAY
:
6541 case SHT_FINI_ARRAY
:
6542 case SHT_PREINIT_ARRAY
:
6543 if (section
->sh_info
!= 0)
6544 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6545 i
, section
->sh_info
);
6551 /* A symbol index - we assume that it is valid. */
6555 /* FIXME: Add support for target specific section types. */
6556 if (section
->sh_type
== SHT_NOBITS
)
6557 /* NOBITS section headers with non-zero sh_info fields can be
6558 created when a binary is stripped of everything but its debug
6559 information. The stripped sections have their headers
6560 preserved but their types set to SHT_NOBITS. So do not check
6561 this type of section. */
6563 else if (section
->sh_flags
& SHF_INFO_LINK
)
6565 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6566 warn (_("[%2u]: Expected link to another section in info field"), i
);
6568 else if (section
->sh_type
< SHT_LOOS
6569 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6570 && section
->sh_info
!= 0)
6571 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6572 i
, section
->sh_info
);
6576 /* Check the sh_size field. */
6577 if (section
->sh_size
> filedata
->file_size
6578 && section
->sh_type
!= SHT_NOBITS
6579 && section
->sh_type
!= SHT_NULL
6580 && section
->sh_type
< SHT_LOOS
)
6581 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6583 printf (" [%2u] ", i
);
6584 if (do_section_details
)
6585 printf ("%s\n ", printable_section_name (filedata
, section
));
6587 print_symbol (-17, SECTION_NAME (section
));
6589 printf (do_wide
? " %-15s " : " %-15.15s ",
6590 get_section_type_name (filedata
, section
->sh_type
));
6594 const char * link_too_big
= NULL
;
6596 print_vma (section
->sh_addr
, LONG_HEX
);
6598 printf ( " %6.6lx %6.6lx %2.2lx",
6599 (unsigned long) section
->sh_offset
,
6600 (unsigned long) section
->sh_size
,
6601 (unsigned long) section
->sh_entsize
);
6603 if (do_section_details
)
6604 fputs (" ", stdout
);
6606 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6608 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6611 /* The sh_link value is out of range. Normally this indicates
6612 an error but it can have special values in Solaris binaries. */
6613 switch (filedata
->file_header
.e_machine
)
6620 case EM_OLD_SPARCV9
:
6621 case EM_SPARC32PLUS
:
6624 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6625 link_too_big
= "BEFORE";
6626 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6627 link_too_big
= "AFTER";
6634 if (do_section_details
)
6636 if (link_too_big
!= NULL
&& * link_too_big
)
6637 printf ("<%s> ", link_too_big
);
6639 printf ("%2u ", section
->sh_link
);
6640 printf ("%3u %2lu\n", section
->sh_info
,
6641 (unsigned long) section
->sh_addralign
);
6644 printf ("%2u %3u %2lu\n",
6647 (unsigned long) section
->sh_addralign
);
6649 if (link_too_big
&& ! * link_too_big
)
6650 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6651 i
, section
->sh_link
);
6655 print_vma (section
->sh_addr
, LONG_HEX
);
6657 if ((long) section
->sh_offset
== section
->sh_offset
)
6658 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6662 print_vma (section
->sh_offset
, LONG_HEX
);
6665 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6666 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6670 print_vma (section
->sh_size
, LONG_HEX
);
6673 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6674 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6678 print_vma (section
->sh_entsize
, LONG_HEX
);
6681 if (do_section_details
)
6682 fputs (" ", stdout
);
6684 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6686 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6688 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6689 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6692 print_vma (section
->sh_addralign
, DEC
);
6696 else if (do_section_details
)
6699 print_vma (section
->sh_addr
, LONG_HEX
);
6700 if ((long) section
->sh_offset
== section
->sh_offset
)
6701 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6705 print_vma (section
->sh_offset
, LONG_HEX
);
6707 printf (" %u\n ", section
->sh_link
);
6708 print_vma (section
->sh_size
, LONG_HEX
);
6710 print_vma (section
->sh_entsize
, LONG_HEX
);
6712 printf (" %-16u %lu\n",
6714 (unsigned long) section
->sh_addralign
);
6719 print_vma (section
->sh_addr
, LONG_HEX
);
6720 if ((long) section
->sh_offset
== section
->sh_offset
)
6721 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6725 print_vma (section
->sh_offset
, LONG_HEX
);
6728 print_vma (section
->sh_size
, LONG_HEX
);
6730 print_vma (section
->sh_entsize
, LONG_HEX
);
6732 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6734 printf (" %2u %3u %lu\n",
6737 (unsigned long) section
->sh_addralign
);
6740 if (do_section_details
)
6742 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6743 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6745 /* Minimum section size is 12 bytes for 32-bit compression
6746 header + 12 bytes for compressed data header. */
6747 unsigned char buf
[24];
6749 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6750 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6751 sizeof (buf
), _("compression header")))
6753 Elf_Internal_Chdr chdr
;
6755 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6756 printf (_(" [<corrupt>]\n"));
6759 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6762 printf (_(" [<unknown>: 0x%x], "),
6764 print_vma (chdr
.ch_size
, LONG_HEX
);
6765 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6772 if (!do_section_details
)
6774 /* The ordering of the letters shown here matches the ordering of the
6775 corresponding SHF_xxx values, and hence the order in which these
6776 letters will be displayed to the user. */
6777 printf (_("Key to Flags:\n\
6778 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6779 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6780 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6781 if (filedata
->file_header
.e_machine
== EM_X86_64
6782 || filedata
->file_header
.e_machine
== EM_L1OM
6783 || filedata
->file_header
.e_machine
== EM_K1OM
)
6784 printf (_("l (large), "));
6785 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6786 printf (_("y (purecode), "));
6787 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6788 printf (_("v (VLE), "));
6789 printf ("p (processor specific)\n");
6796 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6797 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6798 char **strtab
, unsigned long *strtablen
)
6802 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6804 if (*symtab
== NULL
)
6807 if (symsec
->sh_link
!= 0)
6809 Elf_Internal_Shdr
*strsec
;
6811 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6813 error (_("Bad sh_link in symbol table section\n"));
6820 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6822 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6823 1, strsec
->sh_size
, _("string table"));
6824 if (*strtab
== NULL
)
6831 *strtablen
= strsec
->sh_size
;
6837 get_group_flags (unsigned int flags
)
6839 static char buff
[128];
6843 else if (flags
== GRP_COMDAT
)
6846 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
6848 flags
& GRP_MASKOS
? _("<OS specific>") : "",
6849 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
6850 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
6851 ? _("<unknown>") : ""));
6857 process_section_groups (Filedata
* filedata
)
6859 Elf_Internal_Shdr
* section
;
6861 struct group
* group
;
6862 Elf_Internal_Shdr
* symtab_sec
;
6863 Elf_Internal_Shdr
* strtab_sec
;
6864 Elf_Internal_Sym
* symtab
;
6865 unsigned long num_syms
;
6869 /* Don't process section groups unless needed. */
6870 if (!do_unwind
&& !do_section_groups
)
6873 if (filedata
->file_header
.e_shnum
== 0)
6875 if (do_section_groups
)
6876 printf (_("\nThere are no sections to group in this file.\n"));
6881 if (filedata
->section_headers
== NULL
)
6883 error (_("Section headers are not available!\n"));
6884 /* PR 13622: This can happen with a corrupt ELF header. */
6888 filedata
->section_headers_groups
6889 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6890 sizeof (struct group
*));
6892 if (filedata
->section_headers_groups
== NULL
)
6894 error (_("Out of memory reading %u section group headers\n"),
6895 filedata
->file_header
.e_shnum
);
6899 /* Scan the sections for the group section. */
6900 filedata
->group_count
= 0;
6901 for (i
= 0, section
= filedata
->section_headers
;
6902 i
< filedata
->file_header
.e_shnum
;
6904 if (section
->sh_type
== SHT_GROUP
)
6905 filedata
->group_count
++;
6907 if (filedata
->group_count
== 0)
6909 if (do_section_groups
)
6910 printf (_("\nThere are no section groups in this file.\n"));
6915 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
6916 sizeof (struct group
));
6918 if (filedata
->section_groups
== NULL
)
6920 error (_("Out of memory reading %lu groups\n"),
6921 (unsigned long) filedata
->group_count
);
6931 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
6932 i
< filedata
->file_header
.e_shnum
;
6935 if (section
->sh_type
== SHT_GROUP
)
6937 const char * name
= printable_section_name (filedata
, section
);
6938 const char * group_name
;
6939 unsigned char * start
;
6940 unsigned char * indices
;
6941 unsigned int entry
, j
, size
;
6942 Elf_Internal_Shdr
* sec
;
6943 Elf_Internal_Sym
* sym
;
6945 /* Get the symbol table. */
6946 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6947 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6950 error (_("Bad sh_link in group section `%s'\n"), name
);
6954 if (symtab_sec
!= sec
)
6959 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6964 error (_("Corrupt header in group section `%s'\n"), name
);
6968 if (section
->sh_info
>= num_syms
)
6970 error (_("Bad sh_info in group section `%s'\n"), name
);
6974 sym
= symtab
+ section
->sh_info
;
6976 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6978 if (sym
->st_shndx
== 0
6979 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6981 error (_("Bad sh_info in group section `%s'\n"), name
);
6985 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6994 /* Get the string table. */
6995 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7004 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7010 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7011 1, strtab_sec
->sh_size
,
7013 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7015 group_name
= sym
->st_name
< strtab_size
7016 ? strtab
+ sym
->st_name
: _("<corrupt>");
7019 /* PR 17531: file: loop. */
7020 if (section
->sh_entsize
> section
->sh_size
)
7022 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7023 printable_section_name (filedata
, section
),
7024 (unsigned long) section
->sh_entsize
,
7025 (unsigned long) section
->sh_size
);
7029 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7030 1, section
->sh_size
,
7036 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7037 entry
= byte_get (indices
, 4);
7040 if (do_section_groups
)
7042 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7043 get_group_flags (entry
), i
, name
, group_name
, size
);
7045 printf (_(" [Index] Name\n"));
7048 group
->group_index
= i
;
7050 for (j
= 0; j
< size
; j
++)
7052 struct group_list
* g
;
7054 entry
= byte_get (indices
, 4);
7057 if (entry
>= filedata
->file_header
.e_shnum
)
7059 static unsigned num_group_errors
= 0;
7061 if (num_group_errors
++ < 10)
7063 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7064 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7065 if (num_group_errors
== 10)
7066 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7071 if (filedata
->section_headers_groups
[entry
] != NULL
)
7075 static unsigned num_errs
= 0;
7077 if (num_errs
++ < 10)
7079 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7081 filedata
->section_headers_groups
[entry
]->group_index
);
7083 warn (_("Further error messages about already contained group sections suppressed\n"));
7089 /* Intel C/C++ compiler may put section 0 in a
7090 section group. We just warn it the first time
7091 and ignore it afterwards. */
7092 static bfd_boolean warned
= FALSE
;
7095 error (_("section 0 in group section [%5u]\n"),
7096 filedata
->section_headers_groups
[entry
]->group_index
);
7102 filedata
->section_headers_groups
[entry
] = group
;
7104 if (do_section_groups
)
7106 sec
= filedata
->section_headers
+ entry
;
7107 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7110 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7111 g
->section_index
= entry
;
7112 g
->next
= group
->root
;
7130 /* Data used to display dynamic fixups. */
7132 struct ia64_vms_dynfixup
7134 bfd_vma needed_ident
; /* Library ident number. */
7135 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7136 bfd_vma fixup_needed
; /* Index of the library. */
7137 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7138 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7141 /* Data used to display dynamic relocations. */
7143 struct ia64_vms_dynimgrela
7145 bfd_vma img_rela_cnt
; /* Number of relocations. */
7146 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7149 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7153 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7154 struct ia64_vms_dynfixup
* fixup
,
7155 const char * strtab
,
7156 unsigned int strtab_sz
)
7158 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7160 const char * lib_name
;
7162 imfs
= get_data (NULL
, filedata
,
7163 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7164 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7165 _("dynamic section image fixups"));
7169 if (fixup
->needed
< strtab_sz
)
7170 lib_name
= strtab
+ fixup
->needed
;
7173 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7174 (unsigned long) fixup
->needed
);
7178 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7179 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7181 (_("Seg Offset Type SymVec DataType\n"));
7183 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7188 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7189 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7190 type
= BYTE_GET (imfs
[i
].type
);
7191 rtype
= elf_ia64_reloc_type (type
);
7193 printf (" 0x%08x ", type
);
7195 printf (" %-32s ", rtype
);
7196 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7197 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7204 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7207 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7209 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7212 imrs
= get_data (NULL
, filedata
,
7213 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7214 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7215 _("dynamic section image relocations"));
7219 printf (_("\nImage relocs\n"));
7221 (_("Seg Offset Type Addend Seg Sym Off\n"));
7223 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7228 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7229 printf ("%08" BFD_VMA_FMT
"x ",
7230 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7231 type
= BYTE_GET (imrs
[i
].type
);
7232 rtype
= elf_ia64_reloc_type (type
);
7234 printf ("0x%08x ", type
);
7236 printf ("%-31s ", rtype
);
7237 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7238 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7239 printf ("%08" BFD_VMA_FMT
"x\n",
7240 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7247 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7250 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7252 struct ia64_vms_dynfixup fixup
;
7253 struct ia64_vms_dynimgrela imgrela
;
7254 Elf_Internal_Dyn
*entry
;
7255 bfd_vma strtab_off
= 0;
7256 bfd_vma strtab_sz
= 0;
7257 char *strtab
= NULL
;
7258 bfd_boolean res
= TRUE
;
7260 memset (&fixup
, 0, sizeof (fixup
));
7261 memset (&imgrela
, 0, sizeof (imgrela
));
7263 /* Note: the order of the entries is specified by the OpenVMS specs. */
7264 for (entry
= filedata
->dynamic_section
;
7265 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7268 switch (entry
->d_tag
)
7270 case DT_IA_64_VMS_STRTAB_OFFSET
:
7271 strtab_off
= entry
->d_un
.d_val
;
7274 strtab_sz
= entry
->d_un
.d_val
;
7276 strtab
= get_data (NULL
, filedata
,
7277 filedata
->dynamic_addr
+ strtab_off
,
7278 1, strtab_sz
, _("dynamic string section"));
7283 case DT_IA_64_VMS_NEEDED_IDENT
:
7284 fixup
.needed_ident
= entry
->d_un
.d_val
;
7287 fixup
.needed
= entry
->d_un
.d_val
;
7289 case DT_IA_64_VMS_FIXUP_NEEDED
:
7290 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7292 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7293 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7295 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7296 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7297 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7300 case DT_IA_64_VMS_IMG_RELA_CNT
:
7301 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7303 case DT_IA_64_VMS_IMG_RELA_OFF
:
7304 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7305 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7327 dynamic_relocations
[] =
7329 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7330 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7331 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7334 /* Process the reloc section. */
7337 process_relocs (Filedata
* filedata
)
7339 unsigned long rel_size
;
7340 unsigned long rel_offset
;
7345 if (do_using_dynamic
)
7349 bfd_boolean has_dynamic_reloc
;
7352 has_dynamic_reloc
= FALSE
;
7354 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7356 is_rela
= dynamic_relocations
[i
].rela
;
7357 name
= dynamic_relocations
[i
].name
;
7358 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7359 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7362 has_dynamic_reloc
= TRUE
;
7364 if (is_rela
== UNKNOWN
)
7366 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7367 switch (filedata
->dynamic_info
[DT_PLTREL
])
7381 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7382 name
, rel_offset
, rel_size
);
7384 dump_relocations (filedata
,
7385 offset_from_vma (filedata
, rel_offset
, rel_size
),
7387 filedata
->dynamic_symbols
,
7388 filedata
->num_dynamic_syms
,
7389 filedata
->dynamic_strings
,
7390 filedata
->dynamic_strings_length
,
7391 is_rela
, TRUE
/* is_dynamic */);
7395 if (is_ia64_vms (filedata
))
7396 if (process_ia64_vms_dynamic_relocs (filedata
))
7397 has_dynamic_reloc
= TRUE
;
7399 if (! has_dynamic_reloc
)
7400 printf (_("\nThere are no dynamic relocations in this file.\n"));
7404 Elf_Internal_Shdr
* section
;
7406 bfd_boolean found
= FALSE
;
7408 for (i
= 0, section
= filedata
->section_headers
;
7409 i
< filedata
->file_header
.e_shnum
;
7412 if ( section
->sh_type
!= SHT_RELA
7413 && section
->sh_type
!= SHT_REL
)
7416 rel_offset
= section
->sh_offset
;
7417 rel_size
= section
->sh_size
;
7422 unsigned long num_rela
;
7424 printf (_("\nRelocation section "));
7426 if (filedata
->string_table
== NULL
)
7427 printf ("%d", section
->sh_name
);
7429 printf ("'%s'", printable_section_name (filedata
, section
));
7431 num_rela
= rel_size
/ section
->sh_entsize
;
7432 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7433 " at offset 0x%lx contains %lu entries:\n",
7435 rel_offset
, num_rela
);
7437 is_rela
= section
->sh_type
== SHT_RELA
;
7439 if (section
->sh_link
!= 0
7440 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7442 Elf_Internal_Shdr
* symsec
;
7443 Elf_Internal_Sym
* symtab
;
7444 unsigned long nsyms
;
7445 unsigned long strtablen
= 0;
7446 char * strtab
= NULL
;
7448 symsec
= filedata
->section_headers
+ section
->sh_link
;
7449 if (symsec
->sh_type
!= SHT_SYMTAB
7450 && symsec
->sh_type
!= SHT_DYNSYM
)
7453 if (!get_symtab (filedata
, symsec
,
7454 &symtab
, &nsyms
, &strtab
, &strtablen
))
7457 dump_relocations (filedata
, rel_offset
, rel_size
,
7458 symtab
, nsyms
, strtab
, strtablen
,
7460 symsec
->sh_type
== SHT_DYNSYM
);
7466 dump_relocations (filedata
, rel_offset
, rel_size
,
7467 NULL
, 0, NULL
, 0, is_rela
,
7468 FALSE
/* is_dynamic */);
7476 /* Users sometimes forget the -D option, so try to be helpful. */
7477 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7479 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7481 printf (_("\nThere are no static relocations in this file."));
7482 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7487 if (i
== ARRAY_SIZE (dynamic_relocations
))
7488 printf (_("\nThere are no relocations in this file.\n"));
7495 /* An absolute address consists of a section and an offset. If the
7496 section is NULL, the offset itself is the address, otherwise, the
7497 address equals to LOAD_ADDRESS(section) + offset. */
7501 unsigned short section
;
7505 /* Find the nearest symbol at or below ADDR. Returns the symbol
7506 name, if found, and the offset from the symbol to ADDR. */
7509 find_symbol_for_address (Filedata
* filedata
,
7510 Elf_Internal_Sym
* symtab
,
7511 unsigned long nsyms
,
7512 const char * strtab
,
7513 unsigned long strtab_size
,
7514 struct absaddr addr
,
7515 const char ** symname
,
7518 bfd_vma dist
= 0x100000;
7519 Elf_Internal_Sym
* sym
;
7520 Elf_Internal_Sym
* beg
;
7521 Elf_Internal_Sym
* end
;
7522 Elf_Internal_Sym
* best
= NULL
;
7524 REMOVE_ARCH_BITS (addr
.offset
);
7526 end
= symtab
+ nsyms
;
7532 sym
= beg
+ (end
- beg
) / 2;
7534 value
= sym
->st_value
;
7535 REMOVE_ARCH_BITS (value
);
7537 if (sym
->st_name
!= 0
7538 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7539 && addr
.offset
>= value
7540 && addr
.offset
- value
< dist
)
7543 dist
= addr
.offset
- value
;
7548 if (addr
.offset
< value
)
7556 *symname
= (best
->st_name
>= strtab_size
7557 ? _("<corrupt>") : strtab
+ best
->st_name
);
7563 *offset
= addr
.offset
;
7566 static /* signed */ int
7567 symcmp (const void *p
, const void *q
)
7569 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7570 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7572 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7575 /* Process the unwind section. */
7577 #include "unwind-ia64.h"
7579 struct ia64_unw_table_entry
7581 struct absaddr start
;
7583 struct absaddr info
;
7586 struct ia64_unw_aux_info
7588 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7589 unsigned long table_len
; /* Length of unwind table. */
7590 unsigned char * info
; /* Unwind info. */
7591 unsigned long info_size
; /* Size of unwind info. */
7592 bfd_vma info_addr
; /* Starting address of unwind info. */
7593 bfd_vma seg_base
; /* Starting address of segment. */
7594 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7595 unsigned long nsyms
; /* Number of symbols. */
7596 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7597 unsigned long nfuns
; /* Number of entries in funtab. */
7598 char * strtab
; /* The string table. */
7599 unsigned long strtab_size
; /* Size of string table. */
7603 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7605 struct ia64_unw_table_entry
* tp
;
7606 unsigned long j
, nfuns
;
7608 bfd_boolean res
= TRUE
;
7610 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7611 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7612 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7613 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7615 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7617 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7621 const unsigned char * dp
;
7622 const unsigned char * head
;
7623 const unsigned char * end
;
7624 const char * procname
;
7626 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7627 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7629 fputs ("\n<", stdout
);
7633 fputs (procname
, stdout
);
7636 printf ("+%lx", (unsigned long) offset
);
7639 fputs (">: [", stdout
);
7640 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7641 fputc ('-', stdout
);
7642 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7643 printf ("], info at +0x%lx\n",
7644 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7646 /* PR 17531: file: 86232b32. */
7647 if (aux
->info
== NULL
)
7650 offset
= tp
->info
.offset
;
7651 if (tp
->info
.section
)
7653 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7655 warn (_("Invalid section %u in table entry %ld\n"),
7656 tp
->info
.section
, (long) (tp
- aux
->table
));
7660 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7662 offset
-= aux
->info_addr
;
7663 /* PR 17531: file: 0997b4d1. */
7664 if (offset
>= aux
->info_size
7665 || aux
->info_size
- offset
< 8)
7667 warn (_("Invalid offset %lx in table entry %ld\n"),
7668 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7673 head
= aux
->info
+ offset
;
7674 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7676 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7677 (unsigned) UNW_VER (stamp
),
7678 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7679 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7680 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7681 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7683 if (UNW_VER (stamp
) != 1)
7685 printf (_("\tUnknown version.\n"));
7690 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7691 /* PR 17531: file: 16ceda89. */
7692 if (end
> aux
->info
+ aux
->info_size
)
7693 end
= aux
->info
+ aux
->info_size
;
7694 for (dp
= head
+ 8; dp
< end
;)
7695 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7704 slurp_ia64_unwind_table (Filedata
* filedata
,
7705 struct ia64_unw_aux_info
* aux
,
7706 Elf_Internal_Shdr
* sec
)
7708 unsigned long size
, nrelas
, i
;
7709 Elf_Internal_Phdr
* seg
;
7710 struct ia64_unw_table_entry
* tep
;
7711 Elf_Internal_Shdr
* relsec
;
7712 Elf_Internal_Rela
* rela
;
7713 Elf_Internal_Rela
* rp
;
7714 unsigned char * table
;
7716 Elf_Internal_Sym
* sym
;
7717 const char * relname
;
7721 /* First, find the starting address of the segment that includes
7724 if (filedata
->file_header
.e_phnum
)
7726 if (! get_program_headers (filedata
))
7729 for (seg
= filedata
->program_headers
;
7730 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7733 if (seg
->p_type
!= PT_LOAD
)
7736 if (sec
->sh_addr
>= seg
->p_vaddr
7737 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7739 aux
->seg_base
= seg
->p_vaddr
;
7745 /* Second, build the unwind table from the contents of the unwind section: */
7746 size
= sec
->sh_size
;
7747 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7752 aux
->table_len
= size
/ (3 * eh_addr_size
);
7753 aux
->table
= (struct ia64_unw_table_entry
*)
7754 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7757 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7759 tep
->start
.section
= SHN_UNDEF
;
7760 tep
->end
.section
= SHN_UNDEF
;
7761 tep
->info
.section
= SHN_UNDEF
;
7762 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7763 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7764 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7765 tep
->start
.offset
+= aux
->seg_base
;
7766 tep
->end
.offset
+= aux
->seg_base
;
7767 tep
->info
.offset
+= aux
->seg_base
;
7771 /* Third, apply any relocations to the unwind table: */
7772 for (relsec
= filedata
->section_headers
;
7773 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7776 if (relsec
->sh_type
!= SHT_RELA
7777 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7778 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7781 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7790 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7792 unsigned int sym_ndx
;
7793 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7794 relname
= elf_ia64_reloc_type (r_type
);
7796 /* PR 17531: file: 9fa67536. */
7797 if (relname
== NULL
)
7799 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7803 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7805 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7809 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7811 /* PR 17531: file: 5bc8d9bf. */
7812 if (i
>= aux
->table_len
)
7814 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7818 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7819 if (sym_ndx
>= aux
->nsyms
)
7821 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7825 sym
= aux
->symtab
+ sym_ndx
;
7827 switch (rp
->r_offset
/ eh_addr_size
% 3)
7830 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7831 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7834 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7835 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7838 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7839 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7853 ia64_process_unwind (Filedata
* filedata
)
7855 Elf_Internal_Shdr
* sec
;
7856 Elf_Internal_Shdr
* unwsec
= NULL
;
7857 unsigned long i
, unwcount
= 0, unwstart
= 0;
7858 struct ia64_unw_aux_info aux
;
7859 bfd_boolean res
= TRUE
;
7861 memset (& aux
, 0, sizeof (aux
));
7863 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7865 if (sec
->sh_type
== SHT_SYMTAB
)
7869 error (_("Multiple symbol tables encountered\n"));
7875 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7876 &aux
.strtab
, &aux
.strtab_size
))
7879 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7884 printf (_("\nThere are no unwind sections in this file.\n"));
7886 while (unwcount
-- > 0)
7891 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7892 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7893 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7898 /* We have already counted the number of SHT_IA64_UNWIND
7899 sections so the loop above should never fail. */
7900 assert (unwsec
!= NULL
);
7903 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7905 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7907 /* We need to find which section group it is in. */
7908 struct group_list
* g
;
7910 if (filedata
->section_headers_groups
== NULL
7911 || filedata
->section_headers_groups
[i
] == NULL
)
7912 i
= filedata
->file_header
.e_shnum
;
7915 g
= filedata
->section_headers_groups
[i
]->root
;
7917 for (; g
!= NULL
; g
= g
->next
)
7919 sec
= filedata
->section_headers
+ g
->section_index
;
7921 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7926 i
= filedata
->file_header
.e_shnum
;
7929 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7931 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7932 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7933 suffix
= SECTION_NAME (unwsec
) + len
;
7934 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7936 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7937 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7942 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7943 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7944 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7945 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7947 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7948 suffix
= SECTION_NAME (unwsec
) + len
;
7949 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7951 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7952 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7956 if (i
== filedata
->file_header
.e_shnum
)
7958 printf (_("\nCould not find unwind info section for "));
7960 if (filedata
->string_table
== NULL
)
7961 printf ("%d", unwsec
->sh_name
);
7963 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7967 aux
.info_addr
= sec
->sh_addr
;
7968 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7971 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7973 printf (_("\nUnwind section "));
7975 if (filedata
->string_table
== NULL
)
7976 printf ("%d", unwsec
->sh_name
);
7978 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7980 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7981 (unsigned long) unwsec
->sh_offset
,
7982 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7984 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7985 && aux
.table_len
> 0)
7986 dump_ia64_unwind (filedata
, & aux
);
7989 free ((char *) aux
.table
);
7991 free ((char *) aux
.info
);
8000 free ((char *) aux
.strtab
);
8005 struct hppa_unw_table_entry
8007 struct absaddr start
;
8009 unsigned int Cannot_unwind
:1; /* 0 */
8010 unsigned int Millicode
:1; /* 1 */
8011 unsigned int Millicode_save_sr0
:1; /* 2 */
8012 unsigned int Region_description
:2; /* 3..4 */
8013 unsigned int reserved1
:1; /* 5 */
8014 unsigned int Entry_SR
:1; /* 6 */
8015 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8016 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8017 unsigned int Args_stored
:1; /* 16 */
8018 unsigned int Variable_Frame
:1; /* 17 */
8019 unsigned int Separate_Package_Body
:1; /* 18 */
8020 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8021 unsigned int Stack_Overflow_Check
:1; /* 20 */
8022 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8023 unsigned int Ada_Region
:1; /* 22 */
8024 unsigned int cxx_info
:1; /* 23 */
8025 unsigned int cxx_try_catch
:1; /* 24 */
8026 unsigned int sched_entry_seq
:1; /* 25 */
8027 unsigned int reserved2
:1; /* 26 */
8028 unsigned int Save_SP
:1; /* 27 */
8029 unsigned int Save_RP
:1; /* 28 */
8030 unsigned int Save_MRP_in_frame
:1; /* 29 */
8031 unsigned int extn_ptr_defined
:1; /* 30 */
8032 unsigned int Cleanup_defined
:1; /* 31 */
8034 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8035 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8036 unsigned int Large_frame
:1; /* 2 */
8037 unsigned int Pseudo_SP_Set
:1; /* 3 */
8038 unsigned int reserved4
:1; /* 4 */
8039 unsigned int Total_frame_size
:27; /* 5..31 */
8042 struct hppa_unw_aux_info
8044 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8045 unsigned long table_len
; /* Length of unwind table. */
8046 bfd_vma seg_base
; /* Starting address of segment. */
8047 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8048 unsigned long nsyms
; /* Number of symbols. */
8049 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8050 unsigned long nfuns
; /* Number of entries in funtab. */
8051 char * strtab
; /* The string table. */
8052 unsigned long strtab_size
; /* Size of string table. */
8056 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8058 struct hppa_unw_table_entry
* tp
;
8059 unsigned long j
, nfuns
;
8060 bfd_boolean res
= TRUE
;
8062 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8063 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8064 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8065 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8067 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8069 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8072 const char * procname
;
8074 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8075 aux
->strtab_size
, tp
->start
, &procname
,
8078 fputs ("\n<", stdout
);
8082 fputs (procname
, stdout
);
8085 printf ("+%lx", (unsigned long) offset
);
8088 fputs (">: [", stdout
);
8089 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8090 fputc ('-', stdout
);
8091 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8094 #define PF(_m) if (tp->_m) printf (#_m " ");
8095 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8098 PF(Millicode_save_sr0
);
8099 /* PV(Region_description); */
8105 PF(Separate_Package_Body
);
8106 PF(Frame_Extension_Millicode
);
8107 PF(Stack_Overflow_Check
);
8108 PF(Two_Instruction_SP_Increment
);
8112 PF(sched_entry_seq
);
8115 PF(Save_MRP_in_frame
);
8116 PF(extn_ptr_defined
);
8117 PF(Cleanup_defined
);
8118 PF(MPE_XL_interrupt_marker
);
8119 PF(HP_UX_interrupt_marker
);
8122 PV(Total_frame_size
);
8135 slurp_hppa_unwind_table (Filedata
* filedata
,
8136 struct hppa_unw_aux_info
* aux
,
8137 Elf_Internal_Shdr
* sec
)
8139 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8140 Elf_Internal_Phdr
* seg
;
8141 struct hppa_unw_table_entry
* tep
;
8142 Elf_Internal_Shdr
* relsec
;
8143 Elf_Internal_Rela
* rela
;
8144 Elf_Internal_Rela
* rp
;
8145 unsigned char * table
;
8147 Elf_Internal_Sym
* sym
;
8148 const char * relname
;
8150 /* First, find the starting address of the segment that includes
8152 if (filedata
->file_header
.e_phnum
)
8154 if (! get_program_headers (filedata
))
8157 for (seg
= filedata
->program_headers
;
8158 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8161 if (seg
->p_type
!= PT_LOAD
)
8164 if (sec
->sh_addr
>= seg
->p_vaddr
8165 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8167 aux
->seg_base
= seg
->p_vaddr
;
8173 /* Second, build the unwind table from the contents of the unwind
8175 size
= sec
->sh_size
;
8176 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8182 nentries
= size
/ unw_ent_size
;
8183 size
= unw_ent_size
* nentries
;
8185 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8186 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8188 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8190 unsigned int tmp1
, tmp2
;
8192 tep
->start
.section
= SHN_UNDEF
;
8193 tep
->end
.section
= SHN_UNDEF
;
8195 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8196 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8197 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8198 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8200 tep
->start
.offset
+= aux
->seg_base
;
8201 tep
->end
.offset
+= aux
->seg_base
;
8203 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8204 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8205 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8206 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8207 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8208 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8209 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8210 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8211 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8212 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8213 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8214 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8215 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8216 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8217 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8218 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8219 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8220 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8221 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8222 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8223 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8224 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8225 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8226 tep
->Cleanup_defined
= tmp1
& 0x1;
8228 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8229 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8230 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8231 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8232 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8233 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8237 /* Third, apply any relocations to the unwind table. */
8238 for (relsec
= filedata
->section_headers
;
8239 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8242 if (relsec
->sh_type
!= SHT_RELA
8243 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8244 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8247 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8251 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8253 unsigned int sym_ndx
;
8254 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8255 relname
= elf_hppa_reloc_type (r_type
);
8257 if (relname
== NULL
)
8259 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8263 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8264 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8266 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8270 i
= rp
->r_offset
/ unw_ent_size
;
8271 if (i
>= aux
->table_len
)
8273 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8277 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8278 if (sym_ndx
>= aux
->nsyms
)
8280 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8284 sym
= aux
->symtab
+ sym_ndx
;
8286 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8289 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8290 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8293 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8294 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8304 aux
->table_len
= nentries
;
8310 hppa_process_unwind (Filedata
* filedata
)
8312 struct hppa_unw_aux_info aux
;
8313 Elf_Internal_Shdr
* unwsec
= NULL
;
8314 Elf_Internal_Shdr
* sec
;
8316 bfd_boolean res
= TRUE
;
8318 if (filedata
->string_table
== NULL
)
8321 memset (& aux
, 0, sizeof (aux
));
8323 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8325 if (sec
->sh_type
== SHT_SYMTAB
)
8329 error (_("Multiple symbol tables encountered\n"));
8335 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8336 &aux
.strtab
, &aux
.strtab_size
))
8339 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8344 printf (_("\nThere are no unwind sections in this file.\n"));
8346 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8348 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8350 unsigned long num_unwind
= sec
->sh_size
/ 16;
8352 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8353 "contains %lu entry:\n",
8354 "\nUnwind section '%s' at offset 0x%lx "
8355 "contains %lu entries:\n",
8357 printable_section_name (filedata
, sec
),
8358 (unsigned long) sec
->sh_offset
,
8361 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8364 if (res
&& aux
.table_len
> 0)
8366 if (! dump_hppa_unwind (filedata
, &aux
))
8371 free ((char *) aux
.table
);
8379 free ((char *) aux
.strtab
);
8386 unsigned char * data
; /* The unwind data. */
8387 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8388 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8389 unsigned long nrelas
; /* The number of relocations. */
8390 unsigned int rel_type
; /* REL or RELA ? */
8391 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8394 struct arm_unw_aux_info
8396 Filedata
* filedata
; /* The file containing the unwind sections. */
8397 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8398 unsigned long nsyms
; /* Number of symbols. */
8399 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8400 unsigned long nfuns
; /* Number of these symbols. */
8401 char * strtab
; /* The file's string table. */
8402 unsigned long strtab_size
; /* Size of string table. */
8406 arm_print_vma_and_name (Filedata
* filedata
,
8407 struct arm_unw_aux_info
* aux
,
8409 struct absaddr addr
)
8411 const char *procname
;
8414 if (addr
.section
== SHN_UNDEF
)
8417 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8418 aux
->strtab_size
, addr
, &procname
,
8421 print_vma (fn
, PREFIX_HEX
);
8425 fputs (" <", stdout
);
8426 fputs (procname
, stdout
);
8429 printf ("+0x%lx", (unsigned long) sym_offset
);
8430 fputc ('>', stdout
);
8437 arm_free_section (struct arm_section
*arm_sec
)
8439 if (arm_sec
->data
!= NULL
)
8440 free (arm_sec
->data
);
8442 if (arm_sec
->rela
!= NULL
)
8443 free (arm_sec
->rela
);
8446 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8447 cached section and install SEC instead.
8448 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8449 and return its valued in * WORDP, relocating if necessary.
8450 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8451 relocation's offset in ADDR.
8452 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8453 into the string table of the symbol associated with the reloc. If no
8454 reloc was applied store -1 there.
8455 5) Return TRUE upon success, FALSE otherwise. */
8458 get_unwind_section_word (Filedata
* filedata
,
8459 struct arm_unw_aux_info
* aux
,
8460 struct arm_section
* arm_sec
,
8461 Elf_Internal_Shdr
* sec
,
8462 bfd_vma word_offset
,
8463 unsigned int * wordp
,
8464 struct absaddr
* addr
,
8467 Elf_Internal_Rela
*rp
;
8468 Elf_Internal_Sym
*sym
;
8469 const char * relname
;
8471 bfd_boolean wrapped
;
8473 if (sec
== NULL
|| arm_sec
== NULL
)
8476 addr
->section
= SHN_UNDEF
;
8479 if (sym_name
!= NULL
)
8480 *sym_name
= (bfd_vma
) -1;
8482 /* If necessary, update the section cache. */
8483 if (sec
!= arm_sec
->sec
)
8485 Elf_Internal_Shdr
*relsec
;
8487 arm_free_section (arm_sec
);
8490 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8491 sec
->sh_size
, _("unwind data"));
8492 arm_sec
->rela
= NULL
;
8493 arm_sec
->nrelas
= 0;
8495 for (relsec
= filedata
->section_headers
;
8496 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8499 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8500 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8501 /* PR 15745: Check the section type as well. */
8502 || (relsec
->sh_type
!= SHT_REL
8503 && relsec
->sh_type
!= SHT_RELA
))
8506 arm_sec
->rel_type
= relsec
->sh_type
;
8507 if (relsec
->sh_type
== SHT_REL
)
8509 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8511 & arm_sec
->rela
, & arm_sec
->nrelas
))
8514 else /* relsec->sh_type == SHT_RELA */
8516 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8518 & arm_sec
->rela
, & arm_sec
->nrelas
))
8524 arm_sec
->next_rela
= arm_sec
->rela
;
8527 /* If there is no unwind data we can do nothing. */
8528 if (arm_sec
->data
== NULL
)
8531 /* If the offset is invalid then fail. */
8532 if (/* PR 21343 *//* PR 18879 */
8534 || word_offset
> (sec
->sh_size
- 4)
8535 || ((bfd_signed_vma
) word_offset
) < 0)
8538 /* Get the word at the required offset. */
8539 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8541 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8542 if (arm_sec
->rela
== NULL
)
8548 /* Look through the relocs to find the one that applies to the provided offset. */
8550 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8552 bfd_vma prelval
, offset
;
8554 if (rp
->r_offset
> word_offset
&& !wrapped
)
8559 if (rp
->r_offset
> word_offset
)
8562 if (rp
->r_offset
& 3)
8564 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8565 (unsigned long) rp
->r_offset
);
8569 if (rp
->r_offset
< word_offset
)
8572 /* PR 17531: file: 027-161405-0.004 */
8573 if (aux
->symtab
== NULL
)
8576 if (arm_sec
->rel_type
== SHT_REL
)
8578 offset
= word
& 0x7fffffff;
8579 if (offset
& 0x40000000)
8580 offset
|= ~ (bfd_vma
) 0x7fffffff;
8582 else if (arm_sec
->rel_type
== SHT_RELA
)
8583 offset
= rp
->r_addend
;
8586 error (_("Unknown section relocation type %d encountered\n"),
8591 /* PR 17531 file: 027-1241568-0.004. */
8592 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8594 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8595 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8599 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8600 offset
+= sym
->st_value
;
8601 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8603 /* Check that we are processing the expected reloc type. */
8604 if (filedata
->file_header
.e_machine
== EM_ARM
)
8606 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8607 if (relname
== NULL
)
8609 warn (_("Skipping unknown ARM relocation type: %d\n"),
8610 (int) ELF32_R_TYPE (rp
->r_info
));
8614 if (streq (relname
, "R_ARM_NONE"))
8617 if (! streq (relname
, "R_ARM_PREL31"))
8619 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8623 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8625 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8626 if (relname
== NULL
)
8628 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8629 (int) ELF32_R_TYPE (rp
->r_info
));
8633 if (streq (relname
, "R_C6000_NONE"))
8636 if (! streq (relname
, "R_C6000_PREL31"))
8638 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8646 /* This function currently only supports ARM and TI unwinders. */
8647 warn (_("Only TI and ARM unwinders are currently supported\n"));
8651 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8652 addr
->section
= sym
->st_shndx
;
8653 addr
->offset
= offset
;
8656 * sym_name
= sym
->st_name
;
8661 arm_sec
->next_rela
= rp
;
8666 static const char *tic6x_unwind_regnames
[16] =
8668 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8669 "A14", "A13", "A12", "A11", "A10",
8670 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8674 decode_tic6x_unwind_regmask (unsigned int mask
)
8678 for (i
= 12; mask
; mask
>>= 1, i
--)
8682 fputs (tic6x_unwind_regnames
[i
], stdout
);
8684 fputs (", ", stdout
);
8690 if (remaining == 0 && more_words) \
8693 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8694 data_offset, & word, & addr, NULL)) \
8700 #define GET_OP(OP) \
8705 (OP) = word >> 24; \
8710 printf (_("[Truncated opcode]\n")); \
8713 printf ("0x%02x ", OP)
8716 decode_arm_unwind_bytecode (Filedata
* filedata
,
8717 struct arm_unw_aux_info
* aux
,
8719 unsigned int remaining
,
8720 unsigned int more_words
,
8721 bfd_vma data_offset
,
8722 Elf_Internal_Shdr
* data_sec
,
8723 struct arm_section
* data_arm_sec
)
8725 struct absaddr addr
;
8726 bfd_boolean res
= TRUE
;
8728 /* Decode the unwinding instructions. */
8731 unsigned int op
, op2
;
8740 printf (" 0x%02x ", op
);
8742 if ((op
& 0xc0) == 0x00)
8744 int offset
= ((op
& 0x3f) << 2) + 4;
8746 printf (" vsp = vsp + %d", offset
);
8748 else if ((op
& 0xc0) == 0x40)
8750 int offset
= ((op
& 0x3f) << 2) + 4;
8752 printf (" vsp = vsp - %d", offset
);
8754 else if ((op
& 0xf0) == 0x80)
8757 if (op
== 0x80 && op2
== 0)
8758 printf (_("Refuse to unwind"));
8761 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8762 bfd_boolean first
= TRUE
;
8766 for (i
= 0; i
< 12; i
++)
8767 if (mask
& (1 << i
))
8773 printf ("r%d", 4 + i
);
8778 else if ((op
& 0xf0) == 0x90)
8780 if (op
== 0x9d || op
== 0x9f)
8781 printf (_(" [Reserved]"));
8783 printf (" vsp = r%d", op
& 0x0f);
8785 else if ((op
& 0xf0) == 0xa0)
8787 int end
= 4 + (op
& 0x07);
8788 bfd_boolean first
= TRUE
;
8792 for (i
= 4; i
<= end
; i
++)
8808 else if (op
== 0xb0)
8809 printf (_(" finish"));
8810 else if (op
== 0xb1)
8813 if (op2
== 0 || (op2
& 0xf0) != 0)
8814 printf (_("[Spare]"));
8817 unsigned int mask
= op2
& 0x0f;
8818 bfd_boolean first
= TRUE
;
8822 for (i
= 0; i
< 12; i
++)
8823 if (mask
& (1 << i
))
8834 else if (op
== 0xb2)
8836 unsigned char buf
[9];
8837 unsigned int i
, len
;
8838 unsigned long offset
;
8840 for (i
= 0; i
< sizeof (buf
); i
++)
8843 if ((buf
[i
] & 0x80) == 0)
8846 if (i
== sizeof (buf
))
8848 error (_("corrupt change to vsp\n"));
8853 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8854 assert (len
== i
+ 1);
8855 offset
= offset
* 4 + 0x204;
8856 printf ("vsp = vsp + %ld", offset
);
8859 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8861 unsigned int first
, last
;
8868 printf ("pop {D%d", first
);
8870 printf ("-D%d", first
+ last
);
8873 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8875 unsigned int count
= op
& 0x07;
8879 printf ("-D%d", 8 + count
);
8882 else if (op
>= 0xc0 && op
<= 0xc5)
8884 unsigned int count
= op
& 0x07;
8886 printf (" pop {wR10");
8888 printf ("-wR%d", 10 + count
);
8891 else if (op
== 0xc6)
8893 unsigned int first
, last
;
8898 printf ("pop {wR%d", first
);
8900 printf ("-wR%d", first
+ last
);
8903 else if (op
== 0xc7)
8906 if (op2
== 0 || (op2
& 0xf0) != 0)
8907 printf (_("[Spare]"));
8910 unsigned int mask
= op2
& 0x0f;
8911 bfd_boolean first
= TRUE
;
8915 for (i
= 0; i
< 4; i
++)
8916 if (mask
& (1 << i
))
8922 printf ("wCGR%d", i
);
8929 printf (_(" [unsupported opcode]"));
8940 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8941 struct arm_unw_aux_info
* aux
,
8943 unsigned int remaining
,
8944 unsigned int more_words
,
8945 bfd_vma data_offset
,
8946 Elf_Internal_Shdr
* data_sec
,
8947 struct arm_section
* data_arm_sec
)
8949 struct absaddr addr
;
8951 /* Decode the unwinding instructions. */
8954 unsigned int op
, op2
;
8963 printf (" 0x%02x ", op
);
8965 if ((op
& 0xc0) == 0x00)
8967 int offset
= ((op
& 0x3f) << 3) + 8;
8968 printf (" sp = sp + %d", offset
);
8970 else if ((op
& 0xc0) == 0x80)
8973 if (op
== 0x80 && op2
== 0)
8974 printf (_("Refuse to unwind"));
8977 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8979 printf ("pop compact {");
8983 decode_tic6x_unwind_regmask (mask
);
8987 else if ((op
& 0xf0) == 0xc0)
8995 unsigned int offset
;
8999 /* Scan entire instruction first so that GET_OP output is not
9000 interleaved with disassembly. */
9002 for (i
= 0; nregs
< (op
& 0xf); i
++)
9008 regpos
[nregs
].offset
= i
* 2;
9009 regpos
[nregs
].reg
= reg
;
9016 regpos
[nregs
].offset
= i
* 2 + 1;
9017 regpos
[nregs
].reg
= reg
;
9022 printf (_("pop frame {"));
9025 printf (_("*corrupt* - no registers specified"));
9030 for (i
= i
* 2; i
> 0; i
--)
9032 if (regpos
[reg
].offset
== i
- 1)
9034 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9041 fputs (name
, stdout
);
9049 else if (op
== 0xd0)
9050 printf (" MOV FP, SP");
9051 else if (op
== 0xd1)
9052 printf (" __c6xabi_pop_rts");
9053 else if (op
== 0xd2)
9055 unsigned char buf
[9];
9056 unsigned int i
, len
;
9057 unsigned long offset
;
9059 for (i
= 0; i
< sizeof (buf
); i
++)
9062 if ((buf
[i
] & 0x80) == 0)
9065 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9066 if (i
== sizeof (buf
))
9068 warn (_("Corrupt stack pointer adjustment detected\n"));
9072 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9073 assert (len
== i
+ 1);
9074 offset
= offset
* 8 + 0x408;
9075 printf (_("sp = sp + %ld"), offset
);
9077 else if ((op
& 0xf0) == 0xe0)
9079 if ((op
& 0x0f) == 7)
9082 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9086 printf (_(" [unsupported opcode]"));
9095 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9099 offset
= word
& 0x7fffffff;
9100 if (offset
& 0x40000000)
9101 offset
|= ~ (bfd_vma
) 0x7fffffff;
9103 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9106 return offset
+ where
;
9110 decode_arm_unwind (Filedata
* filedata
,
9111 struct arm_unw_aux_info
* aux
,
9113 unsigned int remaining
,
9114 bfd_vma data_offset
,
9115 Elf_Internal_Shdr
* data_sec
,
9116 struct arm_section
* data_arm_sec
)
9119 unsigned int more_words
= 0;
9120 struct absaddr addr
;
9121 bfd_vma sym_name
= (bfd_vma
) -1;
9122 bfd_boolean res
= TRUE
;
9126 /* Fetch the first word.
9127 Note - when decoding an object file the address extracted
9128 here will always be 0. So we also pass in the sym_name
9129 parameter so that we can find the symbol associated with
9130 the personality routine. */
9131 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9132 & word
, & addr
, & sym_name
))
9139 addr
.section
= SHN_UNDEF
;
9143 if ((word
& 0x80000000) == 0)
9145 /* Expand prel31 for personality routine. */
9147 const char *procname
;
9149 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9150 printf (_(" Personality routine: "));
9152 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9153 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9155 procname
= aux
->strtab
+ sym_name
;
9156 print_vma (fn
, PREFIX_HEX
);
9159 fputs (" <", stdout
);
9160 fputs (procname
, stdout
);
9161 fputc ('>', stdout
);
9165 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9166 fputc ('\n', stdout
);
9168 /* The GCC personality routines use the standard compact
9169 encoding, starting with one byte giving the number of
9171 if (procname
!= NULL
9172 && (const_strneq (procname
, "__gcc_personality_v0")
9173 || const_strneq (procname
, "__gxx_personality_v0")
9174 || const_strneq (procname
, "__gcj_personality_v0")
9175 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9182 printf (_(" [Truncated data]\n"));
9185 more_words
= word
>> 24;
9195 /* ARM EHABI Section 6.3:
9197 An exception-handling table entry for the compact model looks like:
9201 1 0 index Data for personalityRoutine[index] */
9203 if (filedata
->file_header
.e_machine
== EM_ARM
9204 && (word
& 0x70000000))
9206 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9210 per_index
= (word
>> 24) & 0x7f;
9211 printf (_(" Compact model index: %d\n"), per_index
);
9218 else if (per_index
< 3)
9220 more_words
= (word
>> 16) & 0xff;
9226 switch (filedata
->file_header
.e_machine
)
9231 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9232 data_offset
, data_sec
, data_arm_sec
))
9237 warn (_("Unknown ARM compact model index encountered\n"));
9238 printf (_(" [reserved]\n"));
9246 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9247 data_offset
, data_sec
, data_arm_sec
))
9250 else if (per_index
< 5)
9252 if (((word
>> 17) & 0x7f) == 0x7f)
9253 printf (_(" Restore stack from frame pointer\n"));
9255 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9256 printf (_(" Registers restored: "));
9258 printf (" (compact) ");
9259 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9261 printf (_(" Return register: %s\n"),
9262 tic6x_unwind_regnames
[word
& 0xf]);
9265 printf (_(" [reserved (%d)]\n"), per_index
);
9269 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9270 filedata
->file_header
.e_machine
);
9274 /* Decode the descriptors. Not implemented. */
9280 dump_arm_unwind (Filedata
* filedata
,
9281 struct arm_unw_aux_info
* aux
,
9282 Elf_Internal_Shdr
* exidx_sec
)
9284 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9285 unsigned int i
, exidx_len
;
9286 unsigned long j
, nfuns
;
9287 bfd_boolean res
= TRUE
;
9289 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9290 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9291 exidx_len
= exidx_sec
->sh_size
/ 8;
9293 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9294 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9295 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9296 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9298 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9300 for (i
= 0; i
< exidx_len
; i
++)
9302 unsigned int exidx_fn
, exidx_entry
;
9303 struct absaddr fn_addr
, entry_addr
;
9306 fputc ('\n', stdout
);
9308 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9309 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9310 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9311 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9314 arm_free_section (& exidx_arm_sec
);
9315 arm_free_section (& extab_arm_sec
);
9319 /* ARM EHABI, Section 5:
9320 An index table entry consists of 2 words.
9321 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9322 if (exidx_fn
& 0x80000000)
9324 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9328 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9330 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9331 fputs (": ", stdout
);
9333 if (exidx_entry
== 1)
9335 print_vma (exidx_entry
, PREFIX_HEX
);
9336 fputs (" [cantunwind]\n", stdout
);
9338 else if (exidx_entry
& 0x80000000)
9340 print_vma (exidx_entry
, PREFIX_HEX
);
9341 fputc ('\n', stdout
);
9342 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9346 bfd_vma table
, table_offset
= 0;
9347 Elf_Internal_Shdr
*table_sec
;
9349 fputs ("@", stdout
);
9350 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9351 print_vma (table
, PREFIX_HEX
);
9354 /* Locate the matching .ARM.extab. */
9355 if (entry_addr
.section
!= SHN_UNDEF
9356 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9358 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9359 table_offset
= entry_addr
.offset
;
9361 if (table_offset
> table_sec
->sh_size
9362 || ((bfd_signed_vma
) table_offset
) < 0)
9364 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9365 (unsigned long) table_offset
,
9366 printable_section_name (filedata
, table_sec
));
9373 table_sec
= find_section_by_address (filedata
, table
);
9374 if (table_sec
!= NULL
)
9375 table_offset
= table
- table_sec
->sh_addr
;
9378 if (table_sec
== NULL
)
9380 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9381 (unsigned long) table
);
9386 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9395 arm_free_section (&exidx_arm_sec
);
9396 arm_free_section (&extab_arm_sec
);
9401 /* Used for both ARM and C6X unwinding tables. */
9404 arm_process_unwind (Filedata
* filedata
)
9406 struct arm_unw_aux_info aux
;
9407 Elf_Internal_Shdr
*unwsec
= NULL
;
9408 Elf_Internal_Shdr
*sec
;
9410 unsigned int sec_type
;
9411 bfd_boolean res
= TRUE
;
9413 switch (filedata
->file_header
.e_machine
)
9416 sec_type
= SHT_ARM_EXIDX
;
9420 sec_type
= SHT_C6000_UNWIND
;
9424 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9425 filedata
->file_header
.e_machine
);
9429 if (filedata
->string_table
== NULL
)
9432 memset (& aux
, 0, sizeof (aux
));
9433 aux
.filedata
= filedata
;
9435 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9437 if (sec
->sh_type
== SHT_SYMTAB
)
9441 error (_("Multiple symbol tables encountered\n"));
9447 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9448 &aux
.strtab
, &aux
.strtab_size
))
9451 else if (sec
->sh_type
== sec_type
)
9456 printf (_("\nThere are no unwind sections in this file.\n"));
9458 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9460 if (sec
->sh_type
== sec_type
)
9462 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9463 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9464 "contains %lu entry:\n",
9465 "\nUnwind section '%s' at offset 0x%lx "
9466 "contains %lu entries:\n",
9468 printable_section_name (filedata
, sec
),
9469 (unsigned long) sec
->sh_offset
,
9472 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9480 free ((char *) aux
.strtab
);
9486 process_unwind (Filedata
* filedata
)
9488 struct unwind_handler
9490 unsigned int machtype
;
9491 bfd_boolean (* handler
)(Filedata
*);
9494 { EM_ARM
, arm_process_unwind
},
9495 { EM_IA_64
, ia64_process_unwind
},
9496 { EM_PARISC
, hppa_process_unwind
},
9497 { EM_TI_C6000
, arm_process_unwind
},
9505 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9506 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9507 return handlers
[i
].handler (filedata
);
9509 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9510 get_machine_name (filedata
->file_header
.e_machine
));
9515 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9517 switch (entry
->d_tag
)
9519 case DT_AARCH64_BTI_PLT
:
9520 case DT_AARCH64_PAC_PLT
:
9523 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9530 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9532 switch (entry
->d_tag
)
9535 if (entry
->d_un
.d_val
== 0)
9539 static const char * opts
[] =
9541 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9542 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9543 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9544 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9548 bfd_boolean first
= TRUE
;
9550 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9551 if (entry
->d_un
.d_val
& (1 << cnt
))
9553 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9559 case DT_MIPS_IVERSION
:
9560 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9561 printf (_("Interface Version: %s"),
9562 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9566 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9567 /* Note: coded this way so that there is a single string for translation. */
9568 printf (_("<corrupt: %s>"), buf
);
9572 case DT_MIPS_TIME_STAMP
:
9576 time_t atime
= entry
->d_un
.d_val
;
9578 tmp
= gmtime (&atime
);
9579 /* PR 17531: file: 6accc532. */
9581 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9583 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9584 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9585 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9586 printf (_("Time Stamp: %s"), timebuf
);
9590 case DT_MIPS_RLD_VERSION
:
9591 case DT_MIPS_LOCAL_GOTNO
:
9592 case DT_MIPS_CONFLICTNO
:
9593 case DT_MIPS_LIBLISTNO
:
9594 case DT_MIPS_SYMTABNO
:
9595 case DT_MIPS_UNREFEXTNO
:
9596 case DT_MIPS_HIPAGENO
:
9597 case DT_MIPS_DELTA_CLASS_NO
:
9598 case DT_MIPS_DELTA_INSTANCE_NO
:
9599 case DT_MIPS_DELTA_RELOC_NO
:
9600 case DT_MIPS_DELTA_SYM_NO
:
9601 case DT_MIPS_DELTA_CLASSSYM_NO
:
9602 case DT_MIPS_COMPACT_SIZE
:
9603 print_vma (entry
->d_un
.d_val
, DEC
);
9607 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9608 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9609 /* Falls through. */
9612 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9618 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9620 switch (entry
->d_tag
)
9622 case DT_HP_DLD_FLAGS
:
9631 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9632 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9633 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9634 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9635 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9636 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9637 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9638 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9639 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9640 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9641 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9642 { DT_HP_GST
, "HP_GST" },
9643 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9644 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9645 { DT_HP_NODELETE
, "HP_NODELETE" },
9646 { DT_HP_GROUP
, "HP_GROUP" },
9647 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9649 bfd_boolean first
= TRUE
;
9651 bfd_vma val
= entry
->d_un
.d_val
;
9653 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9654 if (val
& flags
[cnt
].bit
)
9658 fputs (flags
[cnt
].str
, stdout
);
9660 val
^= flags
[cnt
].bit
;
9663 if (val
!= 0 || first
)
9667 print_vma (val
, HEX
);
9673 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9681 /* VMS vs Unix time offset and factor. */
9683 #define VMS_EPOCH_OFFSET 35067168000000000LL
9684 #define VMS_GRANULARITY_FACTOR 10000000
9686 /* Display a VMS time in a human readable format. */
9689 print_vms_time (bfd_int64_t vmstime
)
9694 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9695 tm
= gmtime (&unxtime
);
9696 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9697 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9698 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9703 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9705 switch (entry
->d_tag
)
9707 case DT_IA_64_PLT_RESERVE
:
9708 /* First 3 slots reserved. */
9709 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9711 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9714 case DT_IA_64_VMS_LINKTIME
:
9716 print_vms_time (entry
->d_un
.d_val
);
9720 case DT_IA_64_VMS_LNKFLAGS
:
9721 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9722 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9723 printf (" CALL_DEBUG");
9724 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9725 printf (" NOP0BUFS");
9726 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9727 printf (" P0IMAGE");
9728 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9729 printf (" MKTHREADS");
9730 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9731 printf (" UPCALLS");
9732 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9734 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9735 printf (" INITIALIZE");
9736 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9738 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9739 printf (" EXE_INIT");
9740 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9741 printf (" TBK_IN_IMG");
9742 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9743 printf (" DBG_IN_IMG");
9744 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9745 printf (" TBK_IN_DSF");
9746 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9747 printf (" DBG_IN_DSF");
9748 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9749 printf (" SIGNATURES");
9750 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9751 printf (" REL_SEG_OFF");
9755 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9762 get_32bit_dynamic_section (Filedata
* filedata
)
9764 Elf32_External_Dyn
* edyn
;
9765 Elf32_External_Dyn
* ext
;
9766 Elf_Internal_Dyn
* entry
;
9768 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9769 filedata
->dynamic_addr
, 1,
9770 filedata
->dynamic_size
,
9771 _("dynamic section"));
9775 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9776 might not have the luxury of section headers. Look for the DT_NULL
9777 terminator to determine the number of entries. */
9778 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9779 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9782 filedata
->dynamic_nent
++;
9783 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9787 filedata
->dynamic_section
9788 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9789 if (filedata
->dynamic_section
== NULL
)
9791 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9792 (unsigned long) filedata
->dynamic_nent
);
9797 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9798 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9801 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9802 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9811 get_64bit_dynamic_section (Filedata
* filedata
)
9813 Elf64_External_Dyn
* edyn
;
9814 Elf64_External_Dyn
* ext
;
9815 Elf_Internal_Dyn
* entry
;
9817 /* Read in the data. */
9818 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
9819 filedata
->dynamic_addr
, 1,
9820 filedata
->dynamic_size
,
9821 _("dynamic section"));
9825 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9826 might not have the luxury of section headers. Look for the DT_NULL
9827 terminator to determine the number of entries. */
9828 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9829 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9830 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9833 filedata
->dynamic_nent
++;
9834 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9838 filedata
->dynamic_section
9839 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9840 if (filedata
->dynamic_section
== NULL
)
9842 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9843 (unsigned long) filedata
->dynamic_nent
);
9848 /* Convert from external to internal formats. */
9849 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
9850 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
9853 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9854 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9863 print_dynamic_flags (bfd_vma flags
)
9865 bfd_boolean first
= TRUE
;
9871 flag
= flags
& - flags
;
9881 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9882 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9883 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9884 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9885 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9886 default: fputs (_("unknown"), stdout
); break;
9893 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
9895 unsigned char * e_data
;
9898 /* If the size_t type is smaller than the bfd_size_type, eg because
9899 you are building a 32-bit tool on a 64-bit host, then make sure
9900 that when (number) is cast to (size_t) no information is lost. */
9901 if (sizeof (size_t) < sizeof (bfd_size_type
)
9902 && (bfd_size_type
) ((size_t) number
) != number
)
9904 error (_("Size truncation prevents reading %s elements of size %u\n"),
9905 bfd_vmatoa ("u", number
), ent_size
);
9909 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9910 attempting to allocate memory when the read is bound to fail. */
9911 if (ent_size
* number
> filedata
->file_size
)
9913 error (_("Invalid number of dynamic entries: %s\n"),
9914 bfd_vmatoa ("u", number
));
9918 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
9921 error (_("Out of memory reading %s dynamic entries\n"),
9922 bfd_vmatoa ("u", number
));
9926 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
9928 error (_("Unable to read in %s bytes of dynamic data\n"),
9929 bfd_vmatoa ("u", number
* ent_size
));
9934 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
9937 error (_("Out of memory allocating space for %s dynamic entries\n"),
9938 bfd_vmatoa ("u", number
));
9944 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9951 static unsigned long
9952 get_num_dynamic_syms (Filedata
* filedata
)
9954 unsigned long num_of_syms
= 0;
9956 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
9959 if (filedata
->dynamic_info
[DT_HASH
])
9961 unsigned char nb
[8];
9962 unsigned char nc
[8];
9963 unsigned int hash_ent_size
= 4;
9965 if ((filedata
->file_header
.e_machine
== EM_ALPHA
9966 || filedata
->file_header
.e_machine
== EM_S390
9967 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
9968 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9971 if (fseek (filedata
->handle
,
9972 (filedata
->archive_file_offset
9973 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
9974 sizeof nb
+ sizeof nc
)),
9977 error (_("Unable to seek to start of dynamic information\n"));
9981 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
9983 error (_("Failed to read in number of buckets\n"));
9987 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
9989 error (_("Failed to read in number of chains\n"));
9993 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
9994 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
9996 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
9998 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10001 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10002 num_of_syms
= filedata
->nchains
;
10005 if (num_of_syms
== 0)
10007 if (filedata
->buckets
)
10009 free (filedata
->buckets
);
10010 filedata
->buckets
= NULL
;
10012 if (filedata
->chains
)
10014 free (filedata
->chains
);
10015 filedata
->chains
= NULL
;
10017 filedata
->nbuckets
= 0;
10021 if (filedata
->dynamic_info_DT_GNU_HASH
)
10023 unsigned char nb
[16];
10024 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10025 bfd_vma buckets_vma
;
10027 bfd_boolean gnu_hash_error
= FALSE
;
10029 if (fseek (filedata
->handle
,
10030 (filedata
->archive_file_offset
10031 + offset_from_vma (filedata
,
10032 filedata
->dynamic_info_DT_GNU_HASH
,
10036 error (_("Unable to seek to start of dynamic information\n"));
10037 gnu_hash_error
= TRUE
;
10041 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10043 error (_("Failed to read in number of buckets\n"));
10044 gnu_hash_error
= TRUE
;
10048 filedata
->ngnubuckets
= byte_get (nb
, 4);
10049 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10050 bitmaskwords
= byte_get (nb
+ 8, 4);
10051 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10053 buckets_vma
+= bitmaskwords
* 4;
10055 buckets_vma
+= bitmaskwords
* 8;
10057 if (fseek (filedata
->handle
,
10058 (filedata
->archive_file_offset
10059 + offset_from_vma (filedata
, buckets_vma
, 4)),
10062 error (_("Unable to seek to start of dynamic information\n"));
10063 gnu_hash_error
= TRUE
;
10067 filedata
->gnubuckets
10068 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10070 if (filedata
->gnubuckets
== NULL
)
10072 gnu_hash_error
= TRUE
;
10076 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10077 if (filedata
->gnubuckets
[i
] != 0)
10079 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10081 gnu_hash_error
= TRUE
;
10085 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10086 maxchain
= filedata
->gnubuckets
[i
];
10089 if (maxchain
== 0xffffffff)
10091 gnu_hash_error
= TRUE
;
10095 maxchain
-= filedata
->gnusymidx
;
10097 if (fseek (filedata
->handle
,
10098 (filedata
->archive_file_offset
10099 + offset_from_vma (filedata
,
10100 buckets_vma
+ 4 * (filedata
->ngnubuckets
10105 error (_("Unable to seek to start of dynamic information\n"));
10106 gnu_hash_error
= TRUE
;
10112 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10114 error (_("Failed to determine last chain length\n"));
10115 gnu_hash_error
= TRUE
;
10119 if (maxchain
+ 1 == 0)
10121 gnu_hash_error
= TRUE
;
10127 while ((byte_get (nb
, 4) & 1) == 0);
10129 if (fseek (filedata
->handle
,
10130 (filedata
->archive_file_offset
10131 + offset_from_vma (filedata
, (buckets_vma
10132 + 4 * filedata
->ngnubuckets
),
10136 error (_("Unable to seek to start of dynamic information\n"));
10137 gnu_hash_error
= TRUE
;
10141 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10142 filedata
->ngnuchains
= maxchain
;
10144 if (filedata
->gnuchains
== NULL
)
10146 gnu_hash_error
= TRUE
;
10150 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10152 if (fseek (filedata
->handle
,
10153 (filedata
->archive_file_offset
10154 + offset_from_vma (filedata
, (buckets_vma
10155 + 4 * (filedata
->ngnubuckets
10159 error (_("Unable to seek to start of dynamic information\n"));
10160 gnu_hash_error
= TRUE
;
10164 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10167 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10168 if (filedata
->gnubuckets
[hn
] != 0)
10170 bfd_vma si
= filedata
->gnubuckets
[hn
];
10171 bfd_vma off
= si
- filedata
->gnusymidx
;
10175 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10177 if (filedata
->mipsxlat
[off
] >= num_of_syms
)
10178 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10182 if (si
>= num_of_syms
)
10183 num_of_syms
= si
+ 1;
10187 while (off
< filedata
->ngnuchains
10188 && (filedata
->gnuchains
[off
++] & 1) == 0);
10192 if (gnu_hash_error
)
10194 if (filedata
->mipsxlat
)
10196 free (filedata
->mipsxlat
);
10197 filedata
->mipsxlat
= NULL
;
10199 if (filedata
->gnuchains
)
10201 free (filedata
->gnuchains
);
10202 filedata
->gnuchains
= NULL
;
10204 if (filedata
->gnubuckets
)
10206 free (filedata
->gnubuckets
);
10207 filedata
->gnubuckets
= NULL
;
10209 filedata
->ngnubuckets
= 0;
10210 filedata
->ngnuchains
= 0;
10214 return num_of_syms
;
10217 /* Parse and display the contents of the dynamic section. */
10220 process_dynamic_section (Filedata
* filedata
)
10222 Elf_Internal_Dyn
* entry
;
10224 if (filedata
->dynamic_size
== 0)
10227 printf (_("\nThere is no dynamic section in this file.\n"));
10234 if (! get_32bit_dynamic_section (filedata
))
10239 if (! get_64bit_dynamic_section (filedata
))
10243 /* Find the appropriate symbol table. */
10244 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10246 for (entry
= filedata
->dynamic_section
;
10247 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10249 if (entry
->d_tag
== DT_SYMTAB
)
10250 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10251 else if (entry
->d_tag
== DT_SYMENT
)
10252 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10253 else if (entry
->d_tag
== DT_HASH
)
10254 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10255 else if (entry
->d_tag
== DT_GNU_HASH
)
10256 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10257 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10258 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10259 && entry
->d_tag
== DT_MIPS_XHASH
)
10261 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10262 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10265 if (filedata
->dynamic_info
[DT_SYMTAB
]
10266 && filedata
->dynamic_info
[DT_SYMENT
])
10268 Elf_Internal_Phdr
*seg
;
10269 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10271 if (! get_program_headers (filedata
))
10273 error (_("Cannot interpret virtual addresses without program headers.\n"));
10277 for (seg
= filedata
->program_headers
;
10278 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10281 unsigned long num_of_syms
;
10283 if (seg
->p_type
!= PT_LOAD
)
10286 if ((seg
->p_offset
+ seg
->p_filesz
)
10287 > filedata
->file_size
)
10289 /* See PR 21379 for a reproducer. */
10290 error (_("Invalid PT_LOAD entry\n"));
10294 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10295 && vma
<= seg
->p_vaddr
+ seg
->p_filesz
10296 && (num_of_syms
= get_num_dynamic_syms (filedata
)) != 0
10297 && filedata
->dynamic_symbols
== NULL
)
10299 /* Since we do not know how big the symbol table is,
10300 we default to reading in up to the end of PT_LOAD
10301 segment and processing that. This is overkill, I
10302 know, but it should work. */
10303 Elf_Internal_Shdr section
;
10304 section
.sh_offset
= (vma
- seg
->p_vaddr
10306 section
.sh_size
= (num_of_syms
10307 * filedata
->dynamic_info
[DT_SYMENT
]);
10308 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10309 section
.sh_name
= filedata
->string_table_length
;
10310 filedata
->dynamic_symbols
10311 = GET_ELF_SYMBOLS (filedata
, §ion
,
10312 &filedata
->num_dynamic_syms
);
10313 if (filedata
->dynamic_symbols
== NULL
10314 || filedata
->num_dynamic_syms
!= num_of_syms
)
10316 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10324 /* Similarly find a string table. */
10325 if (filedata
->dynamic_strings
== NULL
)
10326 for (entry
= filedata
->dynamic_section
;
10327 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10330 if (entry
->d_tag
== DT_STRTAB
)
10331 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10333 if (entry
->d_tag
== DT_STRSZ
)
10334 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10336 if (filedata
->dynamic_info
[DT_STRTAB
]
10337 && filedata
->dynamic_info
[DT_STRSZ
])
10339 unsigned long offset
;
10340 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10342 offset
= offset_from_vma (filedata
,
10343 filedata
->dynamic_info
[DT_STRTAB
],
10345 filedata
->dynamic_strings
10346 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10347 _("dynamic string table"));
10348 if (filedata
->dynamic_strings
== NULL
)
10350 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10354 filedata
->dynamic_strings_length
= str_tab_len
;
10359 /* And find the syminfo section if available. */
10360 if (filedata
->dynamic_syminfo
== NULL
)
10362 unsigned long syminsz
= 0;
10364 for (entry
= filedata
->dynamic_section
;
10365 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10368 if (entry
->d_tag
== DT_SYMINENT
)
10370 /* Note: these braces are necessary to avoid a syntax
10371 error from the SunOS4 C compiler. */
10372 /* PR binutils/17531: A corrupt file can trigger this test.
10373 So do not use an assert, instead generate an error message. */
10374 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10375 error (_("Bad value (%d) for SYMINENT entry\n"),
10376 (int) entry
->d_un
.d_val
);
10378 else if (entry
->d_tag
== DT_SYMINSZ
)
10379 syminsz
= entry
->d_un
.d_val
;
10380 else if (entry
->d_tag
== DT_SYMINFO
)
10381 filedata
->dynamic_syminfo_offset
10382 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10385 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10387 Elf_External_Syminfo
* extsyminfo
;
10388 Elf_External_Syminfo
* extsym
;
10389 Elf_Internal_Syminfo
* syminfo
;
10391 /* There is a syminfo section. Read the data. */
10392 extsyminfo
= (Elf_External_Syminfo
*)
10393 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10394 1, syminsz
, _("symbol information"));
10398 if (filedata
->dynamic_syminfo
!= NULL
)
10400 error (_("Multiple dynamic symbol information sections found\n"));
10401 free (filedata
->dynamic_syminfo
);
10403 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10404 if (filedata
->dynamic_syminfo
== NULL
)
10406 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10407 (unsigned long) syminsz
);
10411 filedata
->dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10412 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10413 syminfo
< filedata
->dynamic_syminfo
+ filedata
->dynamic_syminfo_nent
;
10414 ++syminfo
, ++extsym
)
10416 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10417 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10424 if (do_dynamic
&& filedata
->dynamic_addr
)
10425 printf (ngettext ("\nDynamic section at offset 0x%lx "
10426 "contains %lu entry:\n",
10427 "\nDynamic section at offset 0x%lx "
10428 "contains %lu entries:\n",
10429 filedata
->dynamic_nent
),
10430 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10432 printf (_(" Tag Type Name/Value\n"));
10434 for (entry
= filedata
->dynamic_section
;
10435 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10440 const char * dtype
;
10443 print_vma (entry
->d_tag
, FULL_HEX
);
10444 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10445 printf (" (%s)%*s", dtype
,
10446 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10449 switch (entry
->d_tag
)
10453 print_dynamic_flags (entry
->d_un
.d_val
);
10463 switch (entry
->d_tag
)
10466 printf (_("Auxiliary library"));
10470 printf (_("Filter library"));
10474 printf (_("Configuration file"));
10478 printf (_("Dependency audit library"));
10482 printf (_("Audit library"));
10486 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10487 printf (": [%s]\n",
10488 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10492 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10501 printf (_("Flags:"));
10503 if (entry
->d_un
.d_val
== 0)
10504 printf (_(" None\n"));
10507 unsigned long int val
= entry
->d_un
.d_val
;
10509 if (val
& DTF_1_PARINIT
)
10511 printf (" PARINIT");
10512 val
^= DTF_1_PARINIT
;
10514 if (val
& DTF_1_CONFEXP
)
10516 printf (" CONFEXP");
10517 val
^= DTF_1_CONFEXP
;
10520 printf (" %lx", val
);
10529 printf (_("Flags:"));
10531 if (entry
->d_un
.d_val
== 0)
10532 printf (_(" None\n"));
10535 unsigned long int val
= entry
->d_un
.d_val
;
10537 if (val
& DF_P1_LAZYLOAD
)
10539 printf (" LAZYLOAD");
10540 val
^= DF_P1_LAZYLOAD
;
10542 if (val
& DF_P1_GROUPPERM
)
10544 printf (" GROUPPERM");
10545 val
^= DF_P1_GROUPPERM
;
10548 printf (" %lx", val
);
10557 printf (_("Flags:"));
10558 if (entry
->d_un
.d_val
== 0)
10559 printf (_(" None\n"));
10562 unsigned long int val
= entry
->d_un
.d_val
;
10564 if (val
& DF_1_NOW
)
10569 if (val
& DF_1_GLOBAL
)
10571 printf (" GLOBAL");
10572 val
^= DF_1_GLOBAL
;
10574 if (val
& DF_1_GROUP
)
10579 if (val
& DF_1_NODELETE
)
10581 printf (" NODELETE");
10582 val
^= DF_1_NODELETE
;
10584 if (val
& DF_1_LOADFLTR
)
10586 printf (" LOADFLTR");
10587 val
^= DF_1_LOADFLTR
;
10589 if (val
& DF_1_INITFIRST
)
10591 printf (" INITFIRST");
10592 val
^= DF_1_INITFIRST
;
10594 if (val
& DF_1_NOOPEN
)
10596 printf (" NOOPEN");
10597 val
^= DF_1_NOOPEN
;
10599 if (val
& DF_1_ORIGIN
)
10601 printf (" ORIGIN");
10602 val
^= DF_1_ORIGIN
;
10604 if (val
& DF_1_DIRECT
)
10606 printf (" DIRECT");
10607 val
^= DF_1_DIRECT
;
10609 if (val
& DF_1_TRANS
)
10614 if (val
& DF_1_INTERPOSE
)
10616 printf (" INTERPOSE");
10617 val
^= DF_1_INTERPOSE
;
10619 if (val
& DF_1_NODEFLIB
)
10621 printf (" NODEFLIB");
10622 val
^= DF_1_NODEFLIB
;
10624 if (val
& DF_1_NODUMP
)
10626 printf (" NODUMP");
10627 val
^= DF_1_NODUMP
;
10629 if (val
& DF_1_CONFALT
)
10631 printf (" CONFALT");
10632 val
^= DF_1_CONFALT
;
10634 if (val
& DF_1_ENDFILTEE
)
10636 printf (" ENDFILTEE");
10637 val
^= DF_1_ENDFILTEE
;
10639 if (val
& DF_1_DISPRELDNE
)
10641 printf (" DISPRELDNE");
10642 val
^= DF_1_DISPRELDNE
;
10644 if (val
& DF_1_DISPRELPND
)
10646 printf (" DISPRELPND");
10647 val
^= DF_1_DISPRELPND
;
10649 if (val
& DF_1_NODIRECT
)
10651 printf (" NODIRECT");
10652 val
^= DF_1_NODIRECT
;
10654 if (val
& DF_1_IGNMULDEF
)
10656 printf (" IGNMULDEF");
10657 val
^= DF_1_IGNMULDEF
;
10659 if (val
& DF_1_NOKSYMS
)
10661 printf (" NOKSYMS");
10662 val
^= DF_1_NOKSYMS
;
10664 if (val
& DF_1_NOHDR
)
10669 if (val
& DF_1_EDITED
)
10671 printf (" EDITED");
10672 val
^= DF_1_EDITED
;
10674 if (val
& DF_1_NORELOC
)
10676 printf (" NORELOC");
10677 val
^= DF_1_NORELOC
;
10679 if (val
& DF_1_SYMINTPOSE
)
10681 printf (" SYMINTPOSE");
10682 val
^= DF_1_SYMINTPOSE
;
10684 if (val
& DF_1_GLOBAUDIT
)
10686 printf (" GLOBAUDIT");
10687 val
^= DF_1_GLOBAUDIT
;
10689 if (val
& DF_1_SINGLETON
)
10691 printf (" SINGLETON");
10692 val
^= DF_1_SINGLETON
;
10694 if (val
& DF_1_STUB
)
10699 if (val
& DF_1_PIE
)
10704 if (val
& DF_1_KMOD
)
10709 if (val
& DF_1_WEAKFILTER
)
10711 printf (" WEAKFILTER");
10712 val
^= DF_1_WEAKFILTER
;
10714 if (val
& DF_1_NOCOMMON
)
10716 printf (" NOCOMMON");
10717 val
^= DF_1_NOCOMMON
;
10720 printf (" %lx", val
);
10727 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10729 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10749 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10755 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10756 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10762 switch (entry
->d_tag
)
10765 printf (_("Shared library: [%s]"), name
);
10767 if (streq (name
, filedata
->program_interpreter
))
10768 printf (_(" program interpreter"));
10772 printf (_("Library soname: [%s]"), name
);
10776 printf (_("Library rpath: [%s]"), name
);
10780 printf (_("Library runpath: [%s]"), name
);
10784 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10789 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10802 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10803 /* Fall through. */
10807 case DT_INIT_ARRAYSZ
:
10808 case DT_FINI_ARRAYSZ
:
10809 case DT_GNU_CONFLICTSZ
:
10810 case DT_GNU_LIBLISTSZ
:
10813 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10814 printf (_(" (bytes)\n"));
10819 case DT_VERNEEDNUM
:
10824 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10833 case DT_INIT_ARRAY
:
10834 case DT_FINI_ARRAY
:
10837 if (entry
->d_tag
== DT_USED
10838 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10840 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10844 printf (_("Not needed object: [%s]\n"), name
);
10849 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10855 /* The value of this entry is ignored. */
10860 case DT_GNU_PRELINKED
:
10864 time_t atime
= entry
->d_un
.d_val
;
10866 tmp
= gmtime (&atime
);
10867 /* PR 17533 file: 041-1244816-0.004. */
10869 printf (_("<corrupt time val: %lx"),
10870 (unsigned long) atime
);
10872 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10873 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10874 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10880 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10883 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10889 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10890 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10891 = entry
->d_un
.d_val
;
10895 switch (filedata
->file_header
.e_machine
)
10898 dynamic_section_aarch64_val (entry
);
10901 case EM_MIPS_RS3_LE
:
10902 dynamic_section_mips_val (filedata
, entry
);
10905 dynamic_section_parisc_val (entry
);
10908 dynamic_section_ia64_val (entry
);
10911 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10923 get_ver_flags (unsigned int flags
)
10925 static char buff
[128];
10932 if (flags
& VER_FLG_BASE
)
10933 strcat (buff
, "BASE");
10935 if (flags
& VER_FLG_WEAK
)
10937 if (flags
& VER_FLG_BASE
)
10938 strcat (buff
, " | ");
10940 strcat (buff
, "WEAK");
10943 if (flags
& VER_FLG_INFO
)
10945 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10946 strcat (buff
, " | ");
10948 strcat (buff
, "INFO");
10951 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10953 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10954 strcat (buff
, " | ");
10956 strcat (buff
, _("<unknown>"));
10962 /* Display the contents of the version sections. */
10965 process_version_sections (Filedata
* filedata
)
10967 Elf_Internal_Shdr
* section
;
10969 bfd_boolean found
= FALSE
;
10974 for (i
= 0, section
= filedata
->section_headers
;
10975 i
< filedata
->file_header
.e_shnum
;
10978 switch (section
->sh_type
)
10980 case SHT_GNU_verdef
:
10982 Elf_External_Verdef
* edefs
;
10989 printf (ngettext ("\nVersion definition section '%s' "
10990 "contains %u entry:\n",
10991 "\nVersion definition section '%s' "
10992 "contains %u entries:\n",
10994 printable_section_name (filedata
, section
),
10997 printf (_(" Addr: 0x"));
10998 printf_vma (section
->sh_addr
);
10999 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11000 (unsigned long) section
->sh_offset
, section
->sh_link
,
11001 printable_section_name_from_index (filedata
, section
->sh_link
));
11003 edefs
= (Elf_External_Verdef
*)
11004 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11005 _("version definition section"));
11008 endbuf
= (char *) edefs
+ section
->sh_size
;
11010 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11013 Elf_External_Verdef
* edef
;
11014 Elf_Internal_Verdef ent
;
11015 Elf_External_Verdaux
* eaux
;
11016 Elf_Internal_Verdaux aux
;
11017 unsigned long isum
;
11020 vstart
= ((char *) edefs
) + idx
;
11021 if (vstart
+ sizeof (*edef
) > endbuf
)
11024 edef
= (Elf_External_Verdef
*) vstart
;
11026 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11027 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11028 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11029 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11030 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11031 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11032 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11034 printf (_(" %#06lx: Rev: %d Flags: %s"),
11035 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11037 printf (_(" Index: %d Cnt: %d "),
11038 ent
.vd_ndx
, ent
.vd_cnt
);
11040 /* Check for overflow. */
11041 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11044 vstart
+= ent
.vd_aux
;
11046 if (vstart
+ sizeof (*eaux
) > endbuf
)
11048 eaux
= (Elf_External_Verdaux
*) vstart
;
11050 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11051 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11053 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11054 printf (_("Name: %s\n"),
11055 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11057 printf (_("Name index: %ld\n"), aux
.vda_name
);
11059 isum
= idx
+ ent
.vd_aux
;
11061 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11063 if (aux
.vda_next
< sizeof (*eaux
)
11064 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11066 warn (_("Invalid vda_next field of %lx\n"),
11071 /* Check for overflow. */
11072 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11075 isum
+= aux
.vda_next
;
11076 vstart
+= aux
.vda_next
;
11078 if (vstart
+ sizeof (*eaux
) > endbuf
)
11080 eaux
= (Elf_External_Verdaux
*) vstart
;
11082 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11083 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11085 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11086 printf (_(" %#06lx: Parent %d: %s\n"),
11088 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11090 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11091 isum
, j
, aux
.vda_name
);
11094 if (j
< ent
.vd_cnt
)
11095 printf (_(" Version def aux past end of section\n"));
11098 file: id:000001,src:000172+005151,op:splice,rep:2. */
11099 if (ent
.vd_next
< sizeof (*edef
)
11100 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11102 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11103 cnt
= section
->sh_info
;
11106 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11109 idx
+= ent
.vd_next
;
11112 if (cnt
< section
->sh_info
)
11113 printf (_(" Version definition past end of section\n"));
11119 case SHT_GNU_verneed
:
11121 Elf_External_Verneed
* eneed
;
11128 printf (ngettext ("\nVersion needs section '%s' "
11129 "contains %u entry:\n",
11130 "\nVersion needs section '%s' "
11131 "contains %u entries:\n",
11133 printable_section_name (filedata
, section
), section
->sh_info
);
11135 printf (_(" Addr: 0x"));
11136 printf_vma (section
->sh_addr
);
11137 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11138 (unsigned long) section
->sh_offset
, section
->sh_link
,
11139 printable_section_name_from_index (filedata
, section
->sh_link
));
11141 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11142 section
->sh_offset
, 1,
11144 _("Version Needs section"));
11147 endbuf
= (char *) eneed
+ section
->sh_size
;
11149 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11151 Elf_External_Verneed
* entry
;
11152 Elf_Internal_Verneed ent
;
11153 unsigned long isum
;
11157 vstart
= ((char *) eneed
) + idx
;
11158 if (vstart
+ sizeof (*entry
) > endbuf
)
11161 entry
= (Elf_External_Verneed
*) vstart
;
11163 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11164 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11165 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11166 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11167 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11169 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11171 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11172 printf (_(" File: %s"),
11173 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11175 printf (_(" File: %lx"), ent
.vn_file
);
11177 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11179 /* Check for overflow. */
11180 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11182 vstart
+= ent
.vn_aux
;
11184 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11186 Elf_External_Vernaux
* eaux
;
11187 Elf_Internal_Vernaux aux
;
11189 if (vstart
+ sizeof (*eaux
) > endbuf
)
11191 eaux
= (Elf_External_Vernaux
*) vstart
;
11193 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11194 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11195 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11196 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11197 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11199 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11200 printf (_(" %#06lx: Name: %s"),
11201 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11203 printf (_(" %#06lx: Name index: %lx"),
11204 isum
, aux
.vna_name
);
11206 printf (_(" Flags: %s Version: %d\n"),
11207 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11209 if (aux
.vna_next
< sizeof (*eaux
)
11210 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11212 warn (_("Invalid vna_next field of %lx\n"),
11217 /* Check for overflow. */
11218 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11220 isum
+= aux
.vna_next
;
11221 vstart
+= aux
.vna_next
;
11224 if (j
< ent
.vn_cnt
)
11225 warn (_("Missing Version Needs auxillary information\n"));
11227 if (ent
.vn_next
< sizeof (*entry
)
11228 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11230 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11231 cnt
= section
->sh_info
;
11234 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11236 idx
+= ent
.vn_next
;
11239 if (cnt
< section
->sh_info
)
11240 warn (_("Missing Version Needs information\n"));
11246 case SHT_GNU_versym
:
11248 Elf_Internal_Shdr
* link_section
;
11251 unsigned char * edata
;
11252 unsigned short * data
;
11254 Elf_Internal_Sym
* symbols
;
11255 Elf_Internal_Shdr
* string_sec
;
11256 unsigned long num_syms
;
11259 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11262 link_section
= filedata
->section_headers
+ section
->sh_link
;
11263 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11265 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11270 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11271 if (symbols
== NULL
)
11274 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11276 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11277 string_sec
->sh_size
,
11278 _("version string table"));
11285 printf (ngettext ("\nVersion symbols section '%s' "
11286 "contains %lu entry:\n",
11287 "\nVersion symbols section '%s' "
11288 "contains %lu entries:\n",
11290 printable_section_name (filedata
, section
), (unsigned long) total
);
11292 printf (_(" Addr: 0x"));
11293 printf_vma (section
->sh_addr
);
11294 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11295 (unsigned long) section
->sh_offset
, section
->sh_link
,
11296 printable_section_name (filedata
, link_section
));
11298 off
= offset_from_vma (filedata
,
11299 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11300 total
* sizeof (short));
11301 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11302 sizeof (short), total
,
11303 _("version symbol data"));
11311 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11313 for (cnt
= total
; cnt
--;)
11314 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11319 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11323 char *invalid
= _("*invalid*");
11325 printf (" %03x:", cnt
);
11327 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11328 switch (data
[cnt
+ j
])
11331 fputs (_(" 0 (*local*) "), stdout
);
11335 fputs (_(" 1 (*global*) "), stdout
);
11339 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11340 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11342 /* If this index value is greater than the size of the symbols
11343 array, break to avoid an out-of-bounds read. */
11344 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11346 warn (_("invalid index into symbol array\n"));
11351 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11353 Elf_Internal_Verneed ivn
;
11354 unsigned long offset
;
11356 offset
= offset_from_vma
11358 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11359 sizeof (Elf_External_Verneed
));
11363 Elf_Internal_Vernaux ivna
;
11364 Elf_External_Verneed evn
;
11365 Elf_External_Vernaux evna
;
11366 unsigned long a_off
;
11368 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11369 _("version need")) == NULL
)
11372 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11373 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11375 a_off
= offset
+ ivn
.vn_aux
;
11379 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11380 1, _("version need aux (2)")) == NULL
)
11383 ivna
.vna_other
= 0;
11387 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11388 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11391 a_off
+= ivna
.vna_next
;
11393 while (ivna
.vna_other
!= data
[cnt
+ j
]
11394 && ivna
.vna_next
!= 0);
11396 if (ivna
.vna_other
== data
[cnt
+ j
])
11398 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11400 if (ivna
.vna_name
>= string_sec
->sh_size
)
11403 name
= strtab
+ ivna
.vna_name
;
11407 offset
+= ivn
.vn_next
;
11409 while (ivn
.vn_next
);
11412 if (data
[cnt
+ j
] != 0x8001
11413 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11415 Elf_Internal_Verdef ivd
;
11416 Elf_External_Verdef evd
;
11417 unsigned long offset
;
11419 offset
= offset_from_vma
11421 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11426 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11427 _("version def")) == NULL
)
11430 /* PR 17531: file: 046-1082287-0.004. */
11431 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11436 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11437 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11440 offset
+= ivd
.vd_next
;
11442 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11443 && ivd
.vd_next
!= 0);
11445 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11447 Elf_External_Verdaux evda
;
11448 Elf_Internal_Verdaux ivda
;
11450 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11452 if (get_data (&evda
, filedata
,
11453 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11455 _("version def aux")) == NULL
)
11458 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11460 if (ivda
.vda_name
>= string_sec
->sh_size
)
11462 else if (name
!= NULL
&& name
!= invalid
)
11463 name
= _("*both*");
11465 name
= strtab
+ ivda
.vda_name
;
11469 nn
+= printf ("(%s%-*s",
11471 12 - (int) strlen (name
),
11475 printf ("%*c", 18 - nn
, ' ');
11493 printf (_("\nNo version information found in this file.\n"));
11498 static const char *
11499 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11501 static char buff
[64];
11505 case STB_LOCAL
: return "LOCAL";
11506 case STB_GLOBAL
: return "GLOBAL";
11507 case STB_WEAK
: return "WEAK";
11509 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11510 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11512 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11514 if (binding
== STB_GNU_UNIQUE
11515 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11517 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11520 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11525 static const char *
11526 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11528 static char buff
[64];
11532 case STT_NOTYPE
: return "NOTYPE";
11533 case STT_OBJECT
: return "OBJECT";
11534 case STT_FUNC
: return "FUNC";
11535 case STT_SECTION
: return "SECTION";
11536 case STT_FILE
: return "FILE";
11537 case STT_COMMON
: return "COMMON";
11538 case STT_TLS
: return "TLS";
11539 case STT_RELC
: return "RELC";
11540 case STT_SRELC
: return "SRELC";
11542 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11544 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11545 return "THUMB_FUNC";
11547 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11550 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11551 return "PARISC_MILLI";
11553 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11555 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11557 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11559 if (type
== STT_HP_OPAQUE
)
11560 return "HP_OPAQUE";
11561 if (type
== STT_HP_STUB
)
11565 if (type
== STT_GNU_IFUNC
11566 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11567 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11570 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11573 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11578 static const char *
11579 get_symbol_visibility (unsigned int visibility
)
11581 switch (visibility
)
11583 case STV_DEFAULT
: return "DEFAULT";
11584 case STV_INTERNAL
: return "INTERNAL";
11585 case STV_HIDDEN
: return "HIDDEN";
11586 case STV_PROTECTED
: return "PROTECTED";
11588 error (_("Unrecognized visibility value: %u\n"), visibility
);
11589 return _("<unknown>");
11593 static const char *
11594 get_alpha_symbol_other (unsigned int other
)
11598 case STO_ALPHA_NOPV
: return "NOPV";
11599 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11601 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11602 return _("<unknown>");
11606 static const char *
11607 get_solaris_symbol_visibility (unsigned int visibility
)
11609 switch (visibility
)
11611 case 4: return "EXPORTED";
11612 case 5: return "SINGLETON";
11613 case 6: return "ELIMINATE";
11614 default: return get_symbol_visibility (visibility
);
11618 static const char *
11619 get_aarch64_symbol_other (unsigned int other
)
11621 static char buf
[32];
11623 if (other
& STO_AARCH64_VARIANT_PCS
)
11625 other
&= ~STO_AARCH64_VARIANT_PCS
;
11627 return "VARIANT_PCS";
11628 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11634 static const char *
11635 get_mips_symbol_other (unsigned int other
)
11639 case STO_OPTIONAL
: return "OPTIONAL";
11640 case STO_MIPS_PLT
: return "MIPS PLT";
11641 case STO_MIPS_PIC
: return "MIPS PIC";
11642 case STO_MICROMIPS
: return "MICROMIPS";
11643 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11644 case STO_MIPS16
: return "MIPS16";
11645 default: return NULL
;
11649 static const char *
11650 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11652 if (is_ia64_vms (filedata
))
11654 static char res
[32];
11658 /* Function types is for images and .STB files only. */
11659 switch (filedata
->file_header
.e_type
)
11663 switch (VMS_ST_FUNC_TYPE (other
))
11665 case VMS_SFT_CODE_ADDR
:
11666 strcat (res
, " CA");
11668 case VMS_SFT_SYMV_IDX
:
11669 strcat (res
, " VEC");
11672 strcat (res
, " FD");
11674 case VMS_SFT_RESERVE
:
11675 strcat (res
, " RSV");
11678 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11679 VMS_ST_FUNC_TYPE (other
));
11680 strcat (res
, " <unknown>");
11687 switch (VMS_ST_LINKAGE (other
))
11689 case VMS_STL_IGNORE
:
11690 strcat (res
, " IGN");
11692 case VMS_STL_RESERVE
:
11693 strcat (res
, " RSV");
11696 strcat (res
, " STD");
11699 strcat (res
, " LNK");
11702 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11703 VMS_ST_LINKAGE (other
));
11704 strcat (res
, " <unknown>");
11716 static const char *
11717 get_ppc64_symbol_other (unsigned int other
)
11719 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11722 other
>>= STO_PPC64_LOCAL_BIT
;
11725 static char buf
[64];
11727 other
= ppc64_decode_local_entry (other
);
11728 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11734 static const char *
11735 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11737 const char * result
= NULL
;
11738 static char buff
[64];
11743 switch (filedata
->file_header
.e_machine
)
11746 result
= get_alpha_symbol_other (other
);
11749 result
= get_aarch64_symbol_other (other
);
11752 result
= get_mips_symbol_other (other
);
11755 result
= get_ia64_symbol_other (filedata
, other
);
11758 result
= get_ppc64_symbol_other (other
);
11768 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11772 static const char *
11773 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11775 static char buff
[32];
11779 case SHN_UNDEF
: return "UND";
11780 case SHN_ABS
: return "ABS";
11781 case SHN_COMMON
: return "COM";
11783 if (type
== SHN_IA_64_ANSI_COMMON
11784 && filedata
->file_header
.e_machine
== EM_IA_64
11785 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11787 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11788 || filedata
->file_header
.e_machine
== EM_L1OM
11789 || filedata
->file_header
.e_machine
== EM_K1OM
)
11790 && type
== SHN_X86_64_LCOMMON
)
11791 return "LARGE_COM";
11792 else if ((type
== SHN_MIPS_SCOMMON
11793 && filedata
->file_header
.e_machine
== EM_MIPS
)
11794 || (type
== SHN_TIC6X_SCOMMON
11795 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11797 else if (type
== SHN_MIPS_SUNDEFINED
11798 && filedata
->file_header
.e_machine
== EM_MIPS
)
11800 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11801 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11802 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11803 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11804 else if (type
>= SHN_LORESERVE
)
11805 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11806 else if (filedata
->file_header
.e_shnum
!= 0
11807 && type
>= filedata
->file_header
.e_shnum
)
11808 sprintf (buff
, _("bad section index[%3d]"), type
);
11810 sprintf (buff
, "%3d", type
);
11817 static const char *
11818 get_symbol_version_string (Filedata
* filedata
,
11819 bfd_boolean is_dynsym
,
11820 const char * strtab
,
11821 unsigned long int strtab_size
,
11823 Elf_Internal_Sym
* psym
,
11824 enum versioned_symbol_info
* sym_info
,
11825 unsigned short * vna_other
)
11827 unsigned char data
[2];
11828 unsigned short vers_data
;
11829 unsigned long offset
;
11830 unsigned short max_vd_ndx
;
11833 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11836 offset
= offset_from_vma (filedata
,
11837 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11838 sizeof data
+ si
* sizeof (vers_data
));
11840 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11841 sizeof (data
), 1, _("version data")) == NULL
)
11844 vers_data
= byte_get (data
, 2);
11846 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11849 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11852 /* Usually we'd only see verdef for defined symbols, and verneed for
11853 undefined symbols. However, symbols defined by the linker in
11854 .dynbss for variables copied from a shared library in order to
11855 avoid text relocations are defined yet have verneed. We could
11856 use a heuristic to detect the special case, for example, check
11857 for verneed first on symbols defined in SHT_NOBITS sections, but
11858 it is simpler and more reliable to just look for both verdef and
11859 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11861 if (psym
->st_shndx
!= SHN_UNDEF
11862 && vers_data
!= 0x8001
11863 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11865 Elf_Internal_Verdef ivd
;
11866 Elf_Internal_Verdaux ivda
;
11867 Elf_External_Verdaux evda
;
11870 off
= offset_from_vma (filedata
,
11871 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11872 sizeof (Elf_External_Verdef
));
11876 Elf_External_Verdef evd
;
11878 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11879 _("version def")) == NULL
)
11888 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11889 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11890 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11891 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11894 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11895 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11897 off
+= ivd
.vd_next
;
11899 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11901 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11903 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11906 off
-= ivd
.vd_next
;
11909 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11910 _("version def aux")) != NULL
)
11912 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11914 if (psym
->st_name
!= ivda
.vda_name
)
11915 return (ivda
.vda_name
< strtab_size
11916 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11921 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11923 Elf_External_Verneed evn
;
11924 Elf_Internal_Verneed ivn
;
11925 Elf_Internal_Vernaux ivna
;
11927 offset
= offset_from_vma (filedata
,
11928 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11932 unsigned long vna_off
;
11934 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11935 _("version need")) == NULL
)
11938 ivna
.vna_other
= 0;
11943 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11944 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11946 vna_off
= offset
+ ivn
.vn_aux
;
11950 Elf_External_Vernaux evna
;
11952 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11953 _("version need aux (3)")) == NULL
)
11956 ivna
.vna_other
= 0;
11961 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11962 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11963 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11966 vna_off
+= ivna
.vna_next
;
11968 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11970 if (ivna
.vna_other
== vers_data
)
11973 offset
+= ivn
.vn_next
;
11975 while (ivn
.vn_next
!= 0);
11977 if (ivna
.vna_other
== vers_data
)
11979 *sym_info
= symbol_undefined
;
11980 *vna_other
= ivna
.vna_other
;
11981 return (ivna
.vna_name
< strtab_size
11982 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11984 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11985 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11986 return _("<corrupt>");
11992 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
11993 Elf_Internal_Sym
*symtab
,
11994 Elf_Internal_Shdr
*section
,
11995 char *strtab
, size_t strtab_size
)
11997 const char *version_string
;
11998 enum versioned_symbol_info sym_info
;
11999 unsigned short vna_other
;
12000 Elf_Internal_Sym
*psym
= symtab
+ si
;
12002 printf ("%6ld: ", si
);
12003 print_vma (psym
->st_value
, LONG_HEX
);
12005 print_vma (psym
->st_size
, DEC_5
);
12006 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12007 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12008 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12009 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12012 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12014 printf (" %-7s", get_symbol_visibility (vis
));
12015 /* Check to see if any other bits in the st_other field are set.
12016 Note - displaying this information disrupts the layout of the
12017 table being generated, but for the moment this case is very rare. */
12018 if (psym
->st_other
^ vis
)
12019 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12021 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12022 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
12024 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12027 = get_symbol_version_string (filedata
,
12029 || section
->sh_type
== SHT_DYNSYM
),
12030 strtab
, strtab_size
, si
,
12031 psym
, &sym_info
, &vna_other
);
12032 if (version_string
)
12034 if (sym_info
== symbol_undefined
)
12035 printf ("@%s (%d)", version_string
, vna_other
);
12037 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12043 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12045 && si
>= section
->sh_info
12046 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12047 && filedata
->file_header
.e_machine
!= EM_MIPS
12048 /* Solaris binaries have been found to violate this requirement as
12049 well. Not sure if this is a bug or an ABI requirement. */
12050 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12051 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12052 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12055 /* Dump the symbol table. */
12057 process_symbol_table (Filedata
* filedata
)
12059 Elf_Internal_Shdr
* section
;
12061 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12064 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12066 && do_using_dynamic
12067 && filedata
->dynamic_strings
!= NULL
12068 && filedata
->dynamic_symbols
!= NULL
)
12072 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12073 "\nSymbol table for image contains %lu entries:\n",
12074 filedata
->num_dynamic_syms
),
12075 filedata
->num_dynamic_syms
);
12077 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12079 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12081 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12082 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12083 filedata
->dynamic_strings
,
12084 filedata
->dynamic_strings_length
);
12086 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12087 && filedata
->section_headers
!= NULL
)
12091 for (i
= 0, section
= filedata
->section_headers
;
12092 i
< filedata
->file_header
.e_shnum
;
12095 char * strtab
= NULL
;
12096 unsigned long int strtab_size
= 0;
12097 Elf_Internal_Sym
* symtab
;
12098 unsigned long si
, num_syms
;
12100 if ((section
->sh_type
!= SHT_SYMTAB
12101 && section
->sh_type
!= SHT_DYNSYM
)
12103 && section
->sh_type
== SHT_SYMTAB
))
12106 if (section
->sh_entsize
== 0)
12108 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12109 printable_section_name (filedata
, section
));
12113 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12114 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12115 "\nSymbol table '%s' contains %lu entries:\n",
12117 printable_section_name (filedata
, section
),
12121 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12123 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12125 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12126 if (symtab
== NULL
)
12129 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12131 strtab
= filedata
->string_table
;
12132 strtab_size
= filedata
->string_table_length
;
12134 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12136 Elf_Internal_Shdr
* string_sec
;
12138 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12140 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12141 1, string_sec
->sh_size
,
12142 _("string table"));
12143 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12146 for (si
= 0; si
< num_syms
; si
++)
12147 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12148 strtab
, strtab_size
);
12151 if (strtab
!= filedata
->string_table
)
12157 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12159 if (do_histogram
&& filedata
->buckets
!= NULL
)
12161 unsigned long * lengths
;
12162 unsigned long * counts
;
12165 unsigned long maxlength
= 0;
12166 unsigned long nzero_counts
= 0;
12167 unsigned long nsyms
= 0;
12170 printf (ngettext ("\nHistogram for bucket list length "
12171 "(total of %lu bucket):\n",
12172 "\nHistogram for bucket list length "
12173 "(total of %lu buckets):\n",
12174 (unsigned long) filedata
->nbuckets
),
12175 (unsigned long) filedata
->nbuckets
);
12177 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12178 sizeof (*lengths
));
12179 if (lengths
== NULL
)
12181 error (_("Out of memory allocating space for histogram buckets\n"));
12184 visited
= xcmalloc (filedata
->nchains
, 1);
12185 memset (visited
, 0, filedata
->nchains
);
12187 printf (_(" Length Number %% of total Coverage\n"));
12188 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12190 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12193 if (maxlength
< ++lengths
[hn
])
12195 if (si
>= filedata
->nchains
|| visited
[si
])
12197 error (_("histogram chain is corrupt\n"));
12205 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12206 if (counts
== NULL
)
12209 error (_("Out of memory allocating space for histogram counts\n"));
12213 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12214 ++counts
[lengths
[hn
]];
12216 if (filedata
->nbuckets
> 0)
12219 printf (" 0 %-10lu (%5.1f%%)\n",
12220 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12221 for (i
= 1; i
<= maxlength
; ++i
)
12223 nzero_counts
+= counts
[i
] * i
;
12224 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12225 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12226 (nzero_counts
* 100.0) / nsyms
);
12234 free (filedata
->buckets
);
12235 filedata
->buckets
= NULL
;
12236 filedata
->nbuckets
= 0;
12237 free (filedata
->chains
);
12238 filedata
->chains
= NULL
;
12240 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12242 unsigned long * lengths
;
12243 unsigned long * counts
;
12245 unsigned long maxlength
= 0;
12246 unsigned long nzero_counts
= 0;
12247 unsigned long nsyms
= 0;
12249 printf (ngettext ("\nHistogram for `%s' bucket list length "
12250 "(total of %lu bucket):\n",
12251 "\nHistogram for `%s' bucket list length "
12252 "(total of %lu buckets):\n",
12253 (unsigned long) filedata
->ngnubuckets
),
12254 GNU_HASH_SECTION_NAME (filedata
),
12255 (unsigned long) filedata
->ngnubuckets
);
12257 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12258 sizeof (*lengths
));
12259 if (lengths
== NULL
)
12261 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12265 printf (_(" Length Number %% of total Coverage\n"));
12267 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12268 if (filedata
->gnubuckets
[hn
] != 0)
12270 bfd_vma off
, length
= 1;
12272 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12273 /* PR 17531 file: 010-77222-0.004. */
12274 off
< filedata
->ngnuchains
12275 && (filedata
->gnuchains
[off
] & 1) == 0;
12278 lengths
[hn
] = length
;
12279 if (length
> maxlength
)
12280 maxlength
= length
;
12284 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12285 if (counts
== NULL
)
12288 error (_("Out of memory allocating space for gnu histogram counts\n"));
12292 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12293 ++counts
[lengths
[hn
]];
12295 if (filedata
->ngnubuckets
> 0)
12298 printf (" 0 %-10lu (%5.1f%%)\n",
12299 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12300 for (j
= 1; j
<= maxlength
; ++j
)
12302 nzero_counts
+= counts
[j
] * j
;
12303 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12304 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12305 (nzero_counts
* 100.0) / nsyms
);
12312 free (filedata
->gnubuckets
);
12313 filedata
->gnubuckets
= NULL
;
12314 filedata
->ngnubuckets
= 0;
12315 free (filedata
->gnuchains
);
12316 filedata
->gnuchains
= NULL
;
12317 filedata
->ngnuchains
= 0;
12318 free (filedata
->mipsxlat
);
12319 filedata
->mipsxlat
= NULL
;
12323 free (filedata
->gnubuckets
);
12324 filedata
->gnubuckets
= NULL
;
12325 filedata
->ngnubuckets
= 0;
12326 free (filedata
->gnuchains
);
12327 filedata
->gnuchains
= NULL
;
12328 filedata
->ngnuchains
= 0;
12329 free (filedata
->mipsxlat
);
12330 filedata
->mipsxlat
= NULL
;
12331 free (filedata
->buckets
);
12332 filedata
->buckets
= NULL
;
12333 filedata
->nbuckets
= 0;
12334 free (filedata
->chains
);
12335 filedata
->chains
= NULL
;
12340 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12344 if (filedata
->dynamic_syminfo
== NULL
12346 /* No syminfo, this is ok. */
12349 /* There better should be a dynamic symbol section. */
12350 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12353 if (filedata
->dynamic_addr
)
12354 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12355 "contains %d entry:\n",
12356 "\nDynamic info segment at offset 0x%lx "
12357 "contains %d entries:\n",
12358 filedata
->dynamic_syminfo_nent
),
12359 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12361 printf (_(" Num: Name BoundTo Flags\n"));
12362 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12364 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12366 printf ("%4d: ", i
);
12367 if (i
>= filedata
->num_dynamic_syms
)
12368 printf (_("<corrupt index>"));
12369 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12370 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12371 filedata
->dynamic_symbols
[i
].st_name
));
12373 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12376 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12378 case SYMINFO_BT_SELF
:
12379 fputs ("SELF ", stdout
);
12381 case SYMINFO_BT_PARENT
:
12382 fputs ("PARENT ", stdout
);
12385 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12386 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12387 && VALID_DYNAMIC_NAME (filedata
,
12388 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12390 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12391 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12395 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12399 if (flags
& SYMINFO_FLG_DIRECT
)
12400 printf (" DIRECT");
12401 if (flags
& SYMINFO_FLG_PASSTHRU
)
12402 printf (" PASSTHRU");
12403 if (flags
& SYMINFO_FLG_COPY
)
12405 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12406 printf (" LAZYLOAD");
12414 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12415 is contained by the region START .. END. The types of ADDR, START
12416 and END should all be the same. Note both ADDR + NELEM and END
12417 point to just beyond the end of the regions that are being tested. */
12418 #define IN_RANGE(START,END,ADDR,NELEM) \
12419 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12421 /* Check to see if the given reloc needs to be handled in a target specific
12422 manner. If so then process the reloc and return TRUE otherwise return
12425 If called with reloc == NULL, then this is a signal that reloc processing
12426 for the current section has finished, and any saved state should be
12430 target_specific_reloc_handling (Filedata
* filedata
,
12431 Elf_Internal_Rela
* reloc
,
12432 unsigned char * start
,
12433 unsigned char * end
,
12434 Elf_Internal_Sym
* symtab
,
12435 unsigned long num_syms
)
12437 unsigned int reloc_type
= 0;
12438 unsigned long sym_index
= 0;
12442 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12443 sym_index
= get_reloc_symindex (reloc
->r_info
);
12446 switch (filedata
->file_header
.e_machine
)
12449 case EM_MSP430_OLD
:
12451 static Elf_Internal_Sym
* saved_sym
= NULL
;
12459 switch (reloc_type
)
12461 case 10: /* R_MSP430_SYM_DIFF */
12462 if (uses_msp430x_relocs (filedata
))
12464 /* Fall through. */
12465 case 21: /* R_MSP430X_SYM_DIFF */
12467 if (sym_index
>= num_syms
)
12468 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12471 saved_sym
= symtab
+ sym_index
;
12474 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12475 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12476 goto handle_sym_diff
;
12478 case 5: /* R_MSP430_16_BYTE */
12479 case 9: /* R_MSP430_8 */
12480 if (uses_msp430x_relocs (filedata
))
12482 goto handle_sym_diff
;
12484 case 2: /* R_MSP430_ABS16 */
12485 case 15: /* R_MSP430X_ABS16 */
12486 if (! uses_msp430x_relocs (filedata
))
12488 goto handle_sym_diff
;
12491 if (saved_sym
!= NULL
)
12493 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12496 if (sym_index
>= num_syms
)
12497 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12501 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12502 - saved_sym
->st_value
);
12504 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12505 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12508 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12509 (long) reloc
->r_offset
);
12518 if (saved_sym
!= NULL
)
12519 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12526 case EM_CYGNUS_MN10300
:
12528 static Elf_Internal_Sym
* saved_sym
= NULL
;
12536 switch (reloc_type
)
12538 case 34: /* R_MN10300_ALIGN */
12540 case 33: /* R_MN10300_SYM_DIFF */
12541 if (sym_index
>= num_syms
)
12542 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12545 saved_sym
= symtab
+ sym_index
;
12548 case 1: /* R_MN10300_32 */
12549 case 2: /* R_MN10300_16 */
12550 if (saved_sym
!= NULL
)
12552 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12555 if (sym_index
>= num_syms
)
12556 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12560 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12561 - saved_sym
->st_value
);
12563 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12564 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12566 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12567 (long) reloc
->r_offset
);
12575 if (saved_sym
!= NULL
)
12576 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12584 static bfd_vma saved_sym1
= 0;
12585 static bfd_vma saved_sym2
= 0;
12586 static bfd_vma value
;
12590 saved_sym1
= saved_sym2
= 0;
12594 switch (reloc_type
)
12596 case 0x80: /* R_RL78_SYM. */
12597 saved_sym1
= saved_sym2
;
12598 if (sym_index
>= num_syms
)
12599 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12603 saved_sym2
= symtab
[sym_index
].st_value
;
12604 saved_sym2
+= reloc
->r_addend
;
12608 case 0x83: /* R_RL78_OPsub. */
12609 value
= saved_sym1
- saved_sym2
;
12610 saved_sym2
= saved_sym1
= 0;
12614 case 0x41: /* R_RL78_ABS32. */
12615 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12616 byte_put (start
+ reloc
->r_offset
, value
, 4);
12618 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12619 (long) reloc
->r_offset
);
12623 case 0x43: /* R_RL78_ABS16. */
12624 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12625 byte_put (start
+ reloc
->r_offset
, value
, 2);
12627 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12628 (long) reloc
->r_offset
);
12642 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12643 DWARF debug sections. This is a target specific test. Note - we do not
12644 go through the whole including-target-headers-multiple-times route, (as
12645 we have already done with <elf/h8.h>) because this would become very
12646 messy and even then this function would have to contain target specific
12647 information (the names of the relocs instead of their numeric values).
12648 FIXME: This is not the correct way to solve this problem. The proper way
12649 is to have target specific reloc sizing and typing functions created by
12650 the reloc-macros.h header, in the same way that it already creates the
12651 reloc naming functions. */
12654 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12656 /* Please keep this table alpha-sorted for ease of visual lookup. */
12657 switch (filedata
->file_header
.e_machine
)
12661 return reloc_type
== 1; /* R_386_32. */
12663 return reloc_type
== 1; /* R_68K_32. */
12665 return reloc_type
== 1; /* R_860_32. */
12667 return reloc_type
== 2; /* R_960_32. */
12669 return (reloc_type
== 258
12670 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12672 return reloc_type
== 11; /* R_BPF_DATA_32 */
12673 case EM_ADAPTEVA_EPIPHANY
:
12674 return reloc_type
== 3;
12676 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12678 return reloc_type
== 1; /* R_ARC_32. */
12679 case EM_ARC_COMPACT
:
12680 case EM_ARC_COMPACT2
:
12681 return reloc_type
== 4; /* R_ARC_32. */
12683 return reloc_type
== 2; /* R_ARM_ABS32 */
12686 return reloc_type
== 1;
12688 return reloc_type
== 0x12; /* R_byte4_data. */
12690 return reloc_type
== 3; /* R_CRIS_32. */
12692 return reloc_type
== 3; /* R_CR16_NUM32. */
12694 return reloc_type
== 15; /* R_CRX_NUM32. */
12696 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12697 case EM_CYGNUS_FRV
:
12698 return reloc_type
== 1;
12699 case EM_CYGNUS_D10V
:
12701 return reloc_type
== 6; /* R_D10V_32. */
12702 case EM_CYGNUS_D30V
:
12704 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12706 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12707 case EM_CYGNUS_FR30
:
12709 return reloc_type
== 3; /* R_FR30_32. */
12711 return reloc_type
== 1; /* R_FT32_32. */
12715 return reloc_type
== 1; /* R_H8_DIR32. */
12717 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12718 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12719 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12720 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12723 return reloc_type
== 2; /* R_IP2K_32. */
12725 return reloc_type
== 2; /* R_IQ2000_32. */
12726 case EM_LATTICEMICO32
:
12727 return reloc_type
== 3; /* R_LM32_32. */
12730 return reloc_type
== 3; /* R_M32C_32. */
12732 return reloc_type
== 34; /* R_M32R_32_RELA. */
12735 return reloc_type
== 6; /* R_M68HC11_32. */
12737 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12738 reloc_type
== 6; /* R_S12Z_CW32. */
12740 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12741 case EM_CYGNUS_MEP
:
12742 return reloc_type
== 4; /* R_MEP_32. */
12744 return reloc_type
== 2; /* R_METAG_ADDR32. */
12745 case EM_MICROBLAZE
:
12746 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12748 return reloc_type
== 2; /* R_MIPS_32. */
12750 return reloc_type
== 4; /* R_MMIX_32. */
12751 case EM_CYGNUS_MN10200
:
12753 return reloc_type
== 1; /* R_MN10200_32. */
12754 case EM_CYGNUS_MN10300
:
12756 return reloc_type
== 1; /* R_MN10300_32. */
12758 return reloc_type
== 1; /* R_MOXIE_32. */
12759 case EM_MSP430_OLD
:
12761 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12763 return reloc_type
== 2; /* R_MT_32. */
12765 return reloc_type
== 20; /* R_NDS32_RELA. */
12766 case EM_ALTERA_NIOS2
:
12767 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12769 return reloc_type
== 1; /* R_NIOS_32. */
12771 return reloc_type
== 1; /* R_OR1K_32. */
12773 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12774 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12775 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12778 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12780 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12782 return reloc_type
== 1; /* R_PPC_ADDR32. */
12784 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12786 return reloc_type
== 1; /* R_RISCV_32. */
12788 return reloc_type
== 1; /* R_RL78_DIR32. */
12790 return reloc_type
== 1; /* R_RX_DIR32. */
12792 return reloc_type
== 1; /* R_I370_ADDR31. */
12795 return reloc_type
== 4; /* R_S390_32. */
12797 return reloc_type
== 8; /* R_SCORE_ABS32. */
12799 return reloc_type
== 1; /* R_SH_DIR32. */
12800 case EM_SPARC32PLUS
:
12803 return reloc_type
== 3 /* R_SPARC_32. */
12804 || reloc_type
== 23; /* R_SPARC_UA32. */
12806 return reloc_type
== 6; /* R_SPU_ADDR32 */
12808 return reloc_type
== 1; /* R_C6000_ABS32. */
12810 return reloc_type
== 2; /* R_TILEGX_32. */
12812 return reloc_type
== 1; /* R_TILEPRO_32. */
12813 case EM_CYGNUS_V850
:
12815 return reloc_type
== 6; /* R_V850_ABS32. */
12817 return reloc_type
== 0x33; /* R_V810_WORD. */
12819 return reloc_type
== 1; /* R_VAX_32. */
12821 return reloc_type
== 3; /* R_VISIUM_32. */
12822 case EM_WEBASSEMBLY
:
12823 return reloc_type
== 1; /* R_WASM32_32. */
12827 return reloc_type
== 10; /* R_X86_64_32. */
12830 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12832 return reloc_type
== 4; /* R_XGATE_32. */
12834 return reloc_type
== 1; /* R_XSTROMY16_32. */
12835 case EM_XTENSA_OLD
:
12837 return reloc_type
== 1; /* R_XTENSA_32. */
12839 return reloc_type
== 6; /* R_Z80_32. */
12842 static unsigned int prev_warn
= 0;
12844 /* Avoid repeating the same warning multiple times. */
12845 if (prev_warn
!= filedata
->file_header
.e_machine
)
12846 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12847 filedata
->file_header
.e_machine
);
12848 prev_warn
= filedata
->file_header
.e_machine
;
12854 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12855 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12858 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12860 switch (filedata
->file_header
.e_machine
)
12861 /* Please keep this table alpha-sorted for ease of visual lookup. */
12865 return reloc_type
== 2; /* R_386_PC32. */
12867 return reloc_type
== 4; /* R_68K_PC32. */
12869 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12870 case EM_ADAPTEVA_EPIPHANY
:
12871 return reloc_type
== 6;
12873 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12874 case EM_ARC_COMPACT
:
12875 case EM_ARC_COMPACT2
:
12876 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12878 return reloc_type
== 3; /* R_ARM_REL32 */
12881 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12882 case EM_MICROBLAZE
:
12883 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12885 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12887 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12889 return reloc_type
== 26; /* R_PPC_REL32. */
12891 return reloc_type
== 26; /* R_PPC64_REL32. */
12893 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12896 return reloc_type
== 5; /* R_390_PC32. */
12898 return reloc_type
== 2; /* R_SH_REL32. */
12899 case EM_SPARC32PLUS
:
12902 return reloc_type
== 6; /* R_SPARC_DISP32. */
12904 return reloc_type
== 13; /* R_SPU_REL32. */
12906 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12908 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12910 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12914 return reloc_type
== 2; /* R_X86_64_PC32. */
12916 return reloc_type
== 4; /* R_VAX_PCREL32. */
12917 case EM_XTENSA_OLD
:
12919 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12921 /* Do not abort or issue an error message here. Not all targets use
12922 pc-relative 32-bit relocs in their DWARF debug information and we
12923 have already tested for target coverage in is_32bit_abs_reloc. A
12924 more helpful warning message will be generated by apply_relocations
12925 anyway, so just return. */
12930 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12931 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12934 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12936 switch (filedata
->file_header
.e_machine
)
12939 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12941 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12943 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12944 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12946 return reloc_type
== 80; /* R_PARISC_DIR64. */
12948 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12950 return reloc_type
== 2; /* R_RISCV_64. */
12951 case EM_SPARC32PLUS
:
12954 return reloc_type
== 32 /* R_SPARC_64. */
12955 || reloc_type
== 54; /* R_SPARC_UA64. */
12959 return reloc_type
== 1; /* R_X86_64_64. */
12962 return reloc_type
== 22; /* R_S390_64. */
12964 return reloc_type
== 1; /* R_TILEGX_64. */
12966 return reloc_type
== 18; /* R_MIPS_64. */
12972 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12973 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12976 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12978 switch (filedata
->file_header
.e_machine
)
12981 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12983 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12985 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12986 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12988 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12990 return reloc_type
== 44; /* R_PPC64_REL64. */
12991 case EM_SPARC32PLUS
:
12994 return reloc_type
== 46; /* R_SPARC_DISP64. */
12998 return reloc_type
== 24; /* R_X86_64_PC64. */
13001 return reloc_type
== 23; /* R_S390_PC64. */
13003 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13009 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13010 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13013 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13015 switch (filedata
->file_header
.e_machine
)
13017 case EM_CYGNUS_MN10200
:
13019 return reloc_type
== 4; /* R_MN10200_24. */
13021 return reloc_type
== 5; /* R_FT32_20. */
13023 return reloc_type
== 5; /* R_Z80_24. */
13029 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13030 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13033 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13035 /* Please keep this table alpha-sorted for ease of visual lookup. */
13036 switch (filedata
->file_header
.e_machine
)
13039 case EM_ARC_COMPACT
:
13040 case EM_ARC_COMPACT2
:
13041 return reloc_type
== 2; /* R_ARC_16. */
13042 case EM_ADAPTEVA_EPIPHANY
:
13043 return reloc_type
== 5;
13046 return reloc_type
== 4; /* R_AVR_16. */
13047 case EM_CYGNUS_D10V
:
13049 return reloc_type
== 3; /* R_D10V_16. */
13051 return reloc_type
== 2; /* R_FT32_16. */
13055 return reloc_type
== R_H8_DIR16
;
13058 return reloc_type
== 1; /* R_IP2K_16. */
13061 return reloc_type
== 1; /* R_M32C_16 */
13062 case EM_CYGNUS_MN10200
:
13064 return reloc_type
== 2; /* R_MN10200_16. */
13065 case EM_CYGNUS_MN10300
:
13067 return reloc_type
== 2; /* R_MN10300_16. */
13069 if (uses_msp430x_relocs (filedata
))
13070 return reloc_type
== 2; /* R_MSP430_ABS16. */
13071 /* Fall through. */
13072 case EM_MSP430_OLD
:
13073 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13075 return reloc_type
== 19; /* R_NDS32_RELA. */
13076 case EM_ALTERA_NIOS2
:
13077 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13079 return reloc_type
== 9; /* R_NIOS_16. */
13081 return reloc_type
== 2; /* R_OR1K_16. */
13083 return reloc_type
== 55; /* R_RISCV_SET16. */
13085 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13087 return reloc_type
== 2; /* R_C6000_ABS16. */
13089 return reloc_type
== 2; /* R_VISIUM_16. */
13092 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13094 return reloc_type
== 3; /* R_XGATE_16. */
13096 return reloc_type
== 4; /* R_Z80_16. */
13102 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13103 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13106 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13108 switch (filedata
->file_header
.e_machine
)
13111 return reloc_type
== 54; /* R_RISCV_SET8. */
13113 return reloc_type
== 1; /* R_Z80_8. */
13119 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13120 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13123 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13125 switch (filedata
->file_header
.e_machine
)
13128 return reloc_type
== 53; /* R_RISCV_SET6. */
13134 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13135 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13138 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13140 /* Please keep this table alpha-sorted for ease of visual lookup. */
13141 switch (filedata
->file_header
.e_machine
)
13144 return reloc_type
== 35; /* R_RISCV_ADD32. */
13150 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13151 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13154 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13156 /* Please keep this table alpha-sorted for ease of visual lookup. */
13157 switch (filedata
->file_header
.e_machine
)
13160 return reloc_type
== 39; /* R_RISCV_SUB32. */
13166 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13167 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13170 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13172 /* Please keep this table alpha-sorted for ease of visual lookup. */
13173 switch (filedata
->file_header
.e_machine
)
13176 return reloc_type
== 36; /* R_RISCV_ADD64. */
13182 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13183 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13186 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13188 /* Please keep this table alpha-sorted for ease of visual lookup. */
13189 switch (filedata
->file_header
.e_machine
)
13192 return reloc_type
== 40; /* R_RISCV_SUB64. */
13198 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13199 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13202 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13204 /* Please keep this table alpha-sorted for ease of visual lookup. */
13205 switch (filedata
->file_header
.e_machine
)
13208 return reloc_type
== 34; /* R_RISCV_ADD16. */
13214 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13215 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13218 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13220 /* Please keep this table alpha-sorted for ease of visual lookup. */
13221 switch (filedata
->file_header
.e_machine
)
13224 return reloc_type
== 38; /* R_RISCV_SUB16. */
13230 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13231 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13234 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13236 /* Please keep this table alpha-sorted for ease of visual lookup. */
13237 switch (filedata
->file_header
.e_machine
)
13240 return reloc_type
== 33; /* R_RISCV_ADD8. */
13246 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13247 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13250 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13252 /* Please keep this table alpha-sorted for ease of visual lookup. */
13253 switch (filedata
->file_header
.e_machine
)
13256 return reloc_type
== 37; /* R_RISCV_SUB8. */
13262 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13263 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13266 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13268 switch (filedata
->file_header
.e_machine
)
13271 return reloc_type
== 52; /* R_RISCV_SUB6. */
13277 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13278 relocation entries (possibly formerly used for SHT_GROUP sections). */
13281 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13283 switch (filedata
->file_header
.e_machine
)
13285 case EM_386
: /* R_386_NONE. */
13286 case EM_68K
: /* R_68K_NONE. */
13287 case EM_ADAPTEVA_EPIPHANY
:
13288 case EM_ALPHA
: /* R_ALPHA_NONE. */
13289 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13290 case EM_ARC
: /* R_ARC_NONE. */
13291 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13292 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13293 case EM_ARM
: /* R_ARM_NONE. */
13294 case EM_C166
: /* R_XC16X_NONE. */
13295 case EM_CRIS
: /* R_CRIS_NONE. */
13296 case EM_FT32
: /* R_FT32_NONE. */
13297 case EM_IA_64
: /* R_IA64_NONE. */
13298 case EM_K1OM
: /* R_X86_64_NONE. */
13299 case EM_L1OM
: /* R_X86_64_NONE. */
13300 case EM_M32R
: /* R_M32R_NONE. */
13301 case EM_MIPS
: /* R_MIPS_NONE. */
13302 case EM_MN10300
: /* R_MN10300_NONE. */
13303 case EM_MOXIE
: /* R_MOXIE_NONE. */
13304 case EM_NIOS32
: /* R_NIOS_NONE. */
13305 case EM_OR1K
: /* R_OR1K_NONE. */
13306 case EM_PARISC
: /* R_PARISC_NONE. */
13307 case EM_PPC64
: /* R_PPC64_NONE. */
13308 case EM_PPC
: /* R_PPC_NONE. */
13309 case EM_RISCV
: /* R_RISCV_NONE. */
13310 case EM_S390
: /* R_390_NONE. */
13312 case EM_SH
: /* R_SH_NONE. */
13313 case EM_SPARC32PLUS
:
13314 case EM_SPARC
: /* R_SPARC_NONE. */
13316 case EM_TILEGX
: /* R_TILEGX_NONE. */
13317 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13318 case EM_TI_C6000
:/* R_C6000_NONE. */
13319 case EM_X86_64
: /* R_X86_64_NONE. */
13321 case EM_Z80
: /* R_Z80_NONE. */
13322 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13323 return reloc_type
== 0;
13326 return reloc_type
== 0 || reloc_type
== 256;
13329 return (reloc_type
== 0 /* R_AVR_NONE. */
13330 || reloc_type
== 30 /* R_AVR_DIFF8. */
13331 || reloc_type
== 31 /* R_AVR_DIFF16. */
13332 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13334 return reloc_type
== 3; /* R_METAG_NONE. */
13336 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13337 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13338 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13339 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13340 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13342 return (reloc_type
== 0 /* R_PRU_NONE. */
13343 || reloc_type
== 65 /* R_PRU_DIFF8. */
13344 || reloc_type
== 66 /* R_PRU_DIFF16. */
13345 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13346 case EM_XTENSA_OLD
:
13348 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13349 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13350 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13351 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13352 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13353 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13354 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13355 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13356 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13357 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13362 /* Returns TRUE if there is a relocation against
13363 section NAME at OFFSET bytes. */
13366 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13368 Elf_Internal_Rela
* relocs
;
13369 Elf_Internal_Rela
* rp
;
13371 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13374 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13376 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13377 if (rp
->r_offset
== offset
)
13383 /* Apply relocations to a section.
13384 Returns TRUE upon success, FALSE otherwise.
13385 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13386 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13387 will be set to the number of relocs loaded.
13389 Note: So far support has been added only for those relocations
13390 which can be found in debug sections. FIXME: Add support for
13391 more relocations ? */
13394 apply_relocations (Filedata
* filedata
,
13395 const Elf_Internal_Shdr
* section
,
13396 unsigned char * start
,
13397 bfd_size_type size
,
13398 void ** relocs_return
,
13399 unsigned long * num_relocs_return
)
13401 Elf_Internal_Shdr
* relsec
;
13402 unsigned char * end
= start
+ size
;
13404 if (relocs_return
!= NULL
)
13406 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13407 * num_relocs_return
= 0;
13410 if (filedata
->file_header
.e_type
!= ET_REL
)
13411 /* No relocs to apply. */
13414 /* Find the reloc section associated with the section. */
13415 for (relsec
= filedata
->section_headers
;
13416 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13419 bfd_boolean is_rela
;
13420 unsigned long num_relocs
;
13421 Elf_Internal_Rela
* relocs
;
13422 Elf_Internal_Rela
* rp
;
13423 Elf_Internal_Shdr
* symsec
;
13424 Elf_Internal_Sym
* symtab
;
13425 unsigned long num_syms
;
13426 Elf_Internal_Sym
* sym
;
13428 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13429 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13430 || filedata
->section_headers
+ relsec
->sh_info
!= section
13431 || relsec
->sh_size
== 0
13432 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13435 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13436 if (symsec
->sh_type
!= SHT_SYMTAB
13437 && symsec
->sh_type
!= SHT_DYNSYM
)
13440 is_rela
= relsec
->sh_type
== SHT_RELA
;
13444 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13445 relsec
->sh_size
, & relocs
, & num_relocs
))
13450 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13451 relsec
->sh_size
, & relocs
, & num_relocs
))
13455 /* SH uses RELA but uses in place value instead of the addend field. */
13456 if (filedata
->file_header
.e_machine
== EM_SH
)
13459 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13461 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13464 unsigned int reloc_type
;
13465 unsigned int reloc_size
;
13466 bfd_boolean reloc_inplace
= FALSE
;
13467 bfd_boolean reloc_subtract
= FALSE
;
13468 unsigned char * rloc
;
13469 unsigned long sym_index
;
13471 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13473 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13475 else if (is_none_reloc (filedata
, reloc_type
))
13477 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13478 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13480 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13481 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13483 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13485 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13487 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13488 || is_6bit_abs_reloc (filedata
, reloc_type
))
13490 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13492 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13495 reloc_inplace
= TRUE
;
13497 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13499 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13502 reloc_inplace
= TRUE
;
13504 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13506 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13509 reloc_inplace
= TRUE
;
13511 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13513 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13516 reloc_inplace
= TRUE
;
13518 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13522 reloc_inplace
= TRUE
;
13526 static unsigned int prev_reloc
= 0;
13528 if (reloc_type
!= prev_reloc
)
13529 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13530 reloc_type
, printable_section_name (filedata
, section
));
13531 prev_reloc
= reloc_type
;
13535 rloc
= start
+ rp
->r_offset
;
13536 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13538 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13539 (unsigned long) rp
->r_offset
,
13540 printable_section_name (filedata
, section
));
13544 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13545 if (sym_index
>= num_syms
)
13547 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13548 sym_index
, printable_section_name (filedata
, section
));
13551 sym
= symtab
+ sym_index
;
13553 /* If the reloc has a symbol associated with it,
13554 make sure that it is of an appropriate type.
13556 Relocations against symbols without type can happen.
13557 Gcc -feliminate-dwarf2-dups may generate symbols
13558 without type for debug info.
13560 Icc generates relocations against function symbols
13561 instead of local labels.
13563 Relocations against object symbols can happen, eg when
13564 referencing a global array. For an example of this see
13565 the _clz.o binary in libgcc.a. */
13567 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13568 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13570 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13571 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13572 printable_section_name (filedata
, relsec
),
13573 (long int)(rp
- relocs
));
13579 addend
+= rp
->r_addend
;
13580 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13581 partial_inplace. */
13583 || (filedata
->file_header
.e_machine
== EM_XTENSA
13584 && reloc_type
== 1)
13585 || ((filedata
->file_header
.e_machine
== EM_PJ
13586 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13587 && reloc_type
== 1)
13588 || ((filedata
->file_header
.e_machine
== EM_D30V
13589 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13590 && reloc_type
== 12)
13593 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13594 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13596 addend
+= byte_get (rloc
, reloc_size
);
13599 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13600 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13602 /* On HPPA, all pc-relative relocations are biased by 8. */
13603 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13605 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13608 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13609 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13611 if (reloc_subtract
)
13612 addend
-= sym
->st_value
;
13614 addend
+= sym
->st_value
;
13615 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13616 byte_put (rloc
, addend
, reloc_size
);
13618 else if (reloc_subtract
)
13619 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13621 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13625 /* Let the target specific reloc processing code know that
13626 we have finished with these relocs. */
13627 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13631 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13632 * num_relocs_return
= num_relocs
;
13643 #ifdef SUPPORT_DISASSEMBLY
13645 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13647 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13649 /* FIXME: XXX -- to be done --- XXX */
13655 /* Reads in the contents of SECTION from FILE, returning a pointer
13656 to a malloc'ed buffer or NULL if something went wrong. */
13659 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13661 bfd_size_type num_bytes
= section
->sh_size
;
13663 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13665 printf (_("Section '%s' has no data to dump.\n"),
13666 printable_section_name (filedata
, section
));
13670 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13671 _("section contents"));
13674 /* Uncompresses a section that was compressed using zlib, in place. */
13677 uncompress_section_contents (unsigned char ** buffer
,
13678 dwarf_size_type uncompressed_size
,
13679 dwarf_size_type
* size
)
13681 dwarf_size_type compressed_size
= *size
;
13682 unsigned char * compressed_buffer
= *buffer
;
13683 unsigned char * uncompressed_buffer
;
13687 /* It is possible the section consists of several compressed
13688 buffers concatenated together, so we uncompress in a loop. */
13689 /* PR 18313: The state field in the z_stream structure is supposed
13690 to be invisible to the user (ie us), but some compilers will
13691 still complain about it being used without initialisation. So
13692 we first zero the entire z_stream structure and then set the fields
13694 memset (& strm
, 0, sizeof strm
);
13695 strm
.avail_in
= compressed_size
;
13696 strm
.next_in
= (Bytef
*) compressed_buffer
;
13697 strm
.avail_out
= uncompressed_size
;
13698 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13700 rc
= inflateInit (& strm
);
13701 while (strm
.avail_in
> 0)
13705 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13706 + (uncompressed_size
- strm
.avail_out
));
13707 rc
= inflate (&strm
, Z_FINISH
);
13708 if (rc
!= Z_STREAM_END
)
13710 rc
= inflateReset (& strm
);
13712 rc
= inflateEnd (& strm
);
13714 || strm
.avail_out
!= 0)
13717 *buffer
= uncompressed_buffer
;
13718 *size
= uncompressed_size
;
13722 free (uncompressed_buffer
);
13723 /* Indicate decompression failure. */
13729 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13731 Elf_Internal_Shdr
* relsec
;
13732 bfd_size_type num_bytes
;
13733 unsigned char * data
;
13734 unsigned char * end
;
13735 unsigned char * real_start
;
13736 unsigned char * start
;
13737 bfd_boolean some_strings_shown
;
13739 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13741 /* PR 21820: Do not fail if the section was empty. */
13742 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13744 num_bytes
= section
->sh_size
;
13746 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13748 if (decompress_dumps
)
13750 dwarf_size_type new_size
= num_bytes
;
13751 dwarf_size_type uncompressed_size
= 0;
13753 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13755 Elf_Internal_Chdr chdr
;
13756 unsigned int compression_header_size
13757 = get_compression_header (& chdr
, (unsigned char *) start
,
13759 if (compression_header_size
== 0)
13760 /* An error message will have already been generated
13761 by get_compression_header. */
13764 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13766 warn (_("section '%s' has unsupported compress type: %d\n"),
13767 printable_section_name (filedata
, section
), chdr
.ch_type
);
13770 uncompressed_size
= chdr
.ch_size
;
13771 start
+= compression_header_size
;
13772 new_size
-= compression_header_size
;
13774 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13776 /* Read the zlib header. In this case, it should be "ZLIB"
13777 followed by the uncompressed section size, 8 bytes in
13778 big-endian order. */
13779 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13780 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13781 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13782 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13783 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13784 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13785 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13786 uncompressed_size
+= start
[11];
13791 if (uncompressed_size
)
13793 if (uncompress_section_contents (& start
,
13794 uncompressed_size
, & new_size
))
13795 num_bytes
= new_size
;
13798 error (_("Unable to decompress section %s\n"),
13799 printable_section_name (filedata
, section
));
13804 start
= real_start
;
13807 /* If the section being dumped has relocations against it the user might
13808 be expecting these relocations to have been applied. Check for this
13809 case and issue a warning message in order to avoid confusion.
13810 FIXME: Maybe we ought to have an option that dumps a section with
13811 relocs applied ? */
13812 for (relsec
= filedata
->section_headers
;
13813 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13816 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13817 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13818 || filedata
->section_headers
+ relsec
->sh_info
!= section
13819 || relsec
->sh_size
== 0
13820 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13823 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13828 end
= start
+ num_bytes
;
13829 some_strings_shown
= FALSE
;
13831 #ifdef HAVE_MBSTATE_T
13833 /* Initialise the multibyte conversion state. */
13834 memset (& state
, 0, sizeof (state
));
13837 bfd_boolean continuing
= FALSE
;
13841 while (!ISPRINT (* data
))
13842 if (++ data
>= end
)
13847 size_t maxlen
= end
- data
;
13852 continuing
= FALSE
;
13857 /* PR 11128: Use two separate invocations in order to work
13858 around bugs in the Solaris 8 implementation of printf. */
13859 printf (" [%6tx] ", data
- start
);
13861 printf (" [%6Ix] ", (size_t) (data
- start
));
13876 /* PR 25543: Treat new-lines as string-ending characters. */
13885 /* Do not print control characters directly as they can affect terminal
13886 settings. Such characters usually appear in the names generated
13887 by the assembler for local labels. */
13890 printf ("^%c", c
+ 0x40);
13892 else if (ISPRINT (c
))
13899 #ifdef HAVE_MBSTATE_T
13902 /* Let printf do the hard work of displaying multibyte characters. */
13903 printf ("%.1s", data
- 1);
13904 #ifdef HAVE_MBSTATE_T
13905 /* Try to find out how many bytes made up the character that was
13906 just printed. Advance the symbol pointer past the bytes that
13908 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13912 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13922 printf (_("<corrupt>\n"));
13925 some_strings_shown
= TRUE
;
13929 if (! some_strings_shown
)
13930 printf (_(" No strings found in this section."));
13943 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13944 Filedata
* filedata
,
13945 bfd_boolean relocate
)
13947 Elf_Internal_Shdr
* relsec
;
13948 bfd_size_type bytes
;
13949 bfd_size_type section_size
;
13951 unsigned char * data
;
13952 unsigned char * real_start
;
13953 unsigned char * start
;
13955 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13957 /* PR 21820: Do not fail if the section was empty. */
13958 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13960 section_size
= section
->sh_size
;
13962 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13964 if (decompress_dumps
)
13966 dwarf_size_type new_size
= section_size
;
13967 dwarf_size_type uncompressed_size
= 0;
13969 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13971 Elf_Internal_Chdr chdr
;
13972 unsigned int compression_header_size
13973 = get_compression_header (& chdr
, start
, section_size
);
13975 if (compression_header_size
== 0)
13976 /* An error message will have already been generated
13977 by get_compression_header. */
13980 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13982 warn (_("section '%s' has unsupported compress type: %d\n"),
13983 printable_section_name (filedata
, section
), chdr
.ch_type
);
13986 uncompressed_size
= chdr
.ch_size
;
13987 start
+= compression_header_size
;
13988 new_size
-= compression_header_size
;
13990 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13992 /* Read the zlib header. In this case, it should be "ZLIB"
13993 followed by the uncompressed section size, 8 bytes in
13994 big-endian order. */
13995 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13996 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13997 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13998 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13999 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14000 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14001 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14002 uncompressed_size
+= start
[11];
14007 if (uncompressed_size
)
14009 if (uncompress_section_contents (& start
, uncompressed_size
,
14012 section_size
= new_size
;
14016 error (_("Unable to decompress section %s\n"),
14017 printable_section_name (filedata
, section
));
14018 /* FIXME: Print the section anyway ? */
14023 start
= real_start
;
14028 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14033 /* If the section being dumped has relocations against it the user might
14034 be expecting these relocations to have been applied. Check for this
14035 case and issue a warning message in order to avoid confusion.
14036 FIXME: Maybe we ought to have an option that dumps a section with
14037 relocs applied ? */
14038 for (relsec
= filedata
->section_headers
;
14039 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14042 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14043 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14044 || filedata
->section_headers
+ relsec
->sh_info
!= section
14045 || relsec
->sh_size
== 0
14046 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14049 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14054 addr
= section
->sh_addr
;
14055 bytes
= section_size
;
14064 lbytes
= (bytes
> 16 ? 16 : bytes
);
14066 printf (" 0x%8.8lx ", (unsigned long) addr
);
14068 for (j
= 0; j
< 16; j
++)
14071 printf ("%2.2x", data
[j
]);
14079 for (j
= 0; j
< lbytes
; j
++)
14082 if (k
>= ' ' && k
< 0x7f)
14105 static ctf_sect_t
*
14106 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14108 buf
->cts_name
= SECTION_NAME (shdr
);
14109 buf
->cts_size
= shdr
->sh_size
;
14110 buf
->cts_entsize
= shdr
->sh_entsize
;
14115 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14116 it is passed, or a pointer to newly-allocated storage, in which case
14117 dump_ctf() will free it when it no longer needs it. */
14119 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14120 char *s
, void *arg
)
14122 const char *blanks
= arg
;
14125 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14131 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14133 Elf_Internal_Shdr
* parent_sec
= NULL
;
14134 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14135 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14136 void * data
= NULL
;
14137 void * symdata
= NULL
;
14138 void * strdata
= NULL
;
14139 void * parentdata
= NULL
;
14140 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14141 ctf_sect_t
* symsectp
= NULL
;
14142 ctf_sect_t
* strsectp
= NULL
;
14143 ctf_file_t
* ctf
= NULL
;
14144 ctf_file_t
* parent
= NULL
;
14146 const char *things
[] = {"Header", "Labels", "Data objects",
14147 "Function objects", "Variables", "Types", "Strings",
14149 const char **thing
;
14151 bfd_boolean ret
= FALSE
;
14154 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14155 data
= get_section_contents (section
, filedata
);
14156 ctfsect
.cts_data
= data
;
14158 if (!dump_ctf_symtab_name
)
14159 dump_ctf_symtab_name
= strdup (".symtab");
14161 if (!dump_ctf_strtab_name
)
14162 dump_ctf_strtab_name
= strdup (".strtab");
14164 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14166 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14168 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14171 if ((symdata
= (void *) get_data (NULL
, filedata
,
14172 symtab_sec
->sh_offset
, 1,
14173 symtab_sec
->sh_size
,
14174 _("symbols"))) == NULL
)
14176 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14177 symsect
.cts_data
= symdata
;
14179 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14181 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14183 error (_("No string table section named %s\n"),
14184 dump_ctf_strtab_name
);
14187 if ((strdata
= (void *) get_data (NULL
, filedata
,
14188 strtab_sec
->sh_offset
, 1,
14189 strtab_sec
->sh_size
,
14190 _("strings"))) == NULL
)
14192 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14193 strsect
.cts_data
= strdata
;
14195 if (dump_ctf_parent_name
)
14197 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14199 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14202 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14203 parent_sec
->sh_offset
, 1,
14204 parent_sec
->sh_size
,
14205 _("CTF parent"))) == NULL
)
14207 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14208 parentsect
.cts_data
= parentdata
;
14211 /* Load the CTF file and dump it. */
14213 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14215 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14221 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14223 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14227 ctf_import (ctf
, parent
);
14232 printf (_("\nDump of CTF section '%s':\n"),
14233 printable_section_name (filedata
, section
));
14235 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14237 ctf_dump_state_t
*s
= NULL
;
14240 printf ("\n %s:\n", *thing
);
14241 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14242 (void *) " ")) != NULL
)
14244 printf ("%s\n", item
);
14248 if (ctf_errno (ctf
))
14250 error (_("Iteration failed: %s, %s\n"), *thing
,
14251 ctf_errmsg (ctf_errno (ctf
)));
14257 ctf_file_close (ctf
);
14258 ctf_file_close (parent
);
14267 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14268 const Elf_Internal_Shdr
* sec
,
14271 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14273 Filedata
* filedata
= (Filedata
*) data
;
14275 if (section
->start
!= NULL
)
14277 /* If it is already loaded, do nothing. */
14278 if (streq (section
->filename
, filedata
->file_name
))
14280 free (section
->start
);
14283 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14284 section
->address
= sec
->sh_addr
;
14285 section
->user_data
= NULL
;
14286 section
->filename
= filedata
->file_name
;
14287 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14289 sec
->sh_size
, buf
);
14290 if (section
->start
== NULL
)
14294 unsigned char *start
= section
->start
;
14295 dwarf_size_type size
= sec
->sh_size
;
14296 dwarf_size_type uncompressed_size
= 0;
14298 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14300 Elf_Internal_Chdr chdr
;
14301 unsigned int compression_header_size
;
14303 if (size
< (is_32bit_elf
14304 ? sizeof (Elf32_External_Chdr
)
14305 : sizeof (Elf64_External_Chdr
)))
14307 warn (_("compressed section %s is too small to contain a compression header\n"),
14312 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14313 if (compression_header_size
== 0)
14314 /* An error message will have already been generated
14315 by get_compression_header. */
14318 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14320 warn (_("section '%s' has unsupported compress type: %d\n"),
14321 section
->name
, chdr
.ch_type
);
14324 uncompressed_size
= chdr
.ch_size
;
14325 start
+= compression_header_size
;
14326 size
-= compression_header_size
;
14328 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14330 /* Read the zlib header. In this case, it should be "ZLIB"
14331 followed by the uncompressed section size, 8 bytes in
14332 big-endian order. */
14333 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14334 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14335 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14336 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14337 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14338 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14339 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14340 uncompressed_size
+= start
[11];
14345 if (uncompressed_size
)
14347 if (uncompress_section_contents (&start
, uncompressed_size
,
14350 /* Free the compressed buffer, update the section buffer
14351 and the section size if uncompress is successful. */
14352 free (section
->start
);
14353 section
->start
= start
;
14357 error (_("Unable to decompress section %s\n"),
14358 printable_section_name (filedata
, sec
));
14363 section
->size
= size
;
14366 if (section
->start
== NULL
)
14369 if (debug_displays
[debug
].relocate
)
14371 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14372 & section
->reloc_info
, & section
->num_relocs
))
14377 section
->reloc_info
= NULL
;
14378 section
->num_relocs
= 0;
14384 #if HAVE_LIBDEBUGINFOD
14385 /* Return a hex string representation of the build-id. */
14387 get_build_id (void * data
)
14389 Filedata
* filedata
= (Filedata
*)data
;
14390 Elf_Internal_Shdr
* shdr
;
14393 /* Iterate through notes to find note.gnu.build-id.
14394 FIXME: Only the first note in any note section is examined. */
14395 for (i
= 0, shdr
= filedata
->section_headers
;
14396 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14399 if (shdr
->sh_type
!= SHT_NOTE
)
14404 size_t data_remaining
;
14406 Elf_External_Note
* enote
;
14407 Elf_Internal_Note inote
;
14409 bfd_vma offset
= shdr
->sh_offset
;
14410 bfd_vma align
= shdr
->sh_addralign
;
14411 bfd_vma length
= shdr
->sh_size
;
14413 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14419 else if (align
!= 4 && align
!= 8)
14425 end
= (char *) enote
+ length
;
14426 data_remaining
= end
- (char *) enote
;
14428 if (!is_ia64_vms (filedata
))
14430 min_notesz
= offsetof (Elf_External_Note
, name
);
14431 if (data_remaining
< min_notesz
)
14434 malformed note encountered in section %s whilst scanning for build-id note\n"),
14435 printable_section_name (filedata
, shdr
));
14439 data_remaining
-= min_notesz
;
14441 inote
.type
= BYTE_GET (enote
->type
);
14442 inote
.namesz
= BYTE_GET (enote
->namesz
);
14443 inote
.namedata
= enote
->name
;
14444 inote
.descsz
= BYTE_GET (enote
->descsz
);
14445 inote
.descdata
= ((char *) enote
14446 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14447 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14448 next
= ((char *) enote
14449 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14453 Elf64_External_VMS_Note
*vms_enote
;
14455 /* PR binutils/15191
14456 Make sure that there is enough data to read. */
14457 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14458 if (data_remaining
< min_notesz
)
14461 malformed note encountered in section %s whilst scanning for build-id note\n"),
14462 printable_section_name (filedata
, shdr
));
14466 data_remaining
-= min_notesz
;
14468 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14469 inote
.type
= BYTE_GET (vms_enote
->type
);
14470 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14471 inote
.namedata
= vms_enote
->name
;
14472 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14473 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14474 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14475 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14478 /* Skip malformed notes. */
14479 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14480 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14481 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14482 || ((size_t) (next
- inote
.descdata
)
14483 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14486 malformed note encountered in section %s whilst scanning for build-id note\n"),
14487 printable_section_name (filedata
, shdr
));
14492 /* Check if this is the build-id note. If so then convert the build-id
14493 bytes to a hex string. */
14494 if (inote
.namesz
> 0
14495 && const_strneq (inote
.namedata
, "GNU")
14496 && inote
.type
== NT_GNU_BUILD_ID
)
14501 build_id
= malloc (inote
.descsz
* 2 + 1);
14502 if (build_id
== NULL
)
14508 for (j
= 0; j
< inote
.descsz
; ++j
)
14509 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14510 build_id
[inote
.descsz
* 2] = '\0';
14513 return (unsigned char *) build_id
;
14520 #endif /* HAVE_LIBDEBUGINFOD */
14522 /* If this is not NULL, load_debug_section will only look for sections
14523 within the list of sections given here. */
14524 static unsigned int * section_subset
= NULL
;
14527 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14529 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14530 Elf_Internal_Shdr
* sec
;
14531 Filedata
* filedata
= (Filedata
*) data
;
14533 /* Without section headers we cannot find any sections. */
14534 if (filedata
->section_headers
== NULL
)
14537 if (filedata
->string_table
== NULL
14538 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14539 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14541 Elf_Internal_Shdr
* strs
;
14543 /* Read in the string table, so that we have section names to scan. */
14544 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14546 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14548 filedata
->string_table
14549 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14550 1, strs
->sh_size
, _("string table"));
14552 filedata
->string_table_length
14553 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14557 /* Locate the debug section. */
14558 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14560 section
->name
= section
->uncompressed_name
;
14563 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14565 section
->name
= section
->compressed_name
;
14570 /* If we're loading from a subset of sections, and we've loaded
14571 a section matching this name before, it's likely that it's a
14573 if (section_subset
!= NULL
)
14574 free_debug_section (debug
);
14576 return load_specific_debug_section (debug
, sec
, data
);
14580 free_debug_section (enum dwarf_section_display_enum debug
)
14582 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14584 if (section
->start
== NULL
)
14587 free ((char *) section
->start
);
14588 section
->start
= NULL
;
14589 section
->address
= 0;
14592 if (section
->reloc_info
!= NULL
)
14594 free (section
->reloc_info
);
14595 section
->reloc_info
= NULL
;
14596 section
->num_relocs
= 0;
14601 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14603 char * name
= SECTION_NAME (section
);
14604 const char * print_name
= printable_section_name (filedata
, section
);
14605 bfd_size_type length
;
14606 bfd_boolean result
= TRUE
;
14609 length
= section
->sh_size
;
14612 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14615 if (section
->sh_type
== SHT_NOBITS
)
14617 /* There is no point in dumping the contents of a debugging section
14618 which has the NOBITS type - the bits in the file will be random.
14619 This can happen when a file containing a .eh_frame section is
14620 stripped with the --only-keep-debug command line option. */
14621 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14626 if (const_strneq (name
, ".gnu.linkonce.wi."))
14627 name
= ".debug_info";
14629 /* See if we know how to display the contents of this section. */
14630 for (i
= 0; i
< max
; i
++)
14632 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14633 struct dwarf_section_display
* display
= debug_displays
+ i
;
14634 struct dwarf_section
* sec
= & display
->section
;
14636 if (streq (sec
->uncompressed_name
, name
)
14637 || (id
== line
&& const_strneq (name
, ".debug_line."))
14638 || streq (sec
->compressed_name
, name
))
14640 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14643 free_debug_section (id
);
14645 if (i
== line
&& const_strneq (name
, ".debug_line."))
14647 else if (streq (sec
->uncompressed_name
, name
))
14648 sec
->name
= sec
->uncompressed_name
;
14650 sec
->name
= sec
->compressed_name
;
14652 if (load_specific_debug_section (id
, section
, filedata
))
14654 /* If this debug section is part of a CU/TU set in a .dwp file,
14655 restrict load_debug_section to the sections in that set. */
14656 section_subset
= find_cu_tu_set (filedata
, shndx
);
14658 result
&= display
->display (sec
, filedata
);
14660 section_subset
= NULL
;
14662 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14663 free_debug_section (id
);
14671 printf (_("Unrecognized debug section: %s\n"), print_name
);
14678 /* Set DUMP_SECTS for all sections where dumps were requested
14679 based on section name. */
14682 initialise_dumps_byname (Filedata
* filedata
)
14684 struct dump_list_entry
* cur
;
14686 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14689 bfd_boolean any
= FALSE
;
14691 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14692 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14694 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14699 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14705 process_section_contents (Filedata
* filedata
)
14707 Elf_Internal_Shdr
* section
;
14709 bfd_boolean res
= TRUE
;
14714 initialise_dumps_byname (filedata
);
14716 for (i
= 0, section
= filedata
->section_headers
;
14717 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14720 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14722 #ifdef SUPPORT_DISASSEMBLY
14723 if (dump
& DISASS_DUMP
)
14725 if (! disassemble_section (section
, filedata
))
14729 if (dump
& HEX_DUMP
)
14731 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14735 if (dump
& RELOC_DUMP
)
14737 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14741 if (dump
& STRING_DUMP
)
14743 if (! dump_section_as_strings (section
, filedata
))
14747 if (dump
& DEBUG_DUMP
)
14749 if (! display_debug_section (i
, section
, filedata
))
14753 if (dump
& CTF_DUMP
)
14755 if (! dump_section_as_ctf (section
, filedata
))
14760 /* Check to see if the user requested a
14761 dump of a section that does not exist. */
14762 while (i
< filedata
->dump
.num_dump_sects
)
14764 if (filedata
->dump
.dump_sects
[i
])
14766 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14776 process_mips_fpe_exception (int mask
)
14780 bfd_boolean first
= TRUE
;
14782 if (mask
& OEX_FPU_INEX
)
14783 fputs ("INEX", stdout
), first
= FALSE
;
14784 if (mask
& OEX_FPU_UFLO
)
14785 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14786 if (mask
& OEX_FPU_OFLO
)
14787 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14788 if (mask
& OEX_FPU_DIV0
)
14789 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14790 if (mask
& OEX_FPU_INVAL
)
14791 printf ("%sINVAL", first
? "" : "|");
14794 fputs ("0", stdout
);
14797 /* Display's the value of TAG at location P. If TAG is
14798 greater than 0 it is assumed to be an unknown tag, and
14799 a message is printed to this effect. Otherwise it is
14800 assumed that a message has already been printed.
14802 If the bottom bit of TAG is set it assumed to have a
14803 string value, otherwise it is assumed to have an integer
14806 Returns an updated P pointing to the first unread byte
14807 beyond the end of TAG's value.
14809 Reads at or beyond END will not be made. */
14811 static unsigned char *
14812 display_tag_value (signed int tag
,
14814 const unsigned char * const end
)
14819 printf (" Tag_unknown_%d: ", tag
);
14823 warn (_("<corrupt tag>\n"));
14827 /* PR 17531 file: 027-19978-0.004. */
14828 size_t maxlen
= (end
- p
) - 1;
14833 print_symbol ((int) maxlen
, (const char *) p
);
14834 p
+= strnlen ((char *) p
, maxlen
) + 1;
14838 printf (_("<corrupt string tag>"));
14839 p
= (unsigned char *) end
;
14845 READ_ULEB (val
, p
, end
);
14846 printf ("%ld (0x%lx)\n", val
, val
);
14853 /* ARC ABI attributes section. */
14855 static unsigned char *
14856 display_arc_attribute (unsigned char * p
,
14857 const unsigned char * const end
)
14862 READ_ULEB (tag
, p
, end
);
14866 case Tag_ARC_PCS_config
:
14867 READ_ULEB (val
, p
, end
);
14868 printf (" Tag_ARC_PCS_config: ");
14872 printf (_("Absent/Non standard\n"));
14875 printf (_("Bare metal/mwdt\n"));
14878 printf (_("Bare metal/newlib\n"));
14881 printf (_("Linux/uclibc\n"));
14884 printf (_("Linux/glibc\n"));
14887 printf (_("Unknown\n"));
14892 case Tag_ARC_CPU_base
:
14893 READ_ULEB (val
, p
, end
);
14894 printf (" Tag_ARC_CPU_base: ");
14899 printf (_("Absent\n"));
14901 case TAG_CPU_ARC6xx
:
14902 printf ("ARC6xx\n");
14904 case TAG_CPU_ARC7xx
:
14905 printf ("ARC7xx\n");
14907 case TAG_CPU_ARCEM
:
14908 printf ("ARCEM\n");
14910 case TAG_CPU_ARCHS
:
14911 printf ("ARCHS\n");
14916 case Tag_ARC_CPU_variation
:
14917 READ_ULEB (val
, p
, end
);
14918 printf (" Tag_ARC_CPU_variation: ");
14922 if (val
> 0 && val
< 16)
14923 printf ("Core%d\n", val
);
14925 printf ("Unknown\n");
14929 printf (_("Absent\n"));
14934 case Tag_ARC_CPU_name
:
14935 printf (" Tag_ARC_CPU_name: ");
14936 p
= display_tag_value (-1, p
, end
);
14939 case Tag_ARC_ABI_rf16
:
14940 READ_ULEB (val
, p
, end
);
14941 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14944 case Tag_ARC_ABI_osver
:
14945 READ_ULEB (val
, p
, end
);
14946 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14949 case Tag_ARC_ABI_pic
:
14950 case Tag_ARC_ABI_sda
:
14951 READ_ULEB (val
, p
, end
);
14952 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14953 : " Tag_ARC_ABI_pic: ");
14957 printf (_("Absent\n"));
14966 printf (_("Unknown\n"));
14971 case Tag_ARC_ABI_tls
:
14972 READ_ULEB (val
, p
, end
);
14973 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14976 case Tag_ARC_ABI_enumsize
:
14977 READ_ULEB (val
, p
, end
);
14978 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14982 case Tag_ARC_ABI_exceptions
:
14983 READ_ULEB (val
, p
, end
);
14984 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14988 case Tag_ARC_ABI_double_size
:
14989 READ_ULEB (val
, p
, end
);
14990 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14993 case Tag_ARC_ISA_config
:
14994 printf (" Tag_ARC_ISA_config: ");
14995 p
= display_tag_value (-1, p
, end
);
14998 case Tag_ARC_ISA_apex
:
14999 printf (" Tag_ARC_ISA_apex: ");
15000 p
= display_tag_value (-1, p
, end
);
15003 case Tag_ARC_ISA_mpy_option
:
15004 READ_ULEB (val
, p
, end
);
15005 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15008 case Tag_ARC_ATR_version
:
15009 READ_ULEB (val
, p
, end
);
15010 printf (" Tag_ARC_ATR_version: %d\n", val
);
15014 return display_tag_value (tag
& 1, p
, end
);
15020 /* ARM EABI attributes section. */
15025 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15027 const char ** table
;
15028 } arm_attr_public_tag
;
15030 static const char * arm_attr_tag_CPU_arch
[] =
15031 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15032 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15033 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15034 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15035 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15036 {"No", "Thumb-1", "Thumb-2", "Yes"};
15037 static const char * arm_attr_tag_FP_arch
[] =
15038 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15039 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15040 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15041 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15042 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15043 "NEON for ARMv8.1"};
15044 static const char * arm_attr_tag_PCS_config
[] =
15045 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15046 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15047 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15048 {"V6", "SB", "TLS", "Unused"};
15049 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15050 {"Absolute", "PC-relative", "SB-relative", "None"};
15051 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15052 {"Absolute", "PC-relative", "None"};
15053 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15054 {"None", "direct", "GOT-indirect"};
15055 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15056 {"None", "??? 1", "2", "??? 3", "4"};
15057 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15058 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15059 {"Unused", "Needed", "Sign only"};
15060 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15061 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15062 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15063 {"Unused", "Finite", "RTABI", "IEEE 754"};
15064 static const char * arm_attr_tag_ABI_enum_size
[] =
15065 {"Unused", "small", "int", "forced to int"};
15066 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15067 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15068 static const char * arm_attr_tag_ABI_VFP_args
[] =
15069 {"AAPCS", "VFP registers", "custom", "compatible"};
15070 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15071 {"AAPCS", "WMMX registers", "custom"};
15072 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15073 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15074 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15075 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15076 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15077 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15078 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15079 static const char * arm_attr_tag_FP_HP_extension
[] =
15080 {"Not Allowed", "Allowed"};
15081 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15082 {"None", "IEEE 754", "Alternative Format"};
15083 static const char * arm_attr_tag_DSP_extension
[] =
15084 {"Follow architecture", "Allowed"};
15085 static const char * arm_attr_tag_MPextension_use
[] =
15086 {"Not Allowed", "Allowed"};
15087 static const char * arm_attr_tag_DIV_use
[] =
15088 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15089 "Allowed in v7-A with integer division extension"};
15090 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15091 static const char * arm_attr_tag_Virtualization_use
[] =
15092 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15093 "TrustZone and Virtualization Extensions"};
15094 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15095 {"Not Allowed", "Allowed"};
15097 static const char * arm_attr_tag_MVE_arch
[] =
15098 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15100 #define LOOKUP(id, name) \
15101 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15102 static arm_attr_public_tag arm_attr_public_tags
[] =
15104 {4, "CPU_raw_name", 1, NULL
},
15105 {5, "CPU_name", 1, NULL
},
15106 LOOKUP(6, CPU_arch
),
15107 {7, "CPU_arch_profile", 0, NULL
},
15108 LOOKUP(8, ARM_ISA_use
),
15109 LOOKUP(9, THUMB_ISA_use
),
15110 LOOKUP(10, FP_arch
),
15111 LOOKUP(11, WMMX_arch
),
15112 LOOKUP(12, Advanced_SIMD_arch
),
15113 LOOKUP(13, PCS_config
),
15114 LOOKUP(14, ABI_PCS_R9_use
),
15115 LOOKUP(15, ABI_PCS_RW_data
),
15116 LOOKUP(16, ABI_PCS_RO_data
),
15117 LOOKUP(17, ABI_PCS_GOT_use
),
15118 LOOKUP(18, ABI_PCS_wchar_t
),
15119 LOOKUP(19, ABI_FP_rounding
),
15120 LOOKUP(20, ABI_FP_denormal
),
15121 LOOKUP(21, ABI_FP_exceptions
),
15122 LOOKUP(22, ABI_FP_user_exceptions
),
15123 LOOKUP(23, ABI_FP_number_model
),
15124 {24, "ABI_align_needed", 0, NULL
},
15125 {25, "ABI_align_preserved", 0, NULL
},
15126 LOOKUP(26, ABI_enum_size
),
15127 LOOKUP(27, ABI_HardFP_use
),
15128 LOOKUP(28, ABI_VFP_args
),
15129 LOOKUP(29, ABI_WMMX_args
),
15130 LOOKUP(30, ABI_optimization_goals
),
15131 LOOKUP(31, ABI_FP_optimization_goals
),
15132 {32, "compatibility", 0, NULL
},
15133 LOOKUP(34, CPU_unaligned_access
),
15134 LOOKUP(36, FP_HP_extension
),
15135 LOOKUP(38, ABI_FP_16bit_format
),
15136 LOOKUP(42, MPextension_use
),
15137 LOOKUP(44, DIV_use
),
15138 LOOKUP(46, DSP_extension
),
15139 LOOKUP(48, MVE_arch
),
15140 {64, "nodefaults", 0, NULL
},
15141 {65, "also_compatible_with", 0, NULL
},
15142 LOOKUP(66, T2EE_use
),
15143 {67, "conformance", 1, NULL
},
15144 LOOKUP(68, Virtualization_use
),
15145 LOOKUP(70, MPextension_use_legacy
)
15149 static unsigned char *
15150 display_arm_attribute (unsigned char * p
,
15151 const unsigned char * const end
)
15155 arm_attr_public_tag
* attr
;
15159 READ_ULEB (tag
, p
, end
);
15161 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15163 if (arm_attr_public_tags
[i
].tag
== tag
)
15165 attr
= &arm_attr_public_tags
[i
];
15172 printf (" Tag_%s: ", attr
->name
);
15173 switch (attr
->type
)
15178 case 7: /* Tag_CPU_arch_profile. */
15179 READ_ULEB (val
, p
, end
);
15182 case 0: printf (_("None\n")); break;
15183 case 'A': printf (_("Application\n")); break;
15184 case 'R': printf (_("Realtime\n")); break;
15185 case 'M': printf (_("Microcontroller\n")); break;
15186 case 'S': printf (_("Application or Realtime\n")); break;
15187 default: printf ("??? (%d)\n", val
); break;
15191 case 24: /* Tag_align_needed. */
15192 READ_ULEB (val
, p
, end
);
15195 case 0: printf (_("None\n")); break;
15196 case 1: printf (_("8-byte\n")); break;
15197 case 2: printf (_("4-byte\n")); break;
15198 case 3: printf ("??? 3\n"); break;
15201 printf (_("8-byte and up to %d-byte extended\n"),
15204 printf ("??? (%d)\n", val
);
15209 case 25: /* Tag_align_preserved. */
15210 READ_ULEB (val
, p
, end
);
15213 case 0: printf (_("None\n")); break;
15214 case 1: printf (_("8-byte, except leaf SP\n")); break;
15215 case 2: printf (_("8-byte\n")); break;
15216 case 3: printf ("??? 3\n"); break;
15219 printf (_("8-byte and up to %d-byte extended\n"),
15222 printf ("??? (%d)\n", val
);
15227 case 32: /* Tag_compatibility. */
15229 READ_ULEB (val
, p
, end
);
15230 printf (_("flag = %d, vendor = "), val
);
15233 size_t maxlen
= (end
- p
) - 1;
15235 print_symbol ((int) maxlen
, (const char *) p
);
15236 p
+= strnlen ((char *) p
, maxlen
) + 1;
15240 printf (_("<corrupt>"));
15241 p
= (unsigned char *) end
;
15247 case 64: /* Tag_nodefaults. */
15248 /* PR 17531: file: 001-505008-0.01. */
15251 printf (_("True\n"));
15254 case 65: /* Tag_also_compatible_with. */
15255 READ_ULEB (val
, p
, end
);
15256 if (val
== 6 /* Tag_CPU_arch. */)
15258 READ_ULEB (val
, p
, end
);
15259 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15260 printf ("??? (%d)\n", val
);
15262 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15266 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15271 printf (_("<unknown: %d>\n"), tag
);
15277 return display_tag_value (-1, p
, end
);
15279 return display_tag_value (0, p
, end
);
15282 assert (attr
->type
& 0x80);
15283 READ_ULEB (val
, p
, end
);
15284 type
= attr
->type
& 0x7f;
15286 printf ("??? (%d)\n", val
);
15288 printf ("%s\n", attr
->table
[val
]);
15293 return display_tag_value (tag
, p
, end
);
15296 static unsigned char *
15297 display_gnu_attribute (unsigned char * p
,
15298 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15299 const unsigned char * const end
)
15304 READ_ULEB (tag
, p
, end
);
15306 /* Tag_compatibility is the only generic GNU attribute defined at
15310 READ_ULEB (val
, p
, end
);
15312 printf (_("flag = %d, vendor = "), val
);
15315 printf (_("<corrupt>\n"));
15316 warn (_("corrupt vendor attribute\n"));
15322 size_t maxlen
= (end
- p
) - 1;
15324 print_symbol ((int) maxlen
, (const char *) p
);
15325 p
+= strnlen ((char *) p
, maxlen
) + 1;
15329 printf (_("<corrupt>"));
15330 p
= (unsigned char *) end
;
15337 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15338 return display_proc_gnu_attribute (p
, tag
, end
);
15340 return display_tag_value (tag
, p
, end
);
15343 static unsigned char *
15344 display_power_gnu_attribute (unsigned char * p
,
15346 const unsigned char * const end
)
15350 if (tag
== Tag_GNU_Power_ABI_FP
)
15352 printf (" Tag_GNU_Power_ABI_FP: ");
15355 printf (_("<corrupt>\n"));
15358 READ_ULEB (val
, p
, end
);
15361 printf ("(%#x), ", val
);
15366 printf (_("unspecified hard/soft float, "));
15369 printf (_("hard float, "));
15372 printf (_("soft float, "));
15375 printf (_("single-precision hard float, "));
15382 printf (_("unspecified long double\n"));
15385 printf (_("128-bit IBM long double\n"));
15388 printf (_("64-bit long double\n"));
15391 printf (_("128-bit IEEE long double\n"));
15397 if (tag
== Tag_GNU_Power_ABI_Vector
)
15399 printf (" Tag_GNU_Power_ABI_Vector: ");
15402 printf (_("<corrupt>\n"));
15405 READ_ULEB (val
, p
, end
);
15408 printf ("(%#x), ", val
);
15413 printf (_("unspecified\n"));
15416 printf (_("generic\n"));
15419 printf ("AltiVec\n");
15428 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15430 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15433 printf (_("<corrupt>\n"));
15436 READ_ULEB (val
, p
, end
);
15439 printf ("(%#x), ", val
);
15444 printf (_("unspecified\n"));
15447 printf ("r3/r4\n");
15450 printf (_("memory\n"));
15459 return display_tag_value (tag
& 1, p
, end
);
15462 static unsigned char *
15463 display_s390_gnu_attribute (unsigned char * p
,
15465 const unsigned char * const end
)
15469 if (tag
== Tag_GNU_S390_ABI_Vector
)
15471 printf (" Tag_GNU_S390_ABI_Vector: ");
15472 READ_ULEB (val
, p
, end
);
15477 printf (_("any\n"));
15480 printf (_("software\n"));
15483 printf (_("hardware\n"));
15486 printf ("??? (%d)\n", val
);
15492 return display_tag_value (tag
& 1, p
, end
);
15496 display_sparc_hwcaps (unsigned int mask
)
15500 bfd_boolean first
= TRUE
;
15502 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15503 fputs ("mul32", stdout
), first
= FALSE
;
15504 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15505 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15506 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15507 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15508 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15509 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15510 if (mask
& ELF_SPARC_HWCAP_POPC
)
15511 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15512 if (mask
& ELF_SPARC_HWCAP_VIS
)
15513 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15514 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15515 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15516 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15517 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15518 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15519 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15520 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15521 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15522 if (mask
& ELF_SPARC_HWCAP_HPC
)
15523 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15524 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15525 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15526 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15527 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15528 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15529 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15530 if (mask
& ELF_SPARC_HWCAP_IMA
)
15531 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15532 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15533 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15536 fputc ('0', stdout
);
15537 fputc ('\n', stdout
);
15541 display_sparc_hwcaps2 (unsigned int mask
)
15545 bfd_boolean first
= TRUE
;
15547 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15548 fputs ("fjathplus", stdout
), first
= FALSE
;
15549 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15550 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15551 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15552 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15553 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15554 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15555 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15556 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15557 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15558 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15559 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15560 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15561 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15562 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15563 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15564 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15565 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15566 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15567 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15568 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15571 fputc ('0', stdout
);
15572 fputc ('\n', stdout
);
15575 static unsigned char *
15576 display_sparc_gnu_attribute (unsigned char * p
,
15578 const unsigned char * const end
)
15582 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15584 READ_ULEB (val
, p
, end
);
15585 printf (" Tag_GNU_Sparc_HWCAPS: ");
15586 display_sparc_hwcaps (val
);
15589 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15591 READ_ULEB (val
, p
, end
);
15592 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15593 display_sparc_hwcaps2 (val
);
15597 return display_tag_value (tag
, p
, end
);
15601 print_mips_fp_abi_value (unsigned int val
)
15605 case Val_GNU_MIPS_ABI_FP_ANY
:
15606 printf (_("Hard or soft float\n"));
15608 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15609 printf (_("Hard float (double precision)\n"));
15611 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15612 printf (_("Hard float (single precision)\n"));
15614 case Val_GNU_MIPS_ABI_FP_SOFT
:
15615 printf (_("Soft float\n"));
15617 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15618 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15620 case Val_GNU_MIPS_ABI_FP_XX
:
15621 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15623 case Val_GNU_MIPS_ABI_FP_64
:
15624 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15626 case Val_GNU_MIPS_ABI_FP_64A
:
15627 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15629 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15630 printf (_("NaN 2008 compatibility\n"));
15633 printf ("??? (%d)\n", val
);
15638 static unsigned char *
15639 display_mips_gnu_attribute (unsigned char * p
,
15641 const unsigned char * const end
)
15643 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15647 printf (" Tag_GNU_MIPS_ABI_FP: ");
15648 READ_ULEB (val
, p
, end
);
15649 print_mips_fp_abi_value (val
);
15653 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15657 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15658 READ_ULEB (val
, p
, end
);
15662 case Val_GNU_MIPS_ABI_MSA_ANY
:
15663 printf (_("Any MSA or not\n"));
15665 case Val_GNU_MIPS_ABI_MSA_128
:
15666 printf (_("128-bit MSA\n"));
15669 printf ("??? (%d)\n", val
);
15675 return display_tag_value (tag
& 1, p
, end
);
15678 static unsigned char *
15679 display_tic6x_attribute (unsigned char * p
,
15680 const unsigned char * const end
)
15685 READ_ULEB (tag
, p
, end
);
15690 printf (" Tag_ISA: ");
15691 READ_ULEB (val
, p
, end
);
15695 case C6XABI_Tag_ISA_none
:
15696 printf (_("None\n"));
15698 case C6XABI_Tag_ISA_C62X
:
15701 case C6XABI_Tag_ISA_C67X
:
15704 case C6XABI_Tag_ISA_C67XP
:
15705 printf ("C67x+\n");
15707 case C6XABI_Tag_ISA_C64X
:
15710 case C6XABI_Tag_ISA_C64XP
:
15711 printf ("C64x+\n");
15713 case C6XABI_Tag_ISA_C674X
:
15714 printf ("C674x\n");
15717 printf ("??? (%d)\n", val
);
15722 case Tag_ABI_wchar_t
:
15723 printf (" Tag_ABI_wchar_t: ");
15724 READ_ULEB (val
, p
, end
);
15728 printf (_("Not used\n"));
15731 printf (_("2 bytes\n"));
15734 printf (_("4 bytes\n"));
15737 printf ("??? (%d)\n", val
);
15742 case Tag_ABI_stack_align_needed
:
15743 printf (" Tag_ABI_stack_align_needed: ");
15744 READ_ULEB (val
, p
, end
);
15748 printf (_("8-byte\n"));
15751 printf (_("16-byte\n"));
15754 printf ("??? (%d)\n", val
);
15759 case Tag_ABI_stack_align_preserved
:
15760 READ_ULEB (val
, p
, end
);
15761 printf (" Tag_ABI_stack_align_preserved: ");
15765 printf (_("8-byte\n"));
15768 printf (_("16-byte\n"));
15771 printf ("??? (%d)\n", val
);
15777 READ_ULEB (val
, p
, end
);
15778 printf (" Tag_ABI_DSBT: ");
15782 printf (_("DSBT addressing not used\n"));
15785 printf (_("DSBT addressing used\n"));
15788 printf ("??? (%d)\n", val
);
15794 READ_ULEB (val
, p
, end
);
15795 printf (" Tag_ABI_PID: ");
15799 printf (_("Data addressing position-dependent\n"));
15802 printf (_("Data addressing position-independent, GOT near DP\n"));
15805 printf (_("Data addressing position-independent, GOT far from DP\n"));
15808 printf ("??? (%d)\n", val
);
15814 READ_ULEB (val
, p
, end
);
15815 printf (" Tag_ABI_PIC: ");
15819 printf (_("Code addressing position-dependent\n"));
15822 printf (_("Code addressing position-independent\n"));
15825 printf ("??? (%d)\n", val
);
15830 case Tag_ABI_array_object_alignment
:
15831 READ_ULEB (val
, p
, end
);
15832 printf (" Tag_ABI_array_object_alignment: ");
15836 printf (_("8-byte\n"));
15839 printf (_("4-byte\n"));
15842 printf (_("16-byte\n"));
15845 printf ("??? (%d)\n", val
);
15850 case Tag_ABI_array_object_align_expected
:
15851 READ_ULEB (val
, p
, end
);
15852 printf (" Tag_ABI_array_object_align_expected: ");
15856 printf (_("8-byte\n"));
15859 printf (_("4-byte\n"));
15862 printf (_("16-byte\n"));
15865 printf ("??? (%d)\n", val
);
15870 case Tag_ABI_compatibility
:
15872 READ_ULEB (val
, p
, end
);
15873 printf (" Tag_ABI_compatibility: ");
15874 printf (_("flag = %d, vendor = "), val
);
15877 size_t maxlen
= (end
- p
) - 1;
15879 print_symbol ((int) maxlen
, (const char *) p
);
15880 p
+= strnlen ((char *) p
, maxlen
) + 1;
15884 printf (_("<corrupt>"));
15885 p
= (unsigned char *) end
;
15891 case Tag_ABI_conformance
:
15893 printf (" Tag_ABI_conformance: \"");
15896 size_t maxlen
= (end
- p
) - 1;
15898 print_symbol ((int) maxlen
, (const char *) p
);
15899 p
+= strnlen ((char *) p
, maxlen
) + 1;
15903 printf (_("<corrupt>"));
15904 p
= (unsigned char *) end
;
15911 return display_tag_value (tag
, p
, end
);
15915 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15917 unsigned long addr
= 0;
15918 size_t bytes
= end
- p
;
15925 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15927 printf (" 0x%8.8lx ", addr
);
15929 for (j
= 0; j
< 16; j
++)
15932 printf ("%2.2x", p
[j
]);
15940 for (j
= 0; j
< lbytes
; j
++)
15943 if (k
>= ' ' && k
< 0x7f)
15959 static unsigned char *
15960 display_msp430x_attribute (unsigned char * p
,
15961 const unsigned char * const end
)
15966 READ_ULEB (tag
, p
, end
);
15970 case OFBA_MSPABI_Tag_ISA
:
15971 printf (" Tag_ISA: ");
15972 READ_ULEB (val
, p
, end
);
15975 case 0: printf (_("None\n")); break;
15976 case 1: printf (_("MSP430\n")); break;
15977 case 2: printf (_("MSP430X\n")); break;
15978 default: printf ("??? (%d)\n", val
); break;
15982 case OFBA_MSPABI_Tag_Code_Model
:
15983 printf (" Tag_Code_Model: ");
15984 READ_ULEB (val
, p
, end
);
15987 case 0: printf (_("None\n")); break;
15988 case 1: printf (_("Small\n")); break;
15989 case 2: printf (_("Large\n")); break;
15990 default: printf ("??? (%d)\n", val
); break;
15994 case OFBA_MSPABI_Tag_Data_Model
:
15995 printf (" Tag_Data_Model: ");
15996 READ_ULEB (val
, p
, end
);
15999 case 0: printf (_("None\n")); break;
16000 case 1: printf (_("Small\n")); break;
16001 case 2: printf (_("Large\n")); break;
16002 case 3: printf (_("Restricted Large\n")); break;
16003 default: printf ("??? (%d)\n", val
); break;
16008 printf (_(" <unknown tag %d>: "), tag
);
16015 size_t maxlen
= (end
- p
) - 1;
16017 print_symbol ((int) maxlen
, (const char *) p
);
16018 p
+= strnlen ((char *) p
, maxlen
) + 1;
16022 printf (_("<corrupt>"));
16023 p
= (unsigned char *) end
;
16029 READ_ULEB (val
, p
, end
);
16030 printf ("%d (0x%x)\n", val
, val
);
16039 static unsigned char *
16040 display_msp430_gnu_attribute (unsigned char * p
,
16042 const unsigned char * const end
)
16044 if (tag
== Tag_GNU_MSP430_Data_Region
)
16048 printf (" Tag_GNU_MSP430_Data_Region: ");
16049 READ_ULEB (val
, p
, end
);
16053 case Val_GNU_MSP430_Data_Region_Any
:
16054 printf (_("Any Region\n"));
16056 case Val_GNU_MSP430_Data_Region_Lower
:
16057 printf (_("Lower Region Only\n"));
16060 printf ("??? (%u)\n", val
);
16064 return display_tag_value (tag
& 1, p
, end
);
16067 struct riscv_attr_tag_t
{
16072 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16074 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16077 T(priv_spec_minor
),
16078 T(priv_spec_revision
),
16079 T(unaligned_access
),
16084 static unsigned char *
16085 display_riscv_attribute (unsigned char *p
,
16086 const unsigned char * const end
)
16090 struct riscv_attr_tag_t
*attr
= NULL
;
16093 READ_ULEB (tag
, p
, end
);
16095 /* Find the name of attribute. */
16096 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16098 if (riscv_attr_tag
[i
].tag
== tag
)
16100 attr
= &riscv_attr_tag
[i
];
16106 printf (" %s: ", attr
->name
);
16108 return display_tag_value (tag
, p
, end
);
16112 case Tag_RISCV_priv_spec
:
16113 case Tag_RISCV_priv_spec_minor
:
16114 case Tag_RISCV_priv_spec_revision
:
16115 READ_ULEB (val
, p
, end
);
16116 printf (_("%u\n"), val
);
16118 case Tag_RISCV_unaligned_access
:
16119 READ_ULEB (val
, p
, end
);
16123 printf (_("No unaligned access\n"));
16126 printf (_("Unaligned access\n"));
16130 case Tag_RISCV_stack_align
:
16131 READ_ULEB (val
, p
, end
);
16132 printf (_("%u-bytes\n"), val
);
16134 case Tag_RISCV_arch
:
16135 p
= display_tag_value (-1, p
, end
);
16138 return display_tag_value (tag
, p
, end
);
16145 process_attributes (Filedata
* filedata
,
16146 const char * public_name
,
16147 unsigned int proc_type
,
16148 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16149 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16151 Elf_Internal_Shdr
* sect
;
16153 bfd_boolean res
= TRUE
;
16155 /* Find the section header so that we get the size. */
16156 for (i
= 0, sect
= filedata
->section_headers
;
16157 i
< filedata
->file_header
.e_shnum
;
16160 unsigned char * contents
;
16163 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16166 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16167 sect
->sh_size
, _("attributes"));
16168 if (contents
== NULL
)
16175 /* The first character is the version of the attributes.
16176 Currently only version 1, (aka 'A') is recognised here. */
16179 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16184 bfd_vma section_len
;
16186 section_len
= sect
->sh_size
- 1;
16189 while (section_len
> 0)
16192 unsigned int namelen
;
16193 bfd_boolean public_section
;
16194 bfd_boolean gnu_section
;
16196 if (section_len
<= 4)
16198 error (_("Tag section ends prematurely\n"));
16202 attr_len
= byte_get (p
, 4);
16205 if (attr_len
> section_len
)
16207 error (_("Bad attribute length (%u > %u)\n"),
16208 (unsigned) attr_len
, (unsigned) section_len
);
16209 attr_len
= section_len
;
16212 /* PR 17531: file: 001-101425-0.004 */
16213 else if (attr_len
< 5)
16215 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16220 section_len
-= attr_len
;
16223 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16224 if (namelen
== 0 || namelen
>= attr_len
)
16226 error (_("Corrupt attribute section name\n"));
16231 printf (_("Attribute Section: "));
16232 print_symbol (INT_MAX
, (const char *) p
);
16235 if (public_name
&& streq ((char *) p
, public_name
))
16236 public_section
= TRUE
;
16238 public_section
= FALSE
;
16240 if (streq ((char *) p
, "gnu"))
16241 gnu_section
= TRUE
;
16243 gnu_section
= FALSE
;
16246 attr_len
-= namelen
;
16248 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16253 unsigned char * end
;
16255 /* PR binutils/17531: Safe handling of corrupt files. */
16258 error (_("Unused bytes at end of section\n"));
16265 size
= byte_get (p
, 4);
16266 if (size
> attr_len
)
16268 error (_("Bad subsection length (%u > %u)\n"),
16269 (unsigned) size
, (unsigned) attr_len
);
16273 /* PR binutils/17531: Safe handling of corrupt files. */
16276 error (_("Bad subsection length (%u < 6)\n"),
16284 end
= p
+ size
- 1;
16285 assert (end
<= contents
+ sect
->sh_size
);
16291 printf (_("File Attributes\n"));
16294 printf (_("Section Attributes:"));
16297 printf (_("Symbol Attributes:"));
16298 /* Fall through. */
16302 READ_ULEB (val
, p
, end
);
16305 printf (" %d", val
);
16310 printf (_("Unknown tag: %d\n"), tag
);
16311 public_section
= FALSE
;
16315 if (public_section
&& display_pub_attribute
!= NULL
)
16318 p
= display_pub_attribute (p
, end
);
16321 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16324 p
= display_gnu_attribute (p
,
16325 display_proc_gnu_attribute
,
16331 printf (_(" Unknown attribute:\n"));
16332 display_raw_attribute (p
, end
);
16347 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16348 Print the Address, Access and Initial fields of an entry at VMA ADDR
16349 and return the VMA of the next entry, or -1 if there was a problem.
16350 Does not read from DATA_END or beyond. */
16353 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16354 unsigned char * data_end
)
16357 print_vma (addr
, LONG_HEX
);
16359 if (addr
< pltgot
+ 0xfff0)
16360 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16362 printf ("%10s", "");
16365 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16369 unsigned char * from
= data
+ addr
- pltgot
;
16371 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16373 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16374 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16375 return (bfd_vma
) -1;
16379 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16380 print_vma (entry
, LONG_HEX
);
16383 return addr
+ (is_32bit_elf
? 4 : 8);
16386 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16387 PLTGOT. Print the Address and Initial fields of an entry at VMA
16388 ADDR and return the VMA of the next entry. */
16391 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16394 print_vma (addr
, LONG_HEX
);
16397 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16402 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16403 print_vma (entry
, LONG_HEX
);
16405 return addr
+ (is_32bit_elf
? 4 : 8);
16409 print_mips_ases (unsigned int mask
)
16411 if (mask
& AFL_ASE_DSP
)
16412 fputs ("\n\tDSP ASE", stdout
);
16413 if (mask
& AFL_ASE_DSPR2
)
16414 fputs ("\n\tDSP R2 ASE", stdout
);
16415 if (mask
& AFL_ASE_DSPR3
)
16416 fputs ("\n\tDSP R3 ASE", stdout
);
16417 if (mask
& AFL_ASE_EVA
)
16418 fputs ("\n\tEnhanced VA Scheme", stdout
);
16419 if (mask
& AFL_ASE_MCU
)
16420 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16421 if (mask
& AFL_ASE_MDMX
)
16422 fputs ("\n\tMDMX ASE", stdout
);
16423 if (mask
& AFL_ASE_MIPS3D
)
16424 fputs ("\n\tMIPS-3D ASE", stdout
);
16425 if (mask
& AFL_ASE_MT
)
16426 fputs ("\n\tMT ASE", stdout
);
16427 if (mask
& AFL_ASE_SMARTMIPS
)
16428 fputs ("\n\tSmartMIPS ASE", stdout
);
16429 if (mask
& AFL_ASE_VIRT
)
16430 fputs ("\n\tVZ ASE", stdout
);
16431 if (mask
& AFL_ASE_MSA
)
16432 fputs ("\n\tMSA ASE", stdout
);
16433 if (mask
& AFL_ASE_MIPS16
)
16434 fputs ("\n\tMIPS16 ASE", stdout
);
16435 if (mask
& AFL_ASE_MICROMIPS
)
16436 fputs ("\n\tMICROMIPS ASE", stdout
);
16437 if (mask
& AFL_ASE_XPA
)
16438 fputs ("\n\tXPA ASE", stdout
);
16439 if (mask
& AFL_ASE_MIPS16E2
)
16440 fputs ("\n\tMIPS16e2 ASE", stdout
);
16441 if (mask
& AFL_ASE_CRC
)
16442 fputs ("\n\tCRC ASE", stdout
);
16443 if (mask
& AFL_ASE_GINV
)
16444 fputs ("\n\tGINV ASE", stdout
);
16445 if (mask
& AFL_ASE_LOONGSON_MMI
)
16446 fputs ("\n\tLoongson MMI ASE", stdout
);
16447 if (mask
& AFL_ASE_LOONGSON_CAM
)
16448 fputs ("\n\tLoongson CAM ASE", stdout
);
16449 if (mask
& AFL_ASE_LOONGSON_EXT
)
16450 fputs ("\n\tLoongson EXT ASE", stdout
);
16451 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16452 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16454 fprintf (stdout
, "\n\t%s", _("None"));
16455 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16456 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16460 print_mips_isa_ext (unsigned int isa_ext
)
16465 fputs (_("None"), stdout
);
16468 fputs ("RMI XLR", stdout
);
16470 case AFL_EXT_OCTEON3
:
16471 fputs ("Cavium Networks Octeon3", stdout
);
16473 case AFL_EXT_OCTEON2
:
16474 fputs ("Cavium Networks Octeon2", stdout
);
16476 case AFL_EXT_OCTEONP
:
16477 fputs ("Cavium Networks OcteonP", stdout
);
16479 case AFL_EXT_OCTEON
:
16480 fputs ("Cavium Networks Octeon", stdout
);
16483 fputs ("Toshiba R5900", stdout
);
16486 fputs ("MIPS R4650", stdout
);
16489 fputs ("LSI R4010", stdout
);
16492 fputs ("NEC VR4100", stdout
);
16495 fputs ("Toshiba R3900", stdout
);
16497 case AFL_EXT_10000
:
16498 fputs ("MIPS R10000", stdout
);
16501 fputs ("Broadcom SB-1", stdout
);
16504 fputs ("NEC VR4111/VR4181", stdout
);
16507 fputs ("NEC VR4120", stdout
);
16510 fputs ("NEC VR5400", stdout
);
16513 fputs ("NEC VR5500", stdout
);
16515 case AFL_EXT_LOONGSON_2E
:
16516 fputs ("ST Microelectronics Loongson 2E", stdout
);
16518 case AFL_EXT_LOONGSON_2F
:
16519 fputs ("ST Microelectronics Loongson 2F", stdout
);
16521 case AFL_EXT_INTERAPTIV_MR2
:
16522 fputs ("Imagination interAptiv MR2", stdout
);
16525 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16530 get_mips_reg_size (int reg_size
)
16532 return (reg_size
== AFL_REG_NONE
) ? 0
16533 : (reg_size
== AFL_REG_32
) ? 32
16534 : (reg_size
== AFL_REG_64
) ? 64
16535 : (reg_size
== AFL_REG_128
) ? 128
16540 process_mips_specific (Filedata
* filedata
)
16542 Elf_Internal_Dyn
* entry
;
16543 Elf_Internal_Shdr
*sect
= NULL
;
16544 size_t liblist_offset
= 0;
16545 size_t liblistno
= 0;
16546 size_t conflictsno
= 0;
16547 size_t options_offset
= 0;
16548 size_t conflicts_offset
= 0;
16549 size_t pltrelsz
= 0;
16551 bfd_vma pltgot
= 0;
16552 bfd_vma mips_pltgot
= 0;
16553 bfd_vma jmprel
= 0;
16554 bfd_vma local_gotno
= 0;
16555 bfd_vma gotsym
= 0;
16556 bfd_vma symtabno
= 0;
16557 bfd_boolean res
= TRUE
;
16559 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16560 display_mips_gnu_attribute
))
16563 sect
= find_section (filedata
, ".MIPS.abiflags");
16567 Elf_External_ABIFlags_v0
*abiflags_ext
;
16568 Elf_Internal_ABIFlags_v0 abiflags_in
;
16570 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16572 error (_("Corrupt MIPS ABI Flags section.\n"));
16577 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16578 sect
->sh_size
, _("MIPS ABI Flags section"));
16581 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16582 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16583 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16584 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16585 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16586 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16587 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16588 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16589 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16590 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16591 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16593 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16594 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16595 if (abiflags_in
.isa_rev
> 1)
16596 printf ("r%d", abiflags_in
.isa_rev
);
16597 printf ("\nGPR size: %d",
16598 get_mips_reg_size (abiflags_in
.gpr_size
));
16599 printf ("\nCPR1 size: %d",
16600 get_mips_reg_size (abiflags_in
.cpr1_size
));
16601 printf ("\nCPR2 size: %d",
16602 get_mips_reg_size (abiflags_in
.cpr2_size
));
16603 fputs ("\nFP ABI: ", stdout
);
16604 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16605 fputs ("ISA Extension: ", stdout
);
16606 print_mips_isa_ext (abiflags_in
.isa_ext
);
16607 fputs ("\nASEs:", stdout
);
16608 print_mips_ases (abiflags_in
.ases
);
16609 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16610 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16611 fputc ('\n', stdout
);
16612 free (abiflags_ext
);
16617 /* We have a lot of special sections. Thanks SGI! */
16618 if (filedata
->dynamic_section
== NULL
)
16620 /* No dynamic information available. See if there is static GOT. */
16621 sect
= find_section (filedata
, ".got");
16624 unsigned char *data_end
;
16625 unsigned char *data
;
16629 pltgot
= sect
->sh_addr
;
16632 addr_size
= (is_32bit_elf
? 4 : 8);
16633 end
= pltgot
+ sect
->sh_size
;
16635 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16637 _("Global Offset Table data"));
16638 /* PR 12855: Null data is handled gracefully throughout. */
16639 data_end
= data
+ (end
- pltgot
);
16641 printf (_("\nStatic GOT:\n"));
16642 printf (_(" Canonical gp value: "));
16643 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16646 /* In a dynamic binary GOT[0] is reserved for the dynamic
16647 loader to store the lazy resolver pointer, however in
16648 a static binary it may well have been omitted and GOT
16649 reduced to a table of addresses.
16650 PR 21344: Check for the entry being fully available
16651 before fetching it. */
16653 && data
+ ent
- pltgot
+ addr_size
<= data_end
16654 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16656 printf (_(" Reserved entries:\n"));
16657 printf (_(" %*s %10s %*s\n"),
16658 addr_size
* 2, _("Address"), _("Access"),
16659 addr_size
* 2, _("Value"));
16660 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16662 if (ent
== (bfd_vma
) -1)
16663 goto sgot_print_fail
;
16665 /* Check for the MSB of GOT[1] being set, identifying a
16666 GNU object. This entry will be used by some runtime
16667 loaders, to store the module pointer. Otherwise this
16668 is an ordinary local entry.
16669 PR 21344: Check for the entry being fully available
16670 before fetching it. */
16672 && data
+ ent
- pltgot
+ addr_size
<= data_end
16673 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16674 >> (addr_size
* 8 - 1)) != 0)
16676 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16678 if (ent
== (bfd_vma
) -1)
16679 goto sgot_print_fail
;
16684 if (data
!= NULL
&& ent
< end
)
16686 printf (_(" Local entries:\n"));
16687 printf (" %*s %10s %*s\n",
16688 addr_size
* 2, _("Address"), _("Access"),
16689 addr_size
* 2, _("Value"));
16692 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16694 if (ent
== (bfd_vma
) -1)
16695 goto sgot_print_fail
;
16707 for (entry
= filedata
->dynamic_section
;
16708 /* PR 17531 file: 012-50589-0.004. */
16709 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16710 && entry
->d_tag
!= DT_NULL
);
16712 switch (entry
->d_tag
)
16714 case DT_MIPS_LIBLIST
:
16716 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16717 liblistno
* sizeof (Elf32_External_Lib
));
16719 case DT_MIPS_LIBLISTNO
:
16720 liblistno
= entry
->d_un
.d_val
;
16722 case DT_MIPS_OPTIONS
:
16723 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16725 case DT_MIPS_CONFLICT
:
16727 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16728 conflictsno
* sizeof (Elf32_External_Conflict
));
16730 case DT_MIPS_CONFLICTNO
:
16731 conflictsno
= entry
->d_un
.d_val
;
16734 pltgot
= entry
->d_un
.d_ptr
;
16736 case DT_MIPS_LOCAL_GOTNO
:
16737 local_gotno
= entry
->d_un
.d_val
;
16739 case DT_MIPS_GOTSYM
:
16740 gotsym
= entry
->d_un
.d_val
;
16742 case DT_MIPS_SYMTABNO
:
16743 symtabno
= entry
->d_un
.d_val
;
16745 case DT_MIPS_PLTGOT
:
16746 mips_pltgot
= entry
->d_un
.d_ptr
;
16749 pltrel
= entry
->d_un
.d_val
;
16752 pltrelsz
= entry
->d_un
.d_val
;
16755 jmprel
= entry
->d_un
.d_ptr
;
16761 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16763 Elf32_External_Lib
* elib
;
16766 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16767 sizeof (Elf32_External_Lib
),
16769 _("liblist section data"));
16772 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16773 "\nSection '.liblist' contains %lu entries:\n",
16774 (unsigned long) liblistno
),
16775 (unsigned long) liblistno
);
16776 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16779 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16786 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16787 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16788 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16789 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16790 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16792 tmp
= gmtime (&atime
);
16793 snprintf (timebuf
, sizeof (timebuf
),
16794 "%04u-%02u-%02uT%02u:%02u:%02u",
16795 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16796 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16798 printf ("%3lu: ", (unsigned long) cnt
);
16799 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
16800 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
16802 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16803 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16804 liblist
.l_version
);
16806 if (liblist
.l_flags
== 0)
16810 static const struct
16817 { " EXACT_MATCH", LL_EXACT_MATCH
},
16818 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16819 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16820 { " EXPORTS", LL_EXPORTS
},
16821 { " DELAY_LOAD", LL_DELAY_LOAD
},
16822 { " DELTA", LL_DELTA
}
16824 int flags
= liblist
.l_flags
;
16827 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16828 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16830 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16831 flags
^= l_flags_vals
[fcnt
].bit
;
16834 printf (" %#x", (unsigned int) flags
);
16846 if (options_offset
!= 0)
16848 Elf_External_Options
* eopt
;
16851 sect
= filedata
->section_headers
;
16853 /* Find the section header so that we get the size. */
16854 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16855 /* PR 17533 file: 012-277276-0.004. */
16858 error (_("No MIPS_OPTIONS header found\n"));
16862 if (sect
->sh_size
< sizeof (* eopt
))
16864 error (_("The MIPS options section is too small.\n"));
16868 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16869 sect
->sh_size
, _("options"));
16872 Elf_Internal_Options
* iopt
;
16873 Elf_Internal_Options
* option
;
16874 Elf_Internal_Options
* iopt_end
;
16876 iopt
= (Elf_Internal_Options
*)
16877 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16880 error (_("Out of memory allocating space for MIPS options\n"));
16887 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16889 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16891 Elf_External_Options
* eoption
;
16893 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16895 option
->kind
= BYTE_GET (eoption
->kind
);
16896 option
->size
= BYTE_GET (eoption
->size
);
16897 option
->section
= BYTE_GET (eoption
->section
);
16898 option
->info
= BYTE_GET (eoption
->info
);
16900 /* PR 17531: file: ffa0fa3b. */
16901 if (option
->size
< sizeof (* eopt
)
16902 || offset
+ option
->size
> sect
->sh_size
)
16904 error (_("Invalid size (%u) for MIPS option\n"),
16910 offset
+= option
->size
;
16916 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16917 "\nSection '%s' contains %d entries:\n",
16919 printable_section_name (filedata
, sect
), cnt
);
16928 switch (option
->kind
)
16931 /* This shouldn't happen. */
16932 printf (" NULL %d %lx", option
->section
, option
->info
);
16936 printf (" REGINFO ");
16937 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16939 Elf32_External_RegInfo
* ereg
;
16940 Elf32_RegInfo reginfo
;
16943 if (option
+ 2 > iopt_end
)
16945 printf (_("<corrupt>\n"));
16946 error (_("Truncated MIPS REGINFO option\n"));
16951 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16953 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16954 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16955 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16956 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16957 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16958 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16960 printf ("GPR %08lx GP 0x%lx\n",
16961 reginfo
.ri_gprmask
,
16962 (unsigned long) reginfo
.ri_gp_value
);
16963 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16964 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16965 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16970 Elf64_External_RegInfo
* ereg
;
16971 Elf64_Internal_RegInfo reginfo
;
16973 if (option
+ 2 > iopt_end
)
16975 printf (_("<corrupt>\n"));
16976 error (_("Truncated MIPS REGINFO option\n"));
16981 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16982 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16983 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16984 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16985 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16986 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16987 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16989 printf ("GPR %08lx GP 0x",
16990 reginfo
.ri_gprmask
);
16991 printf_vma (reginfo
.ri_gp_value
);
16994 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16995 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16996 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17001 case ODK_EXCEPTIONS
:
17002 fputs (" EXCEPTIONS fpe_min(", stdout
);
17003 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
17004 fputs (") fpe_max(", stdout
);
17005 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
17006 fputs (")", stdout
);
17008 if (option
->info
& OEX_PAGE0
)
17009 fputs (" PAGE0", stdout
);
17010 if (option
->info
& OEX_SMM
)
17011 fputs (" SMM", stdout
);
17012 if (option
->info
& OEX_FPDBUG
)
17013 fputs (" FPDBUG", stdout
);
17014 if (option
->info
& OEX_DISMISS
)
17015 fputs (" DISMISS", stdout
);
17019 fputs (" PAD ", stdout
);
17020 if (option
->info
& OPAD_PREFIX
)
17021 fputs (" PREFIX", stdout
);
17022 if (option
->info
& OPAD_POSTFIX
)
17023 fputs (" POSTFIX", stdout
);
17024 if (option
->info
& OPAD_SYMBOL
)
17025 fputs (" SYMBOL", stdout
);
17029 fputs (" HWPATCH ", stdout
);
17030 if (option
->info
& OHW_R4KEOP
)
17031 fputs (" R4KEOP", stdout
);
17032 if (option
->info
& OHW_R8KPFETCH
)
17033 fputs (" R8KPFETCH", stdout
);
17034 if (option
->info
& OHW_R5KEOP
)
17035 fputs (" R5KEOP", stdout
);
17036 if (option
->info
& OHW_R5KCVTL
)
17037 fputs (" R5KCVTL", stdout
);
17041 fputs (" FILL ", stdout
);
17042 /* XXX Print content of info word? */
17046 fputs (" TAGS ", stdout
);
17047 /* XXX Print content of info word? */
17051 fputs (" HWAND ", stdout
);
17052 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17053 fputs (" R4KEOP_CHECKED", stdout
);
17054 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17055 fputs (" R4KEOP_CLEAN", stdout
);
17059 fputs (" HWOR ", stdout
);
17060 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17061 fputs (" R4KEOP_CHECKED", stdout
);
17062 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17063 fputs (" R4KEOP_CLEAN", stdout
);
17067 printf (" GP_GROUP %#06lx self-contained %#06lx",
17068 option
->info
& OGP_GROUP
,
17069 (option
->info
& OGP_SELF
) >> 16);
17073 printf (" IDENT %#06lx self-contained %#06lx",
17074 option
->info
& OGP_GROUP
,
17075 (option
->info
& OGP_SELF
) >> 16);
17079 /* This shouldn't happen. */
17080 printf (" %3d ??? %d %lx",
17081 option
->kind
, option
->section
, option
->info
);
17085 len
= sizeof (* eopt
);
17086 while (len
< option
->size
)
17088 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17090 if (ISPRINT (datum
))
17091 printf ("%c", datum
);
17093 printf ("\\%03o", datum
);
17096 fputs ("\n", stdout
);
17098 offset
+= option
->size
;
17108 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17110 Elf32_Conflict
* iconf
;
17113 if (filedata
->dynamic_symbols
== NULL
)
17115 error (_("conflict list found without a dynamic symbol table\n"));
17119 /* PR 21345 - print a slightly more helpful error message
17120 if we are sure that the cmalloc will fail. */
17121 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17123 error (_("Overlarge number of conflicts detected: %lx\n"),
17124 (long) conflictsno
);
17128 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17131 error (_("Out of memory allocating space for dynamic conflicts\n"));
17137 Elf32_External_Conflict
* econf32
;
17139 econf32
= (Elf32_External_Conflict
*)
17140 get_data (NULL
, filedata
, conflicts_offset
,
17141 sizeof (*econf32
), conflictsno
, _("conflict"));
17148 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17149 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17155 Elf64_External_Conflict
* econf64
;
17157 econf64
= (Elf64_External_Conflict
*)
17158 get_data (NULL
, filedata
, conflicts_offset
,
17159 sizeof (*econf64
), conflictsno
, _("conflict"));
17166 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17167 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17172 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17173 "\nSection '.conflict' contains %lu entries:\n",
17174 (unsigned long) conflictsno
),
17175 (unsigned long) conflictsno
);
17176 puts (_(" Num: Index Value Name"));
17178 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17180 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17182 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17183 printf (_("<corrupt symbol index>"));
17186 Elf_Internal_Sym
* psym
;
17188 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17189 print_vma (psym
->st_value
, FULL_HEX
);
17191 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17192 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17194 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17202 if (pltgot
!= 0 && local_gotno
!= 0)
17204 bfd_vma ent
, local_end
, global_end
;
17206 unsigned char * data
;
17207 unsigned char * data_end
;
17211 addr_size
= (is_32bit_elf
? 4 : 8);
17212 local_end
= pltgot
+ local_gotno
* addr_size
;
17214 /* PR binutils/17533 file: 012-111227-0.004 */
17215 if (symtabno
< gotsym
)
17217 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17218 (unsigned long) gotsym
, (unsigned long) symtabno
);
17222 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17223 /* PR 17531: file: 54c91a34. */
17224 if (global_end
< local_end
)
17226 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17230 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17231 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17232 global_end
- pltgot
, 1,
17233 _("Global Offset Table data"));
17234 /* PR 12855: Null data is handled gracefully throughout. */
17235 data_end
= data
+ (global_end
- pltgot
);
17237 printf (_("\nPrimary GOT:\n"));
17238 printf (_(" Canonical gp value: "));
17239 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17242 printf (_(" Reserved entries:\n"));
17243 printf (_(" %*s %10s %*s Purpose\n"),
17244 addr_size
* 2, _("Address"), _("Access"),
17245 addr_size
* 2, _("Initial"));
17246 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17247 printf (_(" Lazy resolver\n"));
17248 if (ent
== (bfd_vma
) -1)
17249 goto got_print_fail
;
17251 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17252 This entry will be used by some runtime loaders, to store the
17253 module pointer. Otherwise this is an ordinary local entry.
17254 PR 21344: Check for the entry being fully available before
17257 && data
+ ent
- pltgot
+ addr_size
<= data_end
17258 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17259 >> (addr_size
* 8 - 1)) != 0)
17261 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17262 printf (_(" Module pointer (GNU extension)\n"));
17263 if (ent
== (bfd_vma
) -1)
17264 goto got_print_fail
;
17268 if (data
!= NULL
&& ent
< local_end
)
17270 printf (_(" Local entries:\n"));
17271 printf (" %*s %10s %*s\n",
17272 addr_size
* 2, _("Address"), _("Access"),
17273 addr_size
* 2, _("Initial"));
17274 while (ent
< local_end
)
17276 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17278 if (ent
== (bfd_vma
) -1)
17279 goto got_print_fail
;
17284 if (data
!= NULL
&& gotsym
< symtabno
)
17288 printf (_(" Global entries:\n"));
17289 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17290 addr_size
* 2, _("Address"),
17292 addr_size
* 2, _("Initial"),
17293 addr_size
* 2, _("Sym.Val."),
17295 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17296 _("Ndx"), _("Name"));
17298 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17300 for (i
= gotsym
; i
< symtabno
; i
++)
17302 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17305 if (filedata
->dynamic_symbols
== NULL
)
17306 printf (_("<no dynamic symbols>"));
17307 else if (i
< filedata
->num_dynamic_syms
)
17309 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17311 print_vma (psym
->st_value
, LONG_HEX
);
17312 printf (" %-7s %3s ",
17313 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17314 get_symbol_index_type (filedata
, psym
->st_shndx
));
17316 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17317 print_symbol (sym_width
,
17318 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17320 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17323 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17324 (unsigned long) i
);
17327 if (ent
== (bfd_vma
) -1)
17338 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17341 size_t offset
, rel_offset
;
17342 unsigned long count
, i
;
17343 unsigned char * data
;
17344 int addr_size
, sym_width
;
17345 Elf_Internal_Rela
* rels
;
17347 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17348 if (pltrel
== DT_RELA
)
17350 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17355 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17360 addr_size
= (is_32bit_elf
? 4 : 8);
17361 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17363 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17364 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17365 1, _("Procedure Linkage Table data"));
17369 printf ("\nPLT GOT:\n\n");
17370 printf (_(" Reserved entries:\n"));
17371 printf (_(" %*s %*s Purpose\n"),
17372 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17373 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17374 printf (_(" PLT lazy resolver\n"));
17375 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17376 printf (_(" Module pointer\n"));
17379 printf (_(" Entries:\n"));
17380 printf (" %*s %*s %*s %-7s %3s %s\n",
17381 addr_size
* 2, _("Address"),
17382 addr_size
* 2, _("Initial"),
17383 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17384 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17385 for (i
= 0; i
< count
; i
++)
17387 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17389 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17392 if (idx
>= filedata
->num_dynamic_syms
)
17393 printf (_("<corrupt symbol index: %lu>"), idx
);
17396 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17398 print_vma (psym
->st_value
, LONG_HEX
);
17399 printf (" %-7s %3s ",
17400 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17401 get_symbol_index_type (filedata
, psym
->st_shndx
));
17402 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17403 print_symbol (sym_width
,
17404 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17406 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17421 process_nds32_specific (Filedata
* filedata
)
17423 Elf_Internal_Shdr
*sect
= NULL
;
17425 sect
= find_section (filedata
, ".nds32_e_flags");
17428 unsigned int *flag
;
17430 printf ("\nNDS32 elf flags section:\n");
17431 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17432 sect
->sh_size
, _("NDS32 elf flags section"));
17437 switch ((*flag
) & 0x3)
17440 printf ("(VEC_SIZE):\tNo entry.\n");
17443 printf ("(VEC_SIZE):\t4 bytes\n");
17446 printf ("(VEC_SIZE):\t16 bytes\n");
17449 printf ("(VEC_SIZE):\treserved\n");
17458 process_gnu_liblist (Filedata
* filedata
)
17460 Elf_Internal_Shdr
* section
;
17461 Elf_Internal_Shdr
* string_sec
;
17462 Elf32_External_Lib
* elib
;
17464 size_t strtab_size
;
17466 unsigned long num_liblist
;
17468 bfd_boolean res
= TRUE
;
17473 for (i
= 0, section
= filedata
->section_headers
;
17474 i
< filedata
->file_header
.e_shnum
;
17477 switch (section
->sh_type
)
17479 case SHT_GNU_LIBLIST
:
17480 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17483 elib
= (Elf32_External_Lib
*)
17484 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17485 _("liblist section data"));
17493 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17494 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17495 string_sec
->sh_size
,
17496 _("liblist string table"));
17498 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17505 strtab_size
= string_sec
->sh_size
;
17507 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17508 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17509 "\nLibrary list section '%s' contains %lu entries:\n",
17511 printable_section_name (filedata
, section
),
17514 puts (_(" Library Time Stamp Checksum Version Flags"));
17516 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17524 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17525 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17526 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17527 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17528 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17530 tmp
= gmtime (&atime
);
17531 snprintf (timebuf
, sizeof (timebuf
),
17532 "%04u-%02u-%02uT%02u:%02u:%02u",
17533 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17534 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17536 printf ("%3lu: ", (unsigned long) cnt
);
17538 printf ("%-20s", liblist
.l_name
< strtab_size
17539 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17541 printf ("%-20.20s", liblist
.l_name
< strtab_size
17542 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17543 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17544 liblist
.l_version
, liblist
.l_flags
);
17555 static const char *
17556 get_note_type (Filedata
* filedata
, unsigned e_type
)
17558 static char buff
[64];
17560 if (filedata
->file_header
.e_type
== ET_CORE
)
17564 return _("NT_AUXV (auxiliary vector)");
17566 return _("NT_PRSTATUS (prstatus structure)");
17568 return _("NT_FPREGSET (floating point registers)");
17570 return _("NT_PRPSINFO (prpsinfo structure)");
17571 case NT_TASKSTRUCT
:
17572 return _("NT_TASKSTRUCT (task structure)");
17574 return _("NT_PRXFPREG (user_xfpregs structure)");
17576 return _("NT_PPC_VMX (ppc Altivec registers)");
17578 return _("NT_PPC_VSX (ppc VSX registers)");
17580 return _("NT_PPC_TAR (ppc TAR register)");
17582 return _("NT_PPC_PPR (ppc PPR register)");
17584 return _("NT_PPC_DSCR (ppc DSCR register)");
17586 return _("NT_PPC_EBB (ppc EBB registers)");
17588 return _("NT_PPC_PMU (ppc PMU registers)");
17589 case NT_PPC_TM_CGPR
:
17590 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17591 case NT_PPC_TM_CFPR
:
17592 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17593 case NT_PPC_TM_CVMX
:
17594 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17595 case NT_PPC_TM_CVSX
:
17596 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17597 case NT_PPC_TM_SPR
:
17598 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17599 case NT_PPC_TM_CTAR
:
17600 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17601 case NT_PPC_TM_CPPR
:
17602 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17603 case NT_PPC_TM_CDSCR
:
17604 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17606 return _("NT_386_TLS (x86 TLS information)");
17607 case NT_386_IOPERM
:
17608 return _("NT_386_IOPERM (x86 I/O permissions)");
17609 case NT_X86_XSTATE
:
17610 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17611 case NT_S390_HIGH_GPRS
:
17612 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17613 case NT_S390_TIMER
:
17614 return _("NT_S390_TIMER (s390 timer register)");
17615 case NT_S390_TODCMP
:
17616 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17617 case NT_S390_TODPREG
:
17618 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17620 return _("NT_S390_CTRS (s390 control registers)");
17621 case NT_S390_PREFIX
:
17622 return _("NT_S390_PREFIX (s390 prefix register)");
17623 case NT_S390_LAST_BREAK
:
17624 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17625 case NT_S390_SYSTEM_CALL
:
17626 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17628 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17629 case NT_S390_VXRS_LOW
:
17630 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17631 case NT_S390_VXRS_HIGH
:
17632 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17633 case NT_S390_GS_CB
:
17634 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17635 case NT_S390_GS_BC
:
17636 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17638 return _("NT_ARM_VFP (arm VFP registers)");
17640 return _("NT_ARM_TLS (AArch TLS registers)");
17641 case NT_ARM_HW_BREAK
:
17642 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17643 case NT_ARM_HW_WATCH
:
17644 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17646 return _("NT_PSTATUS (pstatus structure)");
17648 return _("NT_FPREGS (floating point registers)");
17650 return _("NT_PSINFO (psinfo structure)");
17652 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17654 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17655 case NT_WIN32PSTATUS
:
17656 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17658 return _("NT_SIGINFO (siginfo_t data)");
17660 return _("NT_FILE (mapped files)");
17668 return _("NT_VERSION (version)");
17670 return _("NT_ARCH (architecture)");
17671 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17673 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17679 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17684 print_core_note (Elf_Internal_Note
*pnote
)
17686 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17687 bfd_vma count
, page_size
;
17688 unsigned char *descdata
, *filenames
, *descend
;
17690 if (pnote
->type
!= NT_FILE
)
17700 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17701 /* Still "successful". */
17706 if (pnote
->descsz
< 2 * addr_size
)
17708 error (_(" Malformed note - too short for header\n"));
17712 descdata
= (unsigned char *) pnote
->descdata
;
17713 descend
= descdata
+ pnote
->descsz
;
17715 if (descdata
[pnote
->descsz
- 1] != '\0')
17717 error (_(" Malformed note - does not end with \\0\n"));
17721 count
= byte_get (descdata
, addr_size
);
17722 descdata
+= addr_size
;
17724 page_size
= byte_get (descdata
, addr_size
);
17725 descdata
+= addr_size
;
17727 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17728 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17730 error (_(" Malformed note - too short for supplied file count\n"));
17734 printf (_(" Page size: "));
17735 print_vma (page_size
, DEC
);
17738 printf (_(" %*s%*s%*s\n"),
17739 (int) (2 + 2 * addr_size
), _("Start"),
17740 (int) (4 + 2 * addr_size
), _("End"),
17741 (int) (4 + 2 * addr_size
), _("Page Offset"));
17742 filenames
= descdata
+ count
* 3 * addr_size
;
17743 while (count
-- > 0)
17745 bfd_vma start
, end
, file_ofs
;
17747 if (filenames
== descend
)
17749 error (_(" Malformed note - filenames end too early\n"));
17753 start
= byte_get (descdata
, addr_size
);
17754 descdata
+= addr_size
;
17755 end
= byte_get (descdata
, addr_size
);
17756 descdata
+= addr_size
;
17757 file_ofs
= byte_get (descdata
, addr_size
);
17758 descdata
+= addr_size
;
17761 print_vma (start
, FULL_HEX
);
17763 print_vma (end
, FULL_HEX
);
17765 print_vma (file_ofs
, FULL_HEX
);
17766 printf ("\n %s\n", filenames
);
17768 filenames
+= 1 + strlen ((char *) filenames
);
17774 static const char *
17775 get_gnu_elf_note_type (unsigned e_type
)
17777 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17780 case NT_GNU_ABI_TAG
:
17781 return _("NT_GNU_ABI_TAG (ABI version tag)");
17783 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17784 case NT_GNU_BUILD_ID
:
17785 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17786 case NT_GNU_GOLD_VERSION
:
17787 return _("NT_GNU_GOLD_VERSION (gold version)");
17788 case NT_GNU_PROPERTY_TYPE_0
:
17789 return _("NT_GNU_PROPERTY_TYPE_0");
17790 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17791 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17792 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17793 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17796 static char buff
[64];
17798 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17805 decode_x86_compat_isa (unsigned int bitmask
)
17809 unsigned int bit
= bitmask
& (- bitmask
);
17814 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17817 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17820 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17823 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17826 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17829 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17832 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17835 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17838 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17841 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17844 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17847 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17848 printf ("AVX512F");
17850 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17851 printf ("AVX512CD");
17853 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17854 printf ("AVX512ER");
17856 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17857 printf ("AVX512PF");
17859 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17860 printf ("AVX512VL");
17862 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17863 printf ("AVX512DQ");
17865 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17866 printf ("AVX512BW");
17869 printf (_("<unknown: %x>"), bit
);
17878 decode_x86_isa (unsigned int bitmask
)
17882 printf (_("<None>"));
17888 unsigned int bit
= bitmask
& (- bitmask
);
17893 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17896 case GNU_PROPERTY_X86_ISA_1_SSE
:
17899 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17902 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17905 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17908 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17911 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17914 case GNU_PROPERTY_X86_ISA_1_AVX
:
17917 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17920 case GNU_PROPERTY_X86_ISA_1_FMA
:
17923 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17924 printf ("AVX512F");
17926 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17927 printf ("AVX512CD");
17929 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17930 printf ("AVX512ER");
17932 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17933 printf ("AVX512PF");
17935 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17936 printf ("AVX512VL");
17938 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17939 printf ("AVX512DQ");
17941 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17942 printf ("AVX512BW");
17944 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17945 printf ("AVX512_4FMAPS");
17947 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17948 printf ("AVX512_4VNNIW");
17950 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17951 printf ("AVX512_BITALG");
17953 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17954 printf ("AVX512_IFMA");
17956 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17957 printf ("AVX512_VBMI");
17959 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17960 printf ("AVX512_VBMI2");
17962 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17963 printf ("AVX512_VNNI");
17965 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17966 printf ("AVX512_BF16");
17969 printf (_("<unknown: %x>"), bit
);
17978 decode_x86_feature_1 (unsigned int bitmask
)
17982 printf (_("<None>"));
17988 unsigned int bit
= bitmask
& (- bitmask
);
17993 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17996 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18000 printf (_("<unknown: %x>"), bit
);
18009 decode_x86_feature_2 (unsigned int bitmask
)
18013 printf (_("<None>"));
18019 unsigned int bit
= bitmask
& (- bitmask
);
18024 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18027 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18030 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18033 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18036 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18039 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18042 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18045 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18048 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18049 printf ("XSAVEOPT");
18051 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18055 printf (_("<unknown: %x>"), bit
);
18064 decode_aarch64_feature_1_and (unsigned int bitmask
)
18068 unsigned int bit
= bitmask
& (- bitmask
);
18073 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18077 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18082 printf (_("<unknown: %x>"), bit
);
18091 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18093 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18094 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18095 unsigned int size
= is_32bit_elf
? 4 : 8;
18097 printf (_(" Properties: "));
18099 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18101 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18105 while (ptr
< ptr_end
)
18109 unsigned int datasz
;
18111 if ((size_t) (ptr_end
- ptr
) < 8)
18113 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18117 type
= byte_get (ptr
, 4);
18118 datasz
= byte_get (ptr
+ 4, 4);
18122 if (datasz
> (size_t) (ptr_end
- ptr
))
18124 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18129 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18131 if (filedata
->file_header
.e_machine
== EM_X86_64
18132 || filedata
->file_header
.e_machine
== EM_IAMCU
18133 || filedata
->file_header
.e_machine
== EM_386
)
18135 unsigned int bitmask
;
18138 bitmask
= byte_get (ptr
, 4);
18144 case GNU_PROPERTY_X86_ISA_1_USED
:
18146 printf (_("x86 ISA used: <corrupt length: %#x> "),
18150 printf ("x86 ISA used: ");
18151 decode_x86_isa (bitmask
);
18155 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18157 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18161 printf ("x86 ISA needed: ");
18162 decode_x86_isa (bitmask
);
18166 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18168 printf (_("x86 feature: <corrupt length: %#x> "),
18172 printf ("x86 feature: ");
18173 decode_x86_feature_1 (bitmask
);
18177 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18179 printf (_("x86 feature used: <corrupt length: %#x> "),
18183 printf ("x86 feature used: ");
18184 decode_x86_feature_2 (bitmask
);
18188 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18190 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18193 printf ("x86 feature needed: ");
18194 decode_x86_feature_2 (bitmask
);
18198 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18200 printf (_("x86 ISA used: <corrupt length: %#x> "),
18204 printf ("x86 ISA used: ");
18205 decode_x86_compat_isa (bitmask
);
18209 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18211 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18215 printf ("x86 ISA needed: ");
18216 decode_x86_compat_isa (bitmask
);
18224 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18226 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18228 printf ("AArch64 feature: ");
18230 printf (_("<corrupt length: %#x> "), datasz
);
18232 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18241 case GNU_PROPERTY_STACK_SIZE
:
18242 printf (_("stack size: "));
18243 if (datasz
!= size
)
18244 printf (_("<corrupt length: %#x> "), datasz
);
18246 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18249 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18250 printf ("no copy on protected ");
18252 printf (_("<corrupt length: %#x> "), datasz
);
18260 if (type
< GNU_PROPERTY_LOPROC
)
18261 printf (_("<unknown type %#x data: "), type
);
18262 else if (type
< GNU_PROPERTY_LOUSER
)
18263 printf (_("<procesor-specific type %#x data: "), type
);
18265 printf (_("<application-specific type %#x data: "), type
);
18266 for (j
= 0; j
< datasz
; ++j
)
18267 printf ("%02x ", ptr
[j
] & 0xff);
18271 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18272 if (ptr
== ptr_end
)
18285 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18287 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18288 switch (pnote
->type
)
18290 case NT_GNU_BUILD_ID
:
18294 printf (_(" Build ID: "));
18295 for (i
= 0; i
< pnote
->descsz
; ++i
)
18296 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18301 case NT_GNU_ABI_TAG
:
18303 unsigned long os
, major
, minor
, subminor
;
18304 const char *osname
;
18306 /* PR 17531: file: 030-599401-0.004. */
18307 if (pnote
->descsz
< 16)
18309 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18313 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18314 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18315 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18316 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18320 case GNU_ABI_TAG_LINUX
:
18323 case GNU_ABI_TAG_HURD
:
18326 case GNU_ABI_TAG_SOLARIS
:
18327 osname
= "Solaris";
18329 case GNU_ABI_TAG_FREEBSD
:
18330 osname
= "FreeBSD";
18332 case GNU_ABI_TAG_NETBSD
:
18335 case GNU_ABI_TAG_SYLLABLE
:
18336 osname
= "Syllable";
18338 case GNU_ABI_TAG_NACL
:
18342 osname
= "Unknown";
18346 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18347 major
, minor
, subminor
);
18351 case NT_GNU_GOLD_VERSION
:
18355 printf (_(" Version: "));
18356 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18357 printf ("%c", pnote
->descdata
[i
]);
18364 unsigned long num_entries
, mask
;
18366 /* Hardware capabilities information. Word 0 is the number of entries.
18367 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18368 is a series of entries, where each entry is a single byte followed
18369 by a nul terminated string. The byte gives the bit number to test
18370 if enabled in the bitmask. */
18371 printf (_(" Hardware Capabilities: "));
18372 if (pnote
->descsz
< 8)
18374 error (_("<corrupt GNU_HWCAP>\n"));
18377 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18378 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18379 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18380 /* FIXME: Add code to display the entries... */
18384 case NT_GNU_PROPERTY_TYPE_0
:
18385 print_gnu_property_note (filedata
, pnote
);
18389 /* Handle unrecognised types. An error message should have already been
18390 created by get_gnu_elf_note_type(), so all that we need to do is to
18391 display the data. */
18395 printf (_(" Description data: "));
18396 for (i
= 0; i
< pnote
->descsz
; ++i
)
18397 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18406 static const char *
18407 get_v850_elf_note_type (enum v850_notes n_type
)
18409 static char buff
[64];
18413 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18414 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18415 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18416 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18417 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18418 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18420 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18426 print_v850_note (Elf_Internal_Note
* pnote
)
18430 if (pnote
->descsz
!= 4)
18433 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18437 printf (_("not set\n"));
18441 switch (pnote
->type
)
18443 case V850_NOTE_ALIGNMENT
:
18446 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18447 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18451 case V850_NOTE_DATA_SIZE
:
18454 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18455 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18459 case V850_NOTE_FPU_INFO
:
18462 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18463 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18467 case V850_NOTE_MMU_INFO
:
18468 case V850_NOTE_CACHE_INFO
:
18469 case V850_NOTE_SIMD_INFO
:
18470 if (val
== EF_RH850_SIMD
)
18472 printf (_("yes\n"));
18478 /* An 'unknown note type' message will already have been displayed. */
18482 printf (_("unknown value: %x\n"), val
);
18487 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18489 unsigned int version
;
18491 switch (pnote
->type
)
18493 case NT_NETBSD_IDENT
:
18494 if (pnote
->descsz
< 1)
18496 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18497 if ((version
/ 10000) % 100)
18498 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18499 version
, version
/ 100000000, (version
/ 1000000) % 100,
18500 (version
/ 10000) % 100 > 26 ? "Z" : "",
18501 'A' + (version
/ 10000) % 26);
18503 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18504 version
, version
/ 100000000, (version
/ 1000000) % 100,
18505 (version
/ 100) % 100);
18508 case NT_NETBSD_MARCH
:
18509 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18513 #ifdef NT_NETBSD_PAX
18514 case NT_NETBSD_PAX
:
18515 if (pnote
->descsz
< 1)
18517 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18518 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18519 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18520 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18521 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18522 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18523 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18524 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18529 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18530 pnote
->descsz
, pnote
->type
);
18534 static const char *
18535 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18539 case NT_FREEBSD_THRMISC
:
18540 return _("NT_THRMISC (thrmisc structure)");
18541 case NT_FREEBSD_PROCSTAT_PROC
:
18542 return _("NT_PROCSTAT_PROC (proc data)");
18543 case NT_FREEBSD_PROCSTAT_FILES
:
18544 return _("NT_PROCSTAT_FILES (files data)");
18545 case NT_FREEBSD_PROCSTAT_VMMAP
:
18546 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18547 case NT_FREEBSD_PROCSTAT_GROUPS
:
18548 return _("NT_PROCSTAT_GROUPS (groups data)");
18549 case NT_FREEBSD_PROCSTAT_UMASK
:
18550 return _("NT_PROCSTAT_UMASK (umask data)");
18551 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18552 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18553 case NT_FREEBSD_PROCSTAT_OSREL
:
18554 return _("NT_PROCSTAT_OSREL (osreldate data)");
18555 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18556 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18557 case NT_FREEBSD_PROCSTAT_AUXV
:
18558 return _("NT_PROCSTAT_AUXV (auxv data)");
18559 case NT_FREEBSD_PTLWPINFO
:
18560 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18562 return get_note_type (filedata
, e_type
);
18565 static const char *
18566 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18568 static char buff
[64];
18572 case NT_NETBSDCORE_PROCINFO
:
18573 /* NetBSD core "procinfo" structure. */
18574 return _("NetBSD procinfo structure");
18576 #ifdef NT_NETBSDCORE_AUXV
18577 case NT_NETBSDCORE_AUXV
:
18578 return _("NetBSD ELF auxiliary vector data");
18581 #ifdef NT_NETBSDCORE_LWPSTATUS
18582 case NT_NETBSDCORE_LWPSTATUS
:
18583 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18587 /* As of Jan 2020 there are no other machine-independent notes
18588 defined for NetBSD core files. If the note type is less
18589 than the start of the machine-dependent note types, we don't
18592 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18594 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18600 switch (filedata
->file_header
.e_machine
)
18602 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18603 and PT_GETFPREGS == mach+2. */
18608 case EM_SPARC32PLUS
:
18612 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18613 return _("PT_GETREGS (reg structure)");
18614 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18615 return _("PT_GETFPREGS (fpreg structure)");
18621 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18622 There's also old PT___GETREGS40 == mach + 1 for old reg
18623 structure which lacks GBR. */
18627 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18628 return _("PT___GETREGS40 (old reg structure)");
18629 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18630 return _("PT_GETREGS (reg structure)");
18631 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18632 return _("PT_GETFPREGS (fpreg structure)");
18638 /* On all other arch's, PT_GETREGS == mach+1 and
18639 PT_GETFPREGS == mach+3. */
18643 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18644 return _("PT_GETREGS (reg structure)");
18645 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18646 return _("PT_GETFPREGS (fpreg structure)");
18652 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18653 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18657 static const char *
18658 get_stapsdt_note_type (unsigned e_type
)
18660 static char buff
[64];
18665 return _("NT_STAPSDT (SystemTap probe descriptors)");
18671 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18676 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18678 size_t len
, maxlen
;
18679 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18680 char *data
= pnote
->descdata
;
18681 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18682 bfd_vma pc
, base_addr
, semaphore
;
18683 char *provider
, *probe
, *arg_fmt
;
18685 if (pnote
->descsz
< (addr_size
* 3))
18686 goto stapdt_note_too_small
;
18688 pc
= byte_get ((unsigned char *) data
, addr_size
);
18691 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18694 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18697 if (data
>= data_end
)
18698 goto stapdt_note_too_small
;
18699 maxlen
= data_end
- data
;
18700 len
= strnlen (data
, maxlen
);
18707 goto stapdt_note_too_small
;
18709 if (data
>= data_end
)
18710 goto stapdt_note_too_small
;
18711 maxlen
= data_end
- data
;
18712 len
= strnlen (data
, maxlen
);
18719 goto stapdt_note_too_small
;
18721 if (data
>= data_end
)
18722 goto stapdt_note_too_small
;
18723 maxlen
= data_end
- data
;
18724 len
= strnlen (data
, maxlen
);
18731 goto stapdt_note_too_small
;
18733 printf (_(" Provider: %s\n"), provider
);
18734 printf (_(" Name: %s\n"), probe
);
18735 printf (_(" Location: "));
18736 print_vma (pc
, FULL_HEX
);
18737 printf (_(", Base: "));
18738 print_vma (base_addr
, FULL_HEX
);
18739 printf (_(", Semaphore: "));
18740 print_vma (semaphore
, FULL_HEX
);
18742 printf (_(" Arguments: %s\n"), arg_fmt
);
18744 return data
== data_end
;
18746 stapdt_note_too_small
:
18747 printf (_(" <corrupt - note is too small>\n"));
18748 error (_("corrupt stapdt note - the data size is too small\n"));
18752 static const char *
18753 get_ia64_vms_note_type (unsigned e_type
)
18755 static char buff
[64];
18760 return _("NT_VMS_MHD (module header)");
18762 return _("NT_VMS_LNM (language name)");
18764 return _("NT_VMS_SRC (source files)");
18766 return "NT_VMS_TITLE";
18768 return _("NT_VMS_EIDC (consistency check)");
18769 case NT_VMS_FPMODE
:
18770 return _("NT_VMS_FPMODE (FP mode)");
18771 case NT_VMS_LINKTIME
:
18772 return "NT_VMS_LINKTIME";
18773 case NT_VMS_IMGNAM
:
18774 return _("NT_VMS_IMGNAM (image name)");
18776 return _("NT_VMS_IMGID (image id)");
18777 case NT_VMS_LINKID
:
18778 return _("NT_VMS_LINKID (link id)");
18779 case NT_VMS_IMGBID
:
18780 return _("NT_VMS_IMGBID (build id)");
18781 case NT_VMS_GSTNAM
:
18782 return _("NT_VMS_GSTNAM (sym table name)");
18783 case NT_VMS_ORIG_DYN
:
18784 return "NT_VMS_ORIG_DYN";
18785 case NT_VMS_PATCHTIME
:
18786 return "NT_VMS_PATCHTIME";
18788 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18794 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18796 int maxlen
= pnote
->descsz
;
18798 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18799 goto desc_size_fail
;
18801 switch (pnote
->type
)
18805 goto desc_size_fail
;
18807 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18809 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18810 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18811 if (l
+ 34 < maxlen
)
18813 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18814 if (l
+ 35 < maxlen
)
18815 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18817 printf (_(" Module version : <missing>\n"));
18821 printf (_(" Module name : <missing>\n"));
18822 printf (_(" Module version : <missing>\n"));
18827 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18831 case NT_VMS_FPMODE
:
18832 printf (_(" Floating Point mode: "));
18834 goto desc_size_fail
;
18835 /* FIXME: Generate an error if descsz > 8 ? */
18837 printf ("0x%016" BFD_VMA_FMT
"x\n",
18838 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18841 case NT_VMS_LINKTIME
:
18842 printf (_(" Link time: "));
18844 goto desc_size_fail
;
18845 /* FIXME: Generate an error if descsz > 8 ? */
18848 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18852 case NT_VMS_PATCHTIME
:
18853 printf (_(" Patch time: "));
18855 goto desc_size_fail
;
18856 /* FIXME: Generate an error if descsz > 8 ? */
18859 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18863 case NT_VMS_ORIG_DYN
:
18865 goto desc_size_fail
;
18867 printf (_(" Major id: %u, minor id: %u\n"),
18868 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18869 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18870 printf (_(" Last modified : "));
18872 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18873 printf (_("\n Link flags : "));
18874 printf ("0x%016" BFD_VMA_FMT
"x\n",
18875 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18876 printf (_(" Header flags: 0x%08x\n"),
18877 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18878 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18882 case NT_VMS_IMGNAM
:
18883 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18886 case NT_VMS_GSTNAM
:
18887 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18891 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18894 case NT_VMS_LINKID
:
18895 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18905 printf (_(" <corrupt - data size is too small>\n"));
18906 error (_("corrupt IA64 note: data size is too small\n"));
18910 struct build_attr_cache
{
18911 Filedata
*filedata
;
18913 unsigned long strtablen
;
18914 Elf_Internal_Sym
*symtab
;
18915 unsigned long nsyms
;
18918 /* Find the symbol associated with a build attribute that is attached
18919 to address OFFSET. If PNAME is non-NULL then store the name of
18920 the symbol (if found) in the provided pointer, Returns NULL if a
18921 symbol could not be found. */
18923 static Elf_Internal_Sym
*
18924 get_symbol_for_build_attribute (Filedata
* filedata
,
18925 unsigned long offset
,
18926 bfd_boolean is_open_attr
,
18927 const char ** pname
)
18929 Elf_Internal_Sym
*saved_sym
= NULL
;
18930 Elf_Internal_Sym
*sym
;
18932 if (filedata
->section_headers
!= NULL
18933 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18935 Elf_Internal_Shdr
* symsec
;
18937 free (ba_cache
.strtab
);
18938 ba_cache
.strtab
= NULL
;
18939 free (ba_cache
.symtab
);
18940 ba_cache
.symtab
= NULL
;
18942 /* Load the symbol and string sections. */
18943 for (symsec
= filedata
->section_headers
;
18944 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18947 if (symsec
->sh_type
== SHT_SYMTAB
18948 && get_symtab (filedata
, symsec
,
18949 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18950 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18953 ba_cache
.filedata
= filedata
;
18956 if (ba_cache
.symtab
== NULL
)
18959 /* Find a symbol whose value matches offset. */
18960 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18961 if (sym
->st_value
== offset
)
18963 if (sym
->st_name
>= ba_cache
.strtablen
)
18964 /* Huh ? This should not happen. */
18967 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18970 /* The AArch64 and ARM architectures define mapping symbols
18971 (eg $d, $x, $t) which we want to ignore. */
18972 if (ba_cache
.strtab
[sym
->st_name
] == '$'
18973 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
18974 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
18979 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18980 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18981 FUNC symbols entirely. */
18982 switch (ELF_ST_TYPE (sym
->st_info
))
18989 /* If the symbol has a size associated
18990 with it then we can stop searching. */
18991 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
18996 /* Ignore function symbols. */
19003 switch (ELF_ST_BIND (sym
->st_info
))
19006 if (saved_sym
== NULL
19007 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19012 if (saved_sym
== NULL
)
19022 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19030 if (saved_sym
&& pname
)
19031 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19036 /* Returns true iff addr1 and addr2 are in the same section. */
19039 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19041 Elf_Internal_Shdr
* a1
;
19042 Elf_Internal_Shdr
* a2
;
19044 a1
= find_section_by_address (filedata
, addr1
);
19045 a2
= find_section_by_address (filedata
, addr2
);
19047 return a1
== a2
&& a1
!= NULL
;
19051 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19052 Filedata
* filedata
)
19054 static unsigned long global_offset
= 0;
19055 static unsigned long global_end
= 0;
19056 static unsigned long func_offset
= 0;
19057 static unsigned long func_end
= 0;
19059 Elf_Internal_Sym
* sym
;
19061 unsigned long start
;
19063 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19065 switch (pnote
->descsz
)
19068 /* A zero-length description means that the range of
19069 the previous note of the same type should be used. */
19072 if (global_end
> global_offset
)
19073 printf (_(" Applies to region from %#lx to %#lx\n"),
19074 global_offset
, global_end
);
19076 printf (_(" Applies to region from %#lx\n"), global_offset
);
19080 if (func_end
> func_offset
)
19081 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19083 printf (_(" Applies to region from %#lx\n"), func_offset
);
19088 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19095 /* FIXME: We should check that version 3+ notes are being used here... */
19096 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19097 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19101 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19107 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19108 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19112 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19113 printf (_(" <invalid descsz>"));
19118 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19119 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19120 in order to avoid them being confused with the start address of the
19121 first function in the file... */
19122 if (sym
== NULL
&& is_open_attr
)
19123 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19126 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19127 end
= start
+ sym
->st_size
;
19131 /* FIXME: Need to properly allow for section alignment.
19132 16 is just the alignment used on x86_64. */
19134 && start
> BFD_ALIGN (global_end
, 16)
19135 /* Build notes are not guaranteed to be organised in order of
19136 increasing address, but we should find the all of the notes
19137 for one section in the same place. */
19138 && same_section (filedata
, start
, global_end
))
19139 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19140 global_end
+ 1, start
- 1);
19142 printf (_(" Applies to region from %#lx"), start
);
19143 global_offset
= start
;
19147 printf (_(" to %#lx"), end
);
19153 printf (_(" Applies to region from %#lx"), start
);
19154 func_offset
= start
;
19158 printf (_(" to %#lx"), end
);
19164 printf (_(" (%s)"), name
);
19171 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19173 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19174 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19175 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19177 char name_attribute
;
19178 const char * expected_types
;
19179 const char * name
= pnote
->namedata
;
19183 if (name
== NULL
|| pnote
->namesz
< 2)
19185 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19186 print_symbol (-20, _(" <corrupt name>"));
19195 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19196 if (name
[0] == 'G' && name
[1] == 'A')
19198 if (pnote
->namesz
< 4)
19200 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19201 print_symbol (-20, _(" <corrupt name>"));
19210 switch ((name_type
= * name
))
19212 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19213 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19214 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19215 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19216 printf ("%c", * name
);
19220 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19221 print_symbol (-20, _("<unknown name type>"));
19228 switch ((name_attribute
= * name
))
19230 case GNU_BUILD_ATTRIBUTE_VERSION
:
19231 text
= _("<version>");
19232 expected_types
= string_expected
;
19235 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19236 text
= _("<stack prot>");
19237 expected_types
= "!+*";
19240 case GNU_BUILD_ATTRIBUTE_RELRO
:
19241 text
= _("<relro>");
19242 expected_types
= bool_expected
;
19245 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19246 text
= _("<stack size>");
19247 expected_types
= number_expected
;
19250 case GNU_BUILD_ATTRIBUTE_TOOL
:
19251 text
= _("<tool>");
19252 expected_types
= string_expected
;
19255 case GNU_BUILD_ATTRIBUTE_ABI
:
19257 expected_types
= "$*";
19260 case GNU_BUILD_ATTRIBUTE_PIC
:
19262 expected_types
= number_expected
;
19265 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19266 text
= _("<short enum>");
19267 expected_types
= bool_expected
;
19271 if (ISPRINT (* name
))
19273 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19275 if (len
> left
&& ! do_wide
)
19277 printf ("%.*s:", len
, name
);
19283 static char tmpbuf
[128];
19285 error (_("unrecognised byte in name field: %d\n"), * name
);
19286 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19290 expected_types
= "*$!+";
19295 left
-= printf ("%s", text
);
19297 if (strchr (expected_types
, name_type
) == NULL
)
19298 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19300 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19302 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19303 (unsigned long) pnote
->namesz
,
19304 (long) (name
- pnote
->namedata
));
19308 if (left
< 1 && ! do_wide
)
19313 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19315 unsigned int bytes
;
19316 unsigned long long val
= 0;
19317 unsigned int shift
= 0;
19318 char * decoded
= NULL
;
19320 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19322 /* The -1 is because the name field is always 0 terminated, and we
19323 want to be able to ensure that the shift in the while loop below
19324 will not overflow. */
19327 if (bytes
> sizeof (val
))
19329 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19331 bytes
= sizeof (val
);
19333 /* We do not bother to warn if bytes == 0 as this can
19334 happen with some early versions of the gcc plugin. */
19338 unsigned long byte
= (* name
++) & 0xff;
19340 val
|= byte
<< shift
;
19344 switch (name_attribute
)
19346 case GNU_BUILD_ATTRIBUTE_PIC
:
19349 case 0: decoded
= "static"; break;
19350 case 1: decoded
= "pic"; break;
19351 case 2: decoded
= "PIC"; break;
19352 case 3: decoded
= "pie"; break;
19353 case 4: decoded
= "PIE"; break;
19357 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19360 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19361 case 0: decoded
= "off"; break;
19362 case 1: decoded
= "on"; break;
19363 case 2: decoded
= "all"; break;
19364 case 3: decoded
= "strong"; break;
19365 case 4: decoded
= "explicit"; break;
19373 if (decoded
!= NULL
)
19375 print_symbol (-left
, decoded
);
19386 left
-= printf ("0x%llx", val
);
19388 left
-= printf ("0x%-.*llx", left
, val
);
19392 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19393 left
-= print_symbol (- left
, name
);
19395 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19396 left
-= print_symbol (- left
, "true");
19398 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19399 left
-= print_symbol (- left
, "false");
19403 if (do_wide
&& left
> 0)
19404 printf ("%-*s", left
, " ");
19409 /* Note that by the ELF standard, the name field is already null byte
19410 terminated, and namesz includes the terminating null byte.
19411 I.E. the value of namesz for the name "FSF" is 4.
19413 If the value of namesz is zero, there is no name present. */
19416 process_note (Elf_Internal_Note
* pnote
,
19417 Filedata
* filedata
)
19419 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19422 if (pnote
->namesz
== 0)
19423 /* If there is no note name, then use the default set of
19424 note type strings. */
19425 nt
= get_note_type (filedata
, pnote
->type
);
19427 else if (const_strneq (pnote
->namedata
, "GNU"))
19428 /* GNU-specific object file notes. */
19429 nt
= get_gnu_elf_note_type (pnote
->type
);
19431 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19432 /* FreeBSD-specific core file notes. */
19433 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19435 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19436 /* NetBSD-specific core file notes. */
19437 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19439 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19440 /* NetBSD-specific core file notes. */
19441 return process_netbsd_elf_note (pnote
);
19443 else if (const_strneq (pnote
->namedata
, "PaX"))
19444 /* NetBSD-specific core file notes. */
19445 return process_netbsd_elf_note (pnote
);
19447 else if (strneq (pnote
->namedata
, "SPU/", 4))
19449 /* SPU-specific core file notes. */
19450 nt
= pnote
->namedata
+ 4;
19454 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19455 /* VMS/ia64-specific file notes. */
19456 nt
= get_ia64_vms_note_type (pnote
->type
);
19458 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19459 nt
= get_stapsdt_note_type (pnote
->type
);
19462 /* Don't recognize this note name; just use the default set of
19463 note type strings. */
19464 nt
= get_note_type (filedata
, pnote
->type
);
19468 if (((const_strneq (pnote
->namedata
, "GA")
19469 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19470 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19471 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19472 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19473 print_gnu_build_attribute_name (pnote
);
19475 print_symbol (-20, name
);
19478 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19480 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19482 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19483 return print_ia64_vms_note (pnote
);
19484 else if (const_strneq (pnote
->namedata
, "GNU"))
19485 return print_gnu_note (filedata
, pnote
);
19486 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19487 return print_stapsdt_note (pnote
);
19488 else if (const_strneq (pnote
->namedata
, "CORE"))
19489 return print_core_note (pnote
);
19490 else if (((const_strneq (pnote
->namedata
, "GA")
19491 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19492 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19493 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19494 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19495 return print_gnu_build_attribute_description (pnote
, filedata
);
19501 printf (_(" description data: "));
19502 for (i
= 0; i
< pnote
->descsz
; i
++)
19503 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19515 process_notes_at (Filedata
* filedata
,
19516 Elf_Internal_Shdr
* section
,
19521 Elf_External_Note
* pnotes
;
19522 Elf_External_Note
* external
;
19524 bfd_boolean res
= TRUE
;
19531 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19534 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19542 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19545 if (pnotes
== NULL
)
19551 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19553 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19554 (unsigned long) offset
, (unsigned long) length
);
19556 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19557 specifies that notes should be aligned to 4 bytes in 32-bit
19558 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19559 we also support 4 byte alignment in 64-bit objects. If section
19560 alignment is less than 4, we treate alignment as 4 bytes. */
19563 else if (align
!= 4 && align
!= 8)
19565 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19571 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19573 end
= (char *) pnotes
+ length
;
19574 while ((char *) external
< end
)
19576 Elf_Internal_Note inote
;
19579 char * temp
= NULL
;
19580 size_t data_remaining
= end
- (char *) external
;
19582 if (!is_ia64_vms (filedata
))
19584 /* PR binutils/15191
19585 Make sure that there is enough data to read. */
19586 min_notesz
= offsetof (Elf_External_Note
, name
);
19587 if (data_remaining
< min_notesz
)
19589 warn (ngettext ("Corrupt note: only %ld byte remains, "
19590 "not enough for a full note\n",
19591 "Corrupt note: only %ld bytes remain, "
19592 "not enough for a full note\n",
19594 (long) data_remaining
);
19597 data_remaining
-= min_notesz
;
19599 inote
.type
= BYTE_GET (external
->type
);
19600 inote
.namesz
= BYTE_GET (external
->namesz
);
19601 inote
.namedata
= external
->name
;
19602 inote
.descsz
= BYTE_GET (external
->descsz
);
19603 inote
.descdata
= ((char *) external
19604 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19605 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19606 next
= ((char *) external
19607 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19611 Elf64_External_VMS_Note
*vms_external
;
19613 /* PR binutils/15191
19614 Make sure that there is enough data to read. */
19615 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19616 if (data_remaining
< min_notesz
)
19618 warn (ngettext ("Corrupt note: only %ld byte remains, "
19619 "not enough for a full note\n",
19620 "Corrupt note: only %ld bytes remain, "
19621 "not enough for a full note\n",
19623 (long) data_remaining
);
19626 data_remaining
-= min_notesz
;
19628 vms_external
= (Elf64_External_VMS_Note
*) external
;
19629 inote
.type
= BYTE_GET (vms_external
->type
);
19630 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19631 inote
.namedata
= vms_external
->name
;
19632 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19633 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19634 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19635 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19638 /* PR 17531: file: 3443835e. */
19639 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19640 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19641 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19642 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19643 || ((size_t) (next
- inote
.descdata
)
19644 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19646 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19647 (unsigned long) ((char *) external
- (char *) pnotes
));
19648 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19649 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19653 external
= (Elf_External_Note
*) next
;
19655 /* Verify that name is null terminated. It appears that at least
19656 one version of Linux (RedHat 6.0) generates corefiles that don't
19657 comply with the ELF spec by failing to include the null byte in
19659 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19661 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19663 temp
= (char *) malloc (inote
.namesz
+ 1);
19666 error (_("Out of memory allocating space for inote name\n"));
19671 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19672 inote
.namedata
= temp
;
19674 inote
.namedata
[inote
.namesz
] = 0;
19677 if (! process_note (& inote
, filedata
))
19693 process_corefile_note_segments (Filedata
* filedata
)
19695 Elf_Internal_Phdr
* segment
;
19697 bfd_boolean res
= TRUE
;
19699 if (! get_program_headers (filedata
))
19702 for (i
= 0, segment
= filedata
->program_headers
;
19703 i
< filedata
->file_header
.e_phnum
;
19706 if (segment
->p_type
== PT_NOTE
)
19707 if (! process_notes_at (filedata
, NULL
,
19708 (bfd_vma
) segment
->p_offset
,
19709 (bfd_vma
) segment
->p_filesz
,
19710 (bfd_vma
) segment
->p_align
))
19718 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19720 Elf_External_Note
* pnotes
;
19721 Elf_External_Note
* external
;
19723 bfd_boolean res
= TRUE
;
19728 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19730 if (pnotes
== NULL
)
19734 end
= (char*) pnotes
+ length
;
19736 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19737 (unsigned long) offset
, (unsigned long) length
);
19739 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19741 Elf_External_Note
* next
;
19742 Elf_Internal_Note inote
;
19744 inote
.type
= BYTE_GET (external
->type
);
19745 inote
.namesz
= BYTE_GET (external
->namesz
);
19746 inote
.namedata
= external
->name
;
19747 inote
.descsz
= BYTE_GET (external
->descsz
);
19748 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19749 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19751 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19753 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19754 inote
.descdata
= inote
.namedata
;
19758 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19760 if ( ((char *) next
> end
)
19761 || ((char *) next
< (char *) pnotes
))
19763 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19764 (unsigned long) ((char *) external
- (char *) pnotes
));
19765 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19766 inote
.type
, inote
.namesz
, inote
.descsz
);
19772 /* Prevent out-of-bounds indexing. */
19773 if ( inote
.namedata
+ inote
.namesz
> end
19774 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19776 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19777 (unsigned long) ((char *) external
- (char *) pnotes
));
19778 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19779 inote
.type
, inote
.namesz
, inote
.descsz
);
19783 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19785 if (! print_v850_note (& inote
))
19788 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19789 inote
.namesz
, inote
.descsz
);
19799 process_note_sections (Filedata
* filedata
)
19801 Elf_Internal_Shdr
* section
;
19803 unsigned int n
= 0;
19804 bfd_boolean res
= TRUE
;
19806 for (i
= 0, section
= filedata
->section_headers
;
19807 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19810 if (section
->sh_type
== SHT_NOTE
)
19812 if (! process_notes_at (filedata
, section
,
19813 (bfd_vma
) section
->sh_offset
,
19814 (bfd_vma
) section
->sh_size
,
19815 (bfd_vma
) section
->sh_addralign
))
19820 if (( filedata
->file_header
.e_machine
== EM_V800
19821 || filedata
->file_header
.e_machine
== EM_V850
19822 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19823 && section
->sh_type
== SHT_RENESAS_INFO
)
19825 if (! process_v850_notes (filedata
,
19826 (bfd_vma
) section
->sh_offset
,
19827 (bfd_vma
) section
->sh_size
))
19834 /* Try processing NOTE segments instead. */
19835 return process_corefile_note_segments (filedata
);
19841 process_notes (Filedata
* filedata
)
19843 /* If we have not been asked to display the notes then do nothing. */
19847 if (filedata
->file_header
.e_type
!= ET_CORE
)
19848 return process_note_sections (filedata
);
19850 /* No program headers means no NOTE segment. */
19851 if (filedata
->file_header
.e_phnum
> 0)
19852 return process_corefile_note_segments (filedata
);
19854 printf (_("No note segments present in the core file.\n"));
19858 static unsigned char *
19859 display_public_gnu_attributes (unsigned char * start
,
19860 const unsigned char * const end
)
19862 printf (_(" Unknown GNU attribute: %s\n"), start
);
19864 start
+= strnlen ((char *) start
, end
- start
);
19865 display_raw_attribute (start
, end
);
19867 return (unsigned char *) end
;
19870 static unsigned char *
19871 display_generic_attribute (unsigned char * start
,
19873 const unsigned char * const end
)
19876 return (unsigned char *) end
;
19878 return display_tag_value (tag
, start
, end
);
19882 process_arch_specific (Filedata
* filedata
)
19887 switch (filedata
->file_header
.e_machine
)
19890 case EM_ARC_COMPACT
:
19891 case EM_ARC_COMPACT2
:
19892 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19893 display_arc_attribute
,
19894 display_generic_attribute
);
19896 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19897 display_arm_attribute
,
19898 display_generic_attribute
);
19901 case EM_MIPS_RS3_LE
:
19902 return process_mips_specific (filedata
);
19905 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19906 display_msp430x_attribute
,
19907 display_msp430_gnu_attribute
);
19910 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19911 display_riscv_attribute
,
19912 display_generic_attribute
);
19915 return process_nds32_specific (filedata
);
19919 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19920 display_power_gnu_attribute
);
19924 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19925 display_s390_gnu_attribute
);
19928 case EM_SPARC32PLUS
:
19930 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19931 display_sparc_gnu_attribute
);
19934 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19935 display_tic6x_attribute
,
19936 display_generic_attribute
);
19939 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19940 display_public_gnu_attributes
,
19941 display_generic_attribute
);
19946 get_file_header (Filedata
* filedata
)
19948 /* Read in the identity array. */
19949 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19952 /* Determine how to read the rest of the header. */
19953 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19958 byte_get
= byte_get_little_endian
;
19959 byte_put
= byte_put_little_endian
;
19962 byte_get
= byte_get_big_endian
;
19963 byte_put
= byte_put_big_endian
;
19967 /* For now we only support 32 bit and 64 bit ELF files. */
19968 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19970 /* Read in the rest of the header. */
19973 Elf32_External_Ehdr ehdr32
;
19975 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19978 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19979 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19980 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19981 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19982 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19983 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19984 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19985 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19986 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19987 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19988 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19989 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19990 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19994 Elf64_External_Ehdr ehdr64
;
19996 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19997 we will not be able to cope with the 64bit data found in
19998 64 ELF files. Detect this now and abort before we start
19999 overwriting things. */
20000 if (sizeof (bfd_vma
) < 8)
20002 error (_("This instance of readelf has been built without support for a\n\
20003 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20007 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20010 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20011 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20012 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20013 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20014 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20015 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20016 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20017 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20018 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20019 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20020 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20021 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20022 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20025 if (filedata
->file_header
.e_shoff
)
20027 /* There may be some extensions in the first section header. Don't
20028 bomb if we can't read it. */
20030 get_32bit_section_headers (filedata
, TRUE
);
20032 get_64bit_section_headers (filedata
, TRUE
);
20039 close_file (Filedata
* filedata
)
20043 if (filedata
->handle
)
20044 fclose (filedata
->handle
);
20050 close_debug_file (void * data
)
20052 close_file ((Filedata
*) data
);
20056 open_file (const char * pathname
)
20058 struct stat statbuf
;
20059 Filedata
* filedata
= NULL
;
20061 if (stat (pathname
, & statbuf
) < 0
20062 || ! S_ISREG (statbuf
.st_mode
))
20065 filedata
= calloc (1, sizeof * filedata
);
20066 if (filedata
== NULL
)
20069 filedata
->handle
= fopen (pathname
, "rb");
20070 if (filedata
->handle
== NULL
)
20073 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20074 filedata
->file_name
= pathname
;
20076 if (! get_file_header (filedata
))
20079 if (filedata
->file_header
.e_shoff
)
20083 /* Read the section headers again, this time for real. */
20085 res
= get_32bit_section_headers (filedata
, FALSE
);
20087 res
= get_64bit_section_headers (filedata
, FALSE
);
20098 if (filedata
->handle
)
20099 fclose (filedata
->handle
);
20106 open_debug_file (const char * pathname
)
20108 return open_file (pathname
);
20111 /* Process one ELF object file according to the command line options.
20112 This file may actually be stored in an archive. The file is
20113 positioned at the start of the ELF object. Returns TRUE if no
20114 problems were encountered, FALSE otherwise. */
20117 process_object (Filedata
* filedata
)
20119 bfd_boolean have_separate_files
;
20121 bfd_boolean res
= TRUE
;
20123 if (! get_file_header (filedata
))
20125 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20129 /* Initialise per file variables. */
20130 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20131 filedata
->version_info
[i
] = 0;
20133 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20134 filedata
->dynamic_info
[i
] = 0;
20135 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20136 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20138 /* Process the file. */
20140 printf (_("\nFile: %s\n"), filedata
->file_name
);
20142 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20143 Note we do this even if cmdline_dump_sects is empty because we
20144 must make sure that the dump_sets array is zeroed out before each
20145 object file is processed. */
20146 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20147 memset (filedata
->dump
.dump_sects
, 0,
20148 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20150 if (cmdline
.num_dump_sects
> 0)
20152 if (filedata
->dump
.num_dump_sects
== 0)
20153 /* A sneaky way of allocating the dump_sects array. */
20154 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20156 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20157 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20158 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20161 if (! process_file_header (filedata
))
20164 if (! process_section_headers (filedata
))
20166 /* Without loaded section headers we cannot process lots of things. */
20167 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20169 if (! do_using_dynamic
)
20170 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20173 if (! process_section_groups (filedata
))
20174 /* Without loaded section groups we cannot process unwind. */
20177 if (process_program_headers (filedata
))
20178 process_dynamic_section (filedata
);
20182 if (! process_relocs (filedata
))
20185 if (! process_unwind (filedata
))
20188 if (! process_symbol_table (filedata
))
20191 if (! process_syminfo (filedata
))
20194 if (! process_version_sections (filedata
))
20197 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20198 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20200 have_separate_files
= FALSE
;
20202 if (! process_section_contents (filedata
))
20205 if (have_separate_files
)
20209 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20211 if (! process_section_headers (d
->handle
))
20213 else if (! process_section_contents (d
->handle
))
20217 /* The file handles are closed by the call to free_debug_memory() below. */
20220 if (! process_notes (filedata
))
20223 if (! process_gnu_liblist (filedata
))
20226 if (! process_arch_specific (filedata
))
20229 free (filedata
->program_headers
);
20230 filedata
->program_headers
= NULL
;
20232 free (filedata
->section_headers
);
20233 filedata
->section_headers
= NULL
;
20235 free (filedata
->string_table
);
20236 filedata
->string_table
= NULL
;
20237 filedata
->string_table_length
= 0;
20239 if (filedata
->dump
.dump_sects
!= NULL
)
20241 free (filedata
->dump
.dump_sects
);
20242 filedata
->dump
.dump_sects
= NULL
;
20243 filedata
->dump
.num_dump_sects
= 0;
20246 if (filedata
->dynamic_strings
)
20248 free (filedata
->dynamic_strings
);
20249 filedata
->dynamic_strings
= NULL
;
20250 filedata
->dynamic_strings_length
= 0;
20253 if (filedata
->dynamic_symbols
)
20255 free (filedata
->dynamic_symbols
);
20256 filedata
->dynamic_symbols
= NULL
;
20257 filedata
->num_dynamic_syms
= 0;
20260 if (filedata
->dynamic_syminfo
)
20262 free (filedata
->dynamic_syminfo
);
20263 filedata
->dynamic_syminfo
= NULL
;
20266 if (filedata
->dynamic_section
)
20268 free (filedata
->dynamic_section
);
20269 filedata
->dynamic_section
= NULL
;
20272 while (filedata
->symtab_shndx_list
!= NULL
)
20274 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20275 free (filedata
->symtab_shndx_list
);
20276 filedata
->symtab_shndx_list
= next
;
20279 if (filedata
->section_headers_groups
)
20281 free (filedata
->section_headers_groups
);
20282 filedata
->section_headers_groups
= NULL
;
20285 if (filedata
->section_groups
)
20287 struct group_list
* g
;
20288 struct group_list
* next
;
20290 for (i
= 0; i
< filedata
->group_count
; i
++)
20292 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20299 free (filedata
->section_groups
);
20300 filedata
->section_groups
= NULL
;
20303 free_debug_memory ();
20308 /* Process an ELF archive.
20309 On entry the file is positioned just after the ARMAG string.
20310 Returns TRUE upon success, FALSE otherwise. */
20313 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20315 struct archive_info arch
;
20316 struct archive_info nested_arch
;
20318 bfd_boolean ret
= TRUE
;
20322 /* The ARCH structure is used to hold information about this archive. */
20323 arch
.file_name
= NULL
;
20325 arch
.index_array
= NULL
;
20326 arch
.sym_table
= NULL
;
20327 arch
.longnames
= NULL
;
20329 /* The NESTED_ARCH structure is used as a single-item cache of information
20330 about a nested archive (when members of a thin archive reside within
20331 another regular archive file). */
20332 nested_arch
.file_name
= NULL
;
20333 nested_arch
.file
= NULL
;
20334 nested_arch
.index_array
= NULL
;
20335 nested_arch
.sym_table
= NULL
;
20336 nested_arch
.longnames
= NULL
;
20338 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20339 filedata
->file_size
, is_thin_archive
,
20340 do_archive_index
) != 0)
20346 if (do_archive_index
)
20348 if (arch
.sym_table
== NULL
)
20349 error (_("%s: unable to dump the index as none was found\n"),
20350 filedata
->file_name
);
20353 unsigned long i
, l
;
20354 unsigned long current_pos
;
20356 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20357 "in the symbol table)\n"),
20358 filedata
->file_name
, (unsigned long) arch
.index_num
,
20361 current_pos
= ftell (filedata
->handle
);
20363 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20366 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20369 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20372 if (member_name
!= NULL
)
20374 char * qualified_name
20375 = make_qualified_name (&arch
, &nested_arch
,
20378 if (qualified_name
!= NULL
)
20380 printf (_("Contents of binary %s at offset "),
20382 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20384 free (qualified_name
);
20386 free (member_name
);
20390 if (l
>= arch
.sym_size
)
20392 error (_("%s: end of the symbol table reached "
20393 "before the end of the index\n"),
20394 filedata
->file_name
);
20398 /* PR 17531: file: 0b6630b2. */
20399 printf ("\t%.*s\n",
20400 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20401 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20404 if (arch
.uses_64bit_indices
)
20409 if (l
< arch
.sym_size
)
20411 error (ngettext ("%s: %ld byte remains in the symbol table, "
20412 "but without corresponding entries in "
20413 "the index table\n",
20414 "%s: %ld bytes remain in the symbol table, "
20415 "but without corresponding entries in "
20416 "the index table\n",
20417 arch
.sym_size
- l
),
20418 filedata
->file_name
, arch
.sym_size
- l
);
20422 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20424 error (_("%s: failed to seek back to start of object files "
20425 "in the archive\n"),
20426 filedata
->file_name
);
20432 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20433 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20434 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20435 && !do_section_groups
&& !do_dyn_syms
)
20437 ret
= TRUE
; /* Archive index only. */
20446 char * qualified_name
;
20448 /* Read the next archive header. */
20449 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20451 error (_("%s: failed to seek to next archive header\n"),
20456 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20457 if (got
!= sizeof arch
.arhdr
)
20461 /* PR 24049 - we cannot use filedata->file_name as this will
20462 have already been freed. */
20463 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20468 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20470 error (_("%s: did not find a valid archive header\n"),
20476 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20478 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20479 if (filedata
->archive_file_size
& 01)
20480 ++filedata
->archive_file_size
;
20482 name
= get_archive_member_name (&arch
, &nested_arch
);
20485 error (_("%s: bad archive file name\n"), arch
.file_name
);
20489 namelen
= strlen (name
);
20491 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20492 if (qualified_name
== NULL
)
20494 error (_("%s: bad archive file name\n"), arch
.file_name
);
20500 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20502 /* This is a proxy for an external member of a thin archive. */
20503 Filedata
* member_filedata
;
20504 char * member_file_name
= adjust_relative_path
20505 (filedata
->file_name
, name
, namelen
);
20508 if (member_file_name
== NULL
)
20510 free (qualified_name
);
20515 member_filedata
= open_file (member_file_name
);
20516 if (member_filedata
== NULL
)
20518 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20519 free (member_file_name
);
20520 free (qualified_name
);
20525 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20526 member_filedata
->file_name
= qualified_name
;
20528 if (! process_object (member_filedata
))
20531 close_file (member_filedata
);
20532 free (member_file_name
);
20534 else if (is_thin_archive
)
20536 Filedata thin_filedata
;
20538 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20540 /* PR 15140: Allow for corrupt thin archives. */
20541 if (nested_arch
.file
== NULL
)
20543 error (_("%s: contains corrupt thin archive: %s\n"),
20544 qualified_name
, name
);
20545 free (qualified_name
);
20552 /* This is a proxy for a member of a nested archive. */
20553 filedata
->archive_file_offset
20554 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20556 /* The nested archive file will have been opened and setup by
20557 get_archive_member_name. */
20558 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20561 error (_("%s: failed to seek to archive member.\n"),
20562 nested_arch
.file_name
);
20563 free (qualified_name
);
20568 thin_filedata
.handle
= nested_arch
.file
;
20569 thin_filedata
.file_name
= qualified_name
;
20571 if (! process_object (& thin_filedata
))
20577 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20578 filedata
->file_name
= qualified_name
;
20579 if (! process_object (filedata
))
20581 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20582 /* Stop looping with "negative" archive_file_size. */
20583 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20584 arch
.next_arhdr_offset
= -1ul;
20587 free (qualified_name
);
20591 if (nested_arch
.file
!= NULL
)
20592 fclose (nested_arch
.file
);
20593 release_archive (&nested_arch
);
20594 release_archive (&arch
);
20600 process_file (char * file_name
)
20602 Filedata
* filedata
= NULL
;
20603 struct stat statbuf
;
20604 char armag
[SARMAG
];
20605 bfd_boolean ret
= TRUE
;
20607 if (stat (file_name
, &statbuf
) < 0)
20609 if (errno
== ENOENT
)
20610 error (_("'%s': No such file\n"), file_name
);
20612 error (_("Could not locate '%s'. System error message: %s\n"),
20613 file_name
, strerror (errno
));
20617 if (! S_ISREG (statbuf
.st_mode
))
20619 error (_("'%s' is not an ordinary file\n"), file_name
);
20623 filedata
= calloc (1, sizeof * filedata
);
20624 if (filedata
== NULL
)
20626 error (_("Out of memory allocating file data structure\n"));
20630 filedata
->file_name
= file_name
;
20631 filedata
->handle
= fopen (file_name
, "rb");
20632 if (filedata
->handle
== NULL
)
20634 error (_("Input file '%s' is not readable.\n"), file_name
);
20639 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20641 error (_("%s: Failed to read file's magic number\n"), file_name
);
20642 fclose (filedata
->handle
);
20647 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20649 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20651 if (! process_archive (filedata
, FALSE
))
20654 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20656 if ( ! process_archive (filedata
, TRUE
))
20661 if (do_archive_index
)
20662 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20665 rewind (filedata
->handle
);
20666 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20668 if (! process_object (filedata
))
20672 fclose (filedata
->handle
);
20673 free (filedata
->section_headers
);
20674 free (filedata
->program_headers
);
20675 free (filedata
->string_table
);
20676 free (filedata
->dump
.dump_sects
);
20679 free (ba_cache
.strtab
);
20680 ba_cache
.strtab
= NULL
;
20681 free (ba_cache
.symtab
);
20682 ba_cache
.symtab
= NULL
;
20683 ba_cache
.filedata
= NULL
;
20688 #ifdef SUPPORT_DISASSEMBLY
20689 /* Needed by the i386 disassembler. For extra credit, someone could
20690 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20694 print_address (unsigned int addr
, FILE * outfile
)
20696 fprintf (outfile
,"0x%8.8x", addr
);
20699 /* Needed by the i386 disassembler. */
20702 db_task_printsym (unsigned int addr
)
20704 print_address (addr
, stderr
);
20709 main (int argc
, char ** argv
)
20713 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20714 setlocale (LC_MESSAGES
, "");
20716 #if defined (HAVE_SETLOCALE)
20717 setlocale (LC_CTYPE
, "");
20719 bindtextdomain (PACKAGE
, LOCALEDIR
);
20720 textdomain (PACKAGE
);
20722 expandargv (&argc
, &argv
);
20724 parse_args (& cmdline
, argc
, argv
);
20726 if (optind
< (argc
- 1))
20728 else if (optind
>= argc
)
20730 warn (_("Nothing to do.\n"));
20735 while (optind
< argc
)
20736 if (! process_file (argv
[optind
++]))
20739 if (cmdline
.dump_sects
!= NULL
)
20740 free (cmdline
.dump_sects
);
20742 free (dump_ctf_symtab_name
);
20743 free (dump_ctf_strtab_name
);
20744 free (dump_ctf_parent_name
);
20746 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;