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 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
9998 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10000 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10003 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10004 num_of_syms
= filedata
->nchains
;
10007 if (num_of_syms
== 0)
10009 if (filedata
->buckets
)
10011 free (filedata
->buckets
);
10012 filedata
->buckets
= NULL
;
10014 if (filedata
->chains
)
10016 free (filedata
->chains
);
10017 filedata
->chains
= NULL
;
10019 filedata
->nbuckets
= 0;
10023 if (filedata
->dynamic_info_DT_GNU_HASH
)
10025 unsigned char nb
[16];
10026 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10027 bfd_vma buckets_vma
;
10029 bfd_boolean gnu_hash_error
= FALSE
;
10031 if (fseek (filedata
->handle
,
10032 (filedata
->archive_file_offset
10033 + offset_from_vma (filedata
,
10034 filedata
->dynamic_info_DT_GNU_HASH
,
10038 error (_("Unable to seek to start of dynamic information\n"));
10039 gnu_hash_error
= TRUE
;
10043 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10045 error (_("Failed to read in number of buckets\n"));
10046 gnu_hash_error
= TRUE
;
10050 filedata
->ngnubuckets
= byte_get (nb
, 4);
10051 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10052 bitmaskwords
= byte_get (nb
+ 8, 4);
10053 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10055 buckets_vma
+= bitmaskwords
* 4;
10057 buckets_vma
+= bitmaskwords
* 8;
10059 if (fseek (filedata
->handle
,
10060 (filedata
->archive_file_offset
10061 + offset_from_vma (filedata
, buckets_vma
, 4)),
10064 error (_("Unable to seek to start of dynamic information\n"));
10065 gnu_hash_error
= TRUE
;
10069 filedata
->gnubuckets
10070 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10072 if (filedata
->gnubuckets
== NULL
)
10074 gnu_hash_error
= TRUE
;
10078 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10079 if (filedata
->gnubuckets
[i
] != 0)
10081 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10083 gnu_hash_error
= TRUE
;
10087 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10088 maxchain
= filedata
->gnubuckets
[i
];
10091 if (maxchain
== 0xffffffff)
10093 gnu_hash_error
= TRUE
;
10097 maxchain
-= filedata
->gnusymidx
;
10099 if (fseek (filedata
->handle
,
10100 (filedata
->archive_file_offset
10101 + offset_from_vma (filedata
,
10102 buckets_vma
+ 4 * (filedata
->ngnubuckets
10107 error (_("Unable to seek to start of dynamic information\n"));
10108 gnu_hash_error
= TRUE
;
10114 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10116 error (_("Failed to determine last chain length\n"));
10117 gnu_hash_error
= TRUE
;
10121 if (maxchain
+ 1 == 0)
10123 gnu_hash_error
= TRUE
;
10129 while ((byte_get (nb
, 4) & 1) == 0);
10131 if (fseek (filedata
->handle
,
10132 (filedata
->archive_file_offset
10133 + offset_from_vma (filedata
, (buckets_vma
10134 + 4 * filedata
->ngnubuckets
),
10138 error (_("Unable to seek to start of dynamic information\n"));
10139 gnu_hash_error
= TRUE
;
10143 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10144 filedata
->ngnuchains
= maxchain
;
10146 if (filedata
->gnuchains
== NULL
)
10148 gnu_hash_error
= TRUE
;
10152 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10154 if (fseek (filedata
->handle
,
10155 (filedata
->archive_file_offset
10156 + offset_from_vma (filedata
, (buckets_vma
10157 + 4 * (filedata
->ngnubuckets
10161 error (_("Unable to seek to start of dynamic information\n"));
10162 gnu_hash_error
= TRUE
;
10166 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10169 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10170 if (filedata
->gnubuckets
[hn
] != 0)
10172 bfd_vma si
= filedata
->gnubuckets
[hn
];
10173 bfd_vma off
= si
- filedata
->gnusymidx
;
10177 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10179 if (filedata
->mipsxlat
[off
] >= num_of_syms
)
10180 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10184 if (si
>= num_of_syms
)
10185 num_of_syms
= si
+ 1;
10189 while (off
< filedata
->ngnuchains
10190 && (filedata
->gnuchains
[off
++] & 1) == 0);
10194 if (gnu_hash_error
)
10196 if (filedata
->mipsxlat
)
10198 free (filedata
->mipsxlat
);
10199 filedata
->mipsxlat
= NULL
;
10201 if (filedata
->gnuchains
)
10203 free (filedata
->gnuchains
);
10204 filedata
->gnuchains
= NULL
;
10206 if (filedata
->gnubuckets
)
10208 free (filedata
->gnubuckets
);
10209 filedata
->gnubuckets
= NULL
;
10211 filedata
->ngnubuckets
= 0;
10212 filedata
->ngnuchains
= 0;
10216 return num_of_syms
;
10219 /* Parse and display the contents of the dynamic section. */
10222 process_dynamic_section (Filedata
* filedata
)
10224 Elf_Internal_Dyn
* entry
;
10226 if (filedata
->dynamic_size
== 0)
10229 printf (_("\nThere is no dynamic section in this file.\n"));
10236 if (! get_32bit_dynamic_section (filedata
))
10241 if (! get_64bit_dynamic_section (filedata
))
10245 /* Find the appropriate symbol table. */
10246 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10248 unsigned long num_of_syms
;
10250 for (entry
= filedata
->dynamic_section
;
10251 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10253 if (entry
->d_tag
== DT_SYMTAB
)
10254 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10255 else if (entry
->d_tag
== DT_SYMENT
)
10256 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10257 else if (entry
->d_tag
== DT_HASH
)
10258 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10259 else if (entry
->d_tag
== DT_GNU_HASH
)
10260 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10261 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10262 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10263 && entry
->d_tag
== DT_MIPS_XHASH
)
10265 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10266 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10269 num_of_syms
= get_num_dynamic_syms (filedata
);
10271 if (num_of_syms
!= 0
10272 && filedata
->dynamic_symbols
== NULL
10273 && filedata
->dynamic_info
[DT_SYMTAB
]
10274 && filedata
->dynamic_info
[DT_SYMENT
])
10276 Elf_Internal_Phdr
*seg
;
10277 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10279 if (! get_program_headers (filedata
))
10281 error (_("Cannot interpret virtual addresses "
10282 "without program headers.\n"));
10286 for (seg
= filedata
->program_headers
;
10287 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10290 if (seg
->p_type
!= PT_LOAD
)
10293 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10295 /* See PR 21379 for a reproducer. */
10296 error (_("Invalid PT_LOAD entry\n"));
10300 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10301 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10303 /* Since we do not know how big the symbol table is,
10304 we default to reading in up to the end of PT_LOAD
10305 segment and processing that. This is overkill, I
10306 know, but it should work. */
10307 Elf_Internal_Shdr section
;
10308 section
.sh_offset
= (vma
- seg
->p_vaddr
10310 section
.sh_size
= (num_of_syms
10311 * filedata
->dynamic_info
[DT_SYMENT
]);
10312 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10313 section
.sh_name
= filedata
->string_table_length
;
10314 filedata
->dynamic_symbols
10315 = GET_ELF_SYMBOLS (filedata
, §ion
,
10316 &filedata
->num_dynamic_syms
);
10317 if (filedata
->dynamic_symbols
== NULL
10318 || filedata
->num_dynamic_syms
!= num_of_syms
)
10320 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10329 /* Similarly find a string table. */
10330 if (filedata
->dynamic_strings
== NULL
)
10331 for (entry
= filedata
->dynamic_section
;
10332 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10335 if (entry
->d_tag
== DT_STRTAB
)
10336 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10338 if (entry
->d_tag
== DT_STRSZ
)
10339 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10341 if (filedata
->dynamic_info
[DT_STRTAB
]
10342 && filedata
->dynamic_info
[DT_STRSZ
])
10344 unsigned long offset
;
10345 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10347 offset
= offset_from_vma (filedata
,
10348 filedata
->dynamic_info
[DT_STRTAB
],
10350 filedata
->dynamic_strings
10351 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10352 _("dynamic string table"));
10353 if (filedata
->dynamic_strings
== NULL
)
10355 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10359 filedata
->dynamic_strings_length
= str_tab_len
;
10364 /* And find the syminfo section if available. */
10365 if (filedata
->dynamic_syminfo
== NULL
)
10367 unsigned long syminsz
= 0;
10369 for (entry
= filedata
->dynamic_section
;
10370 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10373 if (entry
->d_tag
== DT_SYMINENT
)
10375 /* Note: these braces are necessary to avoid a syntax
10376 error from the SunOS4 C compiler. */
10377 /* PR binutils/17531: A corrupt file can trigger this test.
10378 So do not use an assert, instead generate an error message. */
10379 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10380 error (_("Bad value (%d) for SYMINENT entry\n"),
10381 (int) entry
->d_un
.d_val
);
10383 else if (entry
->d_tag
== DT_SYMINSZ
)
10384 syminsz
= entry
->d_un
.d_val
;
10385 else if (entry
->d_tag
== DT_SYMINFO
)
10386 filedata
->dynamic_syminfo_offset
10387 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10390 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10392 Elf_External_Syminfo
* extsyminfo
;
10393 Elf_External_Syminfo
* extsym
;
10394 Elf_Internal_Syminfo
* syminfo
;
10396 /* There is a syminfo section. Read the data. */
10397 extsyminfo
= (Elf_External_Syminfo
*)
10398 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10399 1, syminsz
, _("symbol information"));
10403 if (filedata
->dynamic_syminfo
!= NULL
)
10405 error (_("Multiple dynamic symbol information sections found\n"));
10406 free (filedata
->dynamic_syminfo
);
10408 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10409 if (filedata
->dynamic_syminfo
== NULL
)
10411 error (_("Out of memory allocating %lu bytes "
10412 "for dynamic symbol info\n"),
10413 (unsigned long) syminsz
);
10417 filedata
->dynamic_syminfo_nent
10418 = syminsz
/ sizeof (Elf_External_Syminfo
);
10419 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10420 syminfo
< (filedata
->dynamic_syminfo
10421 + filedata
->dynamic_syminfo_nent
);
10422 ++syminfo
, ++extsym
)
10424 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10425 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10432 if (do_dynamic
&& filedata
->dynamic_addr
)
10433 printf (ngettext ("\nDynamic section at offset 0x%lx "
10434 "contains %lu entry:\n",
10435 "\nDynamic section at offset 0x%lx "
10436 "contains %lu entries:\n",
10437 filedata
->dynamic_nent
),
10438 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10440 printf (_(" Tag Type Name/Value\n"));
10442 for (entry
= filedata
->dynamic_section
;
10443 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10448 const char * dtype
;
10451 print_vma (entry
->d_tag
, FULL_HEX
);
10452 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10453 printf (" (%s)%*s", dtype
,
10454 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10457 switch (entry
->d_tag
)
10461 print_dynamic_flags (entry
->d_un
.d_val
);
10471 switch (entry
->d_tag
)
10474 printf (_("Auxiliary library"));
10478 printf (_("Filter library"));
10482 printf (_("Configuration file"));
10486 printf (_("Dependency audit library"));
10490 printf (_("Audit library"));
10494 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10495 printf (": [%s]\n",
10496 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10500 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10509 printf (_("Flags:"));
10511 if (entry
->d_un
.d_val
== 0)
10512 printf (_(" None\n"));
10515 unsigned long int val
= entry
->d_un
.d_val
;
10517 if (val
& DTF_1_PARINIT
)
10519 printf (" PARINIT");
10520 val
^= DTF_1_PARINIT
;
10522 if (val
& DTF_1_CONFEXP
)
10524 printf (" CONFEXP");
10525 val
^= DTF_1_CONFEXP
;
10528 printf (" %lx", val
);
10537 printf (_("Flags:"));
10539 if (entry
->d_un
.d_val
== 0)
10540 printf (_(" None\n"));
10543 unsigned long int val
= entry
->d_un
.d_val
;
10545 if (val
& DF_P1_LAZYLOAD
)
10547 printf (" LAZYLOAD");
10548 val
^= DF_P1_LAZYLOAD
;
10550 if (val
& DF_P1_GROUPPERM
)
10552 printf (" GROUPPERM");
10553 val
^= DF_P1_GROUPPERM
;
10556 printf (" %lx", val
);
10565 printf (_("Flags:"));
10566 if (entry
->d_un
.d_val
== 0)
10567 printf (_(" None\n"));
10570 unsigned long int val
= entry
->d_un
.d_val
;
10572 if (val
& DF_1_NOW
)
10577 if (val
& DF_1_GLOBAL
)
10579 printf (" GLOBAL");
10580 val
^= DF_1_GLOBAL
;
10582 if (val
& DF_1_GROUP
)
10587 if (val
& DF_1_NODELETE
)
10589 printf (" NODELETE");
10590 val
^= DF_1_NODELETE
;
10592 if (val
& DF_1_LOADFLTR
)
10594 printf (" LOADFLTR");
10595 val
^= DF_1_LOADFLTR
;
10597 if (val
& DF_1_INITFIRST
)
10599 printf (" INITFIRST");
10600 val
^= DF_1_INITFIRST
;
10602 if (val
& DF_1_NOOPEN
)
10604 printf (" NOOPEN");
10605 val
^= DF_1_NOOPEN
;
10607 if (val
& DF_1_ORIGIN
)
10609 printf (" ORIGIN");
10610 val
^= DF_1_ORIGIN
;
10612 if (val
& DF_1_DIRECT
)
10614 printf (" DIRECT");
10615 val
^= DF_1_DIRECT
;
10617 if (val
& DF_1_TRANS
)
10622 if (val
& DF_1_INTERPOSE
)
10624 printf (" INTERPOSE");
10625 val
^= DF_1_INTERPOSE
;
10627 if (val
& DF_1_NODEFLIB
)
10629 printf (" NODEFLIB");
10630 val
^= DF_1_NODEFLIB
;
10632 if (val
& DF_1_NODUMP
)
10634 printf (" NODUMP");
10635 val
^= DF_1_NODUMP
;
10637 if (val
& DF_1_CONFALT
)
10639 printf (" CONFALT");
10640 val
^= DF_1_CONFALT
;
10642 if (val
& DF_1_ENDFILTEE
)
10644 printf (" ENDFILTEE");
10645 val
^= DF_1_ENDFILTEE
;
10647 if (val
& DF_1_DISPRELDNE
)
10649 printf (" DISPRELDNE");
10650 val
^= DF_1_DISPRELDNE
;
10652 if (val
& DF_1_DISPRELPND
)
10654 printf (" DISPRELPND");
10655 val
^= DF_1_DISPRELPND
;
10657 if (val
& DF_1_NODIRECT
)
10659 printf (" NODIRECT");
10660 val
^= DF_1_NODIRECT
;
10662 if (val
& DF_1_IGNMULDEF
)
10664 printf (" IGNMULDEF");
10665 val
^= DF_1_IGNMULDEF
;
10667 if (val
& DF_1_NOKSYMS
)
10669 printf (" NOKSYMS");
10670 val
^= DF_1_NOKSYMS
;
10672 if (val
& DF_1_NOHDR
)
10677 if (val
& DF_1_EDITED
)
10679 printf (" EDITED");
10680 val
^= DF_1_EDITED
;
10682 if (val
& DF_1_NORELOC
)
10684 printf (" NORELOC");
10685 val
^= DF_1_NORELOC
;
10687 if (val
& DF_1_SYMINTPOSE
)
10689 printf (" SYMINTPOSE");
10690 val
^= DF_1_SYMINTPOSE
;
10692 if (val
& DF_1_GLOBAUDIT
)
10694 printf (" GLOBAUDIT");
10695 val
^= DF_1_GLOBAUDIT
;
10697 if (val
& DF_1_SINGLETON
)
10699 printf (" SINGLETON");
10700 val
^= DF_1_SINGLETON
;
10702 if (val
& DF_1_STUB
)
10707 if (val
& DF_1_PIE
)
10712 if (val
& DF_1_KMOD
)
10717 if (val
& DF_1_WEAKFILTER
)
10719 printf (" WEAKFILTER");
10720 val
^= DF_1_WEAKFILTER
;
10722 if (val
& DF_1_NOCOMMON
)
10724 printf (" NOCOMMON");
10725 val
^= DF_1_NOCOMMON
;
10728 printf (" %lx", val
);
10735 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10737 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10757 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10763 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10764 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10770 switch (entry
->d_tag
)
10773 printf (_("Shared library: [%s]"), name
);
10775 if (streq (name
, filedata
->program_interpreter
))
10776 printf (_(" program interpreter"));
10780 printf (_("Library soname: [%s]"), name
);
10784 printf (_("Library rpath: [%s]"), name
);
10788 printf (_("Library runpath: [%s]"), name
);
10792 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10797 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10810 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10811 /* Fall through. */
10815 case DT_INIT_ARRAYSZ
:
10816 case DT_FINI_ARRAYSZ
:
10817 case DT_GNU_CONFLICTSZ
:
10818 case DT_GNU_LIBLISTSZ
:
10821 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10822 printf (_(" (bytes)\n"));
10827 case DT_VERNEEDNUM
:
10832 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10841 case DT_INIT_ARRAY
:
10842 case DT_FINI_ARRAY
:
10845 if (entry
->d_tag
== DT_USED
10846 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10848 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10852 printf (_("Not needed object: [%s]\n"), name
);
10857 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10863 /* The value of this entry is ignored. */
10868 case DT_GNU_PRELINKED
:
10872 time_t atime
= entry
->d_un
.d_val
;
10874 tmp
= gmtime (&atime
);
10875 /* PR 17533 file: 041-1244816-0.004. */
10877 printf (_("<corrupt time val: %lx"),
10878 (unsigned long) atime
);
10880 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10881 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10882 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10888 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10891 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10897 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10898 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
10899 = entry
->d_un
.d_val
;
10903 switch (filedata
->file_header
.e_machine
)
10906 dynamic_section_aarch64_val (entry
);
10909 case EM_MIPS_RS3_LE
:
10910 dynamic_section_mips_val (filedata
, entry
);
10913 dynamic_section_parisc_val (entry
);
10916 dynamic_section_ia64_val (entry
);
10919 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10931 get_ver_flags (unsigned int flags
)
10933 static char buff
[128];
10940 if (flags
& VER_FLG_BASE
)
10941 strcat (buff
, "BASE");
10943 if (flags
& VER_FLG_WEAK
)
10945 if (flags
& VER_FLG_BASE
)
10946 strcat (buff
, " | ");
10948 strcat (buff
, "WEAK");
10951 if (flags
& VER_FLG_INFO
)
10953 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10954 strcat (buff
, " | ");
10956 strcat (buff
, "INFO");
10959 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10961 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10962 strcat (buff
, " | ");
10964 strcat (buff
, _("<unknown>"));
10970 /* Display the contents of the version sections. */
10973 process_version_sections (Filedata
* filedata
)
10975 Elf_Internal_Shdr
* section
;
10977 bfd_boolean found
= FALSE
;
10982 for (i
= 0, section
= filedata
->section_headers
;
10983 i
< filedata
->file_header
.e_shnum
;
10986 switch (section
->sh_type
)
10988 case SHT_GNU_verdef
:
10990 Elf_External_Verdef
* edefs
;
10997 printf (ngettext ("\nVersion definition section '%s' "
10998 "contains %u entry:\n",
10999 "\nVersion definition section '%s' "
11000 "contains %u entries:\n",
11002 printable_section_name (filedata
, section
),
11005 printf (_(" Addr: 0x"));
11006 printf_vma (section
->sh_addr
);
11007 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11008 (unsigned long) section
->sh_offset
, section
->sh_link
,
11009 printable_section_name_from_index (filedata
, section
->sh_link
));
11011 edefs
= (Elf_External_Verdef
*)
11012 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11013 _("version definition section"));
11016 endbuf
= (char *) edefs
+ section
->sh_size
;
11018 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11021 Elf_External_Verdef
* edef
;
11022 Elf_Internal_Verdef ent
;
11023 Elf_External_Verdaux
* eaux
;
11024 Elf_Internal_Verdaux aux
;
11025 unsigned long isum
;
11028 vstart
= ((char *) edefs
) + idx
;
11029 if (vstart
+ sizeof (*edef
) > endbuf
)
11032 edef
= (Elf_External_Verdef
*) vstart
;
11034 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11035 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11036 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11037 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11038 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11039 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11040 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11042 printf (_(" %#06lx: Rev: %d Flags: %s"),
11043 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11045 printf (_(" Index: %d Cnt: %d "),
11046 ent
.vd_ndx
, ent
.vd_cnt
);
11048 /* Check for overflow. */
11049 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11052 vstart
+= ent
.vd_aux
;
11054 if (vstart
+ sizeof (*eaux
) > endbuf
)
11056 eaux
= (Elf_External_Verdaux
*) vstart
;
11058 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11059 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11061 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11062 printf (_("Name: %s\n"),
11063 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11065 printf (_("Name index: %ld\n"), aux
.vda_name
);
11067 isum
= idx
+ ent
.vd_aux
;
11069 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11071 if (aux
.vda_next
< sizeof (*eaux
)
11072 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11074 warn (_("Invalid vda_next field of %lx\n"),
11079 /* Check for overflow. */
11080 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11083 isum
+= aux
.vda_next
;
11084 vstart
+= aux
.vda_next
;
11086 if (vstart
+ sizeof (*eaux
) > endbuf
)
11088 eaux
= (Elf_External_Verdaux
*) vstart
;
11090 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11091 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11093 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11094 printf (_(" %#06lx: Parent %d: %s\n"),
11096 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11098 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11099 isum
, j
, aux
.vda_name
);
11102 if (j
< ent
.vd_cnt
)
11103 printf (_(" Version def aux past end of section\n"));
11106 file: id:000001,src:000172+005151,op:splice,rep:2. */
11107 if (ent
.vd_next
< sizeof (*edef
)
11108 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11110 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11111 cnt
= section
->sh_info
;
11114 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11117 idx
+= ent
.vd_next
;
11120 if (cnt
< section
->sh_info
)
11121 printf (_(" Version definition past end of section\n"));
11127 case SHT_GNU_verneed
:
11129 Elf_External_Verneed
* eneed
;
11136 printf (ngettext ("\nVersion needs section '%s' "
11137 "contains %u entry:\n",
11138 "\nVersion needs section '%s' "
11139 "contains %u entries:\n",
11141 printable_section_name (filedata
, section
), section
->sh_info
);
11143 printf (_(" Addr: 0x"));
11144 printf_vma (section
->sh_addr
);
11145 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11146 (unsigned long) section
->sh_offset
, section
->sh_link
,
11147 printable_section_name_from_index (filedata
, section
->sh_link
));
11149 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11150 section
->sh_offset
, 1,
11152 _("Version Needs section"));
11155 endbuf
= (char *) eneed
+ section
->sh_size
;
11157 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11159 Elf_External_Verneed
* entry
;
11160 Elf_Internal_Verneed ent
;
11161 unsigned long isum
;
11165 vstart
= ((char *) eneed
) + idx
;
11166 if (vstart
+ sizeof (*entry
) > endbuf
)
11169 entry
= (Elf_External_Verneed
*) vstart
;
11171 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11172 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11173 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11174 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11175 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11177 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11179 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11180 printf (_(" File: %s"),
11181 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11183 printf (_(" File: %lx"), ent
.vn_file
);
11185 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11187 /* Check for overflow. */
11188 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11190 vstart
+= ent
.vn_aux
;
11192 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11194 Elf_External_Vernaux
* eaux
;
11195 Elf_Internal_Vernaux aux
;
11197 if (vstart
+ sizeof (*eaux
) > endbuf
)
11199 eaux
= (Elf_External_Vernaux
*) vstart
;
11201 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11202 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11203 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11204 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11205 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11207 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11208 printf (_(" %#06lx: Name: %s"),
11209 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11211 printf (_(" %#06lx: Name index: %lx"),
11212 isum
, aux
.vna_name
);
11214 printf (_(" Flags: %s Version: %d\n"),
11215 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11217 if (aux
.vna_next
< sizeof (*eaux
)
11218 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11220 warn (_("Invalid vna_next field of %lx\n"),
11225 /* Check for overflow. */
11226 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11228 isum
+= aux
.vna_next
;
11229 vstart
+= aux
.vna_next
;
11232 if (j
< ent
.vn_cnt
)
11233 warn (_("Missing Version Needs auxillary information\n"));
11235 if (ent
.vn_next
< sizeof (*entry
)
11236 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11238 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11239 cnt
= section
->sh_info
;
11242 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11244 idx
+= ent
.vn_next
;
11247 if (cnt
< section
->sh_info
)
11248 warn (_("Missing Version Needs information\n"));
11254 case SHT_GNU_versym
:
11256 Elf_Internal_Shdr
* link_section
;
11259 unsigned char * edata
;
11260 unsigned short * data
;
11262 Elf_Internal_Sym
* symbols
;
11263 Elf_Internal_Shdr
* string_sec
;
11264 unsigned long num_syms
;
11267 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11270 link_section
= filedata
->section_headers
+ section
->sh_link
;
11271 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11273 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11278 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11279 if (symbols
== NULL
)
11282 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11284 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11285 string_sec
->sh_size
,
11286 _("version string table"));
11293 printf (ngettext ("\nVersion symbols section '%s' "
11294 "contains %lu entry:\n",
11295 "\nVersion symbols section '%s' "
11296 "contains %lu entries:\n",
11298 printable_section_name (filedata
, section
), (unsigned long) total
);
11300 printf (_(" Addr: 0x"));
11301 printf_vma (section
->sh_addr
);
11302 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11303 (unsigned long) section
->sh_offset
, section
->sh_link
,
11304 printable_section_name (filedata
, link_section
));
11306 off
= offset_from_vma (filedata
,
11307 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11308 total
* sizeof (short));
11309 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11310 sizeof (short), total
,
11311 _("version symbol data"));
11319 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11321 for (cnt
= total
; cnt
--;)
11322 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11327 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11331 char *invalid
= _("*invalid*");
11333 printf (" %03x:", cnt
);
11335 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11336 switch (data
[cnt
+ j
])
11339 fputs (_(" 0 (*local*) "), stdout
);
11343 fputs (_(" 1 (*global*) "), stdout
);
11347 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11348 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11350 /* If this index value is greater than the size of the symbols
11351 array, break to avoid an out-of-bounds read. */
11352 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11354 warn (_("invalid index into symbol array\n"));
11359 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11361 Elf_Internal_Verneed ivn
;
11362 unsigned long offset
;
11364 offset
= offset_from_vma
11366 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11367 sizeof (Elf_External_Verneed
));
11371 Elf_Internal_Vernaux ivna
;
11372 Elf_External_Verneed evn
;
11373 Elf_External_Vernaux evna
;
11374 unsigned long a_off
;
11376 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11377 _("version need")) == NULL
)
11380 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11381 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11383 a_off
= offset
+ ivn
.vn_aux
;
11387 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11388 1, _("version need aux (2)")) == NULL
)
11391 ivna
.vna_other
= 0;
11395 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11396 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11399 a_off
+= ivna
.vna_next
;
11401 while (ivna
.vna_other
!= data
[cnt
+ j
]
11402 && ivna
.vna_next
!= 0);
11404 if (ivna
.vna_other
== data
[cnt
+ j
])
11406 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11408 if (ivna
.vna_name
>= string_sec
->sh_size
)
11411 name
= strtab
+ ivna
.vna_name
;
11415 offset
+= ivn
.vn_next
;
11417 while (ivn
.vn_next
);
11420 if (data
[cnt
+ j
] != 0x8001
11421 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11423 Elf_Internal_Verdef ivd
;
11424 Elf_External_Verdef evd
;
11425 unsigned long offset
;
11427 offset
= offset_from_vma
11429 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11434 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11435 _("version def")) == NULL
)
11438 /* PR 17531: file: 046-1082287-0.004. */
11439 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11444 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11445 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11448 offset
+= ivd
.vd_next
;
11450 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11451 && ivd
.vd_next
!= 0);
11453 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11455 Elf_External_Verdaux evda
;
11456 Elf_Internal_Verdaux ivda
;
11458 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11460 if (get_data (&evda
, filedata
,
11461 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11463 _("version def aux")) == NULL
)
11466 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11468 if (ivda
.vda_name
>= string_sec
->sh_size
)
11470 else if (name
!= NULL
&& name
!= invalid
)
11471 name
= _("*both*");
11473 name
= strtab
+ ivda
.vda_name
;
11477 nn
+= printf ("(%s%-*s",
11479 12 - (int) strlen (name
),
11483 printf ("%*c", 18 - nn
, ' ');
11501 printf (_("\nNo version information found in this file.\n"));
11506 static const char *
11507 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11509 static char buff
[64];
11513 case STB_LOCAL
: return "LOCAL";
11514 case STB_GLOBAL
: return "GLOBAL";
11515 case STB_WEAK
: return "WEAK";
11517 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11518 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11520 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11522 if (binding
== STB_GNU_UNIQUE
11523 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11525 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11528 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11533 static const char *
11534 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11536 static char buff
[64];
11540 case STT_NOTYPE
: return "NOTYPE";
11541 case STT_OBJECT
: return "OBJECT";
11542 case STT_FUNC
: return "FUNC";
11543 case STT_SECTION
: return "SECTION";
11544 case STT_FILE
: return "FILE";
11545 case STT_COMMON
: return "COMMON";
11546 case STT_TLS
: return "TLS";
11547 case STT_RELC
: return "RELC";
11548 case STT_SRELC
: return "SRELC";
11550 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11552 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11553 return "THUMB_FUNC";
11555 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11558 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11559 return "PARISC_MILLI";
11561 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11563 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11565 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11567 if (type
== STT_HP_OPAQUE
)
11568 return "HP_OPAQUE";
11569 if (type
== STT_HP_STUB
)
11573 if (type
== STT_GNU_IFUNC
11574 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11575 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11578 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11581 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11586 static const char *
11587 get_symbol_visibility (unsigned int visibility
)
11589 switch (visibility
)
11591 case STV_DEFAULT
: return "DEFAULT";
11592 case STV_INTERNAL
: return "INTERNAL";
11593 case STV_HIDDEN
: return "HIDDEN";
11594 case STV_PROTECTED
: return "PROTECTED";
11596 error (_("Unrecognized visibility value: %u\n"), visibility
);
11597 return _("<unknown>");
11601 static const char *
11602 get_alpha_symbol_other (unsigned int other
)
11606 case STO_ALPHA_NOPV
: return "NOPV";
11607 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11609 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11610 return _("<unknown>");
11614 static const char *
11615 get_solaris_symbol_visibility (unsigned int visibility
)
11617 switch (visibility
)
11619 case 4: return "EXPORTED";
11620 case 5: return "SINGLETON";
11621 case 6: return "ELIMINATE";
11622 default: return get_symbol_visibility (visibility
);
11626 static const char *
11627 get_aarch64_symbol_other (unsigned int other
)
11629 static char buf
[32];
11631 if (other
& STO_AARCH64_VARIANT_PCS
)
11633 other
&= ~STO_AARCH64_VARIANT_PCS
;
11635 return "VARIANT_PCS";
11636 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11642 static const char *
11643 get_mips_symbol_other (unsigned int other
)
11647 case STO_OPTIONAL
: return "OPTIONAL";
11648 case STO_MIPS_PLT
: return "MIPS PLT";
11649 case STO_MIPS_PIC
: return "MIPS PIC";
11650 case STO_MICROMIPS
: return "MICROMIPS";
11651 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11652 case STO_MIPS16
: return "MIPS16";
11653 default: return NULL
;
11657 static const char *
11658 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11660 if (is_ia64_vms (filedata
))
11662 static char res
[32];
11666 /* Function types is for images and .STB files only. */
11667 switch (filedata
->file_header
.e_type
)
11671 switch (VMS_ST_FUNC_TYPE (other
))
11673 case VMS_SFT_CODE_ADDR
:
11674 strcat (res
, " CA");
11676 case VMS_SFT_SYMV_IDX
:
11677 strcat (res
, " VEC");
11680 strcat (res
, " FD");
11682 case VMS_SFT_RESERVE
:
11683 strcat (res
, " RSV");
11686 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11687 VMS_ST_FUNC_TYPE (other
));
11688 strcat (res
, " <unknown>");
11695 switch (VMS_ST_LINKAGE (other
))
11697 case VMS_STL_IGNORE
:
11698 strcat (res
, " IGN");
11700 case VMS_STL_RESERVE
:
11701 strcat (res
, " RSV");
11704 strcat (res
, " STD");
11707 strcat (res
, " LNK");
11710 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11711 VMS_ST_LINKAGE (other
));
11712 strcat (res
, " <unknown>");
11724 static const char *
11725 get_ppc64_symbol_other (unsigned int other
)
11727 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11730 other
>>= STO_PPC64_LOCAL_BIT
;
11733 static char buf
[64];
11735 other
= ppc64_decode_local_entry (other
);
11736 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11742 static const char *
11743 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11745 const char * result
= NULL
;
11746 static char buff
[64];
11751 switch (filedata
->file_header
.e_machine
)
11754 result
= get_alpha_symbol_other (other
);
11757 result
= get_aarch64_symbol_other (other
);
11760 result
= get_mips_symbol_other (other
);
11763 result
= get_ia64_symbol_other (filedata
, other
);
11766 result
= get_ppc64_symbol_other (other
);
11776 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11780 static const char *
11781 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11783 static char buff
[32];
11787 case SHN_UNDEF
: return "UND";
11788 case SHN_ABS
: return "ABS";
11789 case SHN_COMMON
: return "COM";
11791 if (type
== SHN_IA_64_ANSI_COMMON
11792 && filedata
->file_header
.e_machine
== EM_IA_64
11793 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11795 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11796 || filedata
->file_header
.e_machine
== EM_L1OM
11797 || filedata
->file_header
.e_machine
== EM_K1OM
)
11798 && type
== SHN_X86_64_LCOMMON
)
11799 return "LARGE_COM";
11800 else if ((type
== SHN_MIPS_SCOMMON
11801 && filedata
->file_header
.e_machine
== EM_MIPS
)
11802 || (type
== SHN_TIC6X_SCOMMON
11803 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11805 else if (type
== SHN_MIPS_SUNDEFINED
11806 && filedata
->file_header
.e_machine
== EM_MIPS
)
11808 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11809 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11810 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11811 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11812 else if (type
>= SHN_LORESERVE
)
11813 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11814 else if (filedata
->file_header
.e_shnum
!= 0
11815 && type
>= filedata
->file_header
.e_shnum
)
11816 sprintf (buff
, _("bad section index[%3d]"), type
);
11818 sprintf (buff
, "%3d", type
);
11825 static const char *
11826 get_symbol_version_string (Filedata
* filedata
,
11827 bfd_boolean is_dynsym
,
11828 const char * strtab
,
11829 unsigned long int strtab_size
,
11831 Elf_Internal_Sym
* psym
,
11832 enum versioned_symbol_info
* sym_info
,
11833 unsigned short * vna_other
)
11835 unsigned char data
[2];
11836 unsigned short vers_data
;
11837 unsigned long offset
;
11838 unsigned short max_vd_ndx
;
11841 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11844 offset
= offset_from_vma (filedata
,
11845 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11846 sizeof data
+ si
* sizeof (vers_data
));
11848 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11849 sizeof (data
), 1, _("version data")) == NULL
)
11852 vers_data
= byte_get (data
, 2);
11854 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11857 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11860 /* Usually we'd only see verdef for defined symbols, and verneed for
11861 undefined symbols. However, symbols defined by the linker in
11862 .dynbss for variables copied from a shared library in order to
11863 avoid text relocations are defined yet have verneed. We could
11864 use a heuristic to detect the special case, for example, check
11865 for verneed first on symbols defined in SHT_NOBITS sections, but
11866 it is simpler and more reliable to just look for both verdef and
11867 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11869 if (psym
->st_shndx
!= SHN_UNDEF
11870 && vers_data
!= 0x8001
11871 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11873 Elf_Internal_Verdef ivd
;
11874 Elf_Internal_Verdaux ivda
;
11875 Elf_External_Verdaux evda
;
11878 off
= offset_from_vma (filedata
,
11879 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11880 sizeof (Elf_External_Verdef
));
11884 Elf_External_Verdef evd
;
11886 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11887 _("version def")) == NULL
)
11896 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11897 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11898 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11899 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11902 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11903 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11905 off
+= ivd
.vd_next
;
11907 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11909 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11911 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11914 off
-= ivd
.vd_next
;
11917 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11918 _("version def aux")) != NULL
)
11920 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11922 if (psym
->st_name
!= ivda
.vda_name
)
11923 return (ivda
.vda_name
< strtab_size
11924 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11929 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11931 Elf_External_Verneed evn
;
11932 Elf_Internal_Verneed ivn
;
11933 Elf_Internal_Vernaux ivna
;
11935 offset
= offset_from_vma (filedata
,
11936 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11940 unsigned long vna_off
;
11942 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11943 _("version need")) == NULL
)
11946 ivna
.vna_other
= 0;
11951 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11952 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11954 vna_off
= offset
+ ivn
.vn_aux
;
11958 Elf_External_Vernaux evna
;
11960 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11961 _("version need aux (3)")) == NULL
)
11964 ivna
.vna_other
= 0;
11969 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11970 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11971 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11974 vna_off
+= ivna
.vna_next
;
11976 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11978 if (ivna
.vna_other
== vers_data
)
11981 offset
+= ivn
.vn_next
;
11983 while (ivn
.vn_next
!= 0);
11985 if (ivna
.vna_other
== vers_data
)
11987 *sym_info
= symbol_undefined
;
11988 *vna_other
= ivna
.vna_other
;
11989 return (ivna
.vna_name
< strtab_size
11990 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11992 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11993 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11994 return _("<corrupt>");
12000 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12001 Elf_Internal_Sym
*symtab
,
12002 Elf_Internal_Shdr
*section
,
12003 char *strtab
, size_t strtab_size
)
12005 const char *version_string
;
12006 enum versioned_symbol_info sym_info
;
12007 unsigned short vna_other
;
12008 Elf_Internal_Sym
*psym
= symtab
+ si
;
12010 printf ("%6ld: ", si
);
12011 print_vma (psym
->st_value
, LONG_HEX
);
12013 print_vma (psym
->st_size
, DEC_5
);
12014 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12015 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12016 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12017 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12020 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12022 printf (" %-7s", get_symbol_visibility (vis
));
12023 /* Check to see if any other bits in the st_other field are set.
12024 Note - displaying this information disrupts the layout of the
12025 table being generated, but for the moment this case is very rare. */
12026 if (psym
->st_other
^ vis
)
12027 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12029 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12030 print_symbol (25, VALID_SYMBOL_NAME (strtab
, strtab_size
,
12032 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12035 = get_symbol_version_string (filedata
,
12037 || section
->sh_type
== SHT_DYNSYM
),
12038 strtab
, strtab_size
, si
,
12039 psym
, &sym_info
, &vna_other
);
12040 if (version_string
)
12042 if (sym_info
== symbol_undefined
)
12043 printf ("@%s (%d)", version_string
, vna_other
);
12045 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12051 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12053 && si
>= section
->sh_info
12054 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12055 && filedata
->file_header
.e_machine
!= EM_MIPS
12056 /* Solaris binaries have been found to violate this requirement as
12057 well. Not sure if this is a bug or an ABI requirement. */
12058 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12059 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12060 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12063 /* Dump the symbol table. */
12065 process_symbol_table (Filedata
* filedata
)
12067 Elf_Internal_Shdr
* section
;
12069 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12072 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12074 && do_using_dynamic
12075 && filedata
->dynamic_strings
!= NULL
12076 && filedata
->dynamic_symbols
!= NULL
)
12080 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12081 "\nSymbol table for image contains %lu entries:\n",
12082 filedata
->num_dynamic_syms
),
12083 filedata
->num_dynamic_syms
);
12085 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12087 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12089 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12090 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12091 filedata
->dynamic_strings
,
12092 filedata
->dynamic_strings_length
);
12094 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12095 && filedata
->section_headers
!= NULL
)
12099 for (i
= 0, section
= filedata
->section_headers
;
12100 i
< filedata
->file_header
.e_shnum
;
12103 char * strtab
= NULL
;
12104 unsigned long int strtab_size
= 0;
12105 Elf_Internal_Sym
* symtab
;
12106 unsigned long si
, num_syms
;
12108 if ((section
->sh_type
!= SHT_SYMTAB
12109 && section
->sh_type
!= SHT_DYNSYM
)
12111 && section
->sh_type
== SHT_SYMTAB
))
12114 if (section
->sh_entsize
== 0)
12116 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12117 printable_section_name (filedata
, section
));
12121 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12122 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12123 "\nSymbol table '%s' contains %lu entries:\n",
12125 printable_section_name (filedata
, section
),
12129 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12131 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12133 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12134 if (symtab
== NULL
)
12137 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12139 strtab
= filedata
->string_table
;
12140 strtab_size
= filedata
->string_table_length
;
12142 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12144 Elf_Internal_Shdr
* string_sec
;
12146 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12148 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12149 1, string_sec
->sh_size
,
12150 _("string table"));
12151 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12154 for (si
= 0; si
< num_syms
; si
++)
12155 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12156 strtab
, strtab_size
);
12159 if (strtab
!= filedata
->string_table
)
12165 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12167 if (do_histogram
&& filedata
->buckets
!= NULL
)
12169 unsigned long * lengths
;
12170 unsigned long * counts
;
12173 unsigned long maxlength
= 0;
12174 unsigned long nzero_counts
= 0;
12175 unsigned long nsyms
= 0;
12178 printf (ngettext ("\nHistogram for bucket list length "
12179 "(total of %lu bucket):\n",
12180 "\nHistogram for bucket list length "
12181 "(total of %lu buckets):\n",
12182 (unsigned long) filedata
->nbuckets
),
12183 (unsigned long) filedata
->nbuckets
);
12185 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12186 sizeof (*lengths
));
12187 if (lengths
== NULL
)
12189 error (_("Out of memory allocating space for histogram buckets\n"));
12192 visited
= xcmalloc (filedata
->nchains
, 1);
12193 memset (visited
, 0, filedata
->nchains
);
12195 printf (_(" Length Number %% of total Coverage\n"));
12196 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12198 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12201 if (maxlength
< ++lengths
[hn
])
12203 if (si
>= filedata
->nchains
|| visited
[si
])
12205 error (_("histogram chain is corrupt\n"));
12213 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12214 if (counts
== NULL
)
12217 error (_("Out of memory allocating space for histogram counts\n"));
12221 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12222 ++counts
[lengths
[hn
]];
12224 if (filedata
->nbuckets
> 0)
12227 printf (" 0 %-10lu (%5.1f%%)\n",
12228 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12229 for (i
= 1; i
<= maxlength
; ++i
)
12231 nzero_counts
+= counts
[i
] * i
;
12232 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12233 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12234 (nzero_counts
* 100.0) / nsyms
);
12242 free (filedata
->buckets
);
12243 filedata
->buckets
= NULL
;
12244 filedata
->nbuckets
= 0;
12245 free (filedata
->chains
);
12246 filedata
->chains
= NULL
;
12248 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12250 unsigned long * lengths
;
12251 unsigned long * counts
;
12253 unsigned long maxlength
= 0;
12254 unsigned long nzero_counts
= 0;
12255 unsigned long nsyms
= 0;
12257 printf (ngettext ("\nHistogram for `%s' bucket list length "
12258 "(total of %lu bucket):\n",
12259 "\nHistogram for `%s' bucket list length "
12260 "(total of %lu buckets):\n",
12261 (unsigned long) filedata
->ngnubuckets
),
12262 GNU_HASH_SECTION_NAME (filedata
),
12263 (unsigned long) filedata
->ngnubuckets
);
12265 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12266 sizeof (*lengths
));
12267 if (lengths
== NULL
)
12269 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12273 printf (_(" Length Number %% of total Coverage\n"));
12275 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12276 if (filedata
->gnubuckets
[hn
] != 0)
12278 bfd_vma off
, length
= 1;
12280 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12281 /* PR 17531 file: 010-77222-0.004. */
12282 off
< filedata
->ngnuchains
12283 && (filedata
->gnuchains
[off
] & 1) == 0;
12286 lengths
[hn
] = length
;
12287 if (length
> maxlength
)
12288 maxlength
= length
;
12292 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12293 if (counts
== NULL
)
12296 error (_("Out of memory allocating space for gnu histogram counts\n"));
12300 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12301 ++counts
[lengths
[hn
]];
12303 if (filedata
->ngnubuckets
> 0)
12306 printf (" 0 %-10lu (%5.1f%%)\n",
12307 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12308 for (j
= 1; j
<= maxlength
; ++j
)
12310 nzero_counts
+= counts
[j
] * j
;
12311 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12312 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12313 (nzero_counts
* 100.0) / nsyms
);
12320 free (filedata
->gnubuckets
);
12321 filedata
->gnubuckets
= NULL
;
12322 filedata
->ngnubuckets
= 0;
12323 free (filedata
->gnuchains
);
12324 filedata
->gnuchains
= NULL
;
12325 filedata
->ngnuchains
= 0;
12326 free (filedata
->mipsxlat
);
12327 filedata
->mipsxlat
= NULL
;
12331 free (filedata
->gnubuckets
);
12332 filedata
->gnubuckets
= NULL
;
12333 filedata
->ngnubuckets
= 0;
12334 free (filedata
->gnuchains
);
12335 filedata
->gnuchains
= NULL
;
12336 filedata
->ngnuchains
= 0;
12337 free (filedata
->mipsxlat
);
12338 filedata
->mipsxlat
= NULL
;
12339 free (filedata
->buckets
);
12340 filedata
->buckets
= NULL
;
12341 filedata
->nbuckets
= 0;
12342 free (filedata
->chains
);
12343 filedata
->chains
= NULL
;
12348 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12352 if (filedata
->dynamic_syminfo
== NULL
12354 /* No syminfo, this is ok. */
12357 /* There better should be a dynamic symbol section. */
12358 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12361 if (filedata
->dynamic_addr
)
12362 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12363 "contains %d entry:\n",
12364 "\nDynamic info segment at offset 0x%lx "
12365 "contains %d entries:\n",
12366 filedata
->dynamic_syminfo_nent
),
12367 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12369 printf (_(" Num: Name BoundTo Flags\n"));
12370 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12372 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12374 printf ("%4d: ", i
);
12375 if (i
>= filedata
->num_dynamic_syms
)
12376 printf (_("<corrupt index>"));
12377 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12378 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12379 filedata
->dynamic_symbols
[i
].st_name
));
12381 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12384 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12386 case SYMINFO_BT_SELF
:
12387 fputs ("SELF ", stdout
);
12389 case SYMINFO_BT_PARENT
:
12390 fputs ("PARENT ", stdout
);
12393 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12394 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12395 && VALID_DYNAMIC_NAME (filedata
,
12396 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12398 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12399 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12403 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12407 if (flags
& SYMINFO_FLG_DIRECT
)
12408 printf (" DIRECT");
12409 if (flags
& SYMINFO_FLG_PASSTHRU
)
12410 printf (" PASSTHRU");
12411 if (flags
& SYMINFO_FLG_COPY
)
12413 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12414 printf (" LAZYLOAD");
12422 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12423 is contained by the region START .. END. The types of ADDR, START
12424 and END should all be the same. Note both ADDR + NELEM and END
12425 point to just beyond the end of the regions that are being tested. */
12426 #define IN_RANGE(START,END,ADDR,NELEM) \
12427 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12429 /* Check to see if the given reloc needs to be handled in a target specific
12430 manner. If so then process the reloc and return TRUE otherwise return
12433 If called with reloc == NULL, then this is a signal that reloc processing
12434 for the current section has finished, and any saved state should be
12438 target_specific_reloc_handling (Filedata
* filedata
,
12439 Elf_Internal_Rela
* reloc
,
12440 unsigned char * start
,
12441 unsigned char * end
,
12442 Elf_Internal_Sym
* symtab
,
12443 unsigned long num_syms
)
12445 unsigned int reloc_type
= 0;
12446 unsigned long sym_index
= 0;
12450 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12451 sym_index
= get_reloc_symindex (reloc
->r_info
);
12454 switch (filedata
->file_header
.e_machine
)
12457 case EM_MSP430_OLD
:
12459 static Elf_Internal_Sym
* saved_sym
= NULL
;
12467 switch (reloc_type
)
12469 case 10: /* R_MSP430_SYM_DIFF */
12470 if (uses_msp430x_relocs (filedata
))
12472 /* Fall through. */
12473 case 21: /* R_MSP430X_SYM_DIFF */
12475 if (sym_index
>= num_syms
)
12476 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12479 saved_sym
= symtab
+ sym_index
;
12482 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12483 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12484 goto handle_sym_diff
;
12486 case 5: /* R_MSP430_16_BYTE */
12487 case 9: /* R_MSP430_8 */
12488 if (uses_msp430x_relocs (filedata
))
12490 goto handle_sym_diff
;
12492 case 2: /* R_MSP430_ABS16 */
12493 case 15: /* R_MSP430X_ABS16 */
12494 if (! uses_msp430x_relocs (filedata
))
12496 goto handle_sym_diff
;
12499 if (saved_sym
!= NULL
)
12501 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12504 if (sym_index
>= num_syms
)
12505 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12509 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12510 - saved_sym
->st_value
);
12512 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12513 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12516 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12517 (long) reloc
->r_offset
);
12526 if (saved_sym
!= NULL
)
12527 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12534 case EM_CYGNUS_MN10300
:
12536 static Elf_Internal_Sym
* saved_sym
= NULL
;
12544 switch (reloc_type
)
12546 case 34: /* R_MN10300_ALIGN */
12548 case 33: /* R_MN10300_SYM_DIFF */
12549 if (sym_index
>= num_syms
)
12550 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12553 saved_sym
= symtab
+ sym_index
;
12556 case 1: /* R_MN10300_32 */
12557 case 2: /* R_MN10300_16 */
12558 if (saved_sym
!= NULL
)
12560 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12563 if (sym_index
>= num_syms
)
12564 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12568 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12569 - saved_sym
->st_value
);
12571 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12572 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12574 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12575 (long) reloc
->r_offset
);
12583 if (saved_sym
!= NULL
)
12584 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12592 static bfd_vma saved_sym1
= 0;
12593 static bfd_vma saved_sym2
= 0;
12594 static bfd_vma value
;
12598 saved_sym1
= saved_sym2
= 0;
12602 switch (reloc_type
)
12604 case 0x80: /* R_RL78_SYM. */
12605 saved_sym1
= saved_sym2
;
12606 if (sym_index
>= num_syms
)
12607 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12611 saved_sym2
= symtab
[sym_index
].st_value
;
12612 saved_sym2
+= reloc
->r_addend
;
12616 case 0x83: /* R_RL78_OPsub. */
12617 value
= saved_sym1
- saved_sym2
;
12618 saved_sym2
= saved_sym1
= 0;
12622 case 0x41: /* R_RL78_ABS32. */
12623 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12624 byte_put (start
+ reloc
->r_offset
, value
, 4);
12626 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12627 (long) reloc
->r_offset
);
12631 case 0x43: /* R_RL78_ABS16. */
12632 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12633 byte_put (start
+ reloc
->r_offset
, value
, 2);
12635 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12636 (long) reloc
->r_offset
);
12650 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12651 DWARF debug sections. This is a target specific test. Note - we do not
12652 go through the whole including-target-headers-multiple-times route, (as
12653 we have already done with <elf/h8.h>) because this would become very
12654 messy and even then this function would have to contain target specific
12655 information (the names of the relocs instead of their numeric values).
12656 FIXME: This is not the correct way to solve this problem. The proper way
12657 is to have target specific reloc sizing and typing functions created by
12658 the reloc-macros.h header, in the same way that it already creates the
12659 reloc naming functions. */
12662 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12664 /* Please keep this table alpha-sorted for ease of visual lookup. */
12665 switch (filedata
->file_header
.e_machine
)
12669 return reloc_type
== 1; /* R_386_32. */
12671 return reloc_type
== 1; /* R_68K_32. */
12673 return reloc_type
== 1; /* R_860_32. */
12675 return reloc_type
== 2; /* R_960_32. */
12677 return (reloc_type
== 258
12678 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12680 return reloc_type
== 11; /* R_BPF_DATA_32 */
12681 case EM_ADAPTEVA_EPIPHANY
:
12682 return reloc_type
== 3;
12684 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12686 return reloc_type
== 1; /* R_ARC_32. */
12687 case EM_ARC_COMPACT
:
12688 case EM_ARC_COMPACT2
:
12689 return reloc_type
== 4; /* R_ARC_32. */
12691 return reloc_type
== 2; /* R_ARM_ABS32 */
12694 return reloc_type
== 1;
12696 return reloc_type
== 0x12; /* R_byte4_data. */
12698 return reloc_type
== 3; /* R_CRIS_32. */
12700 return reloc_type
== 3; /* R_CR16_NUM32. */
12702 return reloc_type
== 15; /* R_CRX_NUM32. */
12704 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12705 case EM_CYGNUS_FRV
:
12706 return reloc_type
== 1;
12707 case EM_CYGNUS_D10V
:
12709 return reloc_type
== 6; /* R_D10V_32. */
12710 case EM_CYGNUS_D30V
:
12712 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12714 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12715 case EM_CYGNUS_FR30
:
12717 return reloc_type
== 3; /* R_FR30_32. */
12719 return reloc_type
== 1; /* R_FT32_32. */
12723 return reloc_type
== 1; /* R_H8_DIR32. */
12725 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12726 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12727 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12728 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12731 return reloc_type
== 2; /* R_IP2K_32. */
12733 return reloc_type
== 2; /* R_IQ2000_32. */
12734 case EM_LATTICEMICO32
:
12735 return reloc_type
== 3; /* R_LM32_32. */
12738 return reloc_type
== 3; /* R_M32C_32. */
12740 return reloc_type
== 34; /* R_M32R_32_RELA. */
12743 return reloc_type
== 6; /* R_M68HC11_32. */
12745 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12746 reloc_type
== 6; /* R_S12Z_CW32. */
12748 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12749 case EM_CYGNUS_MEP
:
12750 return reloc_type
== 4; /* R_MEP_32. */
12752 return reloc_type
== 2; /* R_METAG_ADDR32. */
12753 case EM_MICROBLAZE
:
12754 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12756 return reloc_type
== 2; /* R_MIPS_32. */
12758 return reloc_type
== 4; /* R_MMIX_32. */
12759 case EM_CYGNUS_MN10200
:
12761 return reloc_type
== 1; /* R_MN10200_32. */
12762 case EM_CYGNUS_MN10300
:
12764 return reloc_type
== 1; /* R_MN10300_32. */
12766 return reloc_type
== 1; /* R_MOXIE_32. */
12767 case EM_MSP430_OLD
:
12769 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12771 return reloc_type
== 2; /* R_MT_32. */
12773 return reloc_type
== 20; /* R_NDS32_RELA. */
12774 case EM_ALTERA_NIOS2
:
12775 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12777 return reloc_type
== 1; /* R_NIOS_32. */
12779 return reloc_type
== 1; /* R_OR1K_32. */
12781 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12782 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12783 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12786 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12788 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12790 return reloc_type
== 1; /* R_PPC_ADDR32. */
12792 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12794 return reloc_type
== 1; /* R_RISCV_32. */
12796 return reloc_type
== 1; /* R_RL78_DIR32. */
12798 return reloc_type
== 1; /* R_RX_DIR32. */
12800 return reloc_type
== 1; /* R_I370_ADDR31. */
12803 return reloc_type
== 4; /* R_S390_32. */
12805 return reloc_type
== 8; /* R_SCORE_ABS32. */
12807 return reloc_type
== 1; /* R_SH_DIR32. */
12808 case EM_SPARC32PLUS
:
12811 return reloc_type
== 3 /* R_SPARC_32. */
12812 || reloc_type
== 23; /* R_SPARC_UA32. */
12814 return reloc_type
== 6; /* R_SPU_ADDR32 */
12816 return reloc_type
== 1; /* R_C6000_ABS32. */
12818 return reloc_type
== 2; /* R_TILEGX_32. */
12820 return reloc_type
== 1; /* R_TILEPRO_32. */
12821 case EM_CYGNUS_V850
:
12823 return reloc_type
== 6; /* R_V850_ABS32. */
12825 return reloc_type
== 0x33; /* R_V810_WORD. */
12827 return reloc_type
== 1; /* R_VAX_32. */
12829 return reloc_type
== 3; /* R_VISIUM_32. */
12830 case EM_WEBASSEMBLY
:
12831 return reloc_type
== 1; /* R_WASM32_32. */
12835 return reloc_type
== 10; /* R_X86_64_32. */
12838 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12840 return reloc_type
== 4; /* R_XGATE_32. */
12842 return reloc_type
== 1; /* R_XSTROMY16_32. */
12843 case EM_XTENSA_OLD
:
12845 return reloc_type
== 1; /* R_XTENSA_32. */
12847 return reloc_type
== 6; /* R_Z80_32. */
12850 static unsigned int prev_warn
= 0;
12852 /* Avoid repeating the same warning multiple times. */
12853 if (prev_warn
!= filedata
->file_header
.e_machine
)
12854 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12855 filedata
->file_header
.e_machine
);
12856 prev_warn
= filedata
->file_header
.e_machine
;
12862 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12863 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12866 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12868 switch (filedata
->file_header
.e_machine
)
12869 /* Please keep this table alpha-sorted for ease of visual lookup. */
12873 return reloc_type
== 2; /* R_386_PC32. */
12875 return reloc_type
== 4; /* R_68K_PC32. */
12877 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12878 case EM_ADAPTEVA_EPIPHANY
:
12879 return reloc_type
== 6;
12881 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12882 case EM_ARC_COMPACT
:
12883 case EM_ARC_COMPACT2
:
12884 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12886 return reloc_type
== 3; /* R_ARM_REL32 */
12889 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12890 case EM_MICROBLAZE
:
12891 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12893 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12895 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12897 return reloc_type
== 26; /* R_PPC_REL32. */
12899 return reloc_type
== 26; /* R_PPC64_REL32. */
12901 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12904 return reloc_type
== 5; /* R_390_PC32. */
12906 return reloc_type
== 2; /* R_SH_REL32. */
12907 case EM_SPARC32PLUS
:
12910 return reloc_type
== 6; /* R_SPARC_DISP32. */
12912 return reloc_type
== 13; /* R_SPU_REL32. */
12914 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12916 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12918 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12922 return reloc_type
== 2; /* R_X86_64_PC32. */
12924 return reloc_type
== 4; /* R_VAX_PCREL32. */
12925 case EM_XTENSA_OLD
:
12927 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12929 /* Do not abort or issue an error message here. Not all targets use
12930 pc-relative 32-bit relocs in their DWARF debug information and we
12931 have already tested for target coverage in is_32bit_abs_reloc. A
12932 more helpful warning message will be generated by apply_relocations
12933 anyway, so just return. */
12938 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12939 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12942 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12944 switch (filedata
->file_header
.e_machine
)
12947 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12949 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12951 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12952 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12954 return reloc_type
== 80; /* R_PARISC_DIR64. */
12956 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12958 return reloc_type
== 2; /* R_RISCV_64. */
12959 case EM_SPARC32PLUS
:
12962 return reloc_type
== 32 /* R_SPARC_64. */
12963 || reloc_type
== 54; /* R_SPARC_UA64. */
12967 return reloc_type
== 1; /* R_X86_64_64. */
12970 return reloc_type
== 22; /* R_S390_64. */
12972 return reloc_type
== 1; /* R_TILEGX_64. */
12974 return reloc_type
== 18; /* R_MIPS_64. */
12980 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12981 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12984 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12986 switch (filedata
->file_header
.e_machine
)
12989 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12991 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12993 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12994 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12996 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12998 return reloc_type
== 44; /* R_PPC64_REL64. */
12999 case EM_SPARC32PLUS
:
13002 return reloc_type
== 46; /* R_SPARC_DISP64. */
13006 return reloc_type
== 24; /* R_X86_64_PC64. */
13009 return reloc_type
== 23; /* R_S390_PC64. */
13011 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13017 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13018 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13021 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13023 switch (filedata
->file_header
.e_machine
)
13025 case EM_CYGNUS_MN10200
:
13027 return reloc_type
== 4; /* R_MN10200_24. */
13029 return reloc_type
== 5; /* R_FT32_20. */
13031 return reloc_type
== 5; /* R_Z80_24. */
13037 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13038 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13041 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13043 /* Please keep this table alpha-sorted for ease of visual lookup. */
13044 switch (filedata
->file_header
.e_machine
)
13047 case EM_ARC_COMPACT
:
13048 case EM_ARC_COMPACT2
:
13049 return reloc_type
== 2; /* R_ARC_16. */
13050 case EM_ADAPTEVA_EPIPHANY
:
13051 return reloc_type
== 5;
13054 return reloc_type
== 4; /* R_AVR_16. */
13055 case EM_CYGNUS_D10V
:
13057 return reloc_type
== 3; /* R_D10V_16. */
13059 return reloc_type
== 2; /* R_FT32_16. */
13063 return reloc_type
== R_H8_DIR16
;
13066 return reloc_type
== 1; /* R_IP2K_16. */
13069 return reloc_type
== 1; /* R_M32C_16 */
13070 case EM_CYGNUS_MN10200
:
13072 return reloc_type
== 2; /* R_MN10200_16. */
13073 case EM_CYGNUS_MN10300
:
13075 return reloc_type
== 2; /* R_MN10300_16. */
13077 if (uses_msp430x_relocs (filedata
))
13078 return reloc_type
== 2; /* R_MSP430_ABS16. */
13079 /* Fall through. */
13080 case EM_MSP430_OLD
:
13081 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13083 return reloc_type
== 19; /* R_NDS32_RELA. */
13084 case EM_ALTERA_NIOS2
:
13085 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13087 return reloc_type
== 9; /* R_NIOS_16. */
13089 return reloc_type
== 2; /* R_OR1K_16. */
13091 return reloc_type
== 55; /* R_RISCV_SET16. */
13093 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13095 return reloc_type
== 2; /* R_C6000_ABS16. */
13097 return reloc_type
== 2; /* R_VISIUM_16. */
13100 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13102 return reloc_type
== 3; /* R_XGATE_16. */
13104 return reloc_type
== 4; /* R_Z80_16. */
13110 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13111 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13114 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13116 switch (filedata
->file_header
.e_machine
)
13119 return reloc_type
== 54; /* R_RISCV_SET8. */
13121 return reloc_type
== 1; /* R_Z80_8. */
13127 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13128 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13131 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13133 switch (filedata
->file_header
.e_machine
)
13136 return reloc_type
== 53; /* R_RISCV_SET6. */
13142 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13143 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13146 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13148 /* Please keep this table alpha-sorted for ease of visual lookup. */
13149 switch (filedata
->file_header
.e_machine
)
13152 return reloc_type
== 35; /* R_RISCV_ADD32. */
13158 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13159 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13162 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13164 /* Please keep this table alpha-sorted for ease of visual lookup. */
13165 switch (filedata
->file_header
.e_machine
)
13168 return reloc_type
== 39; /* R_RISCV_SUB32. */
13174 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13175 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13178 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13180 /* Please keep this table alpha-sorted for ease of visual lookup. */
13181 switch (filedata
->file_header
.e_machine
)
13184 return reloc_type
== 36; /* R_RISCV_ADD64. */
13190 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13191 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13194 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13196 /* Please keep this table alpha-sorted for ease of visual lookup. */
13197 switch (filedata
->file_header
.e_machine
)
13200 return reloc_type
== 40; /* R_RISCV_SUB64. */
13206 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13207 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13210 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13212 /* Please keep this table alpha-sorted for ease of visual lookup. */
13213 switch (filedata
->file_header
.e_machine
)
13216 return reloc_type
== 34; /* R_RISCV_ADD16. */
13222 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13223 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13226 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13228 /* Please keep this table alpha-sorted for ease of visual lookup. */
13229 switch (filedata
->file_header
.e_machine
)
13232 return reloc_type
== 38; /* R_RISCV_SUB16. */
13238 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13239 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13242 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13244 /* Please keep this table alpha-sorted for ease of visual lookup. */
13245 switch (filedata
->file_header
.e_machine
)
13248 return reloc_type
== 33; /* R_RISCV_ADD8. */
13254 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13255 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13258 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13260 /* Please keep this table alpha-sorted for ease of visual lookup. */
13261 switch (filedata
->file_header
.e_machine
)
13264 return reloc_type
== 37; /* R_RISCV_SUB8. */
13270 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13271 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13274 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13276 switch (filedata
->file_header
.e_machine
)
13279 return reloc_type
== 52; /* R_RISCV_SUB6. */
13285 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13286 relocation entries (possibly formerly used for SHT_GROUP sections). */
13289 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13291 switch (filedata
->file_header
.e_machine
)
13293 case EM_386
: /* R_386_NONE. */
13294 case EM_68K
: /* R_68K_NONE. */
13295 case EM_ADAPTEVA_EPIPHANY
:
13296 case EM_ALPHA
: /* R_ALPHA_NONE. */
13297 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13298 case EM_ARC
: /* R_ARC_NONE. */
13299 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13300 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13301 case EM_ARM
: /* R_ARM_NONE. */
13302 case EM_C166
: /* R_XC16X_NONE. */
13303 case EM_CRIS
: /* R_CRIS_NONE. */
13304 case EM_FT32
: /* R_FT32_NONE. */
13305 case EM_IA_64
: /* R_IA64_NONE. */
13306 case EM_K1OM
: /* R_X86_64_NONE. */
13307 case EM_L1OM
: /* R_X86_64_NONE. */
13308 case EM_M32R
: /* R_M32R_NONE. */
13309 case EM_MIPS
: /* R_MIPS_NONE. */
13310 case EM_MN10300
: /* R_MN10300_NONE. */
13311 case EM_MOXIE
: /* R_MOXIE_NONE. */
13312 case EM_NIOS32
: /* R_NIOS_NONE. */
13313 case EM_OR1K
: /* R_OR1K_NONE. */
13314 case EM_PARISC
: /* R_PARISC_NONE. */
13315 case EM_PPC64
: /* R_PPC64_NONE. */
13316 case EM_PPC
: /* R_PPC_NONE. */
13317 case EM_RISCV
: /* R_RISCV_NONE. */
13318 case EM_S390
: /* R_390_NONE. */
13320 case EM_SH
: /* R_SH_NONE. */
13321 case EM_SPARC32PLUS
:
13322 case EM_SPARC
: /* R_SPARC_NONE. */
13324 case EM_TILEGX
: /* R_TILEGX_NONE. */
13325 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13326 case EM_TI_C6000
:/* R_C6000_NONE. */
13327 case EM_X86_64
: /* R_X86_64_NONE. */
13329 case EM_Z80
: /* R_Z80_NONE. */
13330 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13331 return reloc_type
== 0;
13334 return reloc_type
== 0 || reloc_type
== 256;
13337 return (reloc_type
== 0 /* R_AVR_NONE. */
13338 || reloc_type
== 30 /* R_AVR_DIFF8. */
13339 || reloc_type
== 31 /* R_AVR_DIFF16. */
13340 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13342 return reloc_type
== 3; /* R_METAG_NONE. */
13344 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13345 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13346 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13347 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13348 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13350 return (reloc_type
== 0 /* R_PRU_NONE. */
13351 || reloc_type
== 65 /* R_PRU_DIFF8. */
13352 || reloc_type
== 66 /* R_PRU_DIFF16. */
13353 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13354 case EM_XTENSA_OLD
:
13356 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13357 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13358 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13359 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13360 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13361 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13362 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13363 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13364 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13365 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13370 /* Returns TRUE if there is a relocation against
13371 section NAME at OFFSET bytes. */
13374 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13376 Elf_Internal_Rela
* relocs
;
13377 Elf_Internal_Rela
* rp
;
13379 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13382 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13384 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13385 if (rp
->r_offset
== offset
)
13391 /* Apply relocations to a section.
13392 Returns TRUE upon success, FALSE otherwise.
13393 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13394 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13395 will be set to the number of relocs loaded.
13397 Note: So far support has been added only for those relocations
13398 which can be found in debug sections. FIXME: Add support for
13399 more relocations ? */
13402 apply_relocations (Filedata
* filedata
,
13403 const Elf_Internal_Shdr
* section
,
13404 unsigned char * start
,
13405 bfd_size_type size
,
13406 void ** relocs_return
,
13407 unsigned long * num_relocs_return
)
13409 Elf_Internal_Shdr
* relsec
;
13410 unsigned char * end
= start
+ size
;
13412 if (relocs_return
!= NULL
)
13414 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13415 * num_relocs_return
= 0;
13418 if (filedata
->file_header
.e_type
!= ET_REL
)
13419 /* No relocs to apply. */
13422 /* Find the reloc section associated with the section. */
13423 for (relsec
= filedata
->section_headers
;
13424 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13427 bfd_boolean is_rela
;
13428 unsigned long num_relocs
;
13429 Elf_Internal_Rela
* relocs
;
13430 Elf_Internal_Rela
* rp
;
13431 Elf_Internal_Shdr
* symsec
;
13432 Elf_Internal_Sym
* symtab
;
13433 unsigned long num_syms
;
13434 Elf_Internal_Sym
* sym
;
13436 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13437 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13438 || filedata
->section_headers
+ relsec
->sh_info
!= section
13439 || relsec
->sh_size
== 0
13440 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13443 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13444 if (symsec
->sh_type
!= SHT_SYMTAB
13445 && symsec
->sh_type
!= SHT_DYNSYM
)
13448 is_rela
= relsec
->sh_type
== SHT_RELA
;
13452 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13453 relsec
->sh_size
, & relocs
, & num_relocs
))
13458 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13459 relsec
->sh_size
, & relocs
, & num_relocs
))
13463 /* SH uses RELA but uses in place value instead of the addend field. */
13464 if (filedata
->file_header
.e_machine
== EM_SH
)
13467 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13469 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13472 unsigned int reloc_type
;
13473 unsigned int reloc_size
;
13474 bfd_boolean reloc_inplace
= FALSE
;
13475 bfd_boolean reloc_subtract
= FALSE
;
13476 unsigned char * rloc
;
13477 unsigned long sym_index
;
13479 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13481 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13483 else if (is_none_reloc (filedata
, reloc_type
))
13485 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13486 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13488 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13489 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13491 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13493 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13495 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13496 || is_6bit_abs_reloc (filedata
, reloc_type
))
13498 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13500 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13503 reloc_inplace
= TRUE
;
13505 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13507 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13510 reloc_inplace
= TRUE
;
13512 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13514 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13517 reloc_inplace
= TRUE
;
13519 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13521 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13524 reloc_inplace
= TRUE
;
13526 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13530 reloc_inplace
= TRUE
;
13534 static unsigned int prev_reloc
= 0;
13536 if (reloc_type
!= prev_reloc
)
13537 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13538 reloc_type
, printable_section_name (filedata
, section
));
13539 prev_reloc
= reloc_type
;
13543 rloc
= start
+ rp
->r_offset
;
13544 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13546 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13547 (unsigned long) rp
->r_offset
,
13548 printable_section_name (filedata
, section
));
13552 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13553 if (sym_index
>= num_syms
)
13555 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13556 sym_index
, printable_section_name (filedata
, section
));
13559 sym
= symtab
+ sym_index
;
13561 /* If the reloc has a symbol associated with it,
13562 make sure that it is of an appropriate type.
13564 Relocations against symbols without type can happen.
13565 Gcc -feliminate-dwarf2-dups may generate symbols
13566 without type for debug info.
13568 Icc generates relocations against function symbols
13569 instead of local labels.
13571 Relocations against object symbols can happen, eg when
13572 referencing a global array. For an example of this see
13573 the _clz.o binary in libgcc.a. */
13575 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13576 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13578 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13579 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13580 printable_section_name (filedata
, relsec
),
13581 (long int)(rp
- relocs
));
13587 addend
+= rp
->r_addend
;
13588 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13589 partial_inplace. */
13591 || (filedata
->file_header
.e_machine
== EM_XTENSA
13592 && reloc_type
== 1)
13593 || ((filedata
->file_header
.e_machine
== EM_PJ
13594 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13595 && reloc_type
== 1)
13596 || ((filedata
->file_header
.e_machine
== EM_D30V
13597 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13598 && reloc_type
== 12)
13601 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13602 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13604 addend
+= byte_get (rloc
, reloc_size
);
13607 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13608 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13610 /* On HPPA, all pc-relative relocations are biased by 8. */
13611 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13613 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13616 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13617 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13619 if (reloc_subtract
)
13620 addend
-= sym
->st_value
;
13622 addend
+= sym
->st_value
;
13623 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13624 byte_put (rloc
, addend
, reloc_size
);
13626 else if (reloc_subtract
)
13627 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13629 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13633 /* Let the target specific reloc processing code know that
13634 we have finished with these relocs. */
13635 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13639 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13640 * num_relocs_return
= num_relocs
;
13651 #ifdef SUPPORT_DISASSEMBLY
13653 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13655 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13657 /* FIXME: XXX -- to be done --- XXX */
13663 /* Reads in the contents of SECTION from FILE, returning a pointer
13664 to a malloc'ed buffer or NULL if something went wrong. */
13667 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13669 bfd_size_type num_bytes
= section
->sh_size
;
13671 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13673 printf (_("Section '%s' has no data to dump.\n"),
13674 printable_section_name (filedata
, section
));
13678 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13679 _("section contents"));
13682 /* Uncompresses a section that was compressed using zlib, in place. */
13685 uncompress_section_contents (unsigned char ** buffer
,
13686 dwarf_size_type uncompressed_size
,
13687 dwarf_size_type
* size
)
13689 dwarf_size_type compressed_size
= *size
;
13690 unsigned char * compressed_buffer
= *buffer
;
13691 unsigned char * uncompressed_buffer
;
13695 /* It is possible the section consists of several compressed
13696 buffers concatenated together, so we uncompress in a loop. */
13697 /* PR 18313: The state field in the z_stream structure is supposed
13698 to be invisible to the user (ie us), but some compilers will
13699 still complain about it being used without initialisation. So
13700 we first zero the entire z_stream structure and then set the fields
13702 memset (& strm
, 0, sizeof strm
);
13703 strm
.avail_in
= compressed_size
;
13704 strm
.next_in
= (Bytef
*) compressed_buffer
;
13705 strm
.avail_out
= uncompressed_size
;
13706 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13708 rc
= inflateInit (& strm
);
13709 while (strm
.avail_in
> 0)
13713 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13714 + (uncompressed_size
- strm
.avail_out
));
13715 rc
= inflate (&strm
, Z_FINISH
);
13716 if (rc
!= Z_STREAM_END
)
13718 rc
= inflateReset (& strm
);
13720 rc
= inflateEnd (& strm
);
13722 || strm
.avail_out
!= 0)
13725 *buffer
= uncompressed_buffer
;
13726 *size
= uncompressed_size
;
13730 free (uncompressed_buffer
);
13731 /* Indicate decompression failure. */
13737 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13739 Elf_Internal_Shdr
* relsec
;
13740 bfd_size_type num_bytes
;
13741 unsigned char * data
;
13742 unsigned char * end
;
13743 unsigned char * real_start
;
13744 unsigned char * start
;
13745 bfd_boolean some_strings_shown
;
13747 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13749 /* PR 21820: Do not fail if the section was empty. */
13750 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13752 num_bytes
= section
->sh_size
;
13754 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13756 if (decompress_dumps
)
13758 dwarf_size_type new_size
= num_bytes
;
13759 dwarf_size_type uncompressed_size
= 0;
13761 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13763 Elf_Internal_Chdr chdr
;
13764 unsigned int compression_header_size
13765 = get_compression_header (& chdr
, (unsigned char *) start
,
13767 if (compression_header_size
== 0)
13768 /* An error message will have already been generated
13769 by get_compression_header. */
13772 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13774 warn (_("section '%s' has unsupported compress type: %d\n"),
13775 printable_section_name (filedata
, section
), chdr
.ch_type
);
13778 uncompressed_size
= chdr
.ch_size
;
13779 start
+= compression_header_size
;
13780 new_size
-= compression_header_size
;
13782 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13784 /* Read the zlib header. In this case, it should be "ZLIB"
13785 followed by the uncompressed section size, 8 bytes in
13786 big-endian order. */
13787 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13788 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13789 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13790 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13791 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13792 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13793 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13794 uncompressed_size
+= start
[11];
13799 if (uncompressed_size
)
13801 if (uncompress_section_contents (& start
,
13802 uncompressed_size
, & new_size
))
13803 num_bytes
= new_size
;
13806 error (_("Unable to decompress section %s\n"),
13807 printable_section_name (filedata
, section
));
13812 start
= real_start
;
13815 /* If the section being dumped has relocations against it the user might
13816 be expecting these relocations to have been applied. Check for this
13817 case and issue a warning message in order to avoid confusion.
13818 FIXME: Maybe we ought to have an option that dumps a section with
13819 relocs applied ? */
13820 for (relsec
= filedata
->section_headers
;
13821 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13824 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13825 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13826 || filedata
->section_headers
+ relsec
->sh_info
!= section
13827 || relsec
->sh_size
== 0
13828 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13831 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13836 end
= start
+ num_bytes
;
13837 some_strings_shown
= FALSE
;
13839 #ifdef HAVE_MBSTATE_T
13841 /* Initialise the multibyte conversion state. */
13842 memset (& state
, 0, sizeof (state
));
13845 bfd_boolean continuing
= FALSE
;
13849 while (!ISPRINT (* data
))
13850 if (++ data
>= end
)
13855 size_t maxlen
= end
- data
;
13860 continuing
= FALSE
;
13865 /* PR 11128: Use two separate invocations in order to work
13866 around bugs in the Solaris 8 implementation of printf. */
13867 printf (" [%6tx] ", data
- start
);
13869 printf (" [%6Ix] ", (size_t) (data
- start
));
13884 /* PR 25543: Treat new-lines as string-ending characters. */
13893 /* Do not print control characters directly as they can affect terminal
13894 settings. Such characters usually appear in the names generated
13895 by the assembler for local labels. */
13898 printf ("^%c", c
+ 0x40);
13900 else if (ISPRINT (c
))
13907 #ifdef HAVE_MBSTATE_T
13910 /* Let printf do the hard work of displaying multibyte characters. */
13911 printf ("%.1s", data
- 1);
13912 #ifdef HAVE_MBSTATE_T
13913 /* Try to find out how many bytes made up the character that was
13914 just printed. Advance the symbol pointer past the bytes that
13916 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13920 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13930 printf (_("<corrupt>\n"));
13933 some_strings_shown
= TRUE
;
13937 if (! some_strings_shown
)
13938 printf (_(" No strings found in this section."));
13951 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13952 Filedata
* filedata
,
13953 bfd_boolean relocate
)
13955 Elf_Internal_Shdr
* relsec
;
13956 bfd_size_type bytes
;
13957 bfd_size_type section_size
;
13959 unsigned char * data
;
13960 unsigned char * real_start
;
13961 unsigned char * start
;
13963 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13965 /* PR 21820: Do not fail if the section was empty. */
13966 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13968 section_size
= section
->sh_size
;
13970 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13972 if (decompress_dumps
)
13974 dwarf_size_type new_size
= section_size
;
13975 dwarf_size_type uncompressed_size
= 0;
13977 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13979 Elf_Internal_Chdr chdr
;
13980 unsigned int compression_header_size
13981 = get_compression_header (& chdr
, start
, section_size
);
13983 if (compression_header_size
== 0)
13984 /* An error message will have already been generated
13985 by get_compression_header. */
13988 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13990 warn (_("section '%s' has unsupported compress type: %d\n"),
13991 printable_section_name (filedata
, section
), chdr
.ch_type
);
13994 uncompressed_size
= chdr
.ch_size
;
13995 start
+= compression_header_size
;
13996 new_size
-= compression_header_size
;
13998 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14000 /* Read the zlib header. In this case, it should be "ZLIB"
14001 followed by the uncompressed section size, 8 bytes in
14002 big-endian order. */
14003 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14004 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14005 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14006 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14007 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14008 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14009 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14010 uncompressed_size
+= start
[11];
14015 if (uncompressed_size
)
14017 if (uncompress_section_contents (& start
, uncompressed_size
,
14020 section_size
= new_size
;
14024 error (_("Unable to decompress section %s\n"),
14025 printable_section_name (filedata
, section
));
14026 /* FIXME: Print the section anyway ? */
14031 start
= real_start
;
14036 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14041 /* If the section being dumped has relocations against it the user might
14042 be expecting these relocations to have been applied. Check for this
14043 case and issue a warning message in order to avoid confusion.
14044 FIXME: Maybe we ought to have an option that dumps a section with
14045 relocs applied ? */
14046 for (relsec
= filedata
->section_headers
;
14047 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14050 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14051 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14052 || filedata
->section_headers
+ relsec
->sh_info
!= section
14053 || relsec
->sh_size
== 0
14054 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14057 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14062 addr
= section
->sh_addr
;
14063 bytes
= section_size
;
14072 lbytes
= (bytes
> 16 ? 16 : bytes
);
14074 printf (" 0x%8.8lx ", (unsigned long) addr
);
14076 for (j
= 0; j
< 16; j
++)
14079 printf ("%2.2x", data
[j
]);
14087 for (j
= 0; j
< lbytes
; j
++)
14090 if (k
>= ' ' && k
< 0x7f)
14113 static ctf_sect_t
*
14114 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14116 buf
->cts_name
= SECTION_NAME (shdr
);
14117 buf
->cts_size
= shdr
->sh_size
;
14118 buf
->cts_entsize
= shdr
->sh_entsize
;
14123 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14124 it is passed, or a pointer to newly-allocated storage, in which case
14125 dump_ctf() will free it when it no longer needs it. */
14127 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14128 char *s
, void *arg
)
14130 const char *blanks
= arg
;
14133 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14139 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14141 Elf_Internal_Shdr
* parent_sec
= NULL
;
14142 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14143 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14144 void * data
= NULL
;
14145 void * symdata
= NULL
;
14146 void * strdata
= NULL
;
14147 void * parentdata
= NULL
;
14148 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14149 ctf_sect_t
* symsectp
= NULL
;
14150 ctf_sect_t
* strsectp
= NULL
;
14151 ctf_file_t
* ctf
= NULL
;
14152 ctf_file_t
* parent
= NULL
;
14154 const char *things
[] = {"Header", "Labels", "Data objects",
14155 "Function objects", "Variables", "Types", "Strings",
14157 const char **thing
;
14159 bfd_boolean ret
= FALSE
;
14162 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14163 data
= get_section_contents (section
, filedata
);
14164 ctfsect
.cts_data
= data
;
14166 if (!dump_ctf_symtab_name
)
14167 dump_ctf_symtab_name
= strdup (".symtab");
14169 if (!dump_ctf_strtab_name
)
14170 dump_ctf_strtab_name
= strdup (".strtab");
14172 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14174 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14176 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14179 if ((symdata
= (void *) get_data (NULL
, filedata
,
14180 symtab_sec
->sh_offset
, 1,
14181 symtab_sec
->sh_size
,
14182 _("symbols"))) == NULL
)
14184 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14185 symsect
.cts_data
= symdata
;
14187 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14189 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14191 error (_("No string table section named %s\n"),
14192 dump_ctf_strtab_name
);
14195 if ((strdata
= (void *) get_data (NULL
, filedata
,
14196 strtab_sec
->sh_offset
, 1,
14197 strtab_sec
->sh_size
,
14198 _("strings"))) == NULL
)
14200 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14201 strsect
.cts_data
= strdata
;
14203 if (dump_ctf_parent_name
)
14205 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14207 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14210 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14211 parent_sec
->sh_offset
, 1,
14212 parent_sec
->sh_size
,
14213 _("CTF parent"))) == NULL
)
14215 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14216 parentsect
.cts_data
= parentdata
;
14219 /* Load the CTF file and dump it. */
14221 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14223 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14229 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14231 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14235 ctf_import (ctf
, parent
);
14240 printf (_("\nDump of CTF section '%s':\n"),
14241 printable_section_name (filedata
, section
));
14243 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14245 ctf_dump_state_t
*s
= NULL
;
14248 printf ("\n %s:\n", *thing
);
14249 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14250 (void *) " ")) != NULL
)
14252 printf ("%s\n", item
);
14256 if (ctf_errno (ctf
))
14258 error (_("Iteration failed: %s, %s\n"), *thing
,
14259 ctf_errmsg (ctf_errno (ctf
)));
14265 ctf_file_close (ctf
);
14266 ctf_file_close (parent
);
14275 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14276 const Elf_Internal_Shdr
* sec
,
14279 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14281 Filedata
* filedata
= (Filedata
*) data
;
14283 if (section
->start
!= NULL
)
14285 /* If it is already loaded, do nothing. */
14286 if (streq (section
->filename
, filedata
->file_name
))
14288 free (section
->start
);
14291 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14292 section
->address
= sec
->sh_addr
;
14293 section
->user_data
= NULL
;
14294 section
->filename
= filedata
->file_name
;
14295 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14297 sec
->sh_size
, buf
);
14298 if (section
->start
== NULL
)
14302 unsigned char *start
= section
->start
;
14303 dwarf_size_type size
= sec
->sh_size
;
14304 dwarf_size_type uncompressed_size
= 0;
14306 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14308 Elf_Internal_Chdr chdr
;
14309 unsigned int compression_header_size
;
14311 if (size
< (is_32bit_elf
14312 ? sizeof (Elf32_External_Chdr
)
14313 : sizeof (Elf64_External_Chdr
)))
14315 warn (_("compressed section %s is too small to contain a compression header\n"),
14320 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14321 if (compression_header_size
== 0)
14322 /* An error message will have already been generated
14323 by get_compression_header. */
14326 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14328 warn (_("section '%s' has unsupported compress type: %d\n"),
14329 section
->name
, chdr
.ch_type
);
14332 uncompressed_size
= chdr
.ch_size
;
14333 start
+= compression_header_size
;
14334 size
-= compression_header_size
;
14336 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14338 /* Read the zlib header. In this case, it should be "ZLIB"
14339 followed by the uncompressed section size, 8 bytes in
14340 big-endian order. */
14341 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14342 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14343 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14344 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14345 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14346 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14347 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14348 uncompressed_size
+= start
[11];
14353 if (uncompressed_size
)
14355 if (uncompress_section_contents (&start
, uncompressed_size
,
14358 /* Free the compressed buffer, update the section buffer
14359 and the section size if uncompress is successful. */
14360 free (section
->start
);
14361 section
->start
= start
;
14365 error (_("Unable to decompress section %s\n"),
14366 printable_section_name (filedata
, sec
));
14371 section
->size
= size
;
14374 if (section
->start
== NULL
)
14377 if (debug_displays
[debug
].relocate
)
14379 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14380 & section
->reloc_info
, & section
->num_relocs
))
14385 section
->reloc_info
= NULL
;
14386 section
->num_relocs
= 0;
14392 #if HAVE_LIBDEBUGINFOD
14393 /* Return a hex string representation of the build-id. */
14395 get_build_id (void * data
)
14397 Filedata
* filedata
= (Filedata
*)data
;
14398 Elf_Internal_Shdr
* shdr
;
14401 /* Iterate through notes to find note.gnu.build-id.
14402 FIXME: Only the first note in any note section is examined. */
14403 for (i
= 0, shdr
= filedata
->section_headers
;
14404 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14407 if (shdr
->sh_type
!= SHT_NOTE
)
14412 size_t data_remaining
;
14414 Elf_External_Note
* enote
;
14415 Elf_Internal_Note inote
;
14417 bfd_vma offset
= shdr
->sh_offset
;
14418 bfd_vma align
= shdr
->sh_addralign
;
14419 bfd_vma length
= shdr
->sh_size
;
14421 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14427 else if (align
!= 4 && align
!= 8)
14433 end
= (char *) enote
+ length
;
14434 data_remaining
= end
- (char *) enote
;
14436 if (!is_ia64_vms (filedata
))
14438 min_notesz
= offsetof (Elf_External_Note
, name
);
14439 if (data_remaining
< min_notesz
)
14442 malformed note encountered in section %s whilst scanning for build-id note\n"),
14443 printable_section_name (filedata
, shdr
));
14447 data_remaining
-= min_notesz
;
14449 inote
.type
= BYTE_GET (enote
->type
);
14450 inote
.namesz
= BYTE_GET (enote
->namesz
);
14451 inote
.namedata
= enote
->name
;
14452 inote
.descsz
= BYTE_GET (enote
->descsz
);
14453 inote
.descdata
= ((char *) enote
14454 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14455 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14456 next
= ((char *) enote
14457 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14461 Elf64_External_VMS_Note
*vms_enote
;
14463 /* PR binutils/15191
14464 Make sure that there is enough data to read. */
14465 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14466 if (data_remaining
< min_notesz
)
14469 malformed note encountered in section %s whilst scanning for build-id note\n"),
14470 printable_section_name (filedata
, shdr
));
14474 data_remaining
-= min_notesz
;
14476 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14477 inote
.type
= BYTE_GET (vms_enote
->type
);
14478 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14479 inote
.namedata
= vms_enote
->name
;
14480 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14481 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14482 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14483 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14486 /* Skip malformed notes. */
14487 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14488 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14489 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14490 || ((size_t) (next
- inote
.descdata
)
14491 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14494 malformed note encountered in section %s whilst scanning for build-id note\n"),
14495 printable_section_name (filedata
, shdr
));
14500 /* Check if this is the build-id note. If so then convert the build-id
14501 bytes to a hex string. */
14502 if (inote
.namesz
> 0
14503 && const_strneq (inote
.namedata
, "GNU")
14504 && inote
.type
== NT_GNU_BUILD_ID
)
14509 build_id
= malloc (inote
.descsz
* 2 + 1);
14510 if (build_id
== NULL
)
14516 for (j
= 0; j
< inote
.descsz
; ++j
)
14517 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14518 build_id
[inote
.descsz
* 2] = '\0';
14521 return (unsigned char *) build_id
;
14528 #endif /* HAVE_LIBDEBUGINFOD */
14530 /* If this is not NULL, load_debug_section will only look for sections
14531 within the list of sections given here. */
14532 static unsigned int * section_subset
= NULL
;
14535 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14537 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14538 Elf_Internal_Shdr
* sec
;
14539 Filedata
* filedata
= (Filedata
*) data
;
14541 /* Without section headers we cannot find any sections. */
14542 if (filedata
->section_headers
== NULL
)
14545 if (filedata
->string_table
== NULL
14546 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14547 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14549 Elf_Internal_Shdr
* strs
;
14551 /* Read in the string table, so that we have section names to scan. */
14552 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14554 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14556 filedata
->string_table
14557 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14558 1, strs
->sh_size
, _("string table"));
14560 filedata
->string_table_length
14561 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14565 /* Locate the debug section. */
14566 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14568 section
->name
= section
->uncompressed_name
;
14571 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14573 section
->name
= section
->compressed_name
;
14578 /* If we're loading from a subset of sections, and we've loaded
14579 a section matching this name before, it's likely that it's a
14581 if (section_subset
!= NULL
)
14582 free_debug_section (debug
);
14584 return load_specific_debug_section (debug
, sec
, data
);
14588 free_debug_section (enum dwarf_section_display_enum debug
)
14590 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14592 if (section
->start
== NULL
)
14595 free ((char *) section
->start
);
14596 section
->start
= NULL
;
14597 section
->address
= 0;
14600 if (section
->reloc_info
!= NULL
)
14602 free (section
->reloc_info
);
14603 section
->reloc_info
= NULL
;
14604 section
->num_relocs
= 0;
14609 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14611 char * name
= SECTION_NAME (section
);
14612 const char * print_name
= printable_section_name (filedata
, section
);
14613 bfd_size_type length
;
14614 bfd_boolean result
= TRUE
;
14617 length
= section
->sh_size
;
14620 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14623 if (section
->sh_type
== SHT_NOBITS
)
14625 /* There is no point in dumping the contents of a debugging section
14626 which has the NOBITS type - the bits in the file will be random.
14627 This can happen when a file containing a .eh_frame section is
14628 stripped with the --only-keep-debug command line option. */
14629 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14634 if (const_strneq (name
, ".gnu.linkonce.wi."))
14635 name
= ".debug_info";
14637 /* See if we know how to display the contents of this section. */
14638 for (i
= 0; i
< max
; i
++)
14640 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14641 struct dwarf_section_display
* display
= debug_displays
+ i
;
14642 struct dwarf_section
* sec
= & display
->section
;
14644 if (streq (sec
->uncompressed_name
, name
)
14645 || (id
== line
&& const_strneq (name
, ".debug_line."))
14646 || streq (sec
->compressed_name
, name
))
14648 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14651 free_debug_section (id
);
14653 if (i
== line
&& const_strneq (name
, ".debug_line."))
14655 else if (streq (sec
->uncompressed_name
, name
))
14656 sec
->name
= sec
->uncompressed_name
;
14658 sec
->name
= sec
->compressed_name
;
14660 if (load_specific_debug_section (id
, section
, filedata
))
14662 /* If this debug section is part of a CU/TU set in a .dwp file,
14663 restrict load_debug_section to the sections in that set. */
14664 section_subset
= find_cu_tu_set (filedata
, shndx
);
14666 result
&= display
->display (sec
, filedata
);
14668 section_subset
= NULL
;
14670 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14671 free_debug_section (id
);
14679 printf (_("Unrecognized debug section: %s\n"), print_name
);
14686 /* Set DUMP_SECTS for all sections where dumps were requested
14687 based on section name. */
14690 initialise_dumps_byname (Filedata
* filedata
)
14692 struct dump_list_entry
* cur
;
14694 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14697 bfd_boolean any
= FALSE
;
14699 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14700 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14702 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
14707 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14713 process_section_contents (Filedata
* filedata
)
14715 Elf_Internal_Shdr
* section
;
14717 bfd_boolean res
= TRUE
;
14722 initialise_dumps_byname (filedata
);
14724 for (i
= 0, section
= filedata
->section_headers
;
14725 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
14728 dump_type dump
= filedata
->dump
.dump_sects
[i
];
14730 #ifdef SUPPORT_DISASSEMBLY
14731 if (dump
& DISASS_DUMP
)
14733 if (! disassemble_section (section
, filedata
))
14737 if (dump
& HEX_DUMP
)
14739 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14743 if (dump
& RELOC_DUMP
)
14745 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14749 if (dump
& STRING_DUMP
)
14751 if (! dump_section_as_strings (section
, filedata
))
14755 if (dump
& DEBUG_DUMP
)
14757 if (! display_debug_section (i
, section
, filedata
))
14761 if (dump
& CTF_DUMP
)
14763 if (! dump_section_as_ctf (section
, filedata
))
14768 /* Check to see if the user requested a
14769 dump of a section that does not exist. */
14770 while (i
< filedata
->dump
.num_dump_sects
)
14772 if (filedata
->dump
.dump_sects
[i
])
14774 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14784 process_mips_fpe_exception (int mask
)
14788 bfd_boolean first
= TRUE
;
14790 if (mask
& OEX_FPU_INEX
)
14791 fputs ("INEX", stdout
), first
= FALSE
;
14792 if (mask
& OEX_FPU_UFLO
)
14793 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14794 if (mask
& OEX_FPU_OFLO
)
14795 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14796 if (mask
& OEX_FPU_DIV0
)
14797 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14798 if (mask
& OEX_FPU_INVAL
)
14799 printf ("%sINVAL", first
? "" : "|");
14802 fputs ("0", stdout
);
14805 /* Display's the value of TAG at location P. If TAG is
14806 greater than 0 it is assumed to be an unknown tag, and
14807 a message is printed to this effect. Otherwise it is
14808 assumed that a message has already been printed.
14810 If the bottom bit of TAG is set it assumed to have a
14811 string value, otherwise it is assumed to have an integer
14814 Returns an updated P pointing to the first unread byte
14815 beyond the end of TAG's value.
14817 Reads at or beyond END will not be made. */
14819 static unsigned char *
14820 display_tag_value (signed int tag
,
14822 const unsigned char * const end
)
14827 printf (" Tag_unknown_%d: ", tag
);
14831 warn (_("<corrupt tag>\n"));
14835 /* PR 17531 file: 027-19978-0.004. */
14836 size_t maxlen
= (end
- p
) - 1;
14841 print_symbol ((int) maxlen
, (const char *) p
);
14842 p
+= strnlen ((char *) p
, maxlen
) + 1;
14846 printf (_("<corrupt string tag>"));
14847 p
= (unsigned char *) end
;
14853 READ_ULEB (val
, p
, end
);
14854 printf ("%ld (0x%lx)\n", val
, val
);
14861 /* ARC ABI attributes section. */
14863 static unsigned char *
14864 display_arc_attribute (unsigned char * p
,
14865 const unsigned char * const end
)
14870 READ_ULEB (tag
, p
, end
);
14874 case Tag_ARC_PCS_config
:
14875 READ_ULEB (val
, p
, end
);
14876 printf (" Tag_ARC_PCS_config: ");
14880 printf (_("Absent/Non standard\n"));
14883 printf (_("Bare metal/mwdt\n"));
14886 printf (_("Bare metal/newlib\n"));
14889 printf (_("Linux/uclibc\n"));
14892 printf (_("Linux/glibc\n"));
14895 printf (_("Unknown\n"));
14900 case Tag_ARC_CPU_base
:
14901 READ_ULEB (val
, p
, end
);
14902 printf (" Tag_ARC_CPU_base: ");
14907 printf (_("Absent\n"));
14909 case TAG_CPU_ARC6xx
:
14910 printf ("ARC6xx\n");
14912 case TAG_CPU_ARC7xx
:
14913 printf ("ARC7xx\n");
14915 case TAG_CPU_ARCEM
:
14916 printf ("ARCEM\n");
14918 case TAG_CPU_ARCHS
:
14919 printf ("ARCHS\n");
14924 case Tag_ARC_CPU_variation
:
14925 READ_ULEB (val
, p
, end
);
14926 printf (" Tag_ARC_CPU_variation: ");
14930 if (val
> 0 && val
< 16)
14931 printf ("Core%d\n", val
);
14933 printf ("Unknown\n");
14937 printf (_("Absent\n"));
14942 case Tag_ARC_CPU_name
:
14943 printf (" Tag_ARC_CPU_name: ");
14944 p
= display_tag_value (-1, p
, end
);
14947 case Tag_ARC_ABI_rf16
:
14948 READ_ULEB (val
, p
, end
);
14949 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14952 case Tag_ARC_ABI_osver
:
14953 READ_ULEB (val
, p
, end
);
14954 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14957 case Tag_ARC_ABI_pic
:
14958 case Tag_ARC_ABI_sda
:
14959 READ_ULEB (val
, p
, end
);
14960 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14961 : " Tag_ARC_ABI_pic: ");
14965 printf (_("Absent\n"));
14974 printf (_("Unknown\n"));
14979 case Tag_ARC_ABI_tls
:
14980 READ_ULEB (val
, p
, end
);
14981 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14984 case Tag_ARC_ABI_enumsize
:
14985 READ_ULEB (val
, p
, end
);
14986 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14990 case Tag_ARC_ABI_exceptions
:
14991 READ_ULEB (val
, p
, end
);
14992 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14996 case Tag_ARC_ABI_double_size
:
14997 READ_ULEB (val
, p
, end
);
14998 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15001 case Tag_ARC_ISA_config
:
15002 printf (" Tag_ARC_ISA_config: ");
15003 p
= display_tag_value (-1, p
, end
);
15006 case Tag_ARC_ISA_apex
:
15007 printf (" Tag_ARC_ISA_apex: ");
15008 p
= display_tag_value (-1, p
, end
);
15011 case Tag_ARC_ISA_mpy_option
:
15012 READ_ULEB (val
, p
, end
);
15013 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15016 case Tag_ARC_ATR_version
:
15017 READ_ULEB (val
, p
, end
);
15018 printf (" Tag_ARC_ATR_version: %d\n", val
);
15022 return display_tag_value (tag
& 1, p
, end
);
15028 /* ARM EABI attributes section. */
15033 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15035 const char ** table
;
15036 } arm_attr_public_tag
;
15038 static const char * arm_attr_tag_CPU_arch
[] =
15039 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15040 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15041 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15042 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15043 static const char * arm_attr_tag_THUMB_ISA_use
[] =
15044 {"No", "Thumb-1", "Thumb-2", "Yes"};
15045 static const char * arm_attr_tag_FP_arch
[] =
15046 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15047 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15048 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15049 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
15050 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15051 "NEON for ARMv8.1"};
15052 static const char * arm_attr_tag_PCS_config
[] =
15053 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15054 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15055 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
15056 {"V6", "SB", "TLS", "Unused"};
15057 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
15058 {"Absolute", "PC-relative", "SB-relative", "None"};
15059 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
15060 {"Absolute", "PC-relative", "None"};
15061 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
15062 {"None", "direct", "GOT-indirect"};
15063 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
15064 {"None", "??? 1", "2", "??? 3", "4"};
15065 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15066 static const char * arm_attr_tag_ABI_FP_denormal
[] =
15067 {"Unused", "Needed", "Sign only"};
15068 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15069 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15070 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15071 {"Unused", "Finite", "RTABI", "IEEE 754"};
15072 static const char * arm_attr_tag_ABI_enum_size
[] =
15073 {"Unused", "small", "int", "forced to int"};
15074 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15075 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15076 static const char * arm_attr_tag_ABI_VFP_args
[] =
15077 {"AAPCS", "VFP registers", "custom", "compatible"};
15078 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15079 {"AAPCS", "WMMX registers", "custom"};
15080 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15081 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15082 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15083 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15084 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15085 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15086 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15087 static const char * arm_attr_tag_FP_HP_extension
[] =
15088 {"Not Allowed", "Allowed"};
15089 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15090 {"None", "IEEE 754", "Alternative Format"};
15091 static const char * arm_attr_tag_DSP_extension
[] =
15092 {"Follow architecture", "Allowed"};
15093 static const char * arm_attr_tag_MPextension_use
[] =
15094 {"Not Allowed", "Allowed"};
15095 static const char * arm_attr_tag_DIV_use
[] =
15096 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15097 "Allowed in v7-A with integer division extension"};
15098 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15099 static const char * arm_attr_tag_Virtualization_use
[] =
15100 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15101 "TrustZone and Virtualization Extensions"};
15102 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15103 {"Not Allowed", "Allowed"};
15105 static const char * arm_attr_tag_MVE_arch
[] =
15106 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15108 #define LOOKUP(id, name) \
15109 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15110 static arm_attr_public_tag arm_attr_public_tags
[] =
15112 {4, "CPU_raw_name", 1, NULL
},
15113 {5, "CPU_name", 1, NULL
},
15114 LOOKUP(6, CPU_arch
),
15115 {7, "CPU_arch_profile", 0, NULL
},
15116 LOOKUP(8, ARM_ISA_use
),
15117 LOOKUP(9, THUMB_ISA_use
),
15118 LOOKUP(10, FP_arch
),
15119 LOOKUP(11, WMMX_arch
),
15120 LOOKUP(12, Advanced_SIMD_arch
),
15121 LOOKUP(13, PCS_config
),
15122 LOOKUP(14, ABI_PCS_R9_use
),
15123 LOOKUP(15, ABI_PCS_RW_data
),
15124 LOOKUP(16, ABI_PCS_RO_data
),
15125 LOOKUP(17, ABI_PCS_GOT_use
),
15126 LOOKUP(18, ABI_PCS_wchar_t
),
15127 LOOKUP(19, ABI_FP_rounding
),
15128 LOOKUP(20, ABI_FP_denormal
),
15129 LOOKUP(21, ABI_FP_exceptions
),
15130 LOOKUP(22, ABI_FP_user_exceptions
),
15131 LOOKUP(23, ABI_FP_number_model
),
15132 {24, "ABI_align_needed", 0, NULL
},
15133 {25, "ABI_align_preserved", 0, NULL
},
15134 LOOKUP(26, ABI_enum_size
),
15135 LOOKUP(27, ABI_HardFP_use
),
15136 LOOKUP(28, ABI_VFP_args
),
15137 LOOKUP(29, ABI_WMMX_args
),
15138 LOOKUP(30, ABI_optimization_goals
),
15139 LOOKUP(31, ABI_FP_optimization_goals
),
15140 {32, "compatibility", 0, NULL
},
15141 LOOKUP(34, CPU_unaligned_access
),
15142 LOOKUP(36, FP_HP_extension
),
15143 LOOKUP(38, ABI_FP_16bit_format
),
15144 LOOKUP(42, MPextension_use
),
15145 LOOKUP(44, DIV_use
),
15146 LOOKUP(46, DSP_extension
),
15147 LOOKUP(48, MVE_arch
),
15148 {64, "nodefaults", 0, NULL
},
15149 {65, "also_compatible_with", 0, NULL
},
15150 LOOKUP(66, T2EE_use
),
15151 {67, "conformance", 1, NULL
},
15152 LOOKUP(68, Virtualization_use
),
15153 LOOKUP(70, MPextension_use_legacy
)
15157 static unsigned char *
15158 display_arm_attribute (unsigned char * p
,
15159 const unsigned char * const end
)
15163 arm_attr_public_tag
* attr
;
15167 READ_ULEB (tag
, p
, end
);
15169 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15171 if (arm_attr_public_tags
[i
].tag
== tag
)
15173 attr
= &arm_attr_public_tags
[i
];
15180 printf (" Tag_%s: ", attr
->name
);
15181 switch (attr
->type
)
15186 case 7: /* Tag_CPU_arch_profile. */
15187 READ_ULEB (val
, p
, end
);
15190 case 0: printf (_("None\n")); break;
15191 case 'A': printf (_("Application\n")); break;
15192 case 'R': printf (_("Realtime\n")); break;
15193 case 'M': printf (_("Microcontroller\n")); break;
15194 case 'S': printf (_("Application or Realtime\n")); break;
15195 default: printf ("??? (%d)\n", val
); break;
15199 case 24: /* Tag_align_needed. */
15200 READ_ULEB (val
, p
, end
);
15203 case 0: printf (_("None\n")); break;
15204 case 1: printf (_("8-byte\n")); break;
15205 case 2: printf (_("4-byte\n")); break;
15206 case 3: printf ("??? 3\n"); break;
15209 printf (_("8-byte and up to %d-byte extended\n"),
15212 printf ("??? (%d)\n", val
);
15217 case 25: /* Tag_align_preserved. */
15218 READ_ULEB (val
, p
, end
);
15221 case 0: printf (_("None\n")); break;
15222 case 1: printf (_("8-byte, except leaf SP\n")); break;
15223 case 2: printf (_("8-byte\n")); break;
15224 case 3: printf ("??? 3\n"); break;
15227 printf (_("8-byte and up to %d-byte extended\n"),
15230 printf ("??? (%d)\n", val
);
15235 case 32: /* Tag_compatibility. */
15237 READ_ULEB (val
, p
, end
);
15238 printf (_("flag = %d, vendor = "), val
);
15241 size_t maxlen
= (end
- p
) - 1;
15243 print_symbol ((int) maxlen
, (const char *) p
);
15244 p
+= strnlen ((char *) p
, maxlen
) + 1;
15248 printf (_("<corrupt>"));
15249 p
= (unsigned char *) end
;
15255 case 64: /* Tag_nodefaults. */
15256 /* PR 17531: file: 001-505008-0.01. */
15259 printf (_("True\n"));
15262 case 65: /* Tag_also_compatible_with. */
15263 READ_ULEB (val
, p
, end
);
15264 if (val
== 6 /* Tag_CPU_arch. */)
15266 READ_ULEB (val
, p
, end
);
15267 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15268 printf ("??? (%d)\n", val
);
15270 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15274 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15279 printf (_("<unknown: %d>\n"), tag
);
15285 return display_tag_value (-1, p
, end
);
15287 return display_tag_value (0, p
, end
);
15290 assert (attr
->type
& 0x80);
15291 READ_ULEB (val
, p
, end
);
15292 type
= attr
->type
& 0x7f;
15294 printf ("??? (%d)\n", val
);
15296 printf ("%s\n", attr
->table
[val
]);
15301 return display_tag_value (tag
, p
, end
);
15304 static unsigned char *
15305 display_gnu_attribute (unsigned char * p
,
15306 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15307 const unsigned char * const end
)
15312 READ_ULEB (tag
, p
, end
);
15314 /* Tag_compatibility is the only generic GNU attribute defined at
15318 READ_ULEB (val
, p
, end
);
15320 printf (_("flag = %d, vendor = "), val
);
15323 printf (_("<corrupt>\n"));
15324 warn (_("corrupt vendor attribute\n"));
15330 size_t maxlen
= (end
- p
) - 1;
15332 print_symbol ((int) maxlen
, (const char *) p
);
15333 p
+= strnlen ((char *) p
, maxlen
) + 1;
15337 printf (_("<corrupt>"));
15338 p
= (unsigned char *) end
;
15345 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15346 return display_proc_gnu_attribute (p
, tag
, end
);
15348 return display_tag_value (tag
, p
, end
);
15351 static unsigned char *
15352 display_power_gnu_attribute (unsigned char * p
,
15354 const unsigned char * const end
)
15358 if (tag
== Tag_GNU_Power_ABI_FP
)
15360 printf (" Tag_GNU_Power_ABI_FP: ");
15363 printf (_("<corrupt>\n"));
15366 READ_ULEB (val
, p
, end
);
15369 printf ("(%#x), ", val
);
15374 printf (_("unspecified hard/soft float, "));
15377 printf (_("hard float, "));
15380 printf (_("soft float, "));
15383 printf (_("single-precision hard float, "));
15390 printf (_("unspecified long double\n"));
15393 printf (_("128-bit IBM long double\n"));
15396 printf (_("64-bit long double\n"));
15399 printf (_("128-bit IEEE long double\n"));
15405 if (tag
== Tag_GNU_Power_ABI_Vector
)
15407 printf (" Tag_GNU_Power_ABI_Vector: ");
15410 printf (_("<corrupt>\n"));
15413 READ_ULEB (val
, p
, end
);
15416 printf ("(%#x), ", val
);
15421 printf (_("unspecified\n"));
15424 printf (_("generic\n"));
15427 printf ("AltiVec\n");
15436 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15438 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15441 printf (_("<corrupt>\n"));
15444 READ_ULEB (val
, p
, end
);
15447 printf ("(%#x), ", val
);
15452 printf (_("unspecified\n"));
15455 printf ("r3/r4\n");
15458 printf (_("memory\n"));
15467 return display_tag_value (tag
& 1, p
, end
);
15470 static unsigned char *
15471 display_s390_gnu_attribute (unsigned char * p
,
15473 const unsigned char * const end
)
15477 if (tag
== Tag_GNU_S390_ABI_Vector
)
15479 printf (" Tag_GNU_S390_ABI_Vector: ");
15480 READ_ULEB (val
, p
, end
);
15485 printf (_("any\n"));
15488 printf (_("software\n"));
15491 printf (_("hardware\n"));
15494 printf ("??? (%d)\n", val
);
15500 return display_tag_value (tag
& 1, p
, end
);
15504 display_sparc_hwcaps (unsigned int mask
)
15508 bfd_boolean first
= TRUE
;
15510 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15511 fputs ("mul32", stdout
), first
= FALSE
;
15512 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15513 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15514 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15515 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15516 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15517 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15518 if (mask
& ELF_SPARC_HWCAP_POPC
)
15519 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15520 if (mask
& ELF_SPARC_HWCAP_VIS
)
15521 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15522 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15523 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15524 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15525 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15526 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15527 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15528 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15529 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15530 if (mask
& ELF_SPARC_HWCAP_HPC
)
15531 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15532 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15533 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15534 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15535 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15536 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15537 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15538 if (mask
& ELF_SPARC_HWCAP_IMA
)
15539 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15540 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15541 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15544 fputc ('0', stdout
);
15545 fputc ('\n', stdout
);
15549 display_sparc_hwcaps2 (unsigned int mask
)
15553 bfd_boolean first
= TRUE
;
15555 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15556 fputs ("fjathplus", stdout
), first
= FALSE
;
15557 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15558 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15559 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15560 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15561 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15562 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15563 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15564 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15565 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15566 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15567 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15568 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15569 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15570 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15571 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15572 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15573 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15574 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15575 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15576 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15579 fputc ('0', stdout
);
15580 fputc ('\n', stdout
);
15583 static unsigned char *
15584 display_sparc_gnu_attribute (unsigned char * p
,
15586 const unsigned char * const end
)
15590 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15592 READ_ULEB (val
, p
, end
);
15593 printf (" Tag_GNU_Sparc_HWCAPS: ");
15594 display_sparc_hwcaps (val
);
15597 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15599 READ_ULEB (val
, p
, end
);
15600 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15601 display_sparc_hwcaps2 (val
);
15605 return display_tag_value (tag
, p
, end
);
15609 print_mips_fp_abi_value (unsigned int val
)
15613 case Val_GNU_MIPS_ABI_FP_ANY
:
15614 printf (_("Hard or soft float\n"));
15616 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15617 printf (_("Hard float (double precision)\n"));
15619 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15620 printf (_("Hard float (single precision)\n"));
15622 case Val_GNU_MIPS_ABI_FP_SOFT
:
15623 printf (_("Soft float\n"));
15625 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15626 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15628 case Val_GNU_MIPS_ABI_FP_XX
:
15629 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15631 case Val_GNU_MIPS_ABI_FP_64
:
15632 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15634 case Val_GNU_MIPS_ABI_FP_64A
:
15635 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15637 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15638 printf (_("NaN 2008 compatibility\n"));
15641 printf ("??? (%d)\n", val
);
15646 static unsigned char *
15647 display_mips_gnu_attribute (unsigned char * p
,
15649 const unsigned char * const end
)
15651 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15655 printf (" Tag_GNU_MIPS_ABI_FP: ");
15656 READ_ULEB (val
, p
, end
);
15657 print_mips_fp_abi_value (val
);
15661 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15665 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15666 READ_ULEB (val
, p
, end
);
15670 case Val_GNU_MIPS_ABI_MSA_ANY
:
15671 printf (_("Any MSA or not\n"));
15673 case Val_GNU_MIPS_ABI_MSA_128
:
15674 printf (_("128-bit MSA\n"));
15677 printf ("??? (%d)\n", val
);
15683 return display_tag_value (tag
& 1, p
, end
);
15686 static unsigned char *
15687 display_tic6x_attribute (unsigned char * p
,
15688 const unsigned char * const end
)
15693 READ_ULEB (tag
, p
, end
);
15698 printf (" Tag_ISA: ");
15699 READ_ULEB (val
, p
, end
);
15703 case C6XABI_Tag_ISA_none
:
15704 printf (_("None\n"));
15706 case C6XABI_Tag_ISA_C62X
:
15709 case C6XABI_Tag_ISA_C67X
:
15712 case C6XABI_Tag_ISA_C67XP
:
15713 printf ("C67x+\n");
15715 case C6XABI_Tag_ISA_C64X
:
15718 case C6XABI_Tag_ISA_C64XP
:
15719 printf ("C64x+\n");
15721 case C6XABI_Tag_ISA_C674X
:
15722 printf ("C674x\n");
15725 printf ("??? (%d)\n", val
);
15730 case Tag_ABI_wchar_t
:
15731 printf (" Tag_ABI_wchar_t: ");
15732 READ_ULEB (val
, p
, end
);
15736 printf (_("Not used\n"));
15739 printf (_("2 bytes\n"));
15742 printf (_("4 bytes\n"));
15745 printf ("??? (%d)\n", val
);
15750 case Tag_ABI_stack_align_needed
:
15751 printf (" Tag_ABI_stack_align_needed: ");
15752 READ_ULEB (val
, p
, end
);
15756 printf (_("8-byte\n"));
15759 printf (_("16-byte\n"));
15762 printf ("??? (%d)\n", val
);
15767 case Tag_ABI_stack_align_preserved
:
15768 READ_ULEB (val
, p
, end
);
15769 printf (" Tag_ABI_stack_align_preserved: ");
15773 printf (_("8-byte\n"));
15776 printf (_("16-byte\n"));
15779 printf ("??? (%d)\n", val
);
15785 READ_ULEB (val
, p
, end
);
15786 printf (" Tag_ABI_DSBT: ");
15790 printf (_("DSBT addressing not used\n"));
15793 printf (_("DSBT addressing used\n"));
15796 printf ("??? (%d)\n", val
);
15802 READ_ULEB (val
, p
, end
);
15803 printf (" Tag_ABI_PID: ");
15807 printf (_("Data addressing position-dependent\n"));
15810 printf (_("Data addressing position-independent, GOT near DP\n"));
15813 printf (_("Data addressing position-independent, GOT far from DP\n"));
15816 printf ("??? (%d)\n", val
);
15822 READ_ULEB (val
, p
, end
);
15823 printf (" Tag_ABI_PIC: ");
15827 printf (_("Code addressing position-dependent\n"));
15830 printf (_("Code addressing position-independent\n"));
15833 printf ("??? (%d)\n", val
);
15838 case Tag_ABI_array_object_alignment
:
15839 READ_ULEB (val
, p
, end
);
15840 printf (" Tag_ABI_array_object_alignment: ");
15844 printf (_("8-byte\n"));
15847 printf (_("4-byte\n"));
15850 printf (_("16-byte\n"));
15853 printf ("??? (%d)\n", val
);
15858 case Tag_ABI_array_object_align_expected
:
15859 READ_ULEB (val
, p
, end
);
15860 printf (" Tag_ABI_array_object_align_expected: ");
15864 printf (_("8-byte\n"));
15867 printf (_("4-byte\n"));
15870 printf (_("16-byte\n"));
15873 printf ("??? (%d)\n", val
);
15878 case Tag_ABI_compatibility
:
15880 READ_ULEB (val
, p
, end
);
15881 printf (" Tag_ABI_compatibility: ");
15882 printf (_("flag = %d, vendor = "), val
);
15885 size_t maxlen
= (end
- p
) - 1;
15887 print_symbol ((int) maxlen
, (const char *) p
);
15888 p
+= strnlen ((char *) p
, maxlen
) + 1;
15892 printf (_("<corrupt>"));
15893 p
= (unsigned char *) end
;
15899 case Tag_ABI_conformance
:
15901 printf (" Tag_ABI_conformance: \"");
15904 size_t maxlen
= (end
- p
) - 1;
15906 print_symbol ((int) maxlen
, (const char *) p
);
15907 p
+= strnlen ((char *) p
, maxlen
) + 1;
15911 printf (_("<corrupt>"));
15912 p
= (unsigned char *) end
;
15919 return display_tag_value (tag
, p
, end
);
15923 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15925 unsigned long addr
= 0;
15926 size_t bytes
= end
- p
;
15933 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15935 printf (" 0x%8.8lx ", addr
);
15937 for (j
= 0; j
< 16; j
++)
15940 printf ("%2.2x", p
[j
]);
15948 for (j
= 0; j
< lbytes
; j
++)
15951 if (k
>= ' ' && k
< 0x7f)
15967 static unsigned char *
15968 display_msp430x_attribute (unsigned char * p
,
15969 const unsigned char * const end
)
15974 READ_ULEB (tag
, p
, end
);
15978 case OFBA_MSPABI_Tag_ISA
:
15979 printf (" Tag_ISA: ");
15980 READ_ULEB (val
, p
, end
);
15983 case 0: printf (_("None\n")); break;
15984 case 1: printf (_("MSP430\n")); break;
15985 case 2: printf (_("MSP430X\n")); break;
15986 default: printf ("??? (%d)\n", val
); break;
15990 case OFBA_MSPABI_Tag_Code_Model
:
15991 printf (" Tag_Code_Model: ");
15992 READ_ULEB (val
, p
, end
);
15995 case 0: printf (_("None\n")); break;
15996 case 1: printf (_("Small\n")); break;
15997 case 2: printf (_("Large\n")); break;
15998 default: printf ("??? (%d)\n", val
); break;
16002 case OFBA_MSPABI_Tag_Data_Model
:
16003 printf (" Tag_Data_Model: ");
16004 READ_ULEB (val
, p
, end
);
16007 case 0: printf (_("None\n")); break;
16008 case 1: printf (_("Small\n")); break;
16009 case 2: printf (_("Large\n")); break;
16010 case 3: printf (_("Restricted Large\n")); break;
16011 default: printf ("??? (%d)\n", val
); break;
16016 printf (_(" <unknown tag %d>: "), tag
);
16023 size_t maxlen
= (end
- p
) - 1;
16025 print_symbol ((int) maxlen
, (const char *) p
);
16026 p
+= strnlen ((char *) p
, maxlen
) + 1;
16030 printf (_("<corrupt>"));
16031 p
= (unsigned char *) end
;
16037 READ_ULEB (val
, p
, end
);
16038 printf ("%d (0x%x)\n", val
, val
);
16047 static unsigned char *
16048 display_msp430_gnu_attribute (unsigned char * p
,
16050 const unsigned char * const end
)
16052 if (tag
== Tag_GNU_MSP430_Data_Region
)
16056 printf (" Tag_GNU_MSP430_Data_Region: ");
16057 READ_ULEB (val
, p
, end
);
16061 case Val_GNU_MSP430_Data_Region_Any
:
16062 printf (_("Any Region\n"));
16064 case Val_GNU_MSP430_Data_Region_Lower
:
16065 printf (_("Lower Region Only\n"));
16068 printf ("??? (%u)\n", val
);
16072 return display_tag_value (tag
& 1, p
, end
);
16075 struct riscv_attr_tag_t
{
16080 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16082 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16085 T(priv_spec_minor
),
16086 T(priv_spec_revision
),
16087 T(unaligned_access
),
16092 static unsigned char *
16093 display_riscv_attribute (unsigned char *p
,
16094 const unsigned char * const end
)
16098 struct riscv_attr_tag_t
*attr
= NULL
;
16101 READ_ULEB (tag
, p
, end
);
16103 /* Find the name of attribute. */
16104 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16106 if (riscv_attr_tag
[i
].tag
== tag
)
16108 attr
= &riscv_attr_tag
[i
];
16114 printf (" %s: ", attr
->name
);
16116 return display_tag_value (tag
, p
, end
);
16120 case Tag_RISCV_priv_spec
:
16121 case Tag_RISCV_priv_spec_minor
:
16122 case Tag_RISCV_priv_spec_revision
:
16123 READ_ULEB (val
, p
, end
);
16124 printf (_("%u\n"), val
);
16126 case Tag_RISCV_unaligned_access
:
16127 READ_ULEB (val
, p
, end
);
16131 printf (_("No unaligned access\n"));
16134 printf (_("Unaligned access\n"));
16138 case Tag_RISCV_stack_align
:
16139 READ_ULEB (val
, p
, end
);
16140 printf (_("%u-bytes\n"), val
);
16142 case Tag_RISCV_arch
:
16143 p
= display_tag_value (-1, p
, end
);
16146 return display_tag_value (tag
, p
, end
);
16153 process_attributes (Filedata
* filedata
,
16154 const char * public_name
,
16155 unsigned int proc_type
,
16156 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16157 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16159 Elf_Internal_Shdr
* sect
;
16161 bfd_boolean res
= TRUE
;
16163 /* Find the section header so that we get the size. */
16164 for (i
= 0, sect
= filedata
->section_headers
;
16165 i
< filedata
->file_header
.e_shnum
;
16168 unsigned char * contents
;
16171 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16174 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16175 sect
->sh_size
, _("attributes"));
16176 if (contents
== NULL
)
16183 /* The first character is the version of the attributes.
16184 Currently only version 1, (aka 'A') is recognised here. */
16187 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16192 bfd_vma section_len
;
16194 section_len
= sect
->sh_size
- 1;
16197 while (section_len
> 0)
16200 unsigned int namelen
;
16201 bfd_boolean public_section
;
16202 bfd_boolean gnu_section
;
16204 if (section_len
<= 4)
16206 error (_("Tag section ends prematurely\n"));
16210 attr_len
= byte_get (p
, 4);
16213 if (attr_len
> section_len
)
16215 error (_("Bad attribute length (%u > %u)\n"),
16216 (unsigned) attr_len
, (unsigned) section_len
);
16217 attr_len
= section_len
;
16220 /* PR 17531: file: 001-101425-0.004 */
16221 else if (attr_len
< 5)
16223 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16228 section_len
-= attr_len
;
16231 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16232 if (namelen
== 0 || namelen
>= attr_len
)
16234 error (_("Corrupt attribute section name\n"));
16239 printf (_("Attribute Section: "));
16240 print_symbol (INT_MAX
, (const char *) p
);
16243 if (public_name
&& streq ((char *) p
, public_name
))
16244 public_section
= TRUE
;
16246 public_section
= FALSE
;
16248 if (streq ((char *) p
, "gnu"))
16249 gnu_section
= TRUE
;
16251 gnu_section
= FALSE
;
16254 attr_len
-= namelen
;
16256 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16261 unsigned char * end
;
16263 /* PR binutils/17531: Safe handling of corrupt files. */
16266 error (_("Unused bytes at end of section\n"));
16273 size
= byte_get (p
, 4);
16274 if (size
> attr_len
)
16276 error (_("Bad subsection length (%u > %u)\n"),
16277 (unsigned) size
, (unsigned) attr_len
);
16281 /* PR binutils/17531: Safe handling of corrupt files. */
16284 error (_("Bad subsection length (%u < 6)\n"),
16292 end
= p
+ size
- 1;
16293 assert (end
<= contents
+ sect
->sh_size
);
16299 printf (_("File Attributes\n"));
16302 printf (_("Section Attributes:"));
16305 printf (_("Symbol Attributes:"));
16306 /* Fall through. */
16310 READ_ULEB (val
, p
, end
);
16313 printf (" %d", val
);
16318 printf (_("Unknown tag: %d\n"), tag
);
16319 public_section
= FALSE
;
16323 if (public_section
&& display_pub_attribute
!= NULL
)
16326 p
= display_pub_attribute (p
, end
);
16329 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16332 p
= display_gnu_attribute (p
,
16333 display_proc_gnu_attribute
,
16339 printf (_(" Unknown attribute:\n"));
16340 display_raw_attribute (p
, end
);
16355 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16356 Print the Address, Access and Initial fields of an entry at VMA ADDR
16357 and return the VMA of the next entry, or -1 if there was a problem.
16358 Does not read from DATA_END or beyond. */
16361 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16362 unsigned char * data_end
)
16365 print_vma (addr
, LONG_HEX
);
16367 if (addr
< pltgot
+ 0xfff0)
16368 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16370 printf ("%10s", "");
16373 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16377 unsigned char * from
= data
+ addr
- pltgot
;
16379 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16381 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16382 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16383 return (bfd_vma
) -1;
16387 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16388 print_vma (entry
, LONG_HEX
);
16391 return addr
+ (is_32bit_elf
? 4 : 8);
16394 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16395 PLTGOT. Print the Address and Initial fields of an entry at VMA
16396 ADDR and return the VMA of the next entry. */
16399 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16402 print_vma (addr
, LONG_HEX
);
16405 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16410 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16411 print_vma (entry
, LONG_HEX
);
16413 return addr
+ (is_32bit_elf
? 4 : 8);
16417 print_mips_ases (unsigned int mask
)
16419 if (mask
& AFL_ASE_DSP
)
16420 fputs ("\n\tDSP ASE", stdout
);
16421 if (mask
& AFL_ASE_DSPR2
)
16422 fputs ("\n\tDSP R2 ASE", stdout
);
16423 if (mask
& AFL_ASE_DSPR3
)
16424 fputs ("\n\tDSP R3 ASE", stdout
);
16425 if (mask
& AFL_ASE_EVA
)
16426 fputs ("\n\tEnhanced VA Scheme", stdout
);
16427 if (mask
& AFL_ASE_MCU
)
16428 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16429 if (mask
& AFL_ASE_MDMX
)
16430 fputs ("\n\tMDMX ASE", stdout
);
16431 if (mask
& AFL_ASE_MIPS3D
)
16432 fputs ("\n\tMIPS-3D ASE", stdout
);
16433 if (mask
& AFL_ASE_MT
)
16434 fputs ("\n\tMT ASE", stdout
);
16435 if (mask
& AFL_ASE_SMARTMIPS
)
16436 fputs ("\n\tSmartMIPS ASE", stdout
);
16437 if (mask
& AFL_ASE_VIRT
)
16438 fputs ("\n\tVZ ASE", stdout
);
16439 if (mask
& AFL_ASE_MSA
)
16440 fputs ("\n\tMSA ASE", stdout
);
16441 if (mask
& AFL_ASE_MIPS16
)
16442 fputs ("\n\tMIPS16 ASE", stdout
);
16443 if (mask
& AFL_ASE_MICROMIPS
)
16444 fputs ("\n\tMICROMIPS ASE", stdout
);
16445 if (mask
& AFL_ASE_XPA
)
16446 fputs ("\n\tXPA ASE", stdout
);
16447 if (mask
& AFL_ASE_MIPS16E2
)
16448 fputs ("\n\tMIPS16e2 ASE", stdout
);
16449 if (mask
& AFL_ASE_CRC
)
16450 fputs ("\n\tCRC ASE", stdout
);
16451 if (mask
& AFL_ASE_GINV
)
16452 fputs ("\n\tGINV ASE", stdout
);
16453 if (mask
& AFL_ASE_LOONGSON_MMI
)
16454 fputs ("\n\tLoongson MMI ASE", stdout
);
16455 if (mask
& AFL_ASE_LOONGSON_CAM
)
16456 fputs ("\n\tLoongson CAM ASE", stdout
);
16457 if (mask
& AFL_ASE_LOONGSON_EXT
)
16458 fputs ("\n\tLoongson EXT ASE", stdout
);
16459 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16460 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16462 fprintf (stdout
, "\n\t%s", _("None"));
16463 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16464 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16468 print_mips_isa_ext (unsigned int isa_ext
)
16473 fputs (_("None"), stdout
);
16476 fputs ("RMI XLR", stdout
);
16478 case AFL_EXT_OCTEON3
:
16479 fputs ("Cavium Networks Octeon3", stdout
);
16481 case AFL_EXT_OCTEON2
:
16482 fputs ("Cavium Networks Octeon2", stdout
);
16484 case AFL_EXT_OCTEONP
:
16485 fputs ("Cavium Networks OcteonP", stdout
);
16487 case AFL_EXT_OCTEON
:
16488 fputs ("Cavium Networks Octeon", stdout
);
16491 fputs ("Toshiba R5900", stdout
);
16494 fputs ("MIPS R4650", stdout
);
16497 fputs ("LSI R4010", stdout
);
16500 fputs ("NEC VR4100", stdout
);
16503 fputs ("Toshiba R3900", stdout
);
16505 case AFL_EXT_10000
:
16506 fputs ("MIPS R10000", stdout
);
16509 fputs ("Broadcom SB-1", stdout
);
16512 fputs ("NEC VR4111/VR4181", stdout
);
16515 fputs ("NEC VR4120", stdout
);
16518 fputs ("NEC VR5400", stdout
);
16521 fputs ("NEC VR5500", stdout
);
16523 case AFL_EXT_LOONGSON_2E
:
16524 fputs ("ST Microelectronics Loongson 2E", stdout
);
16526 case AFL_EXT_LOONGSON_2F
:
16527 fputs ("ST Microelectronics Loongson 2F", stdout
);
16529 case AFL_EXT_INTERAPTIV_MR2
:
16530 fputs ("Imagination interAptiv MR2", stdout
);
16533 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16538 get_mips_reg_size (int reg_size
)
16540 return (reg_size
== AFL_REG_NONE
) ? 0
16541 : (reg_size
== AFL_REG_32
) ? 32
16542 : (reg_size
== AFL_REG_64
) ? 64
16543 : (reg_size
== AFL_REG_128
) ? 128
16548 process_mips_specific (Filedata
* filedata
)
16550 Elf_Internal_Dyn
* entry
;
16551 Elf_Internal_Shdr
*sect
= NULL
;
16552 size_t liblist_offset
= 0;
16553 size_t liblistno
= 0;
16554 size_t conflictsno
= 0;
16555 size_t options_offset
= 0;
16556 size_t conflicts_offset
= 0;
16557 size_t pltrelsz
= 0;
16559 bfd_vma pltgot
= 0;
16560 bfd_vma mips_pltgot
= 0;
16561 bfd_vma jmprel
= 0;
16562 bfd_vma local_gotno
= 0;
16563 bfd_vma gotsym
= 0;
16564 bfd_vma symtabno
= 0;
16565 bfd_boolean res
= TRUE
;
16567 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16568 display_mips_gnu_attribute
))
16571 sect
= find_section (filedata
, ".MIPS.abiflags");
16575 Elf_External_ABIFlags_v0
*abiflags_ext
;
16576 Elf_Internal_ABIFlags_v0 abiflags_in
;
16578 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16580 error (_("Corrupt MIPS ABI Flags section.\n"));
16585 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16586 sect
->sh_size
, _("MIPS ABI Flags section"));
16589 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16590 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16591 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16592 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16593 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16594 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16595 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16596 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16597 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16598 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16599 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16601 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16602 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16603 if (abiflags_in
.isa_rev
> 1)
16604 printf ("r%d", abiflags_in
.isa_rev
);
16605 printf ("\nGPR size: %d",
16606 get_mips_reg_size (abiflags_in
.gpr_size
));
16607 printf ("\nCPR1 size: %d",
16608 get_mips_reg_size (abiflags_in
.cpr1_size
));
16609 printf ("\nCPR2 size: %d",
16610 get_mips_reg_size (abiflags_in
.cpr2_size
));
16611 fputs ("\nFP ABI: ", stdout
);
16612 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16613 fputs ("ISA Extension: ", stdout
);
16614 print_mips_isa_ext (abiflags_in
.isa_ext
);
16615 fputs ("\nASEs:", stdout
);
16616 print_mips_ases (abiflags_in
.ases
);
16617 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16618 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16619 fputc ('\n', stdout
);
16620 free (abiflags_ext
);
16625 /* We have a lot of special sections. Thanks SGI! */
16626 if (filedata
->dynamic_section
== NULL
)
16628 /* No dynamic information available. See if there is static GOT. */
16629 sect
= find_section (filedata
, ".got");
16632 unsigned char *data_end
;
16633 unsigned char *data
;
16637 pltgot
= sect
->sh_addr
;
16640 addr_size
= (is_32bit_elf
? 4 : 8);
16641 end
= pltgot
+ sect
->sh_size
;
16643 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16645 _("Global Offset Table data"));
16646 /* PR 12855: Null data is handled gracefully throughout. */
16647 data_end
= data
+ (end
- pltgot
);
16649 printf (_("\nStatic GOT:\n"));
16650 printf (_(" Canonical gp value: "));
16651 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16654 /* In a dynamic binary GOT[0] is reserved for the dynamic
16655 loader to store the lazy resolver pointer, however in
16656 a static binary it may well have been omitted and GOT
16657 reduced to a table of addresses.
16658 PR 21344: Check for the entry being fully available
16659 before fetching it. */
16661 && data
+ ent
- pltgot
+ addr_size
<= data_end
16662 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16664 printf (_(" Reserved entries:\n"));
16665 printf (_(" %*s %10s %*s\n"),
16666 addr_size
* 2, _("Address"), _("Access"),
16667 addr_size
* 2, _("Value"));
16668 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16670 if (ent
== (bfd_vma
) -1)
16671 goto sgot_print_fail
;
16673 /* Check for the MSB of GOT[1] being set, identifying a
16674 GNU object. This entry will be used by some runtime
16675 loaders, to store the module pointer. Otherwise this
16676 is an ordinary local entry.
16677 PR 21344: Check for the entry being fully available
16678 before fetching it. */
16680 && data
+ ent
- pltgot
+ addr_size
<= data_end
16681 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16682 >> (addr_size
* 8 - 1)) != 0)
16684 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16686 if (ent
== (bfd_vma
) -1)
16687 goto sgot_print_fail
;
16692 if (data
!= NULL
&& ent
< end
)
16694 printf (_(" Local entries:\n"));
16695 printf (" %*s %10s %*s\n",
16696 addr_size
* 2, _("Address"), _("Access"),
16697 addr_size
* 2, _("Value"));
16700 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16702 if (ent
== (bfd_vma
) -1)
16703 goto sgot_print_fail
;
16715 for (entry
= filedata
->dynamic_section
;
16716 /* PR 17531 file: 012-50589-0.004. */
16717 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
16718 && entry
->d_tag
!= DT_NULL
);
16720 switch (entry
->d_tag
)
16722 case DT_MIPS_LIBLIST
:
16724 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16725 liblistno
* sizeof (Elf32_External_Lib
));
16727 case DT_MIPS_LIBLISTNO
:
16728 liblistno
= entry
->d_un
.d_val
;
16730 case DT_MIPS_OPTIONS
:
16731 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16733 case DT_MIPS_CONFLICT
:
16735 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16736 conflictsno
* sizeof (Elf32_External_Conflict
));
16738 case DT_MIPS_CONFLICTNO
:
16739 conflictsno
= entry
->d_un
.d_val
;
16742 pltgot
= entry
->d_un
.d_ptr
;
16744 case DT_MIPS_LOCAL_GOTNO
:
16745 local_gotno
= entry
->d_un
.d_val
;
16747 case DT_MIPS_GOTSYM
:
16748 gotsym
= entry
->d_un
.d_val
;
16750 case DT_MIPS_SYMTABNO
:
16751 symtabno
= entry
->d_un
.d_val
;
16753 case DT_MIPS_PLTGOT
:
16754 mips_pltgot
= entry
->d_un
.d_ptr
;
16757 pltrel
= entry
->d_un
.d_val
;
16760 pltrelsz
= entry
->d_un
.d_val
;
16763 jmprel
= entry
->d_un
.d_ptr
;
16769 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16771 Elf32_External_Lib
* elib
;
16774 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16775 sizeof (Elf32_External_Lib
),
16777 _("liblist section data"));
16780 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16781 "\nSection '.liblist' contains %lu entries:\n",
16782 (unsigned long) liblistno
),
16783 (unsigned long) liblistno
);
16784 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16787 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16794 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16795 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16796 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16797 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16798 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16800 tmp
= gmtime (&atime
);
16801 snprintf (timebuf
, sizeof (timebuf
),
16802 "%04u-%02u-%02uT%02u:%02u:%02u",
16803 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16804 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16806 printf ("%3lu: ", (unsigned long) cnt
);
16807 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
16808 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
16810 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16811 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16812 liblist
.l_version
);
16814 if (liblist
.l_flags
== 0)
16818 static const struct
16825 { " EXACT_MATCH", LL_EXACT_MATCH
},
16826 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16827 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16828 { " EXPORTS", LL_EXPORTS
},
16829 { " DELAY_LOAD", LL_DELAY_LOAD
},
16830 { " DELTA", LL_DELTA
}
16832 int flags
= liblist
.l_flags
;
16835 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16836 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16838 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16839 flags
^= l_flags_vals
[fcnt
].bit
;
16842 printf (" %#x", (unsigned int) flags
);
16854 if (options_offset
!= 0)
16856 Elf_External_Options
* eopt
;
16859 sect
= filedata
->section_headers
;
16861 /* Find the section header so that we get the size. */
16862 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16863 /* PR 17533 file: 012-277276-0.004. */
16866 error (_("No MIPS_OPTIONS header found\n"));
16870 if (sect
->sh_size
< sizeof (* eopt
))
16872 error (_("The MIPS options section is too small.\n"));
16876 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16877 sect
->sh_size
, _("options"));
16880 Elf_Internal_Options
* iopt
;
16881 Elf_Internal_Options
* option
;
16882 Elf_Internal_Options
* iopt_end
;
16884 iopt
= (Elf_Internal_Options
*)
16885 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16888 error (_("Out of memory allocating space for MIPS options\n"));
16895 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16897 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16899 Elf_External_Options
* eoption
;
16901 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16903 option
->kind
= BYTE_GET (eoption
->kind
);
16904 option
->size
= BYTE_GET (eoption
->size
);
16905 option
->section
= BYTE_GET (eoption
->section
);
16906 option
->info
= BYTE_GET (eoption
->info
);
16908 /* PR 17531: file: ffa0fa3b. */
16909 if (option
->size
< sizeof (* eopt
)
16910 || offset
+ option
->size
> sect
->sh_size
)
16912 error (_("Invalid size (%u) for MIPS option\n"),
16918 offset
+= option
->size
;
16924 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16925 "\nSection '%s' contains %d entries:\n",
16927 printable_section_name (filedata
, sect
), cnt
);
16936 switch (option
->kind
)
16939 /* This shouldn't happen. */
16940 printf (" NULL %d %lx", option
->section
, option
->info
);
16944 printf (" REGINFO ");
16945 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16947 Elf32_External_RegInfo
* ereg
;
16948 Elf32_RegInfo reginfo
;
16951 if (option
+ 2 > iopt_end
)
16953 printf (_("<corrupt>\n"));
16954 error (_("Truncated MIPS REGINFO option\n"));
16959 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16961 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16962 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16963 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16964 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16965 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16966 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16968 printf ("GPR %08lx GP 0x%lx\n",
16969 reginfo
.ri_gprmask
,
16970 (unsigned long) reginfo
.ri_gp_value
);
16971 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16972 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16973 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16978 Elf64_External_RegInfo
* ereg
;
16979 Elf64_Internal_RegInfo reginfo
;
16981 if (option
+ 2 > iopt_end
)
16983 printf (_("<corrupt>\n"));
16984 error (_("Truncated MIPS REGINFO option\n"));
16989 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16990 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16991 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16992 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16993 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16994 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16995 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16997 printf ("GPR %08lx GP 0x",
16998 reginfo
.ri_gprmask
);
16999 printf_vma (reginfo
.ri_gp_value
);
17002 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
17003 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17004 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17009 case ODK_EXCEPTIONS
:
17010 fputs (" EXCEPTIONS fpe_min(", stdout
);
17011 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
17012 fputs (") fpe_max(", stdout
);
17013 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
17014 fputs (")", stdout
);
17016 if (option
->info
& OEX_PAGE0
)
17017 fputs (" PAGE0", stdout
);
17018 if (option
->info
& OEX_SMM
)
17019 fputs (" SMM", stdout
);
17020 if (option
->info
& OEX_FPDBUG
)
17021 fputs (" FPDBUG", stdout
);
17022 if (option
->info
& OEX_DISMISS
)
17023 fputs (" DISMISS", stdout
);
17027 fputs (" PAD ", stdout
);
17028 if (option
->info
& OPAD_PREFIX
)
17029 fputs (" PREFIX", stdout
);
17030 if (option
->info
& OPAD_POSTFIX
)
17031 fputs (" POSTFIX", stdout
);
17032 if (option
->info
& OPAD_SYMBOL
)
17033 fputs (" SYMBOL", stdout
);
17037 fputs (" HWPATCH ", stdout
);
17038 if (option
->info
& OHW_R4KEOP
)
17039 fputs (" R4KEOP", stdout
);
17040 if (option
->info
& OHW_R8KPFETCH
)
17041 fputs (" R8KPFETCH", stdout
);
17042 if (option
->info
& OHW_R5KEOP
)
17043 fputs (" R5KEOP", stdout
);
17044 if (option
->info
& OHW_R5KCVTL
)
17045 fputs (" R5KCVTL", stdout
);
17049 fputs (" FILL ", stdout
);
17050 /* XXX Print content of info word? */
17054 fputs (" TAGS ", stdout
);
17055 /* XXX Print content of info word? */
17059 fputs (" HWAND ", 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 fputs (" HWOR ", stdout
);
17068 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
17069 fputs (" R4KEOP_CHECKED", stdout
);
17070 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
17071 fputs (" R4KEOP_CLEAN", stdout
);
17075 printf (" GP_GROUP %#06lx self-contained %#06lx",
17076 option
->info
& OGP_GROUP
,
17077 (option
->info
& OGP_SELF
) >> 16);
17081 printf (" IDENT %#06lx self-contained %#06lx",
17082 option
->info
& OGP_GROUP
,
17083 (option
->info
& OGP_SELF
) >> 16);
17087 /* This shouldn't happen. */
17088 printf (" %3d ??? %d %lx",
17089 option
->kind
, option
->section
, option
->info
);
17093 len
= sizeof (* eopt
);
17094 while (len
< option
->size
)
17096 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17098 if (ISPRINT (datum
))
17099 printf ("%c", datum
);
17101 printf ("\\%03o", datum
);
17104 fputs ("\n", stdout
);
17106 offset
+= option
->size
;
17116 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17118 Elf32_Conflict
* iconf
;
17121 if (filedata
->dynamic_symbols
== NULL
)
17123 error (_("conflict list found without a dynamic symbol table\n"));
17127 /* PR 21345 - print a slightly more helpful error message
17128 if we are sure that the cmalloc will fail. */
17129 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17131 error (_("Overlarge number of conflicts detected: %lx\n"),
17132 (long) conflictsno
);
17136 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17139 error (_("Out of memory allocating space for dynamic conflicts\n"));
17145 Elf32_External_Conflict
* econf32
;
17147 econf32
= (Elf32_External_Conflict
*)
17148 get_data (NULL
, filedata
, conflicts_offset
,
17149 sizeof (*econf32
), conflictsno
, _("conflict"));
17156 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17157 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17163 Elf64_External_Conflict
* econf64
;
17165 econf64
= (Elf64_External_Conflict
*)
17166 get_data (NULL
, filedata
, conflicts_offset
,
17167 sizeof (*econf64
), conflictsno
, _("conflict"));
17174 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17175 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17180 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17181 "\nSection '.conflict' contains %lu entries:\n",
17182 (unsigned long) conflictsno
),
17183 (unsigned long) conflictsno
);
17184 puts (_(" Num: Index Value Name"));
17186 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17188 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17190 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17191 printf (_("<corrupt symbol index>"));
17194 Elf_Internal_Sym
* psym
;
17196 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17197 print_vma (psym
->st_value
, FULL_HEX
);
17199 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17200 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17202 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17210 if (pltgot
!= 0 && local_gotno
!= 0)
17212 bfd_vma ent
, local_end
, global_end
;
17214 unsigned char * data
;
17215 unsigned char * data_end
;
17219 addr_size
= (is_32bit_elf
? 4 : 8);
17220 local_end
= pltgot
+ local_gotno
* addr_size
;
17222 /* PR binutils/17533 file: 012-111227-0.004 */
17223 if (symtabno
< gotsym
)
17225 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17226 (unsigned long) gotsym
, (unsigned long) symtabno
);
17230 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17231 /* PR 17531: file: 54c91a34. */
17232 if (global_end
< local_end
)
17234 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17238 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17239 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17240 global_end
- pltgot
, 1,
17241 _("Global Offset Table data"));
17242 /* PR 12855: Null data is handled gracefully throughout. */
17243 data_end
= data
+ (global_end
- pltgot
);
17245 printf (_("\nPrimary GOT:\n"));
17246 printf (_(" Canonical gp value: "));
17247 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17250 printf (_(" Reserved entries:\n"));
17251 printf (_(" %*s %10s %*s Purpose\n"),
17252 addr_size
* 2, _("Address"), _("Access"),
17253 addr_size
* 2, _("Initial"));
17254 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17255 printf (_(" Lazy resolver\n"));
17256 if (ent
== (bfd_vma
) -1)
17257 goto got_print_fail
;
17259 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17260 This entry will be used by some runtime loaders, to store the
17261 module pointer. Otherwise this is an ordinary local entry.
17262 PR 21344: Check for the entry being fully available before
17265 && data
+ ent
- pltgot
+ addr_size
<= data_end
17266 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17267 >> (addr_size
* 8 - 1)) != 0)
17269 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17270 printf (_(" Module pointer (GNU extension)\n"));
17271 if (ent
== (bfd_vma
) -1)
17272 goto got_print_fail
;
17276 if (data
!= NULL
&& ent
< local_end
)
17278 printf (_(" Local entries:\n"));
17279 printf (" %*s %10s %*s\n",
17280 addr_size
* 2, _("Address"), _("Access"),
17281 addr_size
* 2, _("Initial"));
17282 while (ent
< local_end
)
17284 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17286 if (ent
== (bfd_vma
) -1)
17287 goto got_print_fail
;
17292 if (data
!= NULL
&& gotsym
< symtabno
)
17296 printf (_(" Global entries:\n"));
17297 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17298 addr_size
* 2, _("Address"),
17300 addr_size
* 2, _("Initial"),
17301 addr_size
* 2, _("Sym.Val."),
17303 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17304 _("Ndx"), _("Name"));
17306 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17308 for (i
= gotsym
; i
< symtabno
; i
++)
17310 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17313 if (filedata
->dynamic_symbols
== NULL
)
17314 printf (_("<no dynamic symbols>"));
17315 else if (i
< filedata
->num_dynamic_syms
)
17317 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
17319 print_vma (psym
->st_value
, LONG_HEX
);
17320 printf (" %-7s %3s ",
17321 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17322 get_symbol_index_type (filedata
, psym
->st_shndx
));
17324 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17325 print_symbol (sym_width
,
17326 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17328 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17331 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17332 (unsigned long) i
);
17335 if (ent
== (bfd_vma
) -1)
17346 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17349 size_t offset
, rel_offset
;
17350 unsigned long count
, i
;
17351 unsigned char * data
;
17352 int addr_size
, sym_width
;
17353 Elf_Internal_Rela
* rels
;
17355 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17356 if (pltrel
== DT_RELA
)
17358 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17363 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17368 addr_size
= (is_32bit_elf
? 4 : 8);
17369 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17371 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17372 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17373 1, _("Procedure Linkage Table data"));
17377 printf ("\nPLT GOT:\n\n");
17378 printf (_(" Reserved entries:\n"));
17379 printf (_(" %*s %*s Purpose\n"),
17380 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17381 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17382 printf (_(" PLT lazy resolver\n"));
17383 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17384 printf (_(" Module pointer\n"));
17387 printf (_(" Entries:\n"));
17388 printf (" %*s %*s %*s %-7s %3s %s\n",
17389 addr_size
* 2, _("Address"),
17390 addr_size
* 2, _("Initial"),
17391 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17392 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17393 for (i
= 0; i
< count
; i
++)
17395 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17397 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17400 if (idx
>= filedata
->num_dynamic_syms
)
17401 printf (_("<corrupt symbol index: %lu>"), idx
);
17404 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
17406 print_vma (psym
->st_value
, LONG_HEX
);
17407 printf (" %-7s %3s ",
17408 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17409 get_symbol_index_type (filedata
, psym
->st_shndx
));
17410 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17411 print_symbol (sym_width
,
17412 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17414 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17429 process_nds32_specific (Filedata
* filedata
)
17431 Elf_Internal_Shdr
*sect
= NULL
;
17433 sect
= find_section (filedata
, ".nds32_e_flags");
17436 unsigned int *flag
;
17438 printf ("\nNDS32 elf flags section:\n");
17439 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17440 sect
->sh_size
, _("NDS32 elf flags section"));
17445 switch ((*flag
) & 0x3)
17448 printf ("(VEC_SIZE):\tNo entry.\n");
17451 printf ("(VEC_SIZE):\t4 bytes\n");
17454 printf ("(VEC_SIZE):\t16 bytes\n");
17457 printf ("(VEC_SIZE):\treserved\n");
17466 process_gnu_liblist (Filedata
* filedata
)
17468 Elf_Internal_Shdr
* section
;
17469 Elf_Internal_Shdr
* string_sec
;
17470 Elf32_External_Lib
* elib
;
17472 size_t strtab_size
;
17474 unsigned long num_liblist
;
17476 bfd_boolean res
= TRUE
;
17481 for (i
= 0, section
= filedata
->section_headers
;
17482 i
< filedata
->file_header
.e_shnum
;
17485 switch (section
->sh_type
)
17487 case SHT_GNU_LIBLIST
:
17488 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17491 elib
= (Elf32_External_Lib
*)
17492 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17493 _("liblist section data"));
17501 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17502 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17503 string_sec
->sh_size
,
17504 _("liblist string table"));
17506 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17513 strtab_size
= string_sec
->sh_size
;
17515 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17516 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17517 "\nLibrary list section '%s' contains %lu entries:\n",
17519 printable_section_name (filedata
, section
),
17522 puts (_(" Library Time Stamp Checksum Version Flags"));
17524 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17532 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17533 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17534 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17535 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17536 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17538 tmp
= gmtime (&atime
);
17539 snprintf (timebuf
, sizeof (timebuf
),
17540 "%04u-%02u-%02uT%02u:%02u:%02u",
17541 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17542 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17544 printf ("%3lu: ", (unsigned long) cnt
);
17546 printf ("%-20s", liblist
.l_name
< strtab_size
17547 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17549 printf ("%-20.20s", liblist
.l_name
< strtab_size
17550 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17551 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17552 liblist
.l_version
, liblist
.l_flags
);
17563 static const char *
17564 get_note_type (Filedata
* filedata
, unsigned e_type
)
17566 static char buff
[64];
17568 if (filedata
->file_header
.e_type
== ET_CORE
)
17572 return _("NT_AUXV (auxiliary vector)");
17574 return _("NT_PRSTATUS (prstatus structure)");
17576 return _("NT_FPREGSET (floating point registers)");
17578 return _("NT_PRPSINFO (prpsinfo structure)");
17579 case NT_TASKSTRUCT
:
17580 return _("NT_TASKSTRUCT (task structure)");
17582 return _("NT_PRXFPREG (user_xfpregs structure)");
17584 return _("NT_PPC_VMX (ppc Altivec registers)");
17586 return _("NT_PPC_VSX (ppc VSX registers)");
17588 return _("NT_PPC_TAR (ppc TAR register)");
17590 return _("NT_PPC_PPR (ppc PPR register)");
17592 return _("NT_PPC_DSCR (ppc DSCR register)");
17594 return _("NT_PPC_EBB (ppc EBB registers)");
17596 return _("NT_PPC_PMU (ppc PMU registers)");
17597 case NT_PPC_TM_CGPR
:
17598 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17599 case NT_PPC_TM_CFPR
:
17600 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17601 case NT_PPC_TM_CVMX
:
17602 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17603 case NT_PPC_TM_CVSX
:
17604 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17605 case NT_PPC_TM_SPR
:
17606 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17607 case NT_PPC_TM_CTAR
:
17608 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17609 case NT_PPC_TM_CPPR
:
17610 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17611 case NT_PPC_TM_CDSCR
:
17612 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17614 return _("NT_386_TLS (x86 TLS information)");
17615 case NT_386_IOPERM
:
17616 return _("NT_386_IOPERM (x86 I/O permissions)");
17617 case NT_X86_XSTATE
:
17618 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17619 case NT_S390_HIGH_GPRS
:
17620 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17621 case NT_S390_TIMER
:
17622 return _("NT_S390_TIMER (s390 timer register)");
17623 case NT_S390_TODCMP
:
17624 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17625 case NT_S390_TODPREG
:
17626 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17628 return _("NT_S390_CTRS (s390 control registers)");
17629 case NT_S390_PREFIX
:
17630 return _("NT_S390_PREFIX (s390 prefix register)");
17631 case NT_S390_LAST_BREAK
:
17632 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17633 case NT_S390_SYSTEM_CALL
:
17634 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17636 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17637 case NT_S390_VXRS_LOW
:
17638 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17639 case NT_S390_VXRS_HIGH
:
17640 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17641 case NT_S390_GS_CB
:
17642 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17643 case NT_S390_GS_BC
:
17644 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17646 return _("NT_ARM_VFP (arm VFP registers)");
17648 return _("NT_ARM_TLS (AArch TLS registers)");
17649 case NT_ARM_HW_BREAK
:
17650 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17651 case NT_ARM_HW_WATCH
:
17652 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17654 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17656 return _("NT_PSTATUS (pstatus structure)");
17658 return _("NT_FPREGS (floating point registers)");
17660 return _("NT_PSINFO (psinfo structure)");
17662 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17664 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17665 case NT_WIN32PSTATUS
:
17666 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17668 return _("NT_SIGINFO (siginfo_t data)");
17670 return _("NT_FILE (mapped files)");
17678 return _("NT_VERSION (version)");
17680 return _("NT_ARCH (architecture)");
17681 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17683 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17689 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17694 print_core_note (Elf_Internal_Note
*pnote
)
17696 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17697 bfd_vma count
, page_size
;
17698 unsigned char *descdata
, *filenames
, *descend
;
17700 if (pnote
->type
!= NT_FILE
)
17710 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17711 /* Still "successful". */
17716 if (pnote
->descsz
< 2 * addr_size
)
17718 error (_(" Malformed note - too short for header\n"));
17722 descdata
= (unsigned char *) pnote
->descdata
;
17723 descend
= descdata
+ pnote
->descsz
;
17725 if (descdata
[pnote
->descsz
- 1] != '\0')
17727 error (_(" Malformed note - does not end with \\0\n"));
17731 count
= byte_get (descdata
, addr_size
);
17732 descdata
+= addr_size
;
17734 page_size
= byte_get (descdata
, addr_size
);
17735 descdata
+= addr_size
;
17737 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17738 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17740 error (_(" Malformed note - too short for supplied file count\n"));
17744 printf (_(" Page size: "));
17745 print_vma (page_size
, DEC
);
17748 printf (_(" %*s%*s%*s\n"),
17749 (int) (2 + 2 * addr_size
), _("Start"),
17750 (int) (4 + 2 * addr_size
), _("End"),
17751 (int) (4 + 2 * addr_size
), _("Page Offset"));
17752 filenames
= descdata
+ count
* 3 * addr_size
;
17753 while (count
-- > 0)
17755 bfd_vma start
, end
, file_ofs
;
17757 if (filenames
== descend
)
17759 error (_(" Malformed note - filenames end too early\n"));
17763 start
= byte_get (descdata
, addr_size
);
17764 descdata
+= addr_size
;
17765 end
= byte_get (descdata
, addr_size
);
17766 descdata
+= addr_size
;
17767 file_ofs
= byte_get (descdata
, addr_size
);
17768 descdata
+= addr_size
;
17771 print_vma (start
, FULL_HEX
);
17773 print_vma (end
, FULL_HEX
);
17775 print_vma (file_ofs
, FULL_HEX
);
17776 printf ("\n %s\n", filenames
);
17778 filenames
+= 1 + strlen ((char *) filenames
);
17784 static const char *
17785 get_gnu_elf_note_type (unsigned e_type
)
17787 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17790 case NT_GNU_ABI_TAG
:
17791 return _("NT_GNU_ABI_TAG (ABI version tag)");
17793 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17794 case NT_GNU_BUILD_ID
:
17795 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17796 case NT_GNU_GOLD_VERSION
:
17797 return _("NT_GNU_GOLD_VERSION (gold version)");
17798 case NT_GNU_PROPERTY_TYPE_0
:
17799 return _("NT_GNU_PROPERTY_TYPE_0");
17800 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17801 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17802 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17803 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17806 static char buff
[64];
17808 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17815 decode_x86_compat_isa (unsigned int bitmask
)
17819 unsigned int bit
= bitmask
& (- bitmask
);
17824 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17827 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17830 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17833 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17836 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17839 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17842 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17845 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17848 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17851 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17854 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17857 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17858 printf ("AVX512F");
17860 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17861 printf ("AVX512CD");
17863 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17864 printf ("AVX512ER");
17866 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17867 printf ("AVX512PF");
17869 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17870 printf ("AVX512VL");
17872 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17873 printf ("AVX512DQ");
17875 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17876 printf ("AVX512BW");
17879 printf (_("<unknown: %x>"), bit
);
17888 decode_x86_isa (unsigned int bitmask
)
17892 printf (_("<None>"));
17898 unsigned int bit
= bitmask
& (- bitmask
);
17903 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17906 case GNU_PROPERTY_X86_ISA_1_SSE
:
17909 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17912 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17915 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17918 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17921 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17924 case GNU_PROPERTY_X86_ISA_1_AVX
:
17927 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17930 case GNU_PROPERTY_X86_ISA_1_FMA
:
17933 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17934 printf ("AVX512F");
17936 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17937 printf ("AVX512CD");
17939 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17940 printf ("AVX512ER");
17942 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17943 printf ("AVX512PF");
17945 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17946 printf ("AVX512VL");
17948 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17949 printf ("AVX512DQ");
17951 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17952 printf ("AVX512BW");
17954 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17955 printf ("AVX512_4FMAPS");
17957 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17958 printf ("AVX512_4VNNIW");
17960 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17961 printf ("AVX512_BITALG");
17963 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17964 printf ("AVX512_IFMA");
17966 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17967 printf ("AVX512_VBMI");
17969 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17970 printf ("AVX512_VBMI2");
17972 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17973 printf ("AVX512_VNNI");
17975 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17976 printf ("AVX512_BF16");
17979 printf (_("<unknown: %x>"), bit
);
17988 decode_x86_feature_1 (unsigned int bitmask
)
17992 printf (_("<None>"));
17998 unsigned int bit
= bitmask
& (- bitmask
);
18003 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18006 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18010 printf (_("<unknown: %x>"), bit
);
18019 decode_x86_feature_2 (unsigned int bitmask
)
18023 printf (_("<None>"));
18029 unsigned int bit
= bitmask
& (- bitmask
);
18034 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18037 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18040 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18043 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18046 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18049 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18052 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18055 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18058 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18059 printf ("XSAVEOPT");
18061 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18065 printf (_("<unknown: %x>"), bit
);
18074 decode_aarch64_feature_1_and (unsigned int bitmask
)
18078 unsigned int bit
= bitmask
& (- bitmask
);
18083 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18087 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18092 printf (_("<unknown: %x>"), bit
);
18101 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18103 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18104 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18105 unsigned int size
= is_32bit_elf
? 4 : 8;
18107 printf (_(" Properties: "));
18109 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18111 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18115 while (ptr
< ptr_end
)
18119 unsigned int datasz
;
18121 if ((size_t) (ptr_end
- ptr
) < 8)
18123 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18127 type
= byte_get (ptr
, 4);
18128 datasz
= byte_get (ptr
+ 4, 4);
18132 if (datasz
> (size_t) (ptr_end
- ptr
))
18134 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18139 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18141 if (filedata
->file_header
.e_machine
== EM_X86_64
18142 || filedata
->file_header
.e_machine
== EM_IAMCU
18143 || filedata
->file_header
.e_machine
== EM_386
)
18145 unsigned int bitmask
;
18148 bitmask
= byte_get (ptr
, 4);
18154 case GNU_PROPERTY_X86_ISA_1_USED
:
18156 printf (_("x86 ISA used: <corrupt length: %#x> "),
18160 printf ("x86 ISA used: ");
18161 decode_x86_isa (bitmask
);
18165 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18167 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18171 printf ("x86 ISA needed: ");
18172 decode_x86_isa (bitmask
);
18176 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18178 printf (_("x86 feature: <corrupt length: %#x> "),
18182 printf ("x86 feature: ");
18183 decode_x86_feature_1 (bitmask
);
18187 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18189 printf (_("x86 feature used: <corrupt length: %#x> "),
18193 printf ("x86 feature used: ");
18194 decode_x86_feature_2 (bitmask
);
18198 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18200 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18203 printf ("x86 feature needed: ");
18204 decode_x86_feature_2 (bitmask
);
18208 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18210 printf (_("x86 ISA used: <corrupt length: %#x> "),
18214 printf ("x86 ISA used: ");
18215 decode_x86_compat_isa (bitmask
);
18219 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18221 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18225 printf ("x86 ISA needed: ");
18226 decode_x86_compat_isa (bitmask
);
18234 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18236 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18238 printf ("AArch64 feature: ");
18240 printf (_("<corrupt length: %#x> "), datasz
);
18242 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18251 case GNU_PROPERTY_STACK_SIZE
:
18252 printf (_("stack size: "));
18253 if (datasz
!= size
)
18254 printf (_("<corrupt length: %#x> "), datasz
);
18256 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18259 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18260 printf ("no copy on protected ");
18262 printf (_("<corrupt length: %#x> "), datasz
);
18270 if (type
< GNU_PROPERTY_LOPROC
)
18271 printf (_("<unknown type %#x data: "), type
);
18272 else if (type
< GNU_PROPERTY_LOUSER
)
18273 printf (_("<procesor-specific type %#x data: "), type
);
18275 printf (_("<application-specific type %#x data: "), type
);
18276 for (j
= 0; j
< datasz
; ++j
)
18277 printf ("%02x ", ptr
[j
] & 0xff);
18281 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18282 if (ptr
== ptr_end
)
18295 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18297 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18298 switch (pnote
->type
)
18300 case NT_GNU_BUILD_ID
:
18304 printf (_(" Build ID: "));
18305 for (i
= 0; i
< pnote
->descsz
; ++i
)
18306 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18311 case NT_GNU_ABI_TAG
:
18313 unsigned long os
, major
, minor
, subminor
;
18314 const char *osname
;
18316 /* PR 17531: file: 030-599401-0.004. */
18317 if (pnote
->descsz
< 16)
18319 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18323 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18324 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18325 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18326 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18330 case GNU_ABI_TAG_LINUX
:
18333 case GNU_ABI_TAG_HURD
:
18336 case GNU_ABI_TAG_SOLARIS
:
18337 osname
= "Solaris";
18339 case GNU_ABI_TAG_FREEBSD
:
18340 osname
= "FreeBSD";
18342 case GNU_ABI_TAG_NETBSD
:
18345 case GNU_ABI_TAG_SYLLABLE
:
18346 osname
= "Syllable";
18348 case GNU_ABI_TAG_NACL
:
18352 osname
= "Unknown";
18356 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18357 major
, minor
, subminor
);
18361 case NT_GNU_GOLD_VERSION
:
18365 printf (_(" Version: "));
18366 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18367 printf ("%c", pnote
->descdata
[i
]);
18374 unsigned long num_entries
, mask
;
18376 /* Hardware capabilities information. Word 0 is the number of entries.
18377 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18378 is a series of entries, where each entry is a single byte followed
18379 by a nul terminated string. The byte gives the bit number to test
18380 if enabled in the bitmask. */
18381 printf (_(" Hardware Capabilities: "));
18382 if (pnote
->descsz
< 8)
18384 error (_("<corrupt GNU_HWCAP>\n"));
18387 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18388 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18389 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18390 /* FIXME: Add code to display the entries... */
18394 case NT_GNU_PROPERTY_TYPE_0
:
18395 print_gnu_property_note (filedata
, pnote
);
18399 /* Handle unrecognised types. An error message should have already been
18400 created by get_gnu_elf_note_type(), so all that we need to do is to
18401 display the data. */
18405 printf (_(" Description data: "));
18406 for (i
= 0; i
< pnote
->descsz
; ++i
)
18407 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18416 static const char *
18417 get_v850_elf_note_type (enum v850_notes n_type
)
18419 static char buff
[64];
18423 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18424 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18425 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18426 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18427 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18428 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18430 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18436 print_v850_note (Elf_Internal_Note
* pnote
)
18440 if (pnote
->descsz
!= 4)
18443 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18447 printf (_("not set\n"));
18451 switch (pnote
->type
)
18453 case V850_NOTE_ALIGNMENT
:
18456 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18457 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18461 case V850_NOTE_DATA_SIZE
:
18464 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18465 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18469 case V850_NOTE_FPU_INFO
:
18472 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18473 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18477 case V850_NOTE_MMU_INFO
:
18478 case V850_NOTE_CACHE_INFO
:
18479 case V850_NOTE_SIMD_INFO
:
18480 if (val
== EF_RH850_SIMD
)
18482 printf (_("yes\n"));
18488 /* An 'unknown note type' message will already have been displayed. */
18492 printf (_("unknown value: %x\n"), val
);
18497 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18499 unsigned int version
;
18501 switch (pnote
->type
)
18503 case NT_NETBSD_IDENT
:
18504 if (pnote
->descsz
< 1)
18506 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18507 if ((version
/ 10000) % 100)
18508 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18509 version
, version
/ 100000000, (version
/ 1000000) % 100,
18510 (version
/ 10000) % 100 > 26 ? "Z" : "",
18511 'A' + (version
/ 10000) % 26);
18513 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18514 version
, version
/ 100000000, (version
/ 1000000) % 100,
18515 (version
/ 100) % 100);
18518 case NT_NETBSD_MARCH
:
18519 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18523 #ifdef NT_NETBSD_PAX
18524 case NT_NETBSD_PAX
:
18525 if (pnote
->descsz
< 1)
18527 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18528 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18529 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18530 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18531 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18532 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18533 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18534 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18539 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18540 pnote
->descsz
, pnote
->type
);
18544 static const char *
18545 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18549 case NT_FREEBSD_THRMISC
:
18550 return _("NT_THRMISC (thrmisc structure)");
18551 case NT_FREEBSD_PROCSTAT_PROC
:
18552 return _("NT_PROCSTAT_PROC (proc data)");
18553 case NT_FREEBSD_PROCSTAT_FILES
:
18554 return _("NT_PROCSTAT_FILES (files data)");
18555 case NT_FREEBSD_PROCSTAT_VMMAP
:
18556 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18557 case NT_FREEBSD_PROCSTAT_GROUPS
:
18558 return _("NT_PROCSTAT_GROUPS (groups data)");
18559 case NT_FREEBSD_PROCSTAT_UMASK
:
18560 return _("NT_PROCSTAT_UMASK (umask data)");
18561 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18562 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18563 case NT_FREEBSD_PROCSTAT_OSREL
:
18564 return _("NT_PROCSTAT_OSREL (osreldate data)");
18565 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18566 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18567 case NT_FREEBSD_PROCSTAT_AUXV
:
18568 return _("NT_PROCSTAT_AUXV (auxv data)");
18569 case NT_FREEBSD_PTLWPINFO
:
18570 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18572 return get_note_type (filedata
, e_type
);
18575 static const char *
18576 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18578 static char buff
[64];
18582 case NT_NETBSDCORE_PROCINFO
:
18583 /* NetBSD core "procinfo" structure. */
18584 return _("NetBSD procinfo structure");
18586 #ifdef NT_NETBSDCORE_AUXV
18587 case NT_NETBSDCORE_AUXV
:
18588 return _("NetBSD ELF auxiliary vector data");
18591 #ifdef NT_NETBSDCORE_LWPSTATUS
18592 case NT_NETBSDCORE_LWPSTATUS
:
18593 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18597 /* As of Jan 2020 there are no other machine-independent notes
18598 defined for NetBSD core files. If the note type is less
18599 than the start of the machine-dependent note types, we don't
18602 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18604 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18610 switch (filedata
->file_header
.e_machine
)
18612 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18613 and PT_GETFPREGS == mach+2. */
18618 case EM_SPARC32PLUS
:
18622 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18623 return _("PT_GETREGS (reg structure)");
18624 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18625 return _("PT_GETFPREGS (fpreg structure)");
18631 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18632 There's also old PT___GETREGS40 == mach + 1 for old reg
18633 structure which lacks GBR. */
18637 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18638 return _("PT___GETREGS40 (old reg structure)");
18639 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18640 return _("PT_GETREGS (reg structure)");
18641 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18642 return _("PT_GETFPREGS (fpreg structure)");
18648 /* On all other arch's, PT_GETREGS == mach+1 and
18649 PT_GETFPREGS == mach+3. */
18653 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18654 return _("PT_GETREGS (reg structure)");
18655 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18656 return _("PT_GETFPREGS (fpreg structure)");
18662 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18663 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18667 static const char *
18668 get_stapsdt_note_type (unsigned e_type
)
18670 static char buff
[64];
18675 return _("NT_STAPSDT (SystemTap probe descriptors)");
18681 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18686 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18688 size_t len
, maxlen
;
18689 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18690 char *data
= pnote
->descdata
;
18691 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18692 bfd_vma pc
, base_addr
, semaphore
;
18693 char *provider
, *probe
, *arg_fmt
;
18695 if (pnote
->descsz
< (addr_size
* 3))
18696 goto stapdt_note_too_small
;
18698 pc
= byte_get ((unsigned char *) data
, addr_size
);
18701 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18704 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18707 if (data
>= data_end
)
18708 goto stapdt_note_too_small
;
18709 maxlen
= data_end
- data
;
18710 len
= strnlen (data
, maxlen
);
18717 goto stapdt_note_too_small
;
18719 if (data
>= data_end
)
18720 goto stapdt_note_too_small
;
18721 maxlen
= data_end
- data
;
18722 len
= strnlen (data
, maxlen
);
18729 goto stapdt_note_too_small
;
18731 if (data
>= data_end
)
18732 goto stapdt_note_too_small
;
18733 maxlen
= data_end
- data
;
18734 len
= strnlen (data
, maxlen
);
18741 goto stapdt_note_too_small
;
18743 printf (_(" Provider: %s\n"), provider
);
18744 printf (_(" Name: %s\n"), probe
);
18745 printf (_(" Location: "));
18746 print_vma (pc
, FULL_HEX
);
18747 printf (_(", Base: "));
18748 print_vma (base_addr
, FULL_HEX
);
18749 printf (_(", Semaphore: "));
18750 print_vma (semaphore
, FULL_HEX
);
18752 printf (_(" Arguments: %s\n"), arg_fmt
);
18754 return data
== data_end
;
18756 stapdt_note_too_small
:
18757 printf (_(" <corrupt - note is too small>\n"));
18758 error (_("corrupt stapdt note - the data size is too small\n"));
18762 static const char *
18763 get_ia64_vms_note_type (unsigned e_type
)
18765 static char buff
[64];
18770 return _("NT_VMS_MHD (module header)");
18772 return _("NT_VMS_LNM (language name)");
18774 return _("NT_VMS_SRC (source files)");
18776 return "NT_VMS_TITLE";
18778 return _("NT_VMS_EIDC (consistency check)");
18779 case NT_VMS_FPMODE
:
18780 return _("NT_VMS_FPMODE (FP mode)");
18781 case NT_VMS_LINKTIME
:
18782 return "NT_VMS_LINKTIME";
18783 case NT_VMS_IMGNAM
:
18784 return _("NT_VMS_IMGNAM (image name)");
18786 return _("NT_VMS_IMGID (image id)");
18787 case NT_VMS_LINKID
:
18788 return _("NT_VMS_LINKID (link id)");
18789 case NT_VMS_IMGBID
:
18790 return _("NT_VMS_IMGBID (build id)");
18791 case NT_VMS_GSTNAM
:
18792 return _("NT_VMS_GSTNAM (sym table name)");
18793 case NT_VMS_ORIG_DYN
:
18794 return "NT_VMS_ORIG_DYN";
18795 case NT_VMS_PATCHTIME
:
18796 return "NT_VMS_PATCHTIME";
18798 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18804 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18806 int maxlen
= pnote
->descsz
;
18808 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18809 goto desc_size_fail
;
18811 switch (pnote
->type
)
18815 goto desc_size_fail
;
18817 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18819 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18820 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18821 if (l
+ 34 < maxlen
)
18823 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18824 if (l
+ 35 < maxlen
)
18825 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18827 printf (_(" Module version : <missing>\n"));
18831 printf (_(" Module name : <missing>\n"));
18832 printf (_(" Module version : <missing>\n"));
18837 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18841 case NT_VMS_FPMODE
:
18842 printf (_(" Floating Point mode: "));
18844 goto desc_size_fail
;
18845 /* FIXME: Generate an error if descsz > 8 ? */
18847 printf ("0x%016" BFD_VMA_FMT
"x\n",
18848 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18851 case NT_VMS_LINKTIME
:
18852 printf (_(" Link time: "));
18854 goto desc_size_fail
;
18855 /* FIXME: Generate an error if descsz > 8 ? */
18858 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18862 case NT_VMS_PATCHTIME
:
18863 printf (_(" Patch time: "));
18865 goto desc_size_fail
;
18866 /* FIXME: Generate an error if descsz > 8 ? */
18869 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18873 case NT_VMS_ORIG_DYN
:
18875 goto desc_size_fail
;
18877 printf (_(" Major id: %u, minor id: %u\n"),
18878 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18879 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18880 printf (_(" Last modified : "));
18882 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18883 printf (_("\n Link flags : "));
18884 printf ("0x%016" BFD_VMA_FMT
"x\n",
18885 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18886 printf (_(" Header flags: 0x%08x\n"),
18887 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18888 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18892 case NT_VMS_IMGNAM
:
18893 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18896 case NT_VMS_GSTNAM
:
18897 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18901 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18904 case NT_VMS_LINKID
:
18905 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18915 printf (_(" <corrupt - data size is too small>\n"));
18916 error (_("corrupt IA64 note: data size is too small\n"));
18920 struct build_attr_cache
{
18921 Filedata
*filedata
;
18923 unsigned long strtablen
;
18924 Elf_Internal_Sym
*symtab
;
18925 unsigned long nsyms
;
18928 /* Find the symbol associated with a build attribute that is attached
18929 to address OFFSET. If PNAME is non-NULL then store the name of
18930 the symbol (if found) in the provided pointer, Returns NULL if a
18931 symbol could not be found. */
18933 static Elf_Internal_Sym
*
18934 get_symbol_for_build_attribute (Filedata
* filedata
,
18935 unsigned long offset
,
18936 bfd_boolean is_open_attr
,
18937 const char ** pname
)
18939 Elf_Internal_Sym
*saved_sym
= NULL
;
18940 Elf_Internal_Sym
*sym
;
18942 if (filedata
->section_headers
!= NULL
18943 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18945 Elf_Internal_Shdr
* symsec
;
18947 free (ba_cache
.strtab
);
18948 ba_cache
.strtab
= NULL
;
18949 free (ba_cache
.symtab
);
18950 ba_cache
.symtab
= NULL
;
18952 /* Load the symbol and string sections. */
18953 for (symsec
= filedata
->section_headers
;
18954 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18957 if (symsec
->sh_type
== SHT_SYMTAB
18958 && get_symtab (filedata
, symsec
,
18959 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18960 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18963 ba_cache
.filedata
= filedata
;
18966 if (ba_cache
.symtab
== NULL
)
18969 /* Find a symbol whose value matches offset. */
18970 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18971 if (sym
->st_value
== offset
)
18973 if (sym
->st_name
>= ba_cache
.strtablen
)
18974 /* Huh ? This should not happen. */
18977 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18980 /* The AArch64 and ARM architectures define mapping symbols
18981 (eg $d, $x, $t) which we want to ignore. */
18982 if (ba_cache
.strtab
[sym
->st_name
] == '$'
18983 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
18984 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
18989 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18990 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18991 FUNC symbols entirely. */
18992 switch (ELF_ST_TYPE (sym
->st_info
))
18999 /* If the symbol has a size associated
19000 with it then we can stop searching. */
19001 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19006 /* Ignore function symbols. */
19013 switch (ELF_ST_BIND (sym
->st_info
))
19016 if (saved_sym
== NULL
19017 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19022 if (saved_sym
== NULL
)
19032 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19040 if (saved_sym
&& pname
)
19041 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19046 /* Returns true iff addr1 and addr2 are in the same section. */
19049 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19051 Elf_Internal_Shdr
* a1
;
19052 Elf_Internal_Shdr
* a2
;
19054 a1
= find_section_by_address (filedata
, addr1
);
19055 a2
= find_section_by_address (filedata
, addr2
);
19057 return a1
== a2
&& a1
!= NULL
;
19061 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19062 Filedata
* filedata
)
19064 static unsigned long global_offset
= 0;
19065 static unsigned long global_end
= 0;
19066 static unsigned long func_offset
= 0;
19067 static unsigned long func_end
= 0;
19069 Elf_Internal_Sym
* sym
;
19071 unsigned long start
;
19073 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19075 switch (pnote
->descsz
)
19078 /* A zero-length description means that the range of
19079 the previous note of the same type should be used. */
19082 if (global_end
> global_offset
)
19083 printf (_(" Applies to region from %#lx to %#lx\n"),
19084 global_offset
, global_end
);
19086 printf (_(" Applies to region from %#lx\n"), global_offset
);
19090 if (func_end
> func_offset
)
19091 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19093 printf (_(" Applies to region from %#lx\n"), func_offset
);
19098 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19105 /* FIXME: We should check that version 3+ notes are being used here... */
19106 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19107 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19111 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19117 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19118 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19122 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19123 printf (_(" <invalid descsz>"));
19128 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19129 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19130 in order to avoid them being confused with the start address of the
19131 first function in the file... */
19132 if (sym
== NULL
&& is_open_attr
)
19133 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19136 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19137 end
= start
+ sym
->st_size
;
19141 /* FIXME: Need to properly allow for section alignment.
19142 16 is just the alignment used on x86_64. */
19144 && start
> BFD_ALIGN (global_end
, 16)
19145 /* Build notes are not guaranteed to be organised in order of
19146 increasing address, but we should find the all of the notes
19147 for one section in the same place. */
19148 && same_section (filedata
, start
, global_end
))
19149 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19150 global_end
+ 1, start
- 1);
19152 printf (_(" Applies to region from %#lx"), start
);
19153 global_offset
= start
;
19157 printf (_(" to %#lx"), end
);
19163 printf (_(" Applies to region from %#lx"), start
);
19164 func_offset
= start
;
19168 printf (_(" to %#lx"), end
);
19174 printf (_(" (%s)"), name
);
19181 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19183 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19184 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19185 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19187 char name_attribute
;
19188 const char * expected_types
;
19189 const char * name
= pnote
->namedata
;
19193 if (name
== NULL
|| pnote
->namesz
< 2)
19195 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19196 print_symbol (-20, _(" <corrupt name>"));
19205 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19206 if (name
[0] == 'G' && name
[1] == 'A')
19208 if (pnote
->namesz
< 4)
19210 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19211 print_symbol (-20, _(" <corrupt name>"));
19220 switch ((name_type
= * name
))
19222 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19223 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19224 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19225 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19226 printf ("%c", * name
);
19230 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19231 print_symbol (-20, _("<unknown name type>"));
19238 switch ((name_attribute
= * name
))
19240 case GNU_BUILD_ATTRIBUTE_VERSION
:
19241 text
= _("<version>");
19242 expected_types
= string_expected
;
19245 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19246 text
= _("<stack prot>");
19247 expected_types
= "!+*";
19250 case GNU_BUILD_ATTRIBUTE_RELRO
:
19251 text
= _("<relro>");
19252 expected_types
= bool_expected
;
19255 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19256 text
= _("<stack size>");
19257 expected_types
= number_expected
;
19260 case GNU_BUILD_ATTRIBUTE_TOOL
:
19261 text
= _("<tool>");
19262 expected_types
= string_expected
;
19265 case GNU_BUILD_ATTRIBUTE_ABI
:
19267 expected_types
= "$*";
19270 case GNU_BUILD_ATTRIBUTE_PIC
:
19272 expected_types
= number_expected
;
19275 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19276 text
= _("<short enum>");
19277 expected_types
= bool_expected
;
19281 if (ISPRINT (* name
))
19283 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19285 if (len
> left
&& ! do_wide
)
19287 printf ("%.*s:", len
, name
);
19293 static char tmpbuf
[128];
19295 error (_("unrecognised byte in name field: %d\n"), * name
);
19296 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19300 expected_types
= "*$!+";
19305 left
-= printf ("%s", text
);
19307 if (strchr (expected_types
, name_type
) == NULL
)
19308 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19310 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19312 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19313 (unsigned long) pnote
->namesz
,
19314 (long) (name
- pnote
->namedata
));
19318 if (left
< 1 && ! do_wide
)
19323 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19325 unsigned int bytes
;
19326 unsigned long long val
= 0;
19327 unsigned int shift
= 0;
19328 char * decoded
= NULL
;
19330 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19332 /* The -1 is because the name field is always 0 terminated, and we
19333 want to be able to ensure that the shift in the while loop below
19334 will not overflow. */
19337 if (bytes
> sizeof (val
))
19339 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19341 bytes
= sizeof (val
);
19343 /* We do not bother to warn if bytes == 0 as this can
19344 happen with some early versions of the gcc plugin. */
19348 unsigned long byte
= (* name
++) & 0xff;
19350 val
|= byte
<< shift
;
19354 switch (name_attribute
)
19356 case GNU_BUILD_ATTRIBUTE_PIC
:
19359 case 0: decoded
= "static"; break;
19360 case 1: decoded
= "pic"; break;
19361 case 2: decoded
= "PIC"; break;
19362 case 3: decoded
= "pie"; break;
19363 case 4: decoded
= "PIE"; break;
19367 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19370 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19371 case 0: decoded
= "off"; break;
19372 case 1: decoded
= "on"; break;
19373 case 2: decoded
= "all"; break;
19374 case 3: decoded
= "strong"; break;
19375 case 4: decoded
= "explicit"; break;
19383 if (decoded
!= NULL
)
19385 print_symbol (-left
, decoded
);
19396 left
-= printf ("0x%llx", val
);
19398 left
-= printf ("0x%-.*llx", left
, val
);
19402 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19403 left
-= print_symbol (- left
, name
);
19405 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19406 left
-= print_symbol (- left
, "true");
19408 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19409 left
-= print_symbol (- left
, "false");
19413 if (do_wide
&& left
> 0)
19414 printf ("%-*s", left
, " ");
19419 /* Note that by the ELF standard, the name field is already null byte
19420 terminated, and namesz includes the terminating null byte.
19421 I.E. the value of namesz for the name "FSF" is 4.
19423 If the value of namesz is zero, there is no name present. */
19426 process_note (Elf_Internal_Note
* pnote
,
19427 Filedata
* filedata
)
19429 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19432 if (pnote
->namesz
== 0)
19433 /* If there is no note name, then use the default set of
19434 note type strings. */
19435 nt
= get_note_type (filedata
, pnote
->type
);
19437 else if (const_strneq (pnote
->namedata
, "GNU"))
19438 /* GNU-specific object file notes. */
19439 nt
= get_gnu_elf_note_type (pnote
->type
);
19441 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19442 /* FreeBSD-specific core file notes. */
19443 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19445 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19446 /* NetBSD-specific core file notes. */
19447 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19449 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19450 /* NetBSD-specific core file notes. */
19451 return process_netbsd_elf_note (pnote
);
19453 else if (const_strneq (pnote
->namedata
, "PaX"))
19454 /* NetBSD-specific core file notes. */
19455 return process_netbsd_elf_note (pnote
);
19457 else if (strneq (pnote
->namedata
, "SPU/", 4))
19459 /* SPU-specific core file notes. */
19460 nt
= pnote
->namedata
+ 4;
19464 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19465 /* VMS/ia64-specific file notes. */
19466 nt
= get_ia64_vms_note_type (pnote
->type
);
19468 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19469 nt
= get_stapsdt_note_type (pnote
->type
);
19472 /* Don't recognize this note name; just use the default set of
19473 note type strings. */
19474 nt
= get_note_type (filedata
, pnote
->type
);
19478 if (((const_strneq (pnote
->namedata
, "GA")
19479 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19480 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19481 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19482 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19483 print_gnu_build_attribute_name (pnote
);
19485 print_symbol (-20, name
);
19488 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19490 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19492 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19493 return print_ia64_vms_note (pnote
);
19494 else if (const_strneq (pnote
->namedata
, "GNU"))
19495 return print_gnu_note (filedata
, pnote
);
19496 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19497 return print_stapsdt_note (pnote
);
19498 else if (const_strneq (pnote
->namedata
, "CORE"))
19499 return print_core_note (pnote
);
19500 else if (((const_strneq (pnote
->namedata
, "GA")
19501 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19502 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19503 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19504 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19505 return print_gnu_build_attribute_description (pnote
, filedata
);
19511 printf (_(" description data: "));
19512 for (i
= 0; i
< pnote
->descsz
; i
++)
19513 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19525 process_notes_at (Filedata
* filedata
,
19526 Elf_Internal_Shdr
* section
,
19531 Elf_External_Note
* pnotes
;
19532 Elf_External_Note
* external
;
19534 bfd_boolean res
= TRUE
;
19541 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19544 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19552 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19555 if (pnotes
== NULL
)
19561 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19563 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19564 (unsigned long) offset
, (unsigned long) length
);
19566 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19567 specifies that notes should be aligned to 4 bytes in 32-bit
19568 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19569 we also support 4 byte alignment in 64-bit objects. If section
19570 alignment is less than 4, we treate alignment as 4 bytes. */
19573 else if (align
!= 4 && align
!= 8)
19575 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19581 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19583 end
= (char *) pnotes
+ length
;
19584 while ((char *) external
< end
)
19586 Elf_Internal_Note inote
;
19589 char * temp
= NULL
;
19590 size_t data_remaining
= end
- (char *) external
;
19592 if (!is_ia64_vms (filedata
))
19594 /* PR binutils/15191
19595 Make sure that there is enough data to read. */
19596 min_notesz
= offsetof (Elf_External_Note
, name
);
19597 if (data_remaining
< min_notesz
)
19599 warn (ngettext ("Corrupt note: only %ld byte remains, "
19600 "not enough for a full note\n",
19601 "Corrupt note: only %ld bytes remain, "
19602 "not enough for a full note\n",
19604 (long) data_remaining
);
19607 data_remaining
-= min_notesz
;
19609 inote
.type
= BYTE_GET (external
->type
);
19610 inote
.namesz
= BYTE_GET (external
->namesz
);
19611 inote
.namedata
= external
->name
;
19612 inote
.descsz
= BYTE_GET (external
->descsz
);
19613 inote
.descdata
= ((char *) external
19614 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19615 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19616 next
= ((char *) external
19617 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19621 Elf64_External_VMS_Note
*vms_external
;
19623 /* PR binutils/15191
19624 Make sure that there is enough data to read. */
19625 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19626 if (data_remaining
< min_notesz
)
19628 warn (ngettext ("Corrupt note: only %ld byte remains, "
19629 "not enough for a full note\n",
19630 "Corrupt note: only %ld bytes remain, "
19631 "not enough for a full note\n",
19633 (long) data_remaining
);
19636 data_remaining
-= min_notesz
;
19638 vms_external
= (Elf64_External_VMS_Note
*) external
;
19639 inote
.type
= BYTE_GET (vms_external
->type
);
19640 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19641 inote
.namedata
= vms_external
->name
;
19642 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19643 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19644 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19645 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19648 /* PR 17531: file: 3443835e. */
19649 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19650 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19651 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19652 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19653 || ((size_t) (next
- inote
.descdata
)
19654 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19656 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19657 (unsigned long) ((char *) external
- (char *) pnotes
));
19658 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19659 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19663 external
= (Elf_External_Note
*) next
;
19665 /* Verify that name is null terminated. It appears that at least
19666 one version of Linux (RedHat 6.0) generates corefiles that don't
19667 comply with the ELF spec by failing to include the null byte in
19669 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19671 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19673 temp
= (char *) malloc (inote
.namesz
+ 1);
19676 error (_("Out of memory allocating space for inote name\n"));
19681 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19682 inote
.namedata
= temp
;
19684 inote
.namedata
[inote
.namesz
] = 0;
19687 if (! process_note (& inote
, filedata
))
19703 process_corefile_note_segments (Filedata
* filedata
)
19705 Elf_Internal_Phdr
* segment
;
19707 bfd_boolean res
= TRUE
;
19709 if (! get_program_headers (filedata
))
19712 for (i
= 0, segment
= filedata
->program_headers
;
19713 i
< filedata
->file_header
.e_phnum
;
19716 if (segment
->p_type
== PT_NOTE
)
19717 if (! process_notes_at (filedata
, NULL
,
19718 (bfd_vma
) segment
->p_offset
,
19719 (bfd_vma
) segment
->p_filesz
,
19720 (bfd_vma
) segment
->p_align
))
19728 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19730 Elf_External_Note
* pnotes
;
19731 Elf_External_Note
* external
;
19733 bfd_boolean res
= TRUE
;
19738 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19740 if (pnotes
== NULL
)
19744 end
= (char*) pnotes
+ length
;
19746 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19747 (unsigned long) offset
, (unsigned long) length
);
19749 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19751 Elf_External_Note
* next
;
19752 Elf_Internal_Note inote
;
19754 inote
.type
= BYTE_GET (external
->type
);
19755 inote
.namesz
= BYTE_GET (external
->namesz
);
19756 inote
.namedata
= external
->name
;
19757 inote
.descsz
= BYTE_GET (external
->descsz
);
19758 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19759 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19761 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19763 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19764 inote
.descdata
= inote
.namedata
;
19768 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19770 if ( ((char *) next
> end
)
19771 || ((char *) next
< (char *) pnotes
))
19773 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19774 (unsigned long) ((char *) external
- (char *) pnotes
));
19775 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19776 inote
.type
, inote
.namesz
, inote
.descsz
);
19782 /* Prevent out-of-bounds indexing. */
19783 if ( inote
.namedata
+ inote
.namesz
> end
19784 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19786 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19787 (unsigned long) ((char *) external
- (char *) pnotes
));
19788 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19789 inote
.type
, inote
.namesz
, inote
.descsz
);
19793 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19795 if (! print_v850_note (& inote
))
19798 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19799 inote
.namesz
, inote
.descsz
);
19809 process_note_sections (Filedata
* filedata
)
19811 Elf_Internal_Shdr
* section
;
19813 unsigned int n
= 0;
19814 bfd_boolean res
= TRUE
;
19816 for (i
= 0, section
= filedata
->section_headers
;
19817 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19820 if (section
->sh_type
== SHT_NOTE
)
19822 if (! process_notes_at (filedata
, section
,
19823 (bfd_vma
) section
->sh_offset
,
19824 (bfd_vma
) section
->sh_size
,
19825 (bfd_vma
) section
->sh_addralign
))
19830 if (( filedata
->file_header
.e_machine
== EM_V800
19831 || filedata
->file_header
.e_machine
== EM_V850
19832 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19833 && section
->sh_type
== SHT_RENESAS_INFO
)
19835 if (! process_v850_notes (filedata
,
19836 (bfd_vma
) section
->sh_offset
,
19837 (bfd_vma
) section
->sh_size
))
19844 /* Try processing NOTE segments instead. */
19845 return process_corefile_note_segments (filedata
);
19851 process_notes (Filedata
* filedata
)
19853 /* If we have not been asked to display the notes then do nothing. */
19857 if (filedata
->file_header
.e_type
!= ET_CORE
)
19858 return process_note_sections (filedata
);
19860 /* No program headers means no NOTE segment. */
19861 if (filedata
->file_header
.e_phnum
> 0)
19862 return process_corefile_note_segments (filedata
);
19864 printf (_("No note segments present in the core file.\n"));
19868 static unsigned char *
19869 display_public_gnu_attributes (unsigned char * start
,
19870 const unsigned char * const end
)
19872 printf (_(" Unknown GNU attribute: %s\n"), start
);
19874 start
+= strnlen ((char *) start
, end
- start
);
19875 display_raw_attribute (start
, end
);
19877 return (unsigned char *) end
;
19880 static unsigned char *
19881 display_generic_attribute (unsigned char * start
,
19883 const unsigned char * const end
)
19886 return (unsigned char *) end
;
19888 return display_tag_value (tag
, start
, end
);
19892 process_arch_specific (Filedata
* filedata
)
19897 switch (filedata
->file_header
.e_machine
)
19900 case EM_ARC_COMPACT
:
19901 case EM_ARC_COMPACT2
:
19902 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19903 display_arc_attribute
,
19904 display_generic_attribute
);
19906 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19907 display_arm_attribute
,
19908 display_generic_attribute
);
19911 case EM_MIPS_RS3_LE
:
19912 return process_mips_specific (filedata
);
19915 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19916 display_msp430x_attribute
,
19917 display_msp430_gnu_attribute
);
19920 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19921 display_riscv_attribute
,
19922 display_generic_attribute
);
19925 return process_nds32_specific (filedata
);
19929 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19930 display_power_gnu_attribute
);
19934 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19935 display_s390_gnu_attribute
);
19938 case EM_SPARC32PLUS
:
19940 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19941 display_sparc_gnu_attribute
);
19944 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19945 display_tic6x_attribute
,
19946 display_generic_attribute
);
19949 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19950 display_public_gnu_attributes
,
19951 display_generic_attribute
);
19956 get_file_header (Filedata
* filedata
)
19958 /* Read in the identity array. */
19959 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19962 /* Determine how to read the rest of the header. */
19963 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19968 byte_get
= byte_get_little_endian
;
19969 byte_put
= byte_put_little_endian
;
19972 byte_get
= byte_get_big_endian
;
19973 byte_put
= byte_put_big_endian
;
19977 /* For now we only support 32 bit and 64 bit ELF files. */
19978 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19980 /* Read in the rest of the header. */
19983 Elf32_External_Ehdr ehdr32
;
19985 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19988 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19989 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19990 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19991 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19992 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19993 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19994 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19995 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19996 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19997 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19998 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19999 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20000 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20004 Elf64_External_Ehdr ehdr64
;
20006 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20007 we will not be able to cope with the 64bit data found in
20008 64 ELF files. Detect this now and abort before we start
20009 overwriting things. */
20010 if (sizeof (bfd_vma
) < 8)
20012 error (_("This instance of readelf has been built without support for a\n\
20013 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20017 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20020 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20021 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20022 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20023 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20024 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20025 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20026 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20027 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20028 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20029 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20030 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20031 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20032 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20035 if (filedata
->file_header
.e_shoff
)
20037 /* There may be some extensions in the first section header. Don't
20038 bomb if we can't read it. */
20040 get_32bit_section_headers (filedata
, TRUE
);
20042 get_64bit_section_headers (filedata
, TRUE
);
20049 close_file (Filedata
* filedata
)
20053 if (filedata
->handle
)
20054 fclose (filedata
->handle
);
20060 close_debug_file (void * data
)
20062 close_file ((Filedata
*) data
);
20066 open_file (const char * pathname
)
20068 struct stat statbuf
;
20069 Filedata
* filedata
= NULL
;
20071 if (stat (pathname
, & statbuf
) < 0
20072 || ! S_ISREG (statbuf
.st_mode
))
20075 filedata
= calloc (1, sizeof * filedata
);
20076 if (filedata
== NULL
)
20079 filedata
->handle
= fopen (pathname
, "rb");
20080 if (filedata
->handle
== NULL
)
20083 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20084 filedata
->file_name
= pathname
;
20086 if (! get_file_header (filedata
))
20089 if (filedata
->file_header
.e_shoff
)
20093 /* Read the section headers again, this time for real. */
20095 res
= get_32bit_section_headers (filedata
, FALSE
);
20097 res
= get_64bit_section_headers (filedata
, FALSE
);
20108 if (filedata
->handle
)
20109 fclose (filedata
->handle
);
20116 open_debug_file (const char * pathname
)
20118 return open_file (pathname
);
20121 /* Process one ELF object file according to the command line options.
20122 This file may actually be stored in an archive. The file is
20123 positioned at the start of the ELF object. Returns TRUE if no
20124 problems were encountered, FALSE otherwise. */
20127 process_object (Filedata
* filedata
)
20129 bfd_boolean have_separate_files
;
20133 if (! get_file_header (filedata
))
20135 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20139 /* Initialise per file variables. */
20140 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20141 filedata
->version_info
[i
] = 0;
20143 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20144 filedata
->dynamic_info
[i
] = 0;
20145 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20146 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20148 /* Process the file. */
20150 printf (_("\nFile: %s\n"), filedata
->file_name
);
20152 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20153 Note we do this even if cmdline_dump_sects is empty because we
20154 must make sure that the dump_sets array is zeroed out before each
20155 object file is processed. */
20156 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20157 memset (filedata
->dump
.dump_sects
, 0,
20158 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20160 if (cmdline
.num_dump_sects
> 0)
20162 if (filedata
->dump
.num_dump_sects
== 0)
20163 /* A sneaky way of allocating the dump_sects array. */
20164 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20166 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20167 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20168 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20171 if (! process_file_header (filedata
))
20174 if (! process_section_headers (filedata
))
20176 /* Without loaded section headers we cannot process lots of things. */
20177 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20179 if (! do_using_dynamic
)
20180 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20183 if (! process_section_groups (filedata
))
20184 /* Without loaded section groups we cannot process unwind. */
20187 res
= process_program_headers (filedata
);
20189 res
= process_dynamic_section (filedata
);
20191 if (! process_relocs (filedata
))
20194 if (! process_unwind (filedata
))
20197 if (! process_symbol_table (filedata
))
20200 if (! process_syminfo (filedata
))
20203 if (! process_version_sections (filedata
))
20206 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20207 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20209 have_separate_files
= FALSE
;
20211 if (! process_section_contents (filedata
))
20214 if (have_separate_files
)
20218 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20220 if (! process_section_headers (d
->handle
))
20222 else if (! process_section_contents (d
->handle
))
20226 /* The file handles are closed by the call to free_debug_memory() below. */
20229 if (! process_notes (filedata
))
20232 if (! process_gnu_liblist (filedata
))
20235 if (! process_arch_specific (filedata
))
20238 free (filedata
->program_headers
);
20239 filedata
->program_headers
= NULL
;
20241 free (filedata
->section_headers
);
20242 filedata
->section_headers
= NULL
;
20244 free (filedata
->string_table
);
20245 filedata
->string_table
= NULL
;
20246 filedata
->string_table_length
= 0;
20248 if (filedata
->dump
.dump_sects
!= NULL
)
20250 free (filedata
->dump
.dump_sects
);
20251 filedata
->dump
.dump_sects
= NULL
;
20252 filedata
->dump
.num_dump_sects
= 0;
20255 if (filedata
->dynamic_strings
)
20257 free (filedata
->dynamic_strings
);
20258 filedata
->dynamic_strings
= NULL
;
20259 filedata
->dynamic_strings_length
= 0;
20262 if (filedata
->dynamic_symbols
)
20264 free (filedata
->dynamic_symbols
);
20265 filedata
->dynamic_symbols
= NULL
;
20266 filedata
->num_dynamic_syms
= 0;
20269 if (filedata
->dynamic_syminfo
)
20271 free (filedata
->dynamic_syminfo
);
20272 filedata
->dynamic_syminfo
= NULL
;
20275 if (filedata
->dynamic_section
)
20277 free (filedata
->dynamic_section
);
20278 filedata
->dynamic_section
= NULL
;
20281 while (filedata
->symtab_shndx_list
!= NULL
)
20283 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
20284 free (filedata
->symtab_shndx_list
);
20285 filedata
->symtab_shndx_list
= next
;
20288 if (filedata
->section_headers_groups
)
20290 free (filedata
->section_headers_groups
);
20291 filedata
->section_headers_groups
= NULL
;
20294 if (filedata
->section_groups
)
20296 struct group_list
* g
;
20297 struct group_list
* next
;
20299 for (i
= 0; i
< filedata
->group_count
; i
++)
20301 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
20308 free (filedata
->section_groups
);
20309 filedata
->section_groups
= NULL
;
20312 free_debug_memory ();
20317 /* Process an ELF archive.
20318 On entry the file is positioned just after the ARMAG string.
20319 Returns TRUE upon success, FALSE otherwise. */
20322 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20324 struct archive_info arch
;
20325 struct archive_info nested_arch
;
20327 bfd_boolean ret
= TRUE
;
20331 /* The ARCH structure is used to hold information about this archive. */
20332 arch
.file_name
= NULL
;
20334 arch
.index_array
= NULL
;
20335 arch
.sym_table
= NULL
;
20336 arch
.longnames
= NULL
;
20338 /* The NESTED_ARCH structure is used as a single-item cache of information
20339 about a nested archive (when members of a thin archive reside within
20340 another regular archive file). */
20341 nested_arch
.file_name
= NULL
;
20342 nested_arch
.file
= NULL
;
20343 nested_arch
.index_array
= NULL
;
20344 nested_arch
.sym_table
= NULL
;
20345 nested_arch
.longnames
= NULL
;
20347 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20348 filedata
->file_size
, is_thin_archive
,
20349 do_archive_index
) != 0)
20355 if (do_archive_index
)
20357 if (arch
.sym_table
== NULL
)
20358 error (_("%s: unable to dump the index as none was found\n"),
20359 filedata
->file_name
);
20362 unsigned long i
, l
;
20363 unsigned long current_pos
;
20365 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20366 "in the symbol table)\n"),
20367 filedata
->file_name
, (unsigned long) arch
.index_num
,
20370 current_pos
= ftell (filedata
->handle
);
20372 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20375 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20378 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20381 if (member_name
!= NULL
)
20383 char * qualified_name
20384 = make_qualified_name (&arch
, &nested_arch
,
20387 if (qualified_name
!= NULL
)
20389 printf (_("Contents of binary %s at offset "),
20391 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20393 free (qualified_name
);
20395 free (member_name
);
20399 if (l
>= arch
.sym_size
)
20401 error (_("%s: end of the symbol table reached "
20402 "before the end of the index\n"),
20403 filedata
->file_name
);
20407 /* PR 17531: file: 0b6630b2. */
20408 printf ("\t%.*s\n",
20409 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20410 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20413 if (arch
.uses_64bit_indices
)
20418 if (l
< arch
.sym_size
)
20420 error (ngettext ("%s: %ld byte remains in the symbol table, "
20421 "but without corresponding entries in "
20422 "the index table\n",
20423 "%s: %ld bytes remain in the symbol table, "
20424 "but without corresponding entries in "
20425 "the index table\n",
20426 arch
.sym_size
- l
),
20427 filedata
->file_name
, arch
.sym_size
- l
);
20431 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20433 error (_("%s: failed to seek back to start of object files "
20434 "in the archive\n"),
20435 filedata
->file_name
);
20441 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20442 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20443 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20444 && !do_section_groups
&& !do_dyn_syms
)
20446 ret
= TRUE
; /* Archive index only. */
20455 char * qualified_name
;
20457 /* Read the next archive header. */
20458 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20460 error (_("%s: failed to seek to next archive header\n"),
20465 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20466 if (got
!= sizeof arch
.arhdr
)
20470 /* PR 24049 - we cannot use filedata->file_name as this will
20471 have already been freed. */
20472 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20477 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20479 error (_("%s: did not find a valid archive header\n"),
20485 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20487 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20488 if (filedata
->archive_file_size
& 01)
20489 ++filedata
->archive_file_size
;
20491 name
= get_archive_member_name (&arch
, &nested_arch
);
20494 error (_("%s: bad archive file name\n"), arch
.file_name
);
20498 namelen
= strlen (name
);
20500 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20501 if (qualified_name
== NULL
)
20503 error (_("%s: bad archive file name\n"), arch
.file_name
);
20509 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20511 /* This is a proxy for an external member of a thin archive. */
20512 Filedata
* member_filedata
;
20513 char * member_file_name
= adjust_relative_path
20514 (filedata
->file_name
, name
, namelen
);
20517 if (member_file_name
== NULL
)
20519 free (qualified_name
);
20524 member_filedata
= open_file (member_file_name
);
20525 if (member_filedata
== NULL
)
20527 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20528 free (member_file_name
);
20529 free (qualified_name
);
20534 filedata
->archive_file_offset
= arch
.nested_member_origin
;
20535 member_filedata
->file_name
= qualified_name
;
20537 if (! process_object (member_filedata
))
20540 close_file (member_filedata
);
20541 free (member_file_name
);
20543 else if (is_thin_archive
)
20545 Filedata thin_filedata
;
20547 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20549 /* PR 15140: Allow for corrupt thin archives. */
20550 if (nested_arch
.file
== NULL
)
20552 error (_("%s: contains corrupt thin archive: %s\n"),
20553 qualified_name
, name
);
20554 free (qualified_name
);
20561 /* This is a proxy for a member of a nested archive. */
20562 filedata
->archive_file_offset
20563 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20565 /* The nested archive file will have been opened and setup by
20566 get_archive_member_name. */
20567 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
20570 error (_("%s: failed to seek to archive member.\n"),
20571 nested_arch
.file_name
);
20572 free (qualified_name
);
20577 thin_filedata
.handle
= nested_arch
.file
;
20578 thin_filedata
.file_name
= qualified_name
;
20580 if (! process_object (& thin_filedata
))
20586 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
20587 filedata
->file_name
= qualified_name
;
20588 if (! process_object (filedata
))
20590 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
20591 /* Stop looping with "negative" archive_file_size. */
20592 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
20593 arch
.next_arhdr_offset
= -1ul;
20596 free (qualified_name
);
20600 if (nested_arch
.file
!= NULL
)
20601 fclose (nested_arch
.file
);
20602 release_archive (&nested_arch
);
20603 release_archive (&arch
);
20609 process_file (char * file_name
)
20611 Filedata
* filedata
= NULL
;
20612 struct stat statbuf
;
20613 char armag
[SARMAG
];
20614 bfd_boolean ret
= TRUE
;
20616 if (stat (file_name
, &statbuf
) < 0)
20618 if (errno
== ENOENT
)
20619 error (_("'%s': No such file\n"), file_name
);
20621 error (_("Could not locate '%s'. System error message: %s\n"),
20622 file_name
, strerror (errno
));
20626 if (! S_ISREG (statbuf
.st_mode
))
20628 error (_("'%s' is not an ordinary file\n"), file_name
);
20632 filedata
= calloc (1, sizeof * filedata
);
20633 if (filedata
== NULL
)
20635 error (_("Out of memory allocating file data structure\n"));
20639 filedata
->file_name
= file_name
;
20640 filedata
->handle
= fopen (file_name
, "rb");
20641 if (filedata
->handle
== NULL
)
20643 error (_("Input file '%s' is not readable.\n"), file_name
);
20648 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20650 error (_("%s: Failed to read file's magic number\n"), file_name
);
20651 fclose (filedata
->handle
);
20656 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20658 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20660 if (! process_archive (filedata
, FALSE
))
20663 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20665 if ( ! process_archive (filedata
, TRUE
))
20670 if (do_archive_index
)
20671 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20674 rewind (filedata
->handle
);
20675 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
20677 if (! process_object (filedata
))
20681 fclose (filedata
->handle
);
20682 free (filedata
->section_headers
);
20683 free (filedata
->program_headers
);
20684 free (filedata
->string_table
);
20685 free (filedata
->dump
.dump_sects
);
20688 free (ba_cache
.strtab
);
20689 ba_cache
.strtab
= NULL
;
20690 free (ba_cache
.symtab
);
20691 ba_cache
.symtab
= NULL
;
20692 ba_cache
.filedata
= NULL
;
20697 #ifdef SUPPORT_DISASSEMBLY
20698 /* Needed by the i386 disassembler. For extra credit, someone could
20699 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20703 print_address (unsigned int addr
, FILE * outfile
)
20705 fprintf (outfile
,"0x%8.8x", addr
);
20708 /* Needed by the i386 disassembler. */
20711 db_task_printsym (unsigned int addr
)
20713 print_address (addr
, stderr
);
20718 main (int argc
, char ** argv
)
20722 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20723 setlocale (LC_MESSAGES
, "");
20725 #if defined (HAVE_SETLOCALE)
20726 setlocale (LC_CTYPE
, "");
20728 bindtextdomain (PACKAGE
, LOCALEDIR
);
20729 textdomain (PACKAGE
);
20731 expandargv (&argc
, &argv
);
20733 parse_args (& cmdline
, argc
, argv
);
20735 if (optind
< (argc
- 1))
20737 else if (optind
>= argc
)
20739 warn (_("Nothing to do.\n"));
20744 while (optind
< argc
)
20745 if (! process_file (argv
[optind
++]))
20748 if (cmdline
.dump_sects
!= NULL
)
20749 free (cmdline
.dump_sects
);
20751 free (dump_ctf_symtab_name
);
20752 free (dump_ctf_strtab_name
);
20753 free (dump_ctf_parent_name
);
20755 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;