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 typedef struct filedata
202 const char * file_name
;
204 bfd_size_type file_size
;
205 Elf_Internal_Ehdr file_header
;
206 Elf_Internal_Shdr
* section_headers
;
207 Elf_Internal_Phdr
* program_headers
;
209 unsigned long string_table_length
;
210 /* A dynamic array of flags indicating for which sections a dump of
211 some kind has been requested. It is reset on a per-object file
212 basis and then initialised from the cmdline_dump_sects array,
213 the results of interpreting the -w switch, and the
214 dump_sects_byname list. */
215 dump_type
* dump_sects
;
216 unsigned int num_dump_sects
;
219 char * program_name
= "readelf";
221 static unsigned long archive_file_offset
;
222 static unsigned long archive_file_size
;
223 static unsigned long dynamic_addr
;
224 static bfd_size_type dynamic_size
;
225 static size_t dynamic_nent
;
226 static char * dynamic_strings
;
227 static unsigned long dynamic_strings_length
;
228 static unsigned long num_dynamic_syms
;
229 static Elf_Internal_Sym
* dynamic_symbols
;
230 static Elf_Internal_Syminfo
* dynamic_syminfo
;
231 static unsigned long dynamic_syminfo_offset
;
232 static unsigned int dynamic_syminfo_nent
;
233 static char program_interpreter
[PATH_MAX
];
234 static bfd_vma dynamic_info
[DT_ENCODING
];
235 static bfd_vma dynamic_info_DT_GNU_HASH
;
236 static bfd_vma dynamic_info_DT_MIPS_XHASH
;
237 static bfd_vma version_info
[16];
238 static Elf_Internal_Dyn
* dynamic_section
;
239 static elf_section_list
* symtab_shndx_list
;
240 static bfd_boolean show_name
= FALSE
;
241 static bfd_boolean do_dynamic
= FALSE
;
242 static bfd_boolean do_syms
= FALSE
;
243 static bfd_boolean do_dyn_syms
= FALSE
;
244 static bfd_boolean do_reloc
= FALSE
;
245 static bfd_boolean do_sections
= FALSE
;
246 static bfd_boolean do_section_groups
= FALSE
;
247 static bfd_boolean do_section_details
= FALSE
;
248 static bfd_boolean do_segments
= FALSE
;
249 static bfd_boolean do_unwind
= FALSE
;
250 static bfd_boolean do_using_dynamic
= FALSE
;
251 static bfd_boolean do_header
= FALSE
;
252 static bfd_boolean do_dump
= FALSE
;
253 static bfd_boolean do_version
= FALSE
;
254 static bfd_boolean do_histogram
= FALSE
;
255 static bfd_boolean do_debugging
= FALSE
;
256 static bfd_boolean do_ctf
= FALSE
;
257 static bfd_boolean do_arch
= FALSE
;
258 static bfd_boolean do_notes
= FALSE
;
259 static bfd_boolean do_archive_index
= FALSE
;
260 static bfd_boolean is_32bit_elf
= FALSE
;
261 static bfd_boolean decompress_dumps
= FALSE
;
263 static char *dump_ctf_parent_name
;
264 static char *dump_ctf_symtab_name
;
265 static char *dump_ctf_strtab_name
;
269 struct group_list
* next
;
270 unsigned int section_index
;
275 struct group_list
* root
;
276 unsigned int group_index
;
279 static size_t group_count
;
280 static struct group
* section_groups
;
281 static struct group
** section_headers_groups
;
283 /* A dynamic array of flags indicating for which sections a dump
284 has been requested via command line switches. */
285 static Filedata cmdline
;
287 static struct dump_list_entry
* dump_sects_byname
;
289 /* How to print a vma value. */
290 typedef enum print_mode
302 /* Versioned symbol info. */
303 enum versioned_symbol_info
310 static const char * get_symbol_version_string
311 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
312 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
316 #define SECTION_NAME(X) \
317 ((X) == NULL ? _("<none>") \
318 : filedata->string_table == NULL ? _("<no-strings>") \
319 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
320 : filedata->string_table + (X)->sh_name))
322 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
324 #define GET_ELF_SYMBOLS(file, section, sym_count) \
325 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
326 : get_64bit_elf_symbols (file, section, sym_count))
328 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
329 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
330 already been called and verified that the string exists. */
331 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
333 #define REMOVE_ARCH_BITS(ADDR) \
336 if (filedata->file_header.e_machine == EM_ARM) \
341 /* Get the correct GNU hash section name. */
342 #define GNU_HASH_SECTION_NAME \
343 dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
345 /* Print a BFD_VMA to an internal buffer, for use in error messages.
346 BFD_FMA_FMT can't be used in translated strings. */
349 bfd_vmatoa (char *fmtch
, bfd_vma value
)
351 /* bfd_vmatoa is used more then once in a printf call for output.
352 Cycle through an array of buffers. */
353 static int buf_pos
= 0;
354 static struct bfd_vmatoa_buf
361 ret
= buf
[buf_pos
++].place
;
362 buf_pos
%= ARRAY_SIZE (buf
);
364 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
365 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
369 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
370 OFFSET + the offset of the current archive member, if we are examining an
371 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
372 allocate a buffer using malloc and fill that. In either case return the
373 pointer to the start of the retrieved data or NULL if something went wrong.
374 If something does go wrong and REASON is not NULL then emit an error
375 message using REASON as part of the context. */
378 get_data (void * var
,
380 unsigned long offset
,
386 bfd_size_type amt
= size
* nmemb
;
388 if (size
== 0 || nmemb
== 0)
391 /* If the size_t type is smaller than the bfd_size_type, eg because
392 you are building a 32-bit tool on a 64-bit host, then make sure
393 that when the sizes are cast to (size_t) no information is lost. */
394 if ((size_t) size
!= size
395 || (size_t) nmemb
!= nmemb
396 || (size_t) amt
!= amt
)
399 error (_("Size truncation prevents reading %s"
400 " elements of size %s for %s\n"),
401 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
405 /* Check for size overflow. */
406 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
409 error (_("Size overflow prevents reading %s"
410 " elements of size %s for %s\n"),
411 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
415 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
416 attempting to allocate memory when the read is bound to fail. */
417 if (archive_file_offset
> filedata
->file_size
418 || offset
> filedata
->file_size
- archive_file_offset
419 || amt
> filedata
->file_size
- archive_file_offset
- offset
)
422 error (_("Reading %s bytes extends past end of file for %s\n"),
423 bfd_vmatoa ("u", amt
), reason
);
427 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
430 error (_("Unable to seek to 0x%lx for %s\n"),
431 archive_file_offset
+ offset
, reason
);
438 /* + 1 so that we can '\0' terminate invalid string table sections. */
439 mvar
= malloc ((size_t) amt
+ 1);
444 error (_("Out of memory allocating %s bytes for %s\n"),
445 bfd_vmatoa ("u", amt
), reason
);
449 ((char *) mvar
)[amt
] = '\0';
452 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
455 error (_("Unable to read in %s bytes of %s\n"),
456 bfd_vmatoa ("u", amt
), reason
);
465 /* Print a VMA value in the MODE specified.
466 Returns the number of characters displayed. */
469 print_vma (bfd_vma vma
, print_mode mode
)
481 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
488 return printf ("%5" BFD_VMA_FMT
"d", vma
);
494 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
497 return printf ("%" BFD_VMA_FMT
"d", vma
);
500 return printf ("%" BFD_VMA_FMT
"u", vma
);
503 /* FIXME: Report unrecognised mode ? */
508 /* Display a symbol on stdout. Handles the display of control characters and
509 multibye characters (assuming the host environment supports them).
511 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
513 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
514 padding as necessary.
516 Returns the number of emitted characters. */
519 print_symbol (signed int width
, const char *symbol
)
521 bfd_boolean extra_padding
= FALSE
;
522 signed int num_printed
= 0;
523 #ifdef HAVE_MBSTATE_T
526 unsigned int width_remaining
;
530 /* Keep the width positive. This helps the code below. */
532 extra_padding
= TRUE
;
538 /* Set the remaining width to a very large value.
539 This simplifies the code below. */
540 width_remaining
= INT_MAX
;
542 width_remaining
= width
;
544 #ifdef HAVE_MBSTATE_T
545 /* Initialise the multibyte conversion state. */
546 memset (& state
, 0, sizeof (state
));
549 while (width_remaining
)
552 const char c
= *symbol
++;
557 /* Do not print control characters directly as they can affect terminal
558 settings. Such characters usually appear in the names generated
559 by the assembler for local labels. */
562 if (width_remaining
< 2)
565 printf ("^%c", c
+ 0x40);
566 width_remaining
-= 2;
569 else if (ISPRINT (c
))
577 #ifdef HAVE_MBSTATE_T
580 /* Let printf do the hard work of displaying multibyte characters. */
581 printf ("%.1s", symbol
- 1);
585 #ifdef HAVE_MBSTATE_T
586 /* Try to find out how many bytes made up the character that was
587 just printed. Advance the symbol pointer past the bytes that
589 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
593 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
598 if (extra_padding
&& num_printed
< width
)
600 /* Fill in the remaining spaces. */
601 printf ("%-*s", width
- num_printed
, " ");
608 /* Returns a pointer to a static buffer containing a printable version of
609 the given section's name. Like print_symbol, except that it does not try
610 to print multibyte characters, it just interprets them as hex values. */
613 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
615 #define MAX_PRINT_SEC_NAME_LEN 128
616 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
617 const char * name
= SECTION_NAME (sec
);
618 char * buf
= sec_name_buf
;
620 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
622 while ((c
= * name
++) != 0)
633 else if (ISPRINT (c
))
640 static char hex
[17] = "0123456789ABCDEF";
645 * buf
++ = hex
[(c
& 0xf0) >> 4];
646 * buf
++ = hex
[c
& 0x0f];
660 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
662 if (ndx
>= filedata
->file_header
.e_shnum
)
663 return _("<corrupt>");
665 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
668 /* Return a pointer to section NAME, or NULL if no such section exists. */
670 static Elf_Internal_Shdr
*
671 find_section (Filedata
* filedata
, const char * name
)
675 if (filedata
->section_headers
== NULL
)
678 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
679 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
680 return filedata
->section_headers
+ i
;
685 /* Return a pointer to a section containing ADDR, or NULL if no such
688 static Elf_Internal_Shdr
*
689 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
693 if (filedata
->section_headers
== NULL
)
696 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
698 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
700 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
707 static Elf_Internal_Shdr
*
708 find_section_by_type (Filedata
* filedata
, unsigned int type
)
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 (sec
->sh_type
== type
)
726 /* Return a pointer to section NAME, or NULL if no such section exists,
727 restricted to the list of sections given in SET. */
729 static Elf_Internal_Shdr
*
730 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
734 if (filedata
->section_headers
== NULL
)
739 while ((i
= *set
++) > 0)
741 /* See PR 21156 for a reproducer. */
742 if (i
>= filedata
->file_header
.e_shnum
)
743 continue; /* FIXME: Should we issue an error message ? */
745 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
746 return filedata
->section_headers
+ i
;
750 return find_section (filedata
, name
);
753 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
754 This OS has so many departures from the ELF standard that we test it at
757 static inline bfd_boolean
758 is_ia64_vms (Filedata
* filedata
)
760 return filedata
->file_header
.e_machine
== EM_IA_64
761 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
764 /* Guess the relocation size commonly used by the specific machines. */
767 guess_is_rela (unsigned int e_machine
)
771 /* Targets that use REL relocations. */
788 /* Targets that use RELA relocations. */
792 case EM_ADAPTEVA_EPIPHANY
:
794 case EM_ALTERA_NIOS2
:
797 case EM_ARC_COMPACT2
:
818 case EM_LATTICEMICO32
:
827 case EM_CYGNUS_MN10200
:
829 case EM_CYGNUS_MN10300
:
865 case EM_MICROBLAZE_OLD
:
887 warn (_("Don't know about relocations on this machine architecture\n"));
892 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
893 Returns TRUE upon success, FALSE otherwise. If successful then a
894 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
895 and the number of relocs loaded is placed in *NRELASP. It is the caller's
896 responsibility to free the allocated buffer. */
899 slurp_rela_relocs (Filedata
* filedata
,
900 unsigned long rel_offset
,
901 unsigned long rel_size
,
902 Elf_Internal_Rela
** relasp
,
903 unsigned long * nrelasp
)
905 Elf_Internal_Rela
* relas
;
911 Elf32_External_Rela
* erelas
;
913 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
914 rel_size
, _("32-bit relocation data"));
918 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
920 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
921 sizeof (Elf_Internal_Rela
));
926 error (_("out of memory parsing relocs\n"));
930 for (i
= 0; i
< nrelas
; i
++)
932 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
933 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
934 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
941 Elf64_External_Rela
* erelas
;
943 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
944 rel_size
, _("64-bit relocation data"));
948 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
950 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
951 sizeof (Elf_Internal_Rela
));
956 error (_("out of memory parsing relocs\n"));
960 for (i
= 0; i
< nrelas
; i
++)
962 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
963 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
964 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
966 /* The #ifdef BFD64 below is to prevent a compile time
967 warning. We know that if we do not have a 64 bit data
968 type that we will never execute this code anyway. */
970 if (filedata
->file_header
.e_machine
== EM_MIPS
971 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
973 /* In little-endian objects, r_info isn't really a
974 64-bit little-endian value: it has a 32-bit
975 little-endian symbol index followed by four
976 individual byte fields. Reorder INFO
978 bfd_vma inf
= relas
[i
].r_info
;
979 inf
= (((inf
& 0xffffffff) << 32)
980 | ((inf
>> 56) & 0xff)
981 | ((inf
>> 40) & 0xff00)
982 | ((inf
>> 24) & 0xff0000)
983 | ((inf
>> 8) & 0xff000000));
984 relas
[i
].r_info
= inf
;
997 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
998 Returns TRUE upon success, FALSE otherwise. If successful then a
999 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1000 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1001 responsibility to free the allocated buffer. */
1004 slurp_rel_relocs (Filedata
* filedata
,
1005 unsigned long rel_offset
,
1006 unsigned long rel_size
,
1007 Elf_Internal_Rela
** relsp
,
1008 unsigned long * nrelsp
)
1010 Elf_Internal_Rela
* rels
;
1016 Elf32_External_Rel
* erels
;
1018 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1019 rel_size
, _("32-bit relocation data"));
1023 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1025 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1030 error (_("out of memory parsing relocs\n"));
1034 for (i
= 0; i
< nrels
; i
++)
1036 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1037 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1038 rels
[i
].r_addend
= 0;
1045 Elf64_External_Rel
* erels
;
1047 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1048 rel_size
, _("64-bit relocation data"));
1052 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1054 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1059 error (_("out of memory parsing relocs\n"));
1063 for (i
= 0; i
< nrels
; i
++)
1065 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1066 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1067 rels
[i
].r_addend
= 0;
1069 /* The #ifdef BFD64 below is to prevent a compile time
1070 warning. We know that if we do not have a 64 bit data
1071 type that we will never execute this code anyway. */
1073 if (filedata
->file_header
.e_machine
== EM_MIPS
1074 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1076 /* In little-endian objects, r_info isn't really a
1077 64-bit little-endian value: it has a 32-bit
1078 little-endian symbol index followed by four
1079 individual byte fields. Reorder INFO
1081 bfd_vma inf
= rels
[i
].r_info
;
1082 inf
= (((inf
& 0xffffffff) << 32)
1083 | ((inf
>> 56) & 0xff)
1084 | ((inf
>> 40) & 0xff00)
1085 | ((inf
>> 24) & 0xff0000)
1086 | ((inf
>> 8) & 0xff000000));
1087 rels
[i
].r_info
= inf
;
1100 /* Returns the reloc type extracted from the reloc info field. */
1103 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1106 return ELF32_R_TYPE (reloc_info
);
1108 switch (filedata
->file_header
.e_machine
)
1111 /* Note: We assume that reloc_info has already been adjusted for us. */
1112 return ELF64_MIPS_R_TYPE (reloc_info
);
1115 return ELF64_R_TYPE_ID (reloc_info
);
1118 return ELF64_R_TYPE (reloc_info
);
1122 /* Return the symbol index extracted from the reloc info field. */
1125 get_reloc_symindex (bfd_vma reloc_info
)
1127 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1130 static inline bfd_boolean
1131 uses_msp430x_relocs (Filedata
* filedata
)
1134 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1135 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1136 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1137 /* TI compiler uses ELFOSABI_NONE. */
1138 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1141 /* Display the contents of the relocation data found at the specified
1145 dump_relocations (Filedata
* filedata
,
1146 unsigned long rel_offset
,
1147 unsigned long rel_size
,
1148 Elf_Internal_Sym
* symtab
,
1149 unsigned long nsyms
,
1151 unsigned long strtablen
,
1153 bfd_boolean is_dynsym
)
1156 Elf_Internal_Rela
* rels
;
1157 bfd_boolean res
= TRUE
;
1159 if (is_rela
== UNKNOWN
)
1160 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1164 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1169 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1178 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1180 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1185 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1187 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1195 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1197 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1202 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1204 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1208 for (i
= 0; i
< rel_size
; i
++)
1213 bfd_vma symtab_index
;
1216 offset
= rels
[i
].r_offset
;
1217 inf
= rels
[i
].r_info
;
1219 type
= get_reloc_type (filedata
, inf
);
1220 symtab_index
= get_reloc_symindex (inf
);
1224 printf ("%8.8lx %8.8lx ",
1225 (unsigned long) offset
& 0xffffffff,
1226 (unsigned long) inf
& 0xffffffff);
1230 #if BFD_HOST_64BIT_LONG
1232 ? "%16.16lx %16.16lx "
1233 : "%12.12lx %12.12lx ",
1235 #elif BFD_HOST_64BIT_LONG_LONG
1238 ? "%16.16llx %16.16llx "
1239 : "%12.12llx %12.12llx ",
1243 ? "%16.16I64x %16.16I64x "
1244 : "%12.12I64x %12.12I64x ",
1249 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1250 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1251 _bfd_int64_high (offset
),
1252 _bfd_int64_low (offset
),
1253 _bfd_int64_high (inf
),
1254 _bfd_int64_low (inf
));
1258 switch (filedata
->file_header
.e_machine
)
1265 rtype
= elf_aarch64_reloc_type (type
);
1269 case EM_CYGNUS_M32R
:
1270 rtype
= elf_m32r_reloc_type (type
);
1275 rtype
= elf_i386_reloc_type (type
);
1280 rtype
= elf_m68hc11_reloc_type (type
);
1284 rtype
= elf_s12z_reloc_type (type
);
1288 rtype
= elf_m68k_reloc_type (type
);
1292 rtype
= elf_i960_reloc_type (type
);
1297 rtype
= elf_avr_reloc_type (type
);
1300 case EM_OLD_SPARCV9
:
1301 case EM_SPARC32PLUS
:
1304 rtype
= elf_sparc_reloc_type (type
);
1308 rtype
= elf_spu_reloc_type (type
);
1312 rtype
= v800_reloc_type (type
);
1315 case EM_CYGNUS_V850
:
1316 rtype
= v850_reloc_type (type
);
1320 case EM_CYGNUS_D10V
:
1321 rtype
= elf_d10v_reloc_type (type
);
1325 case EM_CYGNUS_D30V
:
1326 rtype
= elf_d30v_reloc_type (type
);
1330 rtype
= elf_dlx_reloc_type (type
);
1334 rtype
= elf_sh_reloc_type (type
);
1338 case EM_CYGNUS_MN10300
:
1339 rtype
= elf_mn10300_reloc_type (type
);
1343 case EM_CYGNUS_MN10200
:
1344 rtype
= elf_mn10200_reloc_type (type
);
1348 case EM_CYGNUS_FR30
:
1349 rtype
= elf_fr30_reloc_type (type
);
1353 rtype
= elf_frv_reloc_type (type
);
1357 rtype
= elf_csky_reloc_type (type
);
1361 rtype
= elf_ft32_reloc_type (type
);
1365 rtype
= elf_mcore_reloc_type (type
);
1369 rtype
= elf_mmix_reloc_type (type
);
1373 rtype
= elf_moxie_reloc_type (type
);
1377 if (uses_msp430x_relocs (filedata
))
1379 rtype
= elf_msp430x_reloc_type (type
);
1384 rtype
= elf_msp430_reloc_type (type
);
1388 rtype
= elf_nds32_reloc_type (type
);
1392 rtype
= elf_ppc_reloc_type (type
);
1396 rtype
= elf_ppc64_reloc_type (type
);
1400 case EM_MIPS_RS3_LE
:
1401 rtype
= elf_mips_reloc_type (type
);
1405 rtype
= elf_riscv_reloc_type (type
);
1409 rtype
= elf_alpha_reloc_type (type
);
1413 rtype
= elf_arm_reloc_type (type
);
1417 case EM_ARC_COMPACT
:
1418 case EM_ARC_COMPACT2
:
1419 rtype
= elf_arc_reloc_type (type
);
1423 rtype
= elf_hppa_reloc_type (type
);
1429 rtype
= elf_h8_reloc_type (type
);
1433 rtype
= elf_or1k_reloc_type (type
);
1438 rtype
= elf_pj_reloc_type (type
);
1441 rtype
= elf_ia64_reloc_type (type
);
1445 rtype
= elf_cris_reloc_type (type
);
1449 rtype
= elf_i860_reloc_type (type
);
1455 rtype
= elf_x86_64_reloc_type (type
);
1459 rtype
= i370_reloc_type (type
);
1464 rtype
= elf_s390_reloc_type (type
);
1468 rtype
= elf_score_reloc_type (type
);
1472 rtype
= elf_xstormy16_reloc_type (type
);
1476 rtype
= elf_crx_reloc_type (type
);
1480 rtype
= elf_vax_reloc_type (type
);
1484 rtype
= elf_visium_reloc_type (type
);
1488 rtype
= elf_bpf_reloc_type (type
);
1491 case EM_ADAPTEVA_EPIPHANY
:
1492 rtype
= elf_epiphany_reloc_type (type
);
1497 rtype
= elf_ip2k_reloc_type (type
);
1501 rtype
= elf_iq2000_reloc_type (type
);
1506 rtype
= elf_xtensa_reloc_type (type
);
1509 case EM_LATTICEMICO32
:
1510 rtype
= elf_lm32_reloc_type (type
);
1515 rtype
= elf_m32c_reloc_type (type
);
1519 rtype
= elf_mt_reloc_type (type
);
1523 rtype
= elf_bfin_reloc_type (type
);
1527 rtype
= elf_mep_reloc_type (type
);
1531 rtype
= elf_cr16_reloc_type (type
);
1535 case EM_MICROBLAZE_OLD
:
1536 rtype
= elf_microblaze_reloc_type (type
);
1540 rtype
= elf_rl78_reloc_type (type
);
1544 rtype
= elf_rx_reloc_type (type
);
1548 rtype
= elf_metag_reloc_type (type
);
1553 rtype
= elf_xc16x_reloc_type (type
);
1557 rtype
= elf_tic6x_reloc_type (type
);
1561 rtype
= elf_tilegx_reloc_type (type
);
1565 rtype
= elf_tilepro_reloc_type (type
);
1568 case EM_WEBASSEMBLY
:
1569 rtype
= elf_wasm32_reloc_type (type
);
1573 rtype
= elf_xgate_reloc_type (type
);
1576 case EM_ALTERA_NIOS2
:
1577 rtype
= elf_nios2_reloc_type (type
);
1581 rtype
= elf_pru_reloc_type (type
);
1585 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1586 rtype
= elf_nfp3200_reloc_type (type
);
1588 rtype
= elf_nfp_reloc_type (type
);
1592 rtype
= elf_z80_reloc_type (type
);
1597 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1599 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1601 if (filedata
->file_header
.e_machine
== EM_ALPHA
1603 && streq (rtype
, "R_ALPHA_LITUSE")
1606 switch (rels
[i
].r_addend
)
1608 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1609 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1610 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1611 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1612 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1613 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1614 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1615 default: rtype
= NULL
;
1619 printf (" (%s)", rtype
);
1623 printf (_("<unknown addend: %lx>"),
1624 (unsigned long) rels
[i
].r_addend
);
1628 else if (symtab_index
)
1630 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1632 error (_(" bad symbol index: %08lx in reloc\n"),
1633 (unsigned long) symtab_index
);
1638 Elf_Internal_Sym
* psym
;
1639 const char * version_string
;
1640 enum versioned_symbol_info sym_info
;
1641 unsigned short vna_other
;
1643 psym
= symtab
+ symtab_index
;
1646 = get_symbol_version_string (filedata
, is_dynsym
,
1655 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1659 unsigned int width
= is_32bit_elf
? 8 : 14;
1661 /* Relocations against GNU_IFUNC symbols do not use the value
1662 of the symbol as the address to relocate against. Instead
1663 they invoke the function named by the symbol and use its
1664 result as the address for relocation.
1666 To indicate this to the user, do not display the value of
1667 the symbol in the "Symbols's Value" field. Instead show
1668 its name followed by () as a hint that the symbol is
1672 || psym
->st_name
== 0
1673 || psym
->st_name
>= strtablen
)
1676 name
= strtab
+ psym
->st_name
;
1678 len
= print_symbol (width
, name
);
1680 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1682 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1686 print_vma (psym
->st_value
, LONG_HEX
);
1688 printf (is_32bit_elf
? " " : " ");
1691 if (psym
->st_name
== 0)
1693 const char * sec_name
= "<null>";
1696 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1698 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1699 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1700 else if (psym
->st_shndx
== SHN_ABS
)
1702 else if (psym
->st_shndx
== SHN_COMMON
)
1703 sec_name
= "COMMON";
1704 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1705 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1706 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1707 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1708 sec_name
= "SCOMMON";
1709 else if (filedata
->file_header
.e_machine
== EM_MIPS
1710 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1711 sec_name
= "SUNDEF";
1712 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1713 || filedata
->file_header
.e_machine
== EM_L1OM
1714 || filedata
->file_header
.e_machine
== EM_K1OM
)
1715 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1716 sec_name
= "LARGE_COMMON";
1717 else if (filedata
->file_header
.e_machine
== EM_IA_64
1718 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1719 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1720 sec_name
= "ANSI_COM";
1721 else if (is_ia64_vms (filedata
)
1722 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1723 sec_name
= "VMS_SYMVEC";
1726 sprintf (name_buf
, "<section 0x%x>",
1727 (unsigned int) psym
->st_shndx
);
1728 sec_name
= name_buf
;
1731 print_symbol (22, sec_name
);
1733 else if (strtab
== NULL
)
1734 printf (_("<string table index: %3ld>"), psym
->st_name
);
1735 else if (psym
->st_name
>= strtablen
)
1737 error (_("<corrupt string table index: %3ld>\n"),
1743 print_symbol (22, strtab
+ psym
->st_name
);
1745 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1751 bfd_vma off
= rels
[i
].r_addend
;
1753 if ((bfd_signed_vma
) off
< 0)
1754 printf (" - %" BFD_VMA_FMT
"x", - off
);
1756 printf (" + %" BFD_VMA_FMT
"x", off
);
1762 bfd_vma off
= rels
[i
].r_addend
;
1764 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1765 if ((bfd_signed_vma
) off
< 0)
1766 printf ("-%" BFD_VMA_FMT
"x", - off
);
1768 printf ("%" BFD_VMA_FMT
"x", off
);
1771 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1773 && streq (rtype
, "R_SPARC_OLO10"))
1774 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1779 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1781 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1782 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1783 const char * rtype2
= elf_mips_reloc_type (type2
);
1784 const char * rtype3
= elf_mips_reloc_type (type3
);
1786 printf (" Type2: ");
1789 printf (_("unrecognized: %-7lx"),
1790 (unsigned long) type2
& 0xffffffff);
1792 printf ("%-17.17s", rtype2
);
1794 printf ("\n Type3: ");
1797 printf (_("unrecognized: %-7lx"),
1798 (unsigned long) type3
& 0xffffffff);
1800 printf ("%-17.17s", rtype3
);
1813 get_aarch64_dynamic_type (unsigned long type
)
1817 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1818 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1819 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1826 get_mips_dynamic_type (unsigned long type
)
1830 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1831 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1832 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1833 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1834 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1835 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1836 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1837 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1838 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1839 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1840 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1841 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1842 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1843 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1844 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1845 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1846 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1847 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1848 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1849 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1850 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1851 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1852 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1853 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1854 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1855 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1856 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1857 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1858 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1859 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1860 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1861 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1862 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1863 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1864 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1865 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1866 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1867 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1868 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1869 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1870 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1871 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1872 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1873 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1874 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1875 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1876 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1883 get_sparc64_dynamic_type (unsigned long type
)
1887 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1894 get_ppc_dynamic_type (unsigned long type
)
1898 case DT_PPC_GOT
: return "PPC_GOT";
1899 case DT_PPC_OPT
: return "PPC_OPT";
1906 get_ppc64_dynamic_type (unsigned long type
)
1910 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1911 case DT_PPC64_OPD
: return "PPC64_OPD";
1912 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1913 case DT_PPC64_OPT
: return "PPC64_OPT";
1920 get_parisc_dynamic_type (unsigned long type
)
1924 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1925 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1926 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1927 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1928 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1929 case DT_HP_PREINIT
: return "HP_PREINIT";
1930 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1931 case DT_HP_NEEDED
: return "HP_NEEDED";
1932 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1933 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1934 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1935 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1936 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1937 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1938 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1939 case DT_HP_FILTERED
: return "HP_FILTERED";
1940 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1941 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1942 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1943 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1944 case DT_PLT
: return "PLT";
1945 case DT_PLT_SIZE
: return "PLT_SIZE";
1946 case DT_DLT
: return "DLT";
1947 case DT_DLT_SIZE
: return "DLT_SIZE";
1954 get_ia64_dynamic_type (unsigned long type
)
1958 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1959 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1960 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1961 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1962 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1963 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1964 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1965 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1966 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1967 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1968 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1969 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1970 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1971 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1972 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1973 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1974 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1975 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1976 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1977 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1978 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1979 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1980 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1981 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1982 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1983 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1984 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1985 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1986 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1987 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1988 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1995 get_solaris_section_type (unsigned long type
)
1999 case 0x6fffffee: return "SUNW_ancillary";
2000 case 0x6fffffef: return "SUNW_capchain";
2001 case 0x6ffffff0: return "SUNW_capinfo";
2002 case 0x6ffffff1: return "SUNW_symsort";
2003 case 0x6ffffff2: return "SUNW_tlssort";
2004 case 0x6ffffff3: return "SUNW_LDYNSYM";
2005 case 0x6ffffff4: return "SUNW_dof";
2006 case 0x6ffffff5: return "SUNW_cap";
2007 case 0x6ffffff6: return "SUNW_SIGNATURE";
2008 case 0x6ffffff7: return "SUNW_ANNOTATE";
2009 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2010 case 0x6ffffff9: return "SUNW_DEBUG";
2011 case 0x6ffffffa: return "SUNW_move";
2012 case 0x6ffffffb: return "SUNW_COMDAT";
2013 case 0x6ffffffc: return "SUNW_syminfo";
2014 case 0x6ffffffd: return "SUNW_verdef";
2015 case 0x6ffffffe: return "SUNW_verneed";
2016 case 0x6fffffff: return "SUNW_versym";
2017 case 0x70000000: return "SPARC_GOTDATA";
2018 default: return NULL
;
2023 get_alpha_dynamic_type (unsigned long type
)
2027 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2028 default: return NULL
;
2033 get_score_dynamic_type (unsigned long type
)
2037 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2038 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2039 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2040 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2041 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2042 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2043 default: return NULL
;
2048 get_tic6x_dynamic_type (unsigned long type
)
2052 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2053 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2054 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2055 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2056 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2057 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2058 default: return NULL
;
2063 get_nios2_dynamic_type (unsigned long type
)
2067 case DT_NIOS2_GP
: return "NIOS2_GP";
2068 default: return NULL
;
2073 get_solaris_dynamic_type (unsigned long type
)
2077 case 0x6000000d: return "SUNW_AUXILIARY";
2078 case 0x6000000e: return "SUNW_RTLDINF";
2079 case 0x6000000f: return "SUNW_FILTER";
2080 case 0x60000010: return "SUNW_CAP";
2081 case 0x60000011: return "SUNW_SYMTAB";
2082 case 0x60000012: return "SUNW_SYMSZ";
2083 case 0x60000013: return "SUNW_SORTENT";
2084 case 0x60000014: return "SUNW_SYMSORT";
2085 case 0x60000015: return "SUNW_SYMSORTSZ";
2086 case 0x60000016: return "SUNW_TLSSORT";
2087 case 0x60000017: return "SUNW_TLSSORTSZ";
2088 case 0x60000018: return "SUNW_CAPINFO";
2089 case 0x60000019: return "SUNW_STRPAD";
2090 case 0x6000001a: return "SUNW_CAPCHAIN";
2091 case 0x6000001b: return "SUNW_LDMACH";
2092 case 0x6000001d: return "SUNW_CAPCHAINENT";
2093 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2094 case 0x60000021: return "SUNW_PARENT";
2095 case 0x60000023: return "SUNW_ASLR";
2096 case 0x60000025: return "SUNW_RELAX";
2097 case 0x60000029: return "SUNW_NXHEAP";
2098 case 0x6000002b: return "SUNW_NXSTACK";
2100 case 0x70000001: return "SPARC_REGISTER";
2101 case 0x7ffffffd: return "AUXILIARY";
2102 case 0x7ffffffe: return "USED";
2103 case 0x7fffffff: return "FILTER";
2105 default: return NULL
;
2110 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2112 static char buff
[64];
2116 case DT_NULL
: return "NULL";
2117 case DT_NEEDED
: return "NEEDED";
2118 case DT_PLTRELSZ
: return "PLTRELSZ";
2119 case DT_PLTGOT
: return "PLTGOT";
2120 case DT_HASH
: return "HASH";
2121 case DT_STRTAB
: return "STRTAB";
2122 case DT_SYMTAB
: return "SYMTAB";
2123 case DT_RELA
: return "RELA";
2124 case DT_RELASZ
: return "RELASZ";
2125 case DT_RELAENT
: return "RELAENT";
2126 case DT_STRSZ
: return "STRSZ";
2127 case DT_SYMENT
: return "SYMENT";
2128 case DT_INIT
: return "INIT";
2129 case DT_FINI
: return "FINI";
2130 case DT_SONAME
: return "SONAME";
2131 case DT_RPATH
: return "RPATH";
2132 case DT_SYMBOLIC
: return "SYMBOLIC";
2133 case DT_REL
: return "REL";
2134 case DT_RELSZ
: return "RELSZ";
2135 case DT_RELENT
: return "RELENT";
2136 case DT_PLTREL
: return "PLTREL";
2137 case DT_DEBUG
: return "DEBUG";
2138 case DT_TEXTREL
: return "TEXTREL";
2139 case DT_JMPREL
: return "JMPREL";
2140 case DT_BIND_NOW
: return "BIND_NOW";
2141 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2142 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2143 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2144 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2145 case DT_RUNPATH
: return "RUNPATH";
2146 case DT_FLAGS
: return "FLAGS";
2148 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2149 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2150 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2152 case DT_CHECKSUM
: return "CHECKSUM";
2153 case DT_PLTPADSZ
: return "PLTPADSZ";
2154 case DT_MOVEENT
: return "MOVEENT";
2155 case DT_MOVESZ
: return "MOVESZ";
2156 case DT_FEATURE
: return "FEATURE";
2157 case DT_POSFLAG_1
: return "POSFLAG_1";
2158 case DT_SYMINSZ
: return "SYMINSZ";
2159 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2161 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2162 case DT_CONFIG
: return "CONFIG";
2163 case DT_DEPAUDIT
: return "DEPAUDIT";
2164 case DT_AUDIT
: return "AUDIT";
2165 case DT_PLTPAD
: return "PLTPAD";
2166 case DT_MOVETAB
: return "MOVETAB";
2167 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2169 case DT_VERSYM
: return "VERSYM";
2171 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2172 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2173 case DT_RELACOUNT
: return "RELACOUNT";
2174 case DT_RELCOUNT
: return "RELCOUNT";
2175 case DT_FLAGS_1
: return "FLAGS_1";
2176 case DT_VERDEF
: return "VERDEF";
2177 case DT_VERDEFNUM
: return "VERDEFNUM";
2178 case DT_VERNEED
: return "VERNEED";
2179 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2181 case DT_AUXILIARY
: return "AUXILIARY";
2182 case DT_USED
: return "USED";
2183 case DT_FILTER
: return "FILTER";
2185 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2186 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2187 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2188 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2189 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2190 case DT_GNU_HASH
: return "GNU_HASH";
2193 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2195 const char * result
;
2197 switch (filedata
->file_header
.e_machine
)
2200 result
= get_aarch64_dynamic_type (type
);
2203 case EM_MIPS_RS3_LE
:
2204 result
= get_mips_dynamic_type (type
);
2207 result
= get_sparc64_dynamic_type (type
);
2210 result
= get_ppc_dynamic_type (type
);
2213 result
= get_ppc64_dynamic_type (type
);
2216 result
= get_ia64_dynamic_type (type
);
2219 result
= get_alpha_dynamic_type (type
);
2222 result
= get_score_dynamic_type (type
);
2225 result
= get_tic6x_dynamic_type (type
);
2227 case EM_ALTERA_NIOS2
:
2228 result
= get_nios2_dynamic_type (type
);
2231 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2232 result
= get_solaris_dynamic_type (type
);
2241 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2243 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2244 || (filedata
->file_header
.e_machine
== EM_PARISC
2245 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2247 const char * result
;
2249 switch (filedata
->file_header
.e_machine
)
2252 result
= get_parisc_dynamic_type (type
);
2255 result
= get_ia64_dynamic_type (type
);
2258 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2259 result
= get_solaris_dynamic_type (type
);
2268 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2272 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2279 get_file_type (unsigned e_type
)
2281 static char buff
[32];
2285 case ET_NONE
: return _("NONE (None)");
2286 case ET_REL
: return _("REL (Relocatable file)");
2287 case ET_EXEC
: return _("EXEC (Executable file)");
2288 case ET_DYN
: return _("DYN (Shared object file)");
2289 case ET_CORE
: return _("CORE (Core file)");
2292 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2293 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2294 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2295 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2297 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2303 get_machine_name (unsigned e_machine
)
2305 static char buff
[64]; /* XXX */
2309 /* Please keep this switch table sorted by increasing EM_ value. */
2311 case EM_NONE
: return _("None");
2312 case EM_M32
: return "WE32100";
2313 case EM_SPARC
: return "Sparc";
2314 case EM_386
: return "Intel 80386";
2315 case EM_68K
: return "MC68000";
2316 case EM_88K
: return "MC88000";
2317 case EM_IAMCU
: return "Intel MCU";
2318 case EM_860
: return "Intel 80860";
2319 case EM_MIPS
: return "MIPS R3000";
2320 case EM_S370
: return "IBM System/370";
2322 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2323 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2324 case EM_PARISC
: return "HPPA";
2325 case EM_VPP550
: return "Fujitsu VPP500";
2326 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2327 case EM_960
: return "Intel 80960";
2328 case EM_PPC
: return "PowerPC";
2330 case EM_PPC64
: return "PowerPC64";
2332 case EM_S390
: return "IBM S/390";
2333 case EM_SPU
: return "SPU";
2335 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2336 case EM_FR20
: return "Fujitsu FR20";
2337 case EM_RH32
: return "TRW RH32";
2338 case EM_MCORE
: return "MCORE";
2340 case EM_ARM
: return "ARM";
2341 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2342 case EM_SH
: return "Renesas / SuperH SH";
2343 case EM_SPARCV9
: return "Sparc v9";
2344 case EM_TRICORE
: return "Siemens Tricore";
2345 case EM_ARC
: return "ARC";
2346 case EM_H8_300
: return "Renesas H8/300";
2347 case EM_H8_300H
: return "Renesas H8/300H";
2348 case EM_H8S
: return "Renesas H8S";
2349 case EM_H8_500
: return "Renesas H8/500";
2351 case EM_IA_64
: return "Intel IA-64";
2352 case EM_MIPS_X
: return "Stanford MIPS-X";
2353 case EM_COLDFIRE
: return "Motorola Coldfire";
2354 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2355 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2356 case EM_PCP
: return "Siemens PCP";
2357 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2358 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2359 case EM_STARCORE
: return "Motorola Star*Core processor";
2360 case EM_ME16
: return "Toyota ME16 processor";
2362 case EM_ST100
: return "STMicroelectronics ST100 processor";
2363 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2364 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2365 case EM_PDSP
: return "Sony DSP processor";
2366 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2367 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2368 case EM_FX66
: return "Siemens FX66 microcontroller";
2369 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2370 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2371 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2373 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2374 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2375 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2376 case EM_SVX
: return "Silicon Graphics SVx";
2377 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2378 case EM_VAX
: return "Digital VAX";
2379 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2380 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2381 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2382 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2384 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2385 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2386 case EM_PRISM
: return "Vitesse Prism";
2388 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2389 case EM_CYGNUS_FR30
:
2390 case EM_FR30
: return "Fujitsu FR30";
2391 case EM_CYGNUS_D10V
:
2392 case EM_D10V
: return "d10v";
2393 case EM_CYGNUS_D30V
:
2394 case EM_D30V
: return "d30v";
2395 case EM_CYGNUS_V850
:
2396 case EM_V850
: return "Renesas V850";
2397 case EM_CYGNUS_M32R
:
2398 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2399 case EM_CYGNUS_MN10300
:
2400 case EM_MN10300
: return "mn10300";
2402 case EM_CYGNUS_MN10200
:
2403 case EM_MN10200
: return "mn10200";
2404 case EM_PJ
: return "picoJava";
2405 case EM_OR1K
: return "OpenRISC 1000";
2406 case EM_ARC_COMPACT
: return "ARCompact";
2408 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2409 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2410 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2411 case EM_NS32K
: return "National Semiconductor 32000 series";
2412 case EM_TPC
: return "Tenor Network TPC processor";
2413 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2415 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2417 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2418 case EM_MAX
: return "MAX Processor";
2419 case EM_CR
: return "National Semiconductor CompactRISC";
2420 case EM_F2MC16
: return "Fujitsu F2MC16";
2421 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2422 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2423 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2424 case EM_SEP
: return "Sharp embedded microprocessor";
2425 case EM_ARCA
: return "Arca RISC microprocessor";
2427 case EM_UNICORE
: return "Unicore";
2428 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2429 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2430 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2431 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2432 case EM_XGATE
: return "Motorola XGATE embedded processor";
2434 case EM_XC16X
: return "Infineon Technologies xc16x";
2435 case EM_M16C
: return "Renesas M16C series microprocessors";
2436 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2437 case EM_CE
: return "Freescale Communication Engine RISC core";
2439 case EM_M32C
: return "Renesas M32c";
2441 case EM_TSK3000
: return "Altium TSK3000 core";
2442 case EM_RS08
: return "Freescale RS08 embedded processor";
2443 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2444 case EM_SCORE
: return "SUNPLUS S+Core";
2445 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2446 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2447 case EM_LATTICEMICO32
: return "Lattice Mico32";
2448 case EM_SE_C17
: return "Seiko Epson C17 family";
2450 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2451 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2452 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2453 case EM_TI_PRU
: return "TI PRU I/O processor";
2455 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2456 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2457 case EM_R32C
: return "Renesas R32C series microprocessors";
2458 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2459 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2460 case EM_8051
: return "Intel 8051 and variants";
2461 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2462 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2463 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2464 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2466 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2467 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2468 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2469 case EM_RX
: return "Renesas RX";
2470 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2471 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2472 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2475 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2476 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2477 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2479 case EM_L1OM
: return "Intel L1OM";
2480 case EM_K1OM
: return "Intel K1OM";
2481 case EM_INTEL182
: return "Intel (reserved)";
2482 case EM_AARCH64
: return "AArch64";
2483 case EM_ARM184
: return "ARM (reserved)";
2484 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2485 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2486 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2487 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2489 case EM_CUDA
: return "NVIDIA CUDA architecture";
2490 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2491 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2492 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2493 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2494 case EM_ARC_COMPACT2
: return "ARCv2";
2495 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2496 case EM_RL78
: return "Renesas RL78";
2497 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2498 case EM_78K0R
: return "Renesas 78K0R";
2500 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2501 case EM_BA1
: return "Beyond BA1 CPU architecture";
2502 case EM_BA2
: return "Beyond BA2 CPU architecture";
2503 case EM_XCORE
: return "XMOS xCORE processor family";
2504 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2506 case EM_KM32
: return "KM211 KM32 32-bit processor";
2507 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2508 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2509 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2510 case EM_KVARC
: return "KM211 KVARC processor";
2511 case EM_CDP
: return "Paneve CDP architecture family";
2512 case EM_COGE
: return "Cognitive Smart Memory Processor";
2513 case EM_COOL
: return "Bluechip Systems CoolEngine";
2514 case EM_NORC
: return "Nanoradio Optimized RISC";
2515 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2517 case EM_Z80
: return "Zilog Z80";
2518 case EM_VISIUM
: return "CDS VISIUMcore processor";
2519 case EM_FT32
: return "FTDI Chip FT32";
2520 case EM_MOXIE
: return "Moxie";
2521 case EM_AMDGPU
: return "AMD GPU";
2522 case EM_RISCV
: return "RISC-V";
2523 case EM_LANAI
: return "Lanai 32-bit processor";
2524 case EM_BPF
: return "Linux BPF";
2525 case EM_NFP
: return "Netronome Flow Processor";
2527 /* Large numbers... */
2528 case EM_MT
: return "Morpho Techologies MT processor";
2529 case EM_ALPHA
: return "Alpha";
2530 case EM_WEBASSEMBLY
: return "Web Assembly";
2531 case EM_DLX
: return "OpenDLX";
2532 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2533 case EM_IQ2000
: return "Vitesse IQ2000";
2535 case EM_NIOS32
: return "Altera Nios";
2536 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2537 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2538 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2539 case EM_S12Z
: return "Freescale S12Z";
2540 case EM_CSKY
: return "C-SKY";
2543 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2549 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2551 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2552 other compilers don't a specific architecture type in the e_flags, and
2553 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2554 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2557 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2558 but also sets a specific architecture type in the e_flags field.
2560 However, when decoding the flags we don't worry if we see an
2561 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2562 ARCEM architecture type. */
2564 switch (e_flags
& EF_ARC_MACH_MSK
)
2566 /* We only expect these to occur for EM_ARC_COMPACT2. */
2567 case EF_ARC_CPU_ARCV2EM
:
2568 strcat (buf
, ", ARC EM");
2570 case EF_ARC_CPU_ARCV2HS
:
2571 strcat (buf
, ", ARC HS");
2574 /* We only expect these to occur for EM_ARC_COMPACT. */
2575 case E_ARC_MACH_ARC600
:
2576 strcat (buf
, ", ARC600");
2578 case E_ARC_MACH_ARC601
:
2579 strcat (buf
, ", ARC601");
2581 case E_ARC_MACH_ARC700
:
2582 strcat (buf
, ", ARC700");
2585 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2586 new ELF with new architecture being read by an old version of
2587 readelf, or (c) An ELF built with non-GNU compiler that does not
2588 set the architecture in the e_flags. */
2590 if (e_machine
== EM_ARC_COMPACT
)
2591 strcat (buf
, ", Unknown ARCompact");
2593 strcat (buf
, ", Unknown ARC");
2597 switch (e_flags
& EF_ARC_OSABI_MSK
)
2599 case E_ARC_OSABI_ORIG
:
2600 strcat (buf
, ", (ABI:legacy)");
2602 case E_ARC_OSABI_V2
:
2603 strcat (buf
, ", (ABI:v2)");
2605 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2606 case E_ARC_OSABI_V3
:
2607 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2609 case E_ARC_OSABI_V4
:
2610 strcat (buf
, ", v4 ABI");
2613 strcat (buf
, ", unrecognised ARC OSABI flag");
2619 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2622 bfd_boolean unknown
= FALSE
;
2624 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2625 e_flags
&= ~ EF_ARM_EABIMASK
;
2627 /* Handle "generic" ARM flags. */
2628 if (e_flags
& EF_ARM_RELEXEC
)
2630 strcat (buf
, ", relocatable executable");
2631 e_flags
&= ~ EF_ARM_RELEXEC
;
2634 if (e_flags
& EF_ARM_PIC
)
2636 strcat (buf
, ", position independent");
2637 e_flags
&= ~ EF_ARM_PIC
;
2640 /* Now handle EABI specific flags. */
2644 strcat (buf
, ", <unrecognized EABI>");
2649 case EF_ARM_EABI_VER1
:
2650 strcat (buf
, ", Version1 EABI");
2655 /* Process flags one bit at a time. */
2656 flag
= e_flags
& - e_flags
;
2661 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2662 strcat (buf
, ", sorted symbol tables");
2672 case EF_ARM_EABI_VER2
:
2673 strcat (buf
, ", Version2 EABI");
2678 /* Process flags one bit at a time. */
2679 flag
= e_flags
& - e_flags
;
2684 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2685 strcat (buf
, ", sorted symbol tables");
2688 case EF_ARM_DYNSYMSUSESEGIDX
:
2689 strcat (buf
, ", dynamic symbols use segment index");
2692 case EF_ARM_MAPSYMSFIRST
:
2693 strcat (buf
, ", mapping symbols precede others");
2703 case EF_ARM_EABI_VER3
:
2704 strcat (buf
, ", Version3 EABI");
2707 case EF_ARM_EABI_VER4
:
2708 strcat (buf
, ", Version4 EABI");
2713 /* Process flags one bit at a time. */
2714 flag
= e_flags
& - e_flags
;
2720 strcat (buf
, ", BE8");
2724 strcat (buf
, ", LE8");
2734 case EF_ARM_EABI_VER5
:
2735 strcat (buf
, ", Version5 EABI");
2740 /* Process flags one bit at a time. */
2741 flag
= e_flags
& - e_flags
;
2747 strcat (buf
, ", BE8");
2751 strcat (buf
, ", LE8");
2754 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2755 strcat (buf
, ", soft-float ABI");
2758 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2759 strcat (buf
, ", hard-float ABI");
2769 case EF_ARM_EABI_UNKNOWN
:
2770 strcat (buf
, ", GNU EABI");
2775 /* Process flags one bit at a time. */
2776 flag
= e_flags
& - e_flags
;
2781 case EF_ARM_INTERWORK
:
2782 strcat (buf
, ", interworking enabled");
2785 case EF_ARM_APCS_26
:
2786 strcat (buf
, ", uses APCS/26");
2789 case EF_ARM_APCS_FLOAT
:
2790 strcat (buf
, ", uses APCS/float");
2794 strcat (buf
, ", position independent");
2798 strcat (buf
, ", 8 bit structure alignment");
2801 case EF_ARM_NEW_ABI
:
2802 strcat (buf
, ", uses new ABI");
2805 case EF_ARM_OLD_ABI
:
2806 strcat (buf
, ", uses old ABI");
2809 case EF_ARM_SOFT_FLOAT
:
2810 strcat (buf
, ", software FP");
2813 case EF_ARM_VFP_FLOAT
:
2814 strcat (buf
, ", VFP");
2817 case EF_ARM_MAVERICK_FLOAT
:
2818 strcat (buf
, ", Maverick FP");
2829 strcat (buf
,_(", <unknown>"));
2833 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2835 --size
; /* Leave space for null terminator. */
2837 switch (e_flags
& EF_AVR_MACH
)
2839 case E_AVR_MACH_AVR1
:
2840 strncat (buf
, ", avr:1", size
);
2842 case E_AVR_MACH_AVR2
:
2843 strncat (buf
, ", avr:2", size
);
2845 case E_AVR_MACH_AVR25
:
2846 strncat (buf
, ", avr:25", size
);
2848 case E_AVR_MACH_AVR3
:
2849 strncat (buf
, ", avr:3", size
);
2851 case E_AVR_MACH_AVR31
:
2852 strncat (buf
, ", avr:31", size
);
2854 case E_AVR_MACH_AVR35
:
2855 strncat (buf
, ", avr:35", size
);
2857 case E_AVR_MACH_AVR4
:
2858 strncat (buf
, ", avr:4", size
);
2860 case E_AVR_MACH_AVR5
:
2861 strncat (buf
, ", avr:5", size
);
2863 case E_AVR_MACH_AVR51
:
2864 strncat (buf
, ", avr:51", size
);
2866 case E_AVR_MACH_AVR6
:
2867 strncat (buf
, ", avr:6", size
);
2869 case E_AVR_MACH_AVRTINY
:
2870 strncat (buf
, ", avr:100", size
);
2872 case E_AVR_MACH_XMEGA1
:
2873 strncat (buf
, ", avr:101", size
);
2875 case E_AVR_MACH_XMEGA2
:
2876 strncat (buf
, ", avr:102", size
);
2878 case E_AVR_MACH_XMEGA3
:
2879 strncat (buf
, ", avr:103", size
);
2881 case E_AVR_MACH_XMEGA4
:
2882 strncat (buf
, ", avr:104", size
);
2884 case E_AVR_MACH_XMEGA5
:
2885 strncat (buf
, ", avr:105", size
);
2887 case E_AVR_MACH_XMEGA6
:
2888 strncat (buf
, ", avr:106", size
);
2890 case E_AVR_MACH_XMEGA7
:
2891 strncat (buf
, ", avr:107", size
);
2894 strncat (buf
, ", avr:<unknown>", size
);
2898 size
-= strlen (buf
);
2899 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2900 strncat (buf
, ", link-relax", size
);
2904 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2910 bfd_boolean has_fpu
= FALSE
;
2913 static const char *ABI_STRINGS
[] =
2915 "ABI v0", /* use r5 as return register; only used in N1213HC */
2916 "ABI v1", /* use r0 as return register */
2917 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2918 "ABI v2fp", /* for FPU */
2922 static const char *VER_STRINGS
[] =
2924 "Andes ELF V1.3 or older",
2928 static const char *ARCH_STRINGS
[] =
2937 abi
= EF_NDS_ABI
& e_flags
;
2938 arch
= EF_NDS_ARCH
& e_flags
;
2939 config
= EF_NDS_INST
& e_flags
;
2940 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2942 memset (buf
, 0, size
);
2949 case E_NDS_ABI_V2FP
:
2950 case E_NDS_ABI_AABI
:
2951 case E_NDS_ABI_V2FP_PLUS
:
2952 /* In case there are holes in the array. */
2953 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2957 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2963 case E_NDS32_ELF_VER_1_2
:
2964 case E_NDS32_ELF_VER_1_3
:
2965 case E_NDS32_ELF_VER_1_4
:
2966 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2970 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2974 if (E_NDS_ABI_V0
== abi
)
2976 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2977 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2978 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2979 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2985 case E_NDS_ARCH_STAR_V1_0
:
2986 case E_NDS_ARCH_STAR_V2_0
:
2987 case E_NDS_ARCH_STAR_V3_0
:
2988 case E_NDS_ARCH_STAR_V3_M
:
2989 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2993 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2994 /* ARCH version determines how the e_flags are interpreted.
2995 If it is unknown, we cannot proceed. */
2999 /* Newer ABI; Now handle architecture specific flags. */
3000 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3002 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3003 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3005 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3006 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3008 if (config
& E_NDS32_HAS_DIV_INST
)
3009 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3011 if (config
& E_NDS32_HAS_16BIT_INST
)
3012 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3016 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3018 if (version
<= E_NDS32_ELF_VER_1_3
)
3019 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3021 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3024 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3025 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3027 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3028 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3030 if (config
& E_NDS32_HAS_16BIT_INST
)
3032 if (version
<= E_NDS32_ELF_VER_1_3
)
3033 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3035 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3039 if (config
& E_NDS32_HAS_EXT_INST
)
3040 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3042 if (config
& E_NDS32_HAS_EXT2_INST
)
3043 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3045 if (config
& E_NDS32_HAS_FPU_INST
)
3048 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3051 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3054 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3057 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3060 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3065 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3067 case E_NDS32_FPU_REG_8SP_4DP
:
3068 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3070 case E_NDS32_FPU_REG_16SP_8DP
:
3071 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3073 case E_NDS32_FPU_REG_32SP_16DP
:
3074 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3076 case E_NDS32_FPU_REG_32SP_32DP
:
3077 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3082 if (config
& E_NDS32_HAS_AUDIO_INST
)
3083 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3085 if (config
& E_NDS32_HAS_STRING_INST
)
3086 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3088 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3089 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3091 if (config
& E_NDS32_HAS_VIDEO_INST
)
3093 if (version
<= E_NDS32_ELF_VER_1_3
)
3094 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3096 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3099 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3100 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3102 if (config
& E_NDS32_HAS_L2C_INST
)
3103 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3107 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3109 static char buf
[1024];
3120 case EM_ARC_COMPACT2
:
3121 case EM_ARC_COMPACT
:
3122 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3126 decode_ARM_machine_flags (e_flags
, buf
);
3130 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3134 if (e_flags
& EF_BFIN_PIC
)
3135 strcat (buf
, ", PIC");
3137 if (e_flags
& EF_BFIN_FDPIC
)
3138 strcat (buf
, ", FDPIC");
3140 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3141 strcat (buf
, ", code in L1");
3143 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3144 strcat (buf
, ", data in L1");
3149 switch (e_flags
& EF_FRV_CPU_MASK
)
3151 case EF_FRV_CPU_GENERIC
:
3155 strcat (buf
, ", fr???");
3158 case EF_FRV_CPU_FR300
:
3159 strcat (buf
, ", fr300");
3162 case EF_FRV_CPU_FR400
:
3163 strcat (buf
, ", fr400");
3165 case EF_FRV_CPU_FR405
:
3166 strcat (buf
, ", fr405");
3169 case EF_FRV_CPU_FR450
:
3170 strcat (buf
, ", fr450");
3173 case EF_FRV_CPU_FR500
:
3174 strcat (buf
, ", fr500");
3176 case EF_FRV_CPU_FR550
:
3177 strcat (buf
, ", fr550");
3180 case EF_FRV_CPU_SIMPLE
:
3181 strcat (buf
, ", simple");
3183 case EF_FRV_CPU_TOMCAT
:
3184 strcat (buf
, ", tomcat");
3190 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3191 strcat (buf
, ", m68000");
3192 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3193 strcat (buf
, ", cpu32");
3194 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3195 strcat (buf
, ", fido_a");
3198 char const * isa
= _("unknown");
3199 char const * mac
= _("unknown mac");
3200 char const * additional
= NULL
;
3202 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3204 case EF_M68K_CF_ISA_A_NODIV
:
3206 additional
= ", nodiv";
3208 case EF_M68K_CF_ISA_A
:
3211 case EF_M68K_CF_ISA_A_PLUS
:
3214 case EF_M68K_CF_ISA_B_NOUSP
:
3216 additional
= ", nousp";
3218 case EF_M68K_CF_ISA_B
:
3221 case EF_M68K_CF_ISA_C
:
3224 case EF_M68K_CF_ISA_C_NODIV
:
3226 additional
= ", nodiv";
3229 strcat (buf
, ", cf, isa ");
3232 strcat (buf
, additional
);
3233 if (e_flags
& EF_M68K_CF_FLOAT
)
3234 strcat (buf
, ", float");
3235 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3240 case EF_M68K_CF_MAC
:
3243 case EF_M68K_CF_EMAC
:
3246 case EF_M68K_CF_EMAC_B
:
3259 switch (e_flags
& EF_MEP_CPU_MASK
)
3261 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3262 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3263 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3264 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3265 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3266 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3267 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3270 switch (e_flags
& EF_MEP_COP_MASK
)
3272 case EF_MEP_COP_NONE
: break;
3273 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3274 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3275 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3276 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3277 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3280 if (e_flags
& EF_MEP_LIBRARY
)
3281 strcat (buf
, ", Built for Library");
3283 if (e_flags
& EF_MEP_INDEX_MASK
)
3284 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3285 e_flags
& EF_MEP_INDEX_MASK
);
3287 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3288 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3289 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3293 if (e_flags
& EF_PPC_EMB
)
3294 strcat (buf
, ", emb");
3296 if (e_flags
& EF_PPC_RELOCATABLE
)
3297 strcat (buf
, _(", relocatable"));
3299 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3300 strcat (buf
, _(", relocatable-lib"));
3304 if (e_flags
& EF_PPC64_ABI
)
3306 char abi
[] = ", abiv0";
3308 abi
[6] += e_flags
& EF_PPC64_ABI
;
3314 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3315 strcat (buf
, ", RH850 ABI");
3317 if (e_flags
& EF_V800_850E3
)
3318 strcat (buf
, ", V3 architecture");
3320 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3321 strcat (buf
, ", FPU not used");
3323 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3324 strcat (buf
, ", regmode: COMMON");
3326 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3327 strcat (buf
, ", r4 not used");
3329 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3330 strcat (buf
, ", r30 not used");
3332 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3333 strcat (buf
, ", r5 not used");
3335 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3336 strcat (buf
, ", r2 not used");
3338 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3340 switch (e_flags
& - e_flags
)
3342 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3343 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3344 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3345 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3346 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3347 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3348 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3349 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3350 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3351 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3352 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3353 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3360 case EM_CYGNUS_V850
:
3361 switch (e_flags
& EF_V850_ARCH
)
3363 case E_V850E3V5_ARCH
:
3364 strcat (buf
, ", v850e3v5");
3366 case E_V850E2V3_ARCH
:
3367 strcat (buf
, ", v850e2v3");
3370 strcat (buf
, ", v850e2");
3373 strcat (buf
, ", v850e1");
3376 strcat (buf
, ", v850e");
3379 strcat (buf
, ", v850");
3382 strcat (buf
, _(", unknown v850 architecture variant"));
3388 case EM_CYGNUS_M32R
:
3389 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3390 strcat (buf
, ", m32r");
3394 case EM_MIPS_RS3_LE
:
3395 if (e_flags
& EF_MIPS_NOREORDER
)
3396 strcat (buf
, ", noreorder");
3398 if (e_flags
& EF_MIPS_PIC
)
3399 strcat (buf
, ", pic");
3401 if (e_flags
& EF_MIPS_CPIC
)
3402 strcat (buf
, ", cpic");
3404 if (e_flags
& EF_MIPS_UCODE
)
3405 strcat (buf
, ", ugen_reserved");
3407 if (e_flags
& EF_MIPS_ABI2
)
3408 strcat (buf
, ", abi2");
3410 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3411 strcat (buf
, ", odk first");
3413 if (e_flags
& EF_MIPS_32BITMODE
)
3414 strcat (buf
, ", 32bitmode");
3416 if (e_flags
& EF_MIPS_NAN2008
)
3417 strcat (buf
, ", nan2008");
3419 if (e_flags
& EF_MIPS_FP64
)
3420 strcat (buf
, ", fp64");
3422 switch ((e_flags
& EF_MIPS_MACH
))
3424 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3425 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3426 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3427 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3428 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3429 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3430 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3431 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3432 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3433 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3434 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3435 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3436 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3437 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3438 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3439 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3440 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3441 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3442 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3443 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3444 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3446 /* We simply ignore the field in this case to avoid confusion:
3447 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3450 default: strcat (buf
, _(", unknown CPU")); break;
3453 switch ((e_flags
& EF_MIPS_ABI
))
3455 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3456 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3457 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3458 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3460 /* We simply ignore the field in this case to avoid confusion:
3461 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3462 This means it is likely to be an o32 file, but not for
3465 default: strcat (buf
, _(", unknown ABI")); break;
3468 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3469 strcat (buf
, ", mdmx");
3471 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3472 strcat (buf
, ", mips16");
3474 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3475 strcat (buf
, ", micromips");
3477 switch ((e_flags
& EF_MIPS_ARCH
))
3479 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3480 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3481 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3482 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3483 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3484 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3485 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3486 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3487 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3488 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3489 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3490 default: strcat (buf
, _(", unknown ISA")); break;
3495 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3499 switch (EF_NFP_MACH (e_flags
))
3501 case E_NFP_MACH_3200
:
3502 strcat (buf
, ", NFP-32xx");
3504 case E_NFP_MACH_6000
:
3505 strcat (buf
, ", NFP-6xxx");
3511 if (e_flags
& EF_RISCV_RVC
)
3512 strcat (buf
, ", RVC");
3514 if (e_flags
& EF_RISCV_RVE
)
3515 strcat (buf
, ", RVE");
3517 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3519 case EF_RISCV_FLOAT_ABI_SOFT
:
3520 strcat (buf
, ", soft-float ABI");
3523 case EF_RISCV_FLOAT_ABI_SINGLE
:
3524 strcat (buf
, ", single-float ABI");
3527 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3528 strcat (buf
, ", double-float ABI");
3531 case EF_RISCV_FLOAT_ABI_QUAD
:
3532 strcat (buf
, ", quad-float ABI");
3538 switch ((e_flags
& EF_SH_MACH_MASK
))
3540 case EF_SH1
: strcat (buf
, ", sh1"); break;
3541 case EF_SH2
: strcat (buf
, ", sh2"); break;
3542 case EF_SH3
: strcat (buf
, ", sh3"); break;
3543 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3544 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3545 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3546 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3547 case EF_SH4
: strcat (buf
, ", sh4"); break;
3548 case EF_SH5
: strcat (buf
, ", sh5"); break;
3549 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3550 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3551 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3552 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3553 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3554 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3555 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3556 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3557 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3558 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3559 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3560 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3561 default: strcat (buf
, _(", unknown ISA")); break;
3564 if (e_flags
& EF_SH_PIC
)
3565 strcat (buf
, ", pic");
3567 if (e_flags
& EF_SH_FDPIC
)
3568 strcat (buf
, ", fdpic");
3572 if (e_flags
& EF_OR1K_NODELAY
)
3573 strcat (buf
, ", no delay");
3577 if (e_flags
& EF_SPARC_32PLUS
)
3578 strcat (buf
, ", v8+");
3580 if (e_flags
& EF_SPARC_SUN_US1
)
3581 strcat (buf
, ", ultrasparcI");
3583 if (e_flags
& EF_SPARC_SUN_US3
)
3584 strcat (buf
, ", ultrasparcIII");
3586 if (e_flags
& EF_SPARC_HAL_R1
)
3587 strcat (buf
, ", halr1");
3589 if (e_flags
& EF_SPARC_LEDATA
)
3590 strcat (buf
, ", ledata");
3592 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3593 strcat (buf
, ", tso");
3595 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3596 strcat (buf
, ", pso");
3598 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3599 strcat (buf
, ", rmo");
3603 switch (e_flags
& EF_PARISC_ARCH
)
3605 case EFA_PARISC_1_0
:
3606 strcpy (buf
, ", PA-RISC 1.0");
3608 case EFA_PARISC_1_1
:
3609 strcpy (buf
, ", PA-RISC 1.1");
3611 case EFA_PARISC_2_0
:
3612 strcpy (buf
, ", PA-RISC 2.0");
3617 if (e_flags
& EF_PARISC_TRAPNIL
)
3618 strcat (buf
, ", trapnil");
3619 if (e_flags
& EF_PARISC_EXT
)
3620 strcat (buf
, ", ext");
3621 if (e_flags
& EF_PARISC_LSB
)
3622 strcat (buf
, ", lsb");
3623 if (e_flags
& EF_PARISC_WIDE
)
3624 strcat (buf
, ", wide");
3625 if (e_flags
& EF_PARISC_NO_KABP
)
3626 strcat (buf
, ", no kabp");
3627 if (e_flags
& EF_PARISC_LAZYSWAP
)
3628 strcat (buf
, ", lazyswap");
3633 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3634 strcat (buf
, ", new calling convention");
3636 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3637 strcat (buf
, ", gnu calling convention");
3641 if ((e_flags
& EF_IA_64_ABI64
))
3642 strcat (buf
, ", 64-bit");
3644 strcat (buf
, ", 32-bit");
3645 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3646 strcat (buf
, ", reduced fp model");
3647 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3648 strcat (buf
, ", no function descriptors, constant gp");
3649 else if ((e_flags
& EF_IA_64_CONS_GP
))
3650 strcat (buf
, ", constant gp");
3651 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3652 strcat (buf
, ", absolute");
3653 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3655 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3656 strcat (buf
, ", vms_linkages");
3657 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3659 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3661 case EF_IA_64_VMS_COMCOD_WARNING
:
3662 strcat (buf
, ", warning");
3664 case EF_IA_64_VMS_COMCOD_ERROR
:
3665 strcat (buf
, ", error");
3667 case EF_IA_64_VMS_COMCOD_ABORT
:
3668 strcat (buf
, ", abort");
3671 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3672 e_flags
& EF_IA_64_VMS_COMCOD
);
3673 strcat (buf
, ", <unknown>");
3679 if ((e_flags
& EF_VAX_NONPIC
))
3680 strcat (buf
, ", non-PIC");
3681 if ((e_flags
& EF_VAX_DFLOAT
))
3682 strcat (buf
, ", D-Float");
3683 if ((e_flags
& EF_VAX_GFLOAT
))
3684 strcat (buf
, ", G-Float");
3688 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3689 strcat (buf
, ", mcm");
3690 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3691 strcat (buf
, ", mcm24");
3692 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3693 strcat (buf
, ", gr6");
3697 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3699 case E_FLAG_RL78_ANY_CPU
: break;
3700 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3701 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3702 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3704 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3705 strcat (buf
, ", 64-bit doubles");
3709 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3710 strcat (buf
, ", 64-bit doubles");
3711 if (e_flags
& E_FLAG_RX_DSP
)
3712 strcat (buf
, ", dsp");
3713 if (e_flags
& E_FLAG_RX_PID
)
3714 strcat (buf
, ", pid");
3715 if (e_flags
& E_FLAG_RX_ABI
)
3716 strcat (buf
, ", RX ABI");
3717 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3718 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3719 ? ", uses String instructions" : ", bans String instructions");
3720 if (e_flags
& E_FLAG_RX_V2
)
3721 strcat (buf
, ", V2");
3722 if (e_flags
& E_FLAG_RX_V3
)
3723 strcat (buf
, ", V3");
3727 if (e_flags
& EF_S390_HIGH_GPRS
)
3728 strcat (buf
, ", highgprs");
3732 if ((e_flags
& EF_C6000_REL
))
3733 strcat (buf
, ", relocatable module");
3737 strcat (buf
, _(": architecture variant: "));
3738 switch (e_flags
& EF_MSP430_MACH
)
3740 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3741 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3742 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3743 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3744 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3745 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3746 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3747 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3748 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3749 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3750 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3751 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3752 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3753 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3754 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3756 strcat (buf
, _(": unknown")); break;
3759 if (e_flags
& ~ EF_MSP430_MACH
)
3760 strcat (buf
, _(": unknown extra flag bits also present"));
3764 switch (e_flags
& EF_Z80_MACH_MSK
)
3766 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3767 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3768 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3769 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3770 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3771 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3772 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3774 strcat (buf
, _(", unknown")); break;
3784 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3786 static char buff
[32];
3790 case ELFOSABI_NONE
: return "UNIX - System V";
3791 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3792 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3793 case ELFOSABI_GNU
: return "UNIX - GNU";
3794 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3795 case ELFOSABI_AIX
: return "UNIX - AIX";
3796 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3797 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3798 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3799 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3800 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3801 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3802 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3803 case ELFOSABI_AROS
: return "AROS";
3804 case ELFOSABI_FENIXOS
: return "FenixOS";
3805 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3806 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3809 switch (filedata
->file_header
.e_machine
)
3814 case ELFOSABI_ARM
: return "ARM";
3815 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3826 case ELFOSABI_STANDALONE
: return _("Standalone App");
3835 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3836 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3845 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3851 get_aarch64_segment_type (unsigned long type
)
3855 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3856 default: return NULL
;
3861 get_arm_segment_type (unsigned long type
)
3865 case PT_ARM_EXIDX
: return "EXIDX";
3866 default: return NULL
;
3871 get_s390_segment_type (unsigned long type
)
3875 case PT_S390_PGSTE
: return "S390_PGSTE";
3876 default: return NULL
;
3881 get_mips_segment_type (unsigned long type
)
3885 case PT_MIPS_REGINFO
: return "REGINFO";
3886 case PT_MIPS_RTPROC
: return "RTPROC";
3887 case PT_MIPS_OPTIONS
: return "OPTIONS";
3888 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3889 default: return NULL
;
3894 get_parisc_segment_type (unsigned long type
)
3898 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3899 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3900 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3901 default: return NULL
;
3906 get_ia64_segment_type (unsigned long type
)
3910 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3911 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3912 default: return NULL
;
3917 get_tic6x_segment_type (unsigned long type
)
3921 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3922 default: return NULL
;
3927 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3929 if (e_machine
== EM_PARISC
)
3932 case PT_HP_TLS
: return "HP_TLS";
3933 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3934 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3935 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3936 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3937 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3938 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3939 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3940 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3941 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3942 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3943 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3944 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3945 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3946 case PT_HP_STACK
: return "HP_STACK";
3947 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3948 default: return NULL
;
3951 if (e_machine
== EM_IA_64
)
3954 case PT_HP_TLS
: return "HP_TLS";
3955 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3956 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3957 case PT_IA_64_HP_STACK
: return "HP_STACK";
3958 default: return NULL
;
3965 get_solaris_segment_type (unsigned long type
)
3969 case 0x6464e550: return "PT_SUNW_UNWIND";
3970 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3971 case 0x6ffffff7: return "PT_LOSUNW";
3972 case 0x6ffffffa: return "PT_SUNWBSS";
3973 case 0x6ffffffb: return "PT_SUNWSTACK";
3974 case 0x6ffffffc: return "PT_SUNWDTRACE";
3975 case 0x6ffffffd: return "PT_SUNWCAP";
3976 case 0x6fffffff: return "PT_HISUNW";
3977 default: return NULL
;
3982 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3984 static char buff
[32];
3988 case PT_NULL
: return "NULL";
3989 case PT_LOAD
: return "LOAD";
3990 case PT_DYNAMIC
: return "DYNAMIC";
3991 case PT_INTERP
: return "INTERP";
3992 case PT_NOTE
: return "NOTE";
3993 case PT_SHLIB
: return "SHLIB";
3994 case PT_PHDR
: return "PHDR";
3995 case PT_TLS
: return "TLS";
3996 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3997 case PT_GNU_STACK
: return "GNU_STACK";
3998 case PT_GNU_RELRO
: return "GNU_RELRO";
3999 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4002 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4004 const char * result
;
4006 switch (filedata
->file_header
.e_machine
)
4009 result
= get_aarch64_segment_type (p_type
);
4012 result
= get_arm_segment_type (p_type
);
4015 case EM_MIPS_RS3_LE
:
4016 result
= get_mips_segment_type (p_type
);
4019 result
= get_parisc_segment_type (p_type
);
4022 result
= get_ia64_segment_type (p_type
);
4025 result
= get_tic6x_segment_type (p_type
);
4029 result
= get_s390_segment_type (p_type
);
4039 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4041 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4043 const char * result
= NULL
;
4045 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4048 case ELFOSABI_FREEBSD
:
4049 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4051 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4056 result
= get_hpux_segment_type (p_type
,
4057 filedata
->file_header
.e_machine
);
4059 case ELFOSABI_SOLARIS
:
4060 result
= get_solaris_segment_type (p_type
);
4068 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4071 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4078 get_arc_section_type_name (unsigned int sh_type
)
4082 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4090 get_mips_section_type_name (unsigned int sh_type
)
4094 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4095 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4096 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4097 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4098 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4099 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4100 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4101 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4102 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4103 case SHT_MIPS_RELD
: return "MIPS_RELD";
4104 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4105 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4106 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4107 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4108 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4109 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4110 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4111 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4112 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4113 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4114 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4115 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4116 case SHT_MIPS_LINE
: return "MIPS_LINE";
4117 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4118 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4119 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4120 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4121 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4122 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4123 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4124 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4125 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4126 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4127 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4128 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4129 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4130 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4131 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4132 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4133 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4134 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4142 get_parisc_section_type_name (unsigned int sh_type
)
4146 case SHT_PARISC_EXT
: return "PARISC_EXT";
4147 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4148 case SHT_PARISC_DOC
: return "PARISC_DOC";
4149 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4150 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4151 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4152 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4153 default: return NULL
;
4158 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4160 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4161 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4162 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4166 case SHT_IA_64_EXT
: return "IA_64_EXT";
4167 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4168 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4169 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4170 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4171 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4172 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4173 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4174 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4175 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4183 get_x86_64_section_type_name (unsigned int sh_type
)
4187 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4188 default: return NULL
;
4193 get_aarch64_section_type_name (unsigned int sh_type
)
4197 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4198 default: return NULL
;
4203 get_arm_section_type_name (unsigned int sh_type
)
4207 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4208 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4209 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4210 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4211 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4212 default: return NULL
;
4217 get_tic6x_section_type_name (unsigned int sh_type
)
4221 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4222 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4223 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4224 case SHT_TI_ICODE
: return "TI_ICODE";
4225 case SHT_TI_XREF
: return "TI_XREF";
4226 case SHT_TI_HANDLER
: return "TI_HANDLER";
4227 case SHT_TI_INITINFO
: return "TI_INITINFO";
4228 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4229 default: return NULL
;
4234 get_msp430x_section_type_name (unsigned int sh_type
)
4238 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4239 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4240 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4241 default: return NULL
;
4246 get_nfp_section_type_name (unsigned int sh_type
)
4250 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4251 case SHT_NFP_INITREG
: return "NFP_INITREG";
4252 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4253 default: return NULL
;
4258 get_v850_section_type_name (unsigned int sh_type
)
4262 case SHT_V850_SCOMMON
: return "V850 Small Common";
4263 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4264 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4265 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4266 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4267 default: return NULL
;
4272 get_riscv_section_type_name (unsigned int sh_type
)
4276 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4277 default: return NULL
;
4282 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4284 static char buff
[32];
4285 const char * result
;
4289 case SHT_NULL
: return "NULL";
4290 case SHT_PROGBITS
: return "PROGBITS";
4291 case SHT_SYMTAB
: return "SYMTAB";
4292 case SHT_STRTAB
: return "STRTAB";
4293 case SHT_RELA
: return "RELA";
4294 case SHT_HASH
: return "HASH";
4295 case SHT_DYNAMIC
: return "DYNAMIC";
4296 case SHT_NOTE
: return "NOTE";
4297 case SHT_NOBITS
: return "NOBITS";
4298 case SHT_REL
: return "REL";
4299 case SHT_SHLIB
: return "SHLIB";
4300 case SHT_DYNSYM
: return "DYNSYM";
4301 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4302 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4303 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4304 case SHT_GNU_HASH
: return "GNU_HASH";
4305 case SHT_GROUP
: return "GROUP";
4306 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4307 case SHT_GNU_verdef
: return "VERDEF";
4308 case SHT_GNU_verneed
: return "VERNEED";
4309 case SHT_GNU_versym
: return "VERSYM";
4310 case 0x6ffffff0: return "VERSYM";
4311 case 0x6ffffffc: return "VERDEF";
4312 case 0x7ffffffd: return "AUXILIARY";
4313 case 0x7fffffff: return "FILTER";
4314 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4317 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4319 switch (filedata
->file_header
.e_machine
)
4322 case EM_ARC_COMPACT
:
4323 case EM_ARC_COMPACT2
:
4324 result
= get_arc_section_type_name (sh_type
);
4327 case EM_MIPS_RS3_LE
:
4328 result
= get_mips_section_type_name (sh_type
);
4331 result
= get_parisc_section_type_name (sh_type
);
4334 result
= get_ia64_section_type_name (filedata
, sh_type
);
4339 result
= get_x86_64_section_type_name (sh_type
);
4342 result
= get_aarch64_section_type_name (sh_type
);
4345 result
= get_arm_section_type_name (sh_type
);
4348 result
= get_tic6x_section_type_name (sh_type
);
4351 result
= get_msp430x_section_type_name (sh_type
);
4354 result
= get_nfp_section_type_name (sh_type
);
4358 case EM_CYGNUS_V850
:
4359 result
= get_v850_section_type_name (sh_type
);
4362 result
= get_riscv_section_type_name (sh_type
);
4372 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4374 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4376 switch (filedata
->file_header
.e_machine
)
4379 result
= get_ia64_section_type_name (filedata
, sh_type
);
4382 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4383 result
= get_solaris_section_type (sh_type
);
4388 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4389 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4390 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4391 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4403 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4405 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4407 switch (filedata
->file_header
.e_machine
)
4411 case EM_CYGNUS_V850
:
4412 result
= get_v850_section_type_name (sh_type
);
4422 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4425 /* This message is probably going to be displayed in a 15
4426 character wide field, so put the hex value first. */
4427 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4433 #define OPTION_DEBUG_DUMP 512
4434 #define OPTION_DYN_SYMS 513
4435 #define OPTION_DWARF_DEPTH 514
4436 #define OPTION_DWARF_START 515
4437 #define OPTION_DWARF_CHECK 516
4438 #define OPTION_CTF_DUMP 517
4439 #define OPTION_CTF_PARENT 518
4440 #define OPTION_CTF_SYMBOLS 519
4441 #define OPTION_CTF_STRINGS 520
4443 static struct option options
[] =
4445 {"all", no_argument
, 0, 'a'},
4446 {"file-header", no_argument
, 0, 'h'},
4447 {"program-headers", no_argument
, 0, 'l'},
4448 {"headers", no_argument
, 0, 'e'},
4449 {"histogram", no_argument
, 0, 'I'},
4450 {"segments", no_argument
, 0, 'l'},
4451 {"sections", no_argument
, 0, 'S'},
4452 {"section-headers", no_argument
, 0, 'S'},
4453 {"section-groups", no_argument
, 0, 'g'},
4454 {"section-details", no_argument
, 0, 't'},
4455 {"full-section-name",no_argument
, 0, 'N'},
4456 {"symbols", no_argument
, 0, 's'},
4457 {"syms", no_argument
, 0, 's'},
4458 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4459 {"relocs", no_argument
, 0, 'r'},
4460 {"notes", no_argument
, 0, 'n'},
4461 {"dynamic", no_argument
, 0, 'd'},
4462 {"arch-specific", no_argument
, 0, 'A'},
4463 {"version-info", no_argument
, 0, 'V'},
4464 {"use-dynamic", no_argument
, 0, 'D'},
4465 {"unwind", no_argument
, 0, 'u'},
4466 {"archive-index", no_argument
, 0, 'c'},
4467 {"hex-dump", required_argument
, 0, 'x'},
4468 {"relocated-dump", required_argument
, 0, 'R'},
4469 {"string-dump", required_argument
, 0, 'p'},
4470 {"decompress", no_argument
, 0, 'z'},
4471 #ifdef SUPPORT_DISASSEMBLY
4472 {"instruction-dump", required_argument
, 0, 'i'},
4474 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4476 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4477 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4478 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4480 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4482 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4483 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4484 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4486 {"version", no_argument
, 0, 'v'},
4487 {"wide", no_argument
, 0, 'W'},
4488 {"help", no_argument
, 0, 'H'},
4489 {0, no_argument
, 0, 0}
4493 usage (FILE * stream
)
4495 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4496 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4497 fprintf (stream
, _(" Options are:\n\
4498 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4499 -h --file-header Display the ELF file header\n\
4500 -l --program-headers Display the program headers\n\
4501 --segments An alias for --program-headers\n\
4502 -S --section-headers Display the sections' header\n\
4503 --sections An alias for --section-headers\n\
4504 -g --section-groups Display the section groups\n\
4505 -t --section-details Display the section details\n\
4506 -e --headers Equivalent to: -h -l -S\n\
4507 -s --syms Display the symbol table\n\
4508 --symbols An alias for --syms\n\
4509 --dyn-syms Display the dynamic symbol table\n\
4510 -n --notes Display the core notes (if present)\n\
4511 -r --relocs Display the relocations (if present)\n\
4512 -u --unwind Display the unwind info (if present)\n\
4513 -d --dynamic Display the dynamic section (if present)\n\
4514 -V --version-info Display the version sections (if present)\n\
4515 -A --arch-specific Display architecture specific information (if any)\n\
4516 -c --archive-index Display the symbol/file index in an archive\n\
4517 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4518 -x --hex-dump=<number|name>\n\
4519 Dump the contents of section <number|name> as bytes\n\
4520 -p --string-dump=<number|name>\n\
4521 Dump the contents of section <number|name> as strings\n\
4522 -R --relocated-dump=<number|name>\n\
4523 Dump the contents of section <number|name> as relocated bytes\n\
4524 -z --decompress Decompress section before dumping it\n\
4525 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4526 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4527 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4528 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4529 =addr,=cu_index,=links,=follow-links]\n\
4530 Display the contents of DWARF debug sections\n"));
4531 fprintf (stream
, _("\
4532 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4533 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4535 fprintf (stream
, _("\
4536 --ctf=<number|name> Display CTF info from section <number|name>\n\
4537 --ctf-parent=<number|name>\n\
4538 Use section <number|name> as the CTF parent\n\n\
4539 --ctf-symbols=<number|name>\n\
4540 Use section <number|name> as the CTF external symtab\n\n\
4541 --ctf-strings=<number|name>\n\
4542 Use section <number|name> as the CTF external strtab\n\n"));
4544 #ifdef SUPPORT_DISASSEMBLY
4545 fprintf (stream
, _("\
4546 -i --instruction-dump=<number|name>\n\
4547 Disassemble the contents of section <number|name>\n"));
4549 fprintf (stream
, _("\
4550 -I --histogram Display histogram of bucket list lengths\n\
4551 -W --wide Allow output width to exceed 80 characters\n\
4552 @<file> Read options from <file>\n\
4553 -H --help Display this information\n\
4554 -v --version Display the version number of readelf\n"));
4556 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4557 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4559 exit (stream
== stdout
? 0 : 1);
4562 /* Record the fact that the user wants the contents of section number
4563 SECTION to be displayed using the method(s) encoded as flags bits
4564 in TYPE. Note, TYPE can be zero if we are creating the array for
4568 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4570 if (section
>= filedata
->num_dump_sects
)
4572 dump_type
* new_dump_sects
;
4574 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4575 sizeof (* new_dump_sects
));
4577 if (new_dump_sects
== NULL
)
4578 error (_("Out of memory allocating dump request table.\n"));
4581 if (filedata
->dump_sects
)
4583 /* Copy current flag settings. */
4584 memcpy (new_dump_sects
, filedata
->dump_sects
,
4585 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4587 free (filedata
->dump_sects
);
4590 filedata
->dump_sects
= new_dump_sects
;
4591 filedata
->num_dump_sects
= section
+ 1;
4595 if (filedata
->dump_sects
)
4596 filedata
->dump_sects
[section
] |= type
;
4599 /* Request a dump by section name. */
4602 request_dump_byname (const char * section
, dump_type type
)
4604 struct dump_list_entry
* new_request
;
4606 new_request
= (struct dump_list_entry
*)
4607 malloc (sizeof (struct dump_list_entry
));
4609 error (_("Out of memory allocating dump request table.\n"));
4611 new_request
->name
= strdup (section
);
4612 if (!new_request
->name
)
4613 error (_("Out of memory allocating dump request table.\n"));
4615 new_request
->type
= type
;
4617 new_request
->next
= dump_sects_byname
;
4618 dump_sects_byname
= new_request
;
4622 request_dump (Filedata
* filedata
, dump_type type
)
4628 section
= strtoul (optarg
, & cp
, 0);
4630 if (! *cp
&& section
>= 0)
4631 request_dump_bynumber (filedata
, section
, type
);
4633 request_dump_byname (optarg
, type
);
4637 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4644 while ((c
= getopt_long
4645 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4663 do_section_groups
= TRUE
;
4666 do_histogram
= TRUE
;
4671 do_section_groups
= TRUE
;
4676 do_section_details
= TRUE
;
4687 do_using_dynamic
= TRUE
;
4711 do_histogram
= TRUE
;
4717 do_archive_index
= TRUE
;
4720 request_dump (filedata
, HEX_DUMP
);
4723 request_dump (filedata
, STRING_DUMP
);
4726 request_dump (filedata
, RELOC_DUMP
);
4729 decompress_dumps
= TRUE
;
4735 do_debugging
= TRUE
;
4736 dwarf_select_sections_all ();
4740 do_debugging
= FALSE
;
4741 dwarf_select_sections_by_letters (optarg
);
4744 case OPTION_DEBUG_DUMP
:
4747 do_debugging
= TRUE
;
4750 do_debugging
= FALSE
;
4751 dwarf_select_sections_by_names (optarg
);
4754 case OPTION_DWARF_DEPTH
:
4758 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4761 case OPTION_DWARF_START
:
4765 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4768 case OPTION_DWARF_CHECK
:
4771 case OPTION_CTF_DUMP
:
4773 request_dump (filedata
, CTF_DUMP
);
4775 case OPTION_CTF_SYMBOLS
:
4776 dump_ctf_symtab_name
= strdup (optarg
);
4778 case OPTION_CTF_STRINGS
:
4779 dump_ctf_strtab_name
= strdup (optarg
);
4781 case OPTION_CTF_PARENT
:
4782 dump_ctf_parent_name
= strdup (optarg
);
4784 case OPTION_DYN_SYMS
:
4787 #ifdef SUPPORT_DISASSEMBLY
4789 request_dump (filedata
, DISASS_DUMP
);
4793 print_version (program_name
);
4802 /* xgettext:c-format */
4803 error (_("Invalid option '-%c'\n"), c
);
4810 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4811 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4812 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4813 && !do_section_groups
&& !do_archive_index
4819 get_elf_class (unsigned int elf_class
)
4821 static char buff
[32];
4825 case ELFCLASSNONE
: return _("none");
4826 case ELFCLASS32
: return "ELF32";
4827 case ELFCLASS64
: return "ELF64";
4829 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4835 get_data_encoding (unsigned int encoding
)
4837 static char buff
[32];
4841 case ELFDATANONE
: return _("none");
4842 case ELFDATA2LSB
: return _("2's complement, little endian");
4843 case ELFDATA2MSB
: return _("2's complement, big endian");
4845 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4850 /* Decode the data held in 'filedata->file_header'. */
4853 process_file_header (Filedata
* filedata
)
4855 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4857 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4858 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4859 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4860 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4863 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4867 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4873 printf (_("ELF Header:\n"));
4874 printf (_(" Magic: "));
4875 for (i
= 0; i
< EI_NIDENT
; i
++)
4876 printf ("%2.2x ", header
->e_ident
[i
]);
4878 printf (_(" Class: %s\n"),
4879 get_elf_class (header
->e_ident
[EI_CLASS
]));
4880 printf (_(" Data: %s\n"),
4881 get_data_encoding (header
->e_ident
[EI_DATA
]));
4882 printf (_(" Version: %d%s\n"),
4883 header
->e_ident
[EI_VERSION
],
4884 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4886 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4889 printf (_(" OS/ABI: %s\n"),
4890 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4891 printf (_(" ABI Version: %d\n"),
4892 header
->e_ident
[EI_ABIVERSION
]);
4893 printf (_(" Type: %s\n"),
4894 get_file_type (header
->e_type
));
4895 printf (_(" Machine: %s\n"),
4896 get_machine_name (header
->e_machine
));
4897 printf (_(" Version: 0x%lx\n"),
4900 printf (_(" Entry point address: "));
4901 print_vma (header
->e_entry
, PREFIX_HEX
);
4902 printf (_("\n Start of program headers: "));
4903 print_vma (header
->e_phoff
, DEC
);
4904 printf (_(" (bytes into file)\n Start of section headers: "));
4905 print_vma (header
->e_shoff
, DEC
);
4906 printf (_(" (bytes into file)\n"));
4908 printf (_(" Flags: 0x%lx%s\n"),
4910 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4911 printf (_(" Size of this header: %u (bytes)\n"),
4913 printf (_(" Size of program headers: %u (bytes)\n"),
4914 header
->e_phentsize
);
4915 printf (_(" Number of program headers: %u"),
4917 if (filedata
->section_headers
!= NULL
4918 && header
->e_phnum
== PN_XNUM
4919 && filedata
->section_headers
[0].sh_info
!= 0)
4921 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4922 printf (" (%u)", header
->e_phnum
);
4924 putc ('\n', stdout
);
4925 printf (_(" Size of section headers: %u (bytes)\n"),
4926 header
->e_shentsize
);
4927 printf (_(" Number of section headers: %u"),
4929 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4931 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4932 printf (" (%u)", header
->e_shnum
);
4934 putc ('\n', stdout
);
4935 printf (_(" Section header string table index: %u"),
4936 header
->e_shstrndx
);
4937 if (filedata
->section_headers
!= NULL
4938 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4940 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4941 printf (" (%u)", header
->e_shstrndx
);
4943 if (header
->e_shstrndx
!= SHN_UNDEF
4944 && header
->e_shstrndx
>= header
->e_shnum
)
4946 header
->e_shstrndx
= SHN_UNDEF
;
4947 printf (_(" <corrupt: out of range>"));
4949 putc ('\n', stdout
);
4952 if (filedata
->section_headers
!= NULL
)
4954 if (header
->e_phnum
== PN_XNUM
4955 && filedata
->section_headers
[0].sh_info
!= 0)
4956 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4957 if (header
->e_shnum
== SHN_UNDEF
)
4958 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4959 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4960 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4961 if (header
->e_shstrndx
>= header
->e_shnum
)
4962 header
->e_shstrndx
= SHN_UNDEF
;
4963 free (filedata
->section_headers
);
4964 filedata
->section_headers
= NULL
;
4970 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4971 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4974 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4976 Elf32_External_Phdr
* phdrs
;
4977 Elf32_External_Phdr
* external
;
4978 Elf_Internal_Phdr
* internal
;
4980 unsigned int size
= filedata
->file_header
.e_phentsize
;
4981 unsigned int num
= filedata
->file_header
.e_phnum
;
4983 /* PR binutils/17531: Cope with unexpected section header sizes. */
4984 if (size
== 0 || num
== 0)
4986 if (size
< sizeof * phdrs
)
4988 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4991 if (size
> sizeof * phdrs
)
4992 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4994 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4995 size
, num
, _("program headers"));
4999 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5000 i
< filedata
->file_header
.e_phnum
;
5001 i
++, internal
++, external
++)
5003 internal
->p_type
= BYTE_GET (external
->p_type
);
5004 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5005 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5006 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5007 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5008 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5009 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5010 internal
->p_align
= BYTE_GET (external
->p_align
);
5017 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5018 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5021 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5023 Elf64_External_Phdr
* phdrs
;
5024 Elf64_External_Phdr
* external
;
5025 Elf_Internal_Phdr
* internal
;
5027 unsigned int size
= filedata
->file_header
.e_phentsize
;
5028 unsigned int num
= filedata
->file_header
.e_phnum
;
5030 /* PR binutils/17531: Cope with unexpected section header sizes. */
5031 if (size
== 0 || num
== 0)
5033 if (size
< sizeof * phdrs
)
5035 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5038 if (size
> sizeof * phdrs
)
5039 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5041 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5042 size
, num
, _("program headers"));
5046 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5047 i
< filedata
->file_header
.e_phnum
;
5048 i
++, internal
++, external
++)
5050 internal
->p_type
= BYTE_GET (external
->p_type
);
5051 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5052 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5053 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5054 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5055 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5056 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5057 internal
->p_align
= BYTE_GET (external
->p_align
);
5064 /* Returns TRUE if the program headers were read into `program_headers'. */
5067 get_program_headers (Filedata
* filedata
)
5069 Elf_Internal_Phdr
* phdrs
;
5071 /* Check cache of prior read. */
5072 if (filedata
->program_headers
!= NULL
)
5075 /* Be kind to memory checkers by looking for
5076 e_phnum values which we know must be invalid. */
5077 if (filedata
->file_header
.e_phnum
5078 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5079 >= filedata
->file_size
)
5081 error (_("Too many program headers - %#x - the file is not that big\n"),
5082 filedata
->file_header
.e_phnum
);
5086 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5087 sizeof (Elf_Internal_Phdr
));
5090 error (_("Out of memory reading %u program headers\n"),
5091 filedata
->file_header
.e_phnum
);
5096 ? get_32bit_program_headers (filedata
, phdrs
)
5097 : get_64bit_program_headers (filedata
, phdrs
))
5099 filedata
->program_headers
= phdrs
;
5107 /* Returns TRUE if the program headers were loaded. */
5110 process_program_headers (Filedata
* filedata
)
5112 Elf_Internal_Phdr
* segment
;
5114 Elf_Internal_Phdr
* previous_load
= NULL
;
5119 if (filedata
->file_header
.e_phnum
== 0)
5121 /* PR binutils/12467. */
5122 if (filedata
->file_header
.e_phoff
!= 0)
5124 warn (_("possibly corrupt ELF header - it has a non-zero program"
5125 " header offset, but no program headers\n"));
5128 else if (do_segments
)
5129 printf (_("\nThere are no program headers in this file.\n"));
5133 if (do_segments
&& !do_header
)
5135 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5136 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5137 printf (ngettext ("There is %d program header, starting at offset %s\n",
5138 "There are %d program headers, starting at offset %s\n",
5139 filedata
->file_header
.e_phnum
),
5140 filedata
->file_header
.e_phnum
,
5141 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5144 if (! get_program_headers (filedata
))
5149 if (filedata
->file_header
.e_phnum
> 1)
5150 printf (_("\nProgram Headers:\n"));
5152 printf (_("\nProgram Headers:\n"));
5156 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5159 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5163 (_(" Type Offset VirtAddr PhysAddr\n"));
5165 (_(" FileSiz MemSiz Flags Align\n"));
5169 for (i
= 0, segment
= filedata
->program_headers
;
5170 i
< filedata
->file_header
.e_phnum
;
5175 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5179 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5180 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5181 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5182 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5183 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5185 (segment
->p_flags
& PF_R
? 'R' : ' '),
5186 (segment
->p_flags
& PF_W
? 'W' : ' '),
5187 (segment
->p_flags
& PF_X
? 'E' : ' '));
5188 printf ("%#lx", (unsigned long) segment
->p_align
);
5192 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5193 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5196 print_vma (segment
->p_offset
, FULL_HEX
);
5200 print_vma (segment
->p_vaddr
, FULL_HEX
);
5202 print_vma (segment
->p_paddr
, FULL_HEX
);
5205 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5206 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5209 print_vma (segment
->p_filesz
, FULL_HEX
);
5213 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5214 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5217 print_vma (segment
->p_memsz
, FULL_HEX
);
5221 (segment
->p_flags
& PF_R
? 'R' : ' '),
5222 (segment
->p_flags
& PF_W
? 'W' : ' '),
5223 (segment
->p_flags
& PF_X
? 'E' : ' '));
5225 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5226 printf ("%#lx", (unsigned long) segment
->p_align
);
5229 print_vma (segment
->p_align
, PREFIX_HEX
);
5234 print_vma (segment
->p_offset
, FULL_HEX
);
5236 print_vma (segment
->p_vaddr
, FULL_HEX
);
5238 print_vma (segment
->p_paddr
, FULL_HEX
);
5240 print_vma (segment
->p_filesz
, FULL_HEX
);
5242 print_vma (segment
->p_memsz
, FULL_HEX
);
5244 (segment
->p_flags
& PF_R
? 'R' : ' '),
5245 (segment
->p_flags
& PF_W
? 'W' : ' '),
5246 (segment
->p_flags
& PF_X
? 'E' : ' '));
5247 print_vma (segment
->p_align
, PREFIX_HEX
);
5250 putc ('\n', stdout
);
5253 switch (segment
->p_type
)
5256 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5257 required by the ELF standard, several programs, including the Linux
5258 kernel, make use of non-ordered segments. */
5260 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5261 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5263 if (segment
->p_memsz
< segment
->p_filesz
)
5264 error (_("the segment's file size is larger than its memory size\n"));
5265 previous_load
= segment
;
5269 /* PR 20815 - Verify that the program header is loaded into memory. */
5270 if (i
> 0 && previous_load
!= NULL
)
5271 error (_("the PHDR segment must occur before any LOAD segment\n"));
5272 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5276 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5278 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5279 if (load
->p_type
== PT_LOAD
5280 && load
->p_offset
<= segment
->p_offset
5281 && (load
->p_offset
+ load
->p_filesz
5282 >= segment
->p_offset
+ segment
->p_filesz
)
5283 && load
->p_vaddr
<= segment
->p_vaddr
5284 && (load
->p_vaddr
+ load
->p_filesz
5285 >= segment
->p_vaddr
+ segment
->p_filesz
))
5288 if (j
== filedata
->file_header
.e_phnum
)
5289 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5295 error (_("more than one dynamic segment\n"));
5297 /* By default, assume that the .dynamic section is the first
5298 section in the DYNAMIC segment. */
5299 dynamic_addr
= segment
->p_offset
;
5300 dynamic_size
= segment
->p_filesz
;
5302 /* Try to locate the .dynamic section. If there is
5303 a section header table, we can easily locate it. */
5304 if (filedata
->section_headers
!= NULL
)
5306 Elf_Internal_Shdr
* sec
;
5308 sec
= find_section (filedata
, ".dynamic");
5309 if (sec
== NULL
|| sec
->sh_size
== 0)
5311 /* A corresponding .dynamic section is expected, but on
5312 IA-64/OpenVMS it is OK for it to be missing. */
5313 if (!is_ia64_vms (filedata
))
5314 error (_("no .dynamic section in the dynamic segment\n"));
5318 if (sec
->sh_type
== SHT_NOBITS
)
5324 dynamic_addr
= sec
->sh_offset
;
5325 dynamic_size
= sec
->sh_size
;
5327 if (dynamic_addr
< segment
->p_offset
5328 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5329 warn (_("the .dynamic section is not contained"
5330 " within the dynamic segment\n"));
5331 else if (dynamic_addr
> segment
->p_offset
)
5332 warn (_("the .dynamic section is not the first section"
5333 " in the dynamic segment.\n"));
5336 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5337 segment. Check this after matching against the section headers
5338 so we don't warn on debuginfo file (which have NOBITS .dynamic
5340 if (dynamic_addr
> filedata
->file_size
5341 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5343 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5344 dynamic_addr
= dynamic_size
= 0;
5349 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5351 error (_("Unable to find program interpreter name\n"));
5355 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5357 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5358 error (_("Internal error: failed to create format string to display program interpreter\n"));
5360 program_interpreter
[0] = 0;
5361 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5362 error (_("Unable to read program interpreter name\n"));
5365 printf (_(" [Requesting program interpreter: %s]\n"),
5366 program_interpreter
);
5373 && filedata
->section_headers
!= NULL
5374 && filedata
->string_table
!= NULL
)
5376 printf (_("\n Section to Segment mapping:\n"));
5377 printf (_(" Segment Sections...\n"));
5379 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5382 Elf_Internal_Shdr
* section
;
5384 segment
= filedata
->program_headers
+ i
;
5385 section
= filedata
->section_headers
+ 1;
5387 printf (" %2.2d ", i
);
5389 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5391 if (!ELF_TBSS_SPECIAL (section
, segment
)
5392 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5393 printf ("%s ", printable_section_name (filedata
, section
));
5404 /* Find the file offset corresponding to VMA by using the program headers. */
5407 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5409 Elf_Internal_Phdr
* seg
;
5411 if (! get_program_headers (filedata
))
5413 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5417 for (seg
= filedata
->program_headers
;
5418 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5421 if (seg
->p_type
!= PT_LOAD
)
5424 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5425 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5426 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5429 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5430 (unsigned long) vma
);
5435 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5436 If PROBE is true, this is just a probe and we do not generate any error
5437 messages if the load fails. */
5440 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5442 Elf32_External_Shdr
* shdrs
;
5443 Elf_Internal_Shdr
* internal
;
5445 unsigned int size
= filedata
->file_header
.e_shentsize
;
5446 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5448 /* PR binutils/17531: Cope with unexpected section header sizes. */
5449 if (size
== 0 || num
== 0)
5451 if (size
< sizeof * shdrs
)
5454 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5457 if (!probe
&& size
> sizeof * shdrs
)
5458 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5460 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5462 probe
? NULL
: _("section headers"));
5466 free (filedata
->section_headers
);
5467 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5468 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5469 if (filedata
->section_headers
== NULL
)
5472 error (_("Out of memory reading %u section headers\n"), num
);
5477 for (i
= 0, internal
= filedata
->section_headers
;
5481 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5482 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5483 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5484 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5485 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5486 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5487 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5488 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5489 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5490 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5491 if (!probe
&& internal
->sh_link
> num
)
5492 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5493 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5494 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5501 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5504 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5506 Elf64_External_Shdr
* shdrs
;
5507 Elf_Internal_Shdr
* internal
;
5509 unsigned int size
= filedata
->file_header
.e_shentsize
;
5510 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5512 /* PR binutils/17531: Cope with unexpected section header sizes. */
5513 if (size
== 0 || num
== 0)
5516 if (size
< sizeof * shdrs
)
5519 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5523 if (! probe
&& size
> sizeof * shdrs
)
5524 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5526 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5527 filedata
->file_header
.e_shoff
,
5529 probe
? NULL
: _("section headers"));
5533 free (filedata
->section_headers
);
5534 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5535 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5536 if (filedata
->section_headers
== NULL
)
5539 error (_("Out of memory reading %u section headers\n"), num
);
5544 for (i
= 0, internal
= filedata
->section_headers
;
5548 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5549 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5550 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5551 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5552 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5553 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5554 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5555 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5556 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5557 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5558 if (!probe
&& internal
->sh_link
> num
)
5559 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5560 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5561 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5568 static Elf_Internal_Sym
*
5569 get_32bit_elf_symbols (Filedata
* filedata
,
5570 Elf_Internal_Shdr
* section
,
5571 unsigned long * num_syms_return
)
5573 unsigned long number
= 0;
5574 Elf32_External_Sym
* esyms
= NULL
;
5575 Elf_External_Sym_Shndx
* shndx
= NULL
;
5576 Elf_Internal_Sym
* isyms
= NULL
;
5577 Elf_Internal_Sym
* psym
;
5579 elf_section_list
* entry
;
5581 if (section
->sh_size
== 0)
5583 if (num_syms_return
!= NULL
)
5584 * num_syms_return
= 0;
5588 /* Run some sanity checks first. */
5589 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5591 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5592 printable_section_name (filedata
, section
),
5593 (unsigned long) section
->sh_entsize
);
5597 if (section
->sh_size
> filedata
->file_size
)
5599 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5600 printable_section_name (filedata
, section
),
5601 (unsigned long) section
->sh_size
);
5605 number
= section
->sh_size
/ section
->sh_entsize
;
5607 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5609 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5610 (unsigned long) section
->sh_size
,
5611 printable_section_name (filedata
, section
),
5612 (unsigned long) section
->sh_entsize
);
5616 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5617 section
->sh_size
, _("symbols"));
5622 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5624 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5629 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5633 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5634 entry
->hdr
->sh_offset
,
5635 1, entry
->hdr
->sh_size
,
5636 _("symbol table section indices"));
5640 /* PR17531: file: heap-buffer-overflow */
5641 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5643 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5644 printable_section_name (filedata
, entry
->hdr
),
5645 (unsigned long) entry
->hdr
->sh_size
,
5646 (unsigned long) section
->sh_size
);
5651 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5655 error (_("Out of memory reading %lu symbols\n"),
5656 (unsigned long) number
);
5660 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5662 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5663 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5664 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5665 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5666 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5668 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5669 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5670 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5671 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5672 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5679 if (num_syms_return
!= NULL
)
5680 * num_syms_return
= isyms
== NULL
? 0 : number
;
5685 static Elf_Internal_Sym
*
5686 get_64bit_elf_symbols (Filedata
* filedata
,
5687 Elf_Internal_Shdr
* section
,
5688 unsigned long * num_syms_return
)
5690 unsigned long number
= 0;
5691 Elf64_External_Sym
* esyms
= NULL
;
5692 Elf_External_Sym_Shndx
* shndx
= NULL
;
5693 Elf_Internal_Sym
* isyms
= NULL
;
5694 Elf_Internal_Sym
* psym
;
5696 elf_section_list
* entry
;
5698 if (section
->sh_size
== 0)
5700 if (num_syms_return
!= NULL
)
5701 * num_syms_return
= 0;
5705 /* Run some sanity checks first. */
5706 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5708 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5709 printable_section_name (filedata
, section
),
5710 (unsigned long) section
->sh_entsize
);
5714 if (section
->sh_size
> filedata
->file_size
)
5716 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5717 printable_section_name (filedata
, section
),
5718 (unsigned long) section
->sh_size
);
5722 number
= section
->sh_size
/ section
->sh_entsize
;
5724 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5726 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5727 (unsigned long) section
->sh_size
,
5728 printable_section_name (filedata
, section
),
5729 (unsigned long) section
->sh_entsize
);
5733 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5734 section
->sh_size
, _("symbols"));
5739 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5741 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5746 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5750 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5751 entry
->hdr
->sh_offset
,
5752 1, entry
->hdr
->sh_size
,
5753 _("symbol table section indices"));
5757 /* PR17531: file: heap-buffer-overflow */
5758 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5760 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5761 printable_section_name (filedata
, entry
->hdr
),
5762 (unsigned long) entry
->hdr
->sh_size
,
5763 (unsigned long) section
->sh_size
);
5768 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5772 error (_("Out of memory reading %lu symbols\n"),
5773 (unsigned long) number
);
5777 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5779 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5780 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5781 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5782 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5784 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5786 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5787 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5788 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5790 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5791 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5798 if (num_syms_return
!= NULL
)
5799 * num_syms_return
= isyms
== NULL
? 0 : number
;
5805 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5807 static char buff
[1024];
5809 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5811 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5812 bfd_vma os_flags
= 0;
5813 bfd_vma proc_flags
= 0;
5814 bfd_vma unknown_flags
= 0;
5822 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5823 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5824 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5825 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5826 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5827 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5828 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5829 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5830 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5831 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5832 /* IA-64 specific. */
5833 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5834 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5835 /* IA-64 OpenVMS specific. */
5836 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5837 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5838 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5839 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5840 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5841 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5843 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5844 /* SPARC specific. */
5845 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5846 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5848 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5849 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5850 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5852 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5854 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5857 if (do_section_details
)
5859 sprintf (buff
, "[%*.*lx]: ",
5860 field_size
, field_size
, (unsigned long) sh_flags
);
5861 p
+= field_size
+ 4;
5868 flag
= sh_flags
& - sh_flags
;
5871 if (do_section_details
)
5875 case SHF_WRITE
: sindex
= 0; break;
5876 case SHF_ALLOC
: sindex
= 1; break;
5877 case SHF_EXECINSTR
: sindex
= 2; break;
5878 case SHF_MERGE
: sindex
= 3; break;
5879 case SHF_STRINGS
: sindex
= 4; break;
5880 case SHF_INFO_LINK
: sindex
= 5; break;
5881 case SHF_LINK_ORDER
: sindex
= 6; break;
5882 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5883 case SHF_GROUP
: sindex
= 8; break;
5884 case SHF_TLS
: sindex
= 9; break;
5885 case SHF_EXCLUDE
: sindex
= 18; break;
5886 case SHF_COMPRESSED
: sindex
= 20; break;
5887 case SHF_GNU_MBIND
: sindex
= 24; break;
5891 switch (filedata
->file_header
.e_machine
)
5894 if (flag
== SHF_IA_64_SHORT
)
5896 else if (flag
== SHF_IA_64_NORECOV
)
5899 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5902 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5903 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5904 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5905 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5906 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5907 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5918 case EM_OLD_SPARCV9
:
5919 case EM_SPARC32PLUS
:
5922 if (flag
== SHF_ORDERED
)
5929 case SHF_ENTRYSECT
: sindex
= 21; break;
5930 case SHF_ARM_PURECODE
: sindex
= 22; break;
5931 case SHF_COMDEF
: sindex
= 23; break;
5936 if (flag
== SHF_PPC_VLE
)
5947 if (p
!= buff
+ field_size
+ 4)
5949 if (size
< (10 + 2))
5951 warn (_("Internal error: not enough buffer room for section flag info"));
5952 return _("<unknown>");
5959 size
-= flags
[sindex
].len
;
5960 p
= stpcpy (p
, flags
[sindex
].str
);
5962 else if (flag
& SHF_MASKOS
)
5964 else if (flag
& SHF_MASKPROC
)
5967 unknown_flags
|= flag
;
5973 case SHF_WRITE
: *p
= 'W'; break;
5974 case SHF_ALLOC
: *p
= 'A'; break;
5975 case SHF_EXECINSTR
: *p
= 'X'; break;
5976 case SHF_MERGE
: *p
= 'M'; break;
5977 case SHF_STRINGS
: *p
= 'S'; break;
5978 case SHF_INFO_LINK
: *p
= 'I'; break;
5979 case SHF_LINK_ORDER
: *p
= 'L'; break;
5980 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5981 case SHF_GROUP
: *p
= 'G'; break;
5982 case SHF_TLS
: *p
= 'T'; break;
5983 case SHF_EXCLUDE
: *p
= 'E'; break;
5984 case SHF_COMPRESSED
: *p
= 'C'; break;
5985 case SHF_GNU_MBIND
: *p
= 'D'; break;
5988 if ((filedata
->file_header
.e_machine
== EM_X86_64
5989 || filedata
->file_header
.e_machine
== EM_L1OM
5990 || filedata
->file_header
.e_machine
== EM_K1OM
)
5991 && flag
== SHF_X86_64_LARGE
)
5993 else if (filedata
->file_header
.e_machine
== EM_ARM
5994 && flag
== SHF_ARM_PURECODE
)
5996 else if (filedata
->file_header
.e_machine
== EM_PPC
5997 && flag
== SHF_PPC_VLE
)
5999 else if (flag
& SHF_MASKOS
)
6002 sh_flags
&= ~ SHF_MASKOS
;
6004 else if (flag
& SHF_MASKPROC
)
6007 sh_flags
&= ~ SHF_MASKPROC
;
6017 if (do_section_details
)
6021 size
-= 5 + field_size
;
6022 if (p
!= buff
+ field_size
+ 4)
6026 warn (_("Internal error: not enough buffer room for section flag info"));
6027 return _("<unknown>");
6033 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6034 (unsigned long) os_flags
);
6035 p
+= 5 + field_size
;
6039 size
-= 7 + field_size
;
6040 if (p
!= buff
+ field_size
+ 4)
6044 warn (_("Internal error: not enough buffer room for section flag info"));
6045 return _("<unknown>");
6051 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6052 (unsigned long) proc_flags
);
6053 p
+= 7 + field_size
;
6057 size
-= 10 + field_size
;
6058 if (p
!= buff
+ field_size
+ 4)
6062 warn (_("Internal error: not enough buffer room for section flag info"));
6063 return _("<unknown>");
6069 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6070 (unsigned long) unknown_flags
);
6071 p
+= 10 + field_size
;
6080 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6084 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6086 if (size
< sizeof (* echdr
))
6088 error (_("Compressed section is too small even for a compression header\n"));
6092 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6093 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6094 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6095 return sizeof (*echdr
);
6099 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6101 if (size
< sizeof (* echdr
))
6103 error (_("Compressed section is too small even for a compression header\n"));
6107 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6108 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6109 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6110 return sizeof (*echdr
);
6115 process_section_headers (Filedata
* filedata
)
6117 Elf_Internal_Shdr
* section
;
6120 free (filedata
->section_headers
);
6121 filedata
->section_headers
= NULL
;
6123 if (filedata
->file_header
.e_shnum
== 0)
6125 /* PR binutils/12467. */
6126 if (filedata
->file_header
.e_shoff
!= 0)
6128 warn (_("possibly corrupt ELF file header - it has a non-zero"
6129 " section header offset, but no section headers\n"));
6132 else if (do_sections
)
6133 printf (_("\nThere are no sections in this file.\n"));
6138 if (do_sections
&& !do_header
)
6139 printf (ngettext ("There is %d section header, "
6140 "starting at offset 0x%lx:\n",
6141 "There are %d section headers, "
6142 "starting at offset 0x%lx:\n",
6143 filedata
->file_header
.e_shnum
),
6144 filedata
->file_header
.e_shnum
,
6145 (unsigned long) filedata
->file_header
.e_shoff
);
6149 if (! get_32bit_section_headers (filedata
, FALSE
))
6154 if (! get_64bit_section_headers (filedata
, FALSE
))
6158 /* Read in the string table, so that we have names to display. */
6159 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6160 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6162 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6164 if (section
->sh_size
!= 0)
6166 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6167 1, section
->sh_size
,
6170 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6174 /* Scan the sections for the dynamic symbol table
6175 and dynamic string table and debug sections. */
6176 free (dynamic_symbols
);
6177 dynamic_symbols
= NULL
;
6178 num_dynamic_syms
= 0;
6179 free (dynamic_strings
);
6180 dynamic_strings
= NULL
;
6181 dynamic_strings_length
= 0;
6182 free (dynamic_syminfo
);
6183 dynamic_syminfo
= NULL
;
6184 while (symtab_shndx_list
!= NULL
)
6186 elf_section_list
*next
= symtab_shndx_list
->next
;
6187 free (symtab_shndx_list
);
6188 symtab_shndx_list
= next
;
6191 eh_addr_size
= is_32bit_elf
? 4 : 8;
6192 switch (filedata
->file_header
.e_machine
)
6195 case EM_MIPS_RS3_LE
:
6196 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6197 FDE addresses. However, the ABI also has a semi-official ILP32
6198 variant for which the normal FDE address size rules apply.
6200 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6201 section, where XX is the size of longs in bits. Unfortunately,
6202 earlier compilers provided no way of distinguishing ILP32 objects
6203 from LP64 objects, so if there's any doubt, we should assume that
6204 the official LP64 form is being used. */
6205 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6206 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6212 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6214 case E_H8_MACH_H8300
:
6215 case E_H8_MACH_H8300HN
:
6216 case E_H8_MACH_H8300SN
:
6217 case E_H8_MACH_H8300SXN
:
6220 case E_H8_MACH_H8300H
:
6221 case E_H8_MACH_H8300S
:
6222 case E_H8_MACH_H8300SX
:
6230 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6232 case EF_M32C_CPU_M16C
:
6239 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6242 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6243 if (section->sh_entsize != expected_entsize) \
6246 sprintf_vma (buf, section->sh_entsize); \
6247 /* Note: coded this way so that there is a single string for \
6249 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6250 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6251 (unsigned) expected_entsize); \
6252 section->sh_entsize = expected_entsize; \
6257 #define CHECK_ENTSIZE(section, i, type) \
6258 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6259 sizeof (Elf64_External_##type))
6261 for (i
= 0, section
= filedata
->section_headers
;
6262 i
< filedata
->file_header
.e_shnum
;
6265 char * name
= SECTION_NAME (section
);
6267 if (section
->sh_type
== SHT_DYNSYM
)
6269 if (dynamic_symbols
!= NULL
)
6271 error (_("File contains multiple dynamic symbol tables\n"));
6275 CHECK_ENTSIZE (section
, i
, Sym
);
6276 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6278 else if (section
->sh_type
== SHT_STRTAB
6279 && streq (name
, ".dynstr"))
6281 if (dynamic_strings
!= NULL
)
6283 error (_("File contains multiple dynamic string tables\n"));
6287 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6288 1, section
->sh_size
,
6289 _("dynamic strings"));
6290 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6292 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6294 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6296 entry
->hdr
= section
;
6297 entry
->next
= symtab_shndx_list
;
6298 symtab_shndx_list
= entry
;
6300 else if (section
->sh_type
== SHT_SYMTAB
)
6301 CHECK_ENTSIZE (section
, i
, Sym
);
6302 else if (section
->sh_type
== SHT_GROUP
)
6303 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6304 else if (section
->sh_type
== SHT_REL
)
6305 CHECK_ENTSIZE (section
, i
, Rel
);
6306 else if (section
->sh_type
== SHT_RELA
)
6307 CHECK_ENTSIZE (section
, i
, Rela
);
6308 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6309 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6310 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6311 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6312 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6313 && (const_strneq (name
, ".debug_")
6314 || const_strneq (name
, ".zdebug_")))
6317 name
+= sizeof (".zdebug_") - 1;
6319 name
+= sizeof (".debug_") - 1;
6322 || (do_debug_info
&& const_strneq (name
, "info"))
6323 || (do_debug_info
&& const_strneq (name
, "types"))
6324 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6325 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6326 || (do_debug_lines
&& const_strneq (name
, "line."))
6327 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6328 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6329 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6330 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6331 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6332 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6333 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6334 || (do_debug_frames
&& const_strneq (name
, "frame"))
6335 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6336 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6337 || (do_debug_str
&& const_strneq (name
, "str"))
6338 || (do_debug_loc
&& const_strneq (name
, "loc"))
6339 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6340 || (do_debug_addr
&& const_strneq (name
, "addr"))
6341 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6342 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6344 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6346 /* Linkonce section to be combined with .debug_info at link time. */
6347 else if ((do_debugging
|| do_debug_info
)
6348 && const_strneq (name
, ".gnu.linkonce.wi."))
6349 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6350 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6351 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6352 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6353 || streq (name
, ".debug_names")))
6354 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6355 /* Trace sections for Itanium VMS. */
6356 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6357 || do_trace_aranges
)
6358 && const_strneq (name
, ".trace_"))
6360 name
+= sizeof (".trace_") - 1;
6363 || (do_trace_info
&& streq (name
, "info"))
6364 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6365 || (do_trace_aranges
&& streq (name
, "aranges"))
6367 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6369 else if ((do_debugging
|| do_debug_links
)
6370 && (const_strneq (name
, ".gnu_debuglink")
6371 || const_strneq (name
, ".gnu_debugaltlink")))
6372 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6378 if (filedata
->file_header
.e_shnum
> 1)
6379 printf (_("\nSection Headers:\n"));
6381 printf (_("\nSection Header:\n"));
6385 if (do_section_details
)
6387 printf (_(" [Nr] Name\n"));
6388 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6392 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6396 if (do_section_details
)
6398 printf (_(" [Nr] Name\n"));
6399 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6403 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6407 if (do_section_details
)
6409 printf (_(" [Nr] Name\n"));
6410 printf (_(" Type Address Offset Link\n"));
6411 printf (_(" Size EntSize Info Align\n"));
6415 printf (_(" [Nr] Name Type Address Offset\n"));
6416 printf (_(" Size EntSize Flags Link Info Align\n"));
6420 if (do_section_details
)
6421 printf (_(" Flags\n"));
6423 for (i
= 0, section
= filedata
->section_headers
;
6424 i
< filedata
->file_header
.e_shnum
;
6427 /* Run some sanity checks on the section header. */
6429 /* Check the sh_link field. */
6430 switch (section
->sh_type
)
6434 if (section
->sh_link
== 0
6435 && (filedata
->file_header
.e_type
== ET_EXEC
6436 || filedata
->file_header
.e_type
== ET_DYN
))
6437 /* A dynamic relocation section where all entries use a
6438 zero symbol index need not specify a symtab section. */
6441 case SHT_SYMTAB_SHNDX
:
6445 case SHT_GNU_versym
:
6446 if (section
->sh_link
== 0
6447 || section
->sh_link
>= filedata
->file_header
.e_shnum
6448 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6449 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6450 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6451 i
, section
->sh_link
);
6457 case SHT_GNU_verneed
:
6458 case SHT_GNU_verdef
:
6459 case SHT_GNU_LIBLIST
:
6460 if (section
->sh_link
== 0
6461 || section
->sh_link
>= filedata
->file_header
.e_shnum
6462 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6463 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6464 i
, section
->sh_link
);
6467 case SHT_INIT_ARRAY
:
6468 case SHT_FINI_ARRAY
:
6469 case SHT_PREINIT_ARRAY
:
6470 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6471 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6472 i
, section
->sh_link
);
6476 /* FIXME: Add support for target specific section types. */
6477 #if 0 /* Currently we do not check other section types as there are too
6478 many special cases. Stab sections for example have a type
6479 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6481 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6482 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6483 i
, section
->sh_link
);
6488 /* Check the sh_info field. */
6489 switch (section
->sh_type
)
6493 if (section
->sh_info
== 0
6494 && (filedata
->file_header
.e_type
== ET_EXEC
6495 || filedata
->file_header
.e_type
== ET_DYN
))
6496 /* Dynamic relocations apply to segments, so they do not
6497 need to specify the section they relocate. */
6499 if (section
->sh_info
== 0
6500 || section
->sh_info
>= filedata
->file_header
.e_shnum
6501 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6502 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6503 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6504 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6505 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6506 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6507 /* FIXME: Are other section types valid ? */
6508 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6509 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6510 i
, section
->sh_info
);
6515 case SHT_SYMTAB_SHNDX
:
6516 case SHT_INIT_ARRAY
:
6517 case SHT_FINI_ARRAY
:
6518 case SHT_PREINIT_ARRAY
:
6519 if (section
->sh_info
!= 0)
6520 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6521 i
, section
->sh_info
);
6527 /* A symbol index - we assume that it is valid. */
6531 /* FIXME: Add support for target specific section types. */
6532 if (section
->sh_type
== SHT_NOBITS
)
6533 /* NOBITS section headers with non-zero sh_info fields can be
6534 created when a binary is stripped of everything but its debug
6535 information. The stripped sections have their headers
6536 preserved but their types set to SHT_NOBITS. So do not check
6537 this type of section. */
6539 else if (section
->sh_flags
& SHF_INFO_LINK
)
6541 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6542 warn (_("[%2u]: Expected link to another section in info field"), i
);
6544 else if (section
->sh_type
< SHT_LOOS
6545 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6546 && section
->sh_info
!= 0)
6547 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6548 i
, section
->sh_info
);
6552 /* Check the sh_size field. */
6553 if (section
->sh_size
> filedata
->file_size
6554 && section
->sh_type
!= SHT_NOBITS
6555 && section
->sh_type
!= SHT_NULL
6556 && section
->sh_type
< SHT_LOOS
)
6557 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6559 printf (" [%2u] ", i
);
6560 if (do_section_details
)
6561 printf ("%s\n ", printable_section_name (filedata
, section
));
6563 print_symbol (-17, SECTION_NAME (section
));
6565 printf (do_wide
? " %-15s " : " %-15.15s ",
6566 get_section_type_name (filedata
, section
->sh_type
));
6570 const char * link_too_big
= NULL
;
6572 print_vma (section
->sh_addr
, LONG_HEX
);
6574 printf ( " %6.6lx %6.6lx %2.2lx",
6575 (unsigned long) section
->sh_offset
,
6576 (unsigned long) section
->sh_size
,
6577 (unsigned long) section
->sh_entsize
);
6579 if (do_section_details
)
6580 fputs (" ", stdout
);
6582 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6584 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6587 /* The sh_link value is out of range. Normally this indicates
6588 an error but it can have special values in Solaris binaries. */
6589 switch (filedata
->file_header
.e_machine
)
6596 case EM_OLD_SPARCV9
:
6597 case EM_SPARC32PLUS
:
6600 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6601 link_too_big
= "BEFORE";
6602 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6603 link_too_big
= "AFTER";
6610 if (do_section_details
)
6612 if (link_too_big
!= NULL
&& * link_too_big
)
6613 printf ("<%s> ", link_too_big
);
6615 printf ("%2u ", section
->sh_link
);
6616 printf ("%3u %2lu\n", section
->sh_info
,
6617 (unsigned long) section
->sh_addralign
);
6620 printf ("%2u %3u %2lu\n",
6623 (unsigned long) section
->sh_addralign
);
6625 if (link_too_big
&& ! * link_too_big
)
6626 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6627 i
, section
->sh_link
);
6631 print_vma (section
->sh_addr
, LONG_HEX
);
6633 if ((long) section
->sh_offset
== section
->sh_offset
)
6634 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6638 print_vma (section
->sh_offset
, LONG_HEX
);
6641 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6642 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6646 print_vma (section
->sh_size
, LONG_HEX
);
6649 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6650 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6654 print_vma (section
->sh_entsize
, LONG_HEX
);
6657 if (do_section_details
)
6658 fputs (" ", stdout
);
6660 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6662 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6664 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6665 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6668 print_vma (section
->sh_addralign
, DEC
);
6672 else if (do_section_details
)
6675 print_vma (section
->sh_addr
, LONG_HEX
);
6676 if ((long) section
->sh_offset
== section
->sh_offset
)
6677 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6681 print_vma (section
->sh_offset
, LONG_HEX
);
6683 printf (" %u\n ", section
->sh_link
);
6684 print_vma (section
->sh_size
, LONG_HEX
);
6686 print_vma (section
->sh_entsize
, LONG_HEX
);
6688 printf (" %-16u %lu\n",
6690 (unsigned long) section
->sh_addralign
);
6695 print_vma (section
->sh_addr
, LONG_HEX
);
6696 if ((long) section
->sh_offset
== section
->sh_offset
)
6697 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6701 print_vma (section
->sh_offset
, LONG_HEX
);
6704 print_vma (section
->sh_size
, LONG_HEX
);
6706 print_vma (section
->sh_entsize
, LONG_HEX
);
6708 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6710 printf (" %2u %3u %lu\n",
6713 (unsigned long) section
->sh_addralign
);
6716 if (do_section_details
)
6718 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6719 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6721 /* Minimum section size is 12 bytes for 32-bit compression
6722 header + 12 bytes for compressed data header. */
6723 unsigned char buf
[24];
6725 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6726 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6727 sizeof (buf
), _("compression header")))
6729 Elf_Internal_Chdr chdr
;
6731 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6733 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6736 printf (_(" [<unknown>: 0x%x], "),
6738 print_vma (chdr
.ch_size
, LONG_HEX
);
6739 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6745 if (!do_section_details
)
6747 /* The ordering of the letters shown here matches the ordering of the
6748 corresponding SHF_xxx values, and hence the order in which these
6749 letters will be displayed to the user. */
6750 printf (_("Key to Flags:\n\
6751 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6752 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6753 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6754 if (filedata
->file_header
.e_machine
== EM_X86_64
6755 || filedata
->file_header
.e_machine
== EM_L1OM
6756 || filedata
->file_header
.e_machine
== EM_K1OM
)
6757 printf (_("l (large), "));
6758 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6759 printf (_("y (purecode), "));
6760 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6761 printf (_("v (VLE), "));
6762 printf ("p (processor specific)\n");
6769 get_group_flags (unsigned int flags
)
6771 static char buff
[128];
6775 else if (flags
== GRP_COMDAT
)
6778 snprintf (buff
, 14, _("[0x%x: "), flags
);
6780 flags
&= ~ GRP_COMDAT
;
6781 if (flags
& GRP_MASKOS
)
6783 strcat (buff
, "<OS specific>");
6784 flags
&= ~ GRP_MASKOS
;
6787 if (flags
& GRP_MASKPROC
)
6789 strcat (buff
, "<PROC specific>");
6790 flags
&= ~ GRP_MASKPROC
;
6794 strcat (buff
, "<unknown>");
6801 process_section_groups (Filedata
* filedata
)
6803 Elf_Internal_Shdr
* section
;
6805 struct group
* group
;
6806 Elf_Internal_Shdr
* symtab_sec
;
6807 Elf_Internal_Shdr
* strtab_sec
;
6808 Elf_Internal_Sym
* symtab
;
6809 unsigned long num_syms
;
6813 /* Don't process section groups unless needed. */
6814 if (!do_unwind
&& !do_section_groups
)
6817 if (filedata
->file_header
.e_shnum
== 0)
6819 if (do_section_groups
)
6820 printf (_("\nThere are no sections to group in this file.\n"));
6825 if (filedata
->section_headers
== NULL
)
6827 error (_("Section headers are not available!\n"));
6828 /* PR 13622: This can happen with a corrupt ELF header. */
6832 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6833 sizeof (struct group
*));
6835 if (section_headers_groups
== NULL
)
6837 error (_("Out of memory reading %u section group headers\n"),
6838 filedata
->file_header
.e_shnum
);
6842 /* Scan the sections for the group section. */
6844 for (i
= 0, section
= filedata
->section_headers
;
6845 i
< filedata
->file_header
.e_shnum
;
6847 if (section
->sh_type
== SHT_GROUP
)
6850 if (group_count
== 0)
6852 if (do_section_groups
)
6853 printf (_("\nThere are no section groups in this file.\n"));
6858 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6860 if (section_groups
== NULL
)
6862 error (_("Out of memory reading %lu groups\n"),
6863 (unsigned long) group_count
);
6873 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6874 i
< filedata
->file_header
.e_shnum
;
6877 if (section
->sh_type
== SHT_GROUP
)
6879 const char * name
= printable_section_name (filedata
, section
);
6880 const char * group_name
;
6881 unsigned char * start
;
6882 unsigned char * indices
;
6883 unsigned int entry
, j
, size
;
6884 Elf_Internal_Shdr
* sec
;
6885 Elf_Internal_Sym
* sym
;
6887 /* Get the symbol table. */
6888 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6889 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6892 error (_("Bad sh_link in group section `%s'\n"), name
);
6896 if (symtab_sec
!= sec
)
6901 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6906 error (_("Corrupt header in group section `%s'\n"), name
);
6910 if (section
->sh_info
>= num_syms
)
6912 error (_("Bad sh_info in group section `%s'\n"), name
);
6916 sym
= symtab
+ section
->sh_info
;
6918 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6920 if (sym
->st_shndx
== 0
6921 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6923 error (_("Bad sh_info in group section `%s'\n"), name
);
6927 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6936 /* Get the string table. */
6937 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6946 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6952 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6953 1, strtab_sec
->sh_size
,
6955 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6957 group_name
= sym
->st_name
< strtab_size
6958 ? strtab
+ sym
->st_name
: _("<corrupt>");
6961 /* PR 17531: file: loop. */
6962 if (section
->sh_entsize
> section
->sh_size
)
6964 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6965 printable_section_name (filedata
, section
),
6966 (unsigned long) section
->sh_entsize
,
6967 (unsigned long) section
->sh_size
);
6971 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6972 1, section
->sh_size
,
6978 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6979 entry
= byte_get (indices
, 4);
6982 if (do_section_groups
)
6984 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6985 get_group_flags (entry
), i
, name
, group_name
, size
);
6987 printf (_(" [Index] Name\n"));
6990 group
->group_index
= i
;
6992 for (j
= 0; j
< size
; j
++)
6994 struct group_list
* g
;
6996 entry
= byte_get (indices
, 4);
6999 if (entry
>= filedata
->file_header
.e_shnum
)
7001 static unsigned num_group_errors
= 0;
7003 if (num_group_errors
++ < 10)
7005 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7006 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7007 if (num_group_errors
== 10)
7008 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7013 if (section_headers_groups
[entry
] != NULL
)
7017 static unsigned num_errs
= 0;
7019 if (num_errs
++ < 10)
7021 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7023 section_headers_groups
[entry
]->group_index
);
7025 warn (_("Further error messages about already contained group sections suppressed\n"));
7031 /* Intel C/C++ compiler may put section 0 in a
7032 section group. We just warn it the first time
7033 and ignore it afterwards. */
7034 static bfd_boolean warned
= FALSE
;
7037 error (_("section 0 in group section [%5u]\n"),
7038 section_headers_groups
[entry
]->group_index
);
7044 section_headers_groups
[entry
] = group
;
7046 if (do_section_groups
)
7048 sec
= filedata
->section_headers
+ entry
;
7049 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7052 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7053 g
->section_index
= entry
;
7054 g
->next
= group
->root
;
7072 /* Data used to display dynamic fixups. */
7074 struct ia64_vms_dynfixup
7076 bfd_vma needed_ident
; /* Library ident number. */
7077 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7078 bfd_vma fixup_needed
; /* Index of the library. */
7079 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7080 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7083 /* Data used to display dynamic relocations. */
7085 struct ia64_vms_dynimgrela
7087 bfd_vma img_rela_cnt
; /* Number of relocations. */
7088 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7091 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7095 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7096 struct ia64_vms_dynfixup
* fixup
,
7097 const char * strtab
,
7098 unsigned int strtab_sz
)
7100 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7102 const char * lib_name
;
7104 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7105 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7106 _("dynamic section image fixups"));
7110 if (fixup
->needed
< strtab_sz
)
7111 lib_name
= strtab
+ fixup
->needed
;
7114 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7115 (unsigned long) fixup
->needed
);
7119 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7120 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7122 (_("Seg Offset Type SymVec DataType\n"));
7124 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7129 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7130 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7131 type
= BYTE_GET (imfs
[i
].type
);
7132 rtype
= elf_ia64_reloc_type (type
);
7134 printf (" 0x%08x ", type
);
7136 printf (" %-32s ", rtype
);
7137 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7138 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7145 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7148 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7150 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7153 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7154 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7155 _("dynamic section image relocations"));
7159 printf (_("\nImage relocs\n"));
7161 (_("Seg Offset Type Addend Seg Sym Off\n"));
7163 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7168 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7169 printf ("%08" BFD_VMA_FMT
"x ",
7170 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7171 type
= BYTE_GET (imrs
[i
].type
);
7172 rtype
= elf_ia64_reloc_type (type
);
7174 printf ("0x%08x ", type
);
7176 printf ("%-31s ", rtype
);
7177 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7178 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7179 printf ("%08" BFD_VMA_FMT
"x\n",
7180 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7187 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7190 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7192 struct ia64_vms_dynfixup fixup
;
7193 struct ia64_vms_dynimgrela imgrela
;
7194 Elf_Internal_Dyn
*entry
;
7195 bfd_vma strtab_off
= 0;
7196 bfd_vma strtab_sz
= 0;
7197 char *strtab
= NULL
;
7198 bfd_boolean res
= TRUE
;
7200 memset (&fixup
, 0, sizeof (fixup
));
7201 memset (&imgrela
, 0, sizeof (imgrela
));
7203 /* Note: the order of the entries is specified by the OpenVMS specs. */
7204 for (entry
= dynamic_section
;
7205 entry
< dynamic_section
+ dynamic_nent
;
7208 switch (entry
->d_tag
)
7210 case DT_IA_64_VMS_STRTAB_OFFSET
:
7211 strtab_off
= entry
->d_un
.d_val
;
7214 strtab_sz
= entry
->d_un
.d_val
;
7216 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7217 1, strtab_sz
, _("dynamic string section"));
7222 case DT_IA_64_VMS_NEEDED_IDENT
:
7223 fixup
.needed_ident
= entry
->d_un
.d_val
;
7226 fixup
.needed
= entry
->d_un
.d_val
;
7228 case DT_IA_64_VMS_FIXUP_NEEDED
:
7229 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7231 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7232 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7234 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7235 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7236 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7239 case DT_IA_64_VMS_IMG_RELA_CNT
:
7240 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7242 case DT_IA_64_VMS_IMG_RELA_OFF
:
7243 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7244 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7266 dynamic_relocations
[] =
7268 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7269 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7270 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7273 /* Process the reloc section. */
7276 process_relocs (Filedata
* filedata
)
7278 unsigned long rel_size
;
7279 unsigned long rel_offset
;
7284 if (do_using_dynamic
)
7288 bfd_boolean has_dynamic_reloc
;
7291 has_dynamic_reloc
= FALSE
;
7293 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7295 is_rela
= dynamic_relocations
[i
].rela
;
7296 name
= dynamic_relocations
[i
].name
;
7297 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7298 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7301 has_dynamic_reloc
= TRUE
;
7303 if (is_rela
== UNKNOWN
)
7305 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7306 switch (dynamic_info
[DT_PLTREL
])
7320 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7321 name
, rel_offset
, rel_size
);
7323 dump_relocations (filedata
,
7324 offset_from_vma (filedata
, rel_offset
, rel_size
),
7326 dynamic_symbols
, num_dynamic_syms
,
7327 dynamic_strings
, dynamic_strings_length
,
7328 is_rela
, TRUE
/* is_dynamic */);
7332 if (is_ia64_vms (filedata
))
7333 if (process_ia64_vms_dynamic_relocs (filedata
))
7334 has_dynamic_reloc
= TRUE
;
7336 if (! has_dynamic_reloc
)
7337 printf (_("\nThere are no dynamic relocations in this file.\n"));
7341 Elf_Internal_Shdr
* section
;
7343 bfd_boolean found
= FALSE
;
7345 for (i
= 0, section
= filedata
->section_headers
;
7346 i
< filedata
->file_header
.e_shnum
;
7349 if ( section
->sh_type
!= SHT_RELA
7350 && section
->sh_type
!= SHT_REL
)
7353 rel_offset
= section
->sh_offset
;
7354 rel_size
= section
->sh_size
;
7358 Elf_Internal_Shdr
* strsec
;
7360 unsigned long num_rela
;
7362 printf (_("\nRelocation section "));
7364 if (filedata
->string_table
== NULL
)
7365 printf ("%d", section
->sh_name
);
7367 printf ("'%s'", printable_section_name (filedata
, section
));
7369 num_rela
= rel_size
/ section
->sh_entsize
;
7370 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7371 " at offset 0x%lx contains %lu entries:\n",
7373 rel_offset
, num_rela
);
7375 is_rela
= section
->sh_type
== SHT_RELA
;
7377 if (section
->sh_link
!= 0
7378 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7380 Elf_Internal_Shdr
* symsec
;
7381 Elf_Internal_Sym
* symtab
;
7382 unsigned long nsyms
;
7383 unsigned long strtablen
= 0;
7384 char * strtab
= NULL
;
7386 symsec
= filedata
->section_headers
+ section
->sh_link
;
7387 if (symsec
->sh_type
!= SHT_SYMTAB
7388 && symsec
->sh_type
!= SHT_DYNSYM
)
7391 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7396 if (symsec
->sh_link
!= 0
7397 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7399 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7401 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7404 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7407 dump_relocations (filedata
, rel_offset
, rel_size
,
7408 symtab
, nsyms
, strtab
, strtablen
,
7410 symsec
->sh_type
== SHT_DYNSYM
);
7416 dump_relocations (filedata
, rel_offset
, rel_size
,
7417 NULL
, 0, NULL
, 0, is_rela
,
7418 FALSE
/* is_dynamic */);
7426 /* Users sometimes forget the -D option, so try to be helpful. */
7427 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7429 if (dynamic_info
[dynamic_relocations
[i
].size
])
7431 printf (_("\nThere are no static relocations in this file."));
7432 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7437 if (i
== ARRAY_SIZE (dynamic_relocations
))
7438 printf (_("\nThere are no relocations in this file.\n"));
7445 /* An absolute address consists of a section and an offset. If the
7446 section is NULL, the offset itself is the address, otherwise, the
7447 address equals to LOAD_ADDRESS(section) + offset. */
7451 unsigned short section
;
7455 /* Find the nearest symbol at or below ADDR. Returns the symbol
7456 name, if found, and the offset from the symbol to ADDR. */
7459 find_symbol_for_address (Filedata
* filedata
,
7460 Elf_Internal_Sym
* symtab
,
7461 unsigned long nsyms
,
7462 const char * strtab
,
7463 unsigned long strtab_size
,
7464 struct absaddr addr
,
7465 const char ** symname
,
7468 bfd_vma dist
= 0x100000;
7469 Elf_Internal_Sym
* sym
;
7470 Elf_Internal_Sym
* beg
;
7471 Elf_Internal_Sym
* end
;
7472 Elf_Internal_Sym
* best
= NULL
;
7474 REMOVE_ARCH_BITS (addr
.offset
);
7476 end
= symtab
+ nsyms
;
7482 sym
= beg
+ (end
- beg
) / 2;
7484 value
= sym
->st_value
;
7485 REMOVE_ARCH_BITS (value
);
7487 if (sym
->st_name
!= 0
7488 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7489 && addr
.offset
>= value
7490 && addr
.offset
- value
< dist
)
7493 dist
= addr
.offset
- value
;
7498 if (addr
.offset
< value
)
7506 *symname
= (best
->st_name
>= strtab_size
7507 ? _("<corrupt>") : strtab
+ best
->st_name
);
7513 *offset
= addr
.offset
;
7516 static /* signed */ int
7517 symcmp (const void *p
, const void *q
)
7519 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7520 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7522 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7525 /* Process the unwind section. */
7527 #include "unwind-ia64.h"
7529 struct ia64_unw_table_entry
7531 struct absaddr start
;
7533 struct absaddr info
;
7536 struct ia64_unw_aux_info
7538 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7539 unsigned long table_len
; /* Length of unwind table. */
7540 unsigned char * info
; /* Unwind info. */
7541 unsigned long info_size
; /* Size of unwind info. */
7542 bfd_vma info_addr
; /* Starting address of unwind info. */
7543 bfd_vma seg_base
; /* Starting address of segment. */
7544 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7545 unsigned long nsyms
; /* Number of symbols. */
7546 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7547 unsigned long nfuns
; /* Number of entries in funtab. */
7548 char * strtab
; /* The string table. */
7549 unsigned long strtab_size
; /* Size of string table. */
7553 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7555 struct ia64_unw_table_entry
* tp
;
7556 unsigned long j
, nfuns
;
7558 bfd_boolean res
= TRUE
;
7560 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7561 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7562 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7563 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7565 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7567 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7571 const unsigned char * dp
;
7572 const unsigned char * head
;
7573 const unsigned char * end
;
7574 const char * procname
;
7576 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7577 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7579 fputs ("\n<", stdout
);
7583 fputs (procname
, stdout
);
7586 printf ("+%lx", (unsigned long) offset
);
7589 fputs (">: [", stdout
);
7590 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7591 fputc ('-', stdout
);
7592 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7593 printf ("], info at +0x%lx\n",
7594 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7596 /* PR 17531: file: 86232b32. */
7597 if (aux
->info
== NULL
)
7600 offset
= tp
->info
.offset
;
7601 if (tp
->info
.section
)
7603 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7605 warn (_("Invalid section %u in table entry %ld\n"),
7606 tp
->info
.section
, (long) (tp
- aux
->table
));
7610 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7612 offset
-= aux
->info_addr
;
7613 /* PR 17531: file: 0997b4d1. */
7614 if (offset
>= aux
->info_size
7615 || aux
->info_size
- offset
< 8)
7617 warn (_("Invalid offset %lx in table entry %ld\n"),
7618 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7623 head
= aux
->info
+ offset
;
7624 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7626 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7627 (unsigned) UNW_VER (stamp
),
7628 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7629 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7630 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7631 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7633 if (UNW_VER (stamp
) != 1)
7635 printf (_("\tUnknown version.\n"));
7640 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7641 /* PR 17531: file: 16ceda89. */
7642 if (end
> aux
->info
+ aux
->info_size
)
7643 end
= aux
->info
+ aux
->info_size
;
7644 for (dp
= head
+ 8; dp
< end
;)
7645 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7654 slurp_ia64_unwind_table (Filedata
* filedata
,
7655 struct ia64_unw_aux_info
* aux
,
7656 Elf_Internal_Shdr
* sec
)
7658 unsigned long size
, nrelas
, i
;
7659 Elf_Internal_Phdr
* seg
;
7660 struct ia64_unw_table_entry
* tep
;
7661 Elf_Internal_Shdr
* relsec
;
7662 Elf_Internal_Rela
* rela
;
7663 Elf_Internal_Rela
* rp
;
7664 unsigned char * table
;
7666 Elf_Internal_Sym
* sym
;
7667 const char * relname
;
7671 /* First, find the starting address of the segment that includes
7674 if (filedata
->file_header
.e_phnum
)
7676 if (! get_program_headers (filedata
))
7679 for (seg
= filedata
->program_headers
;
7680 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7683 if (seg
->p_type
!= PT_LOAD
)
7686 if (sec
->sh_addr
>= seg
->p_vaddr
7687 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7689 aux
->seg_base
= seg
->p_vaddr
;
7695 /* Second, build the unwind table from the contents of the unwind section: */
7696 size
= sec
->sh_size
;
7697 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7702 aux
->table_len
= size
/ (3 * eh_addr_size
);
7703 aux
->table
= (struct ia64_unw_table_entry
*)
7704 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7707 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7709 tep
->start
.section
= SHN_UNDEF
;
7710 tep
->end
.section
= SHN_UNDEF
;
7711 tep
->info
.section
= SHN_UNDEF
;
7712 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7713 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7714 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7715 tep
->start
.offset
+= aux
->seg_base
;
7716 tep
->end
.offset
+= aux
->seg_base
;
7717 tep
->info
.offset
+= aux
->seg_base
;
7721 /* Third, apply any relocations to the unwind table: */
7722 for (relsec
= filedata
->section_headers
;
7723 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7726 if (relsec
->sh_type
!= SHT_RELA
7727 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7728 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7731 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7740 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7742 unsigned int sym_ndx
;
7743 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7744 relname
= elf_ia64_reloc_type (r_type
);
7746 /* PR 17531: file: 9fa67536. */
7747 if (relname
== NULL
)
7749 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7753 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7755 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7759 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7761 /* PR 17531: file: 5bc8d9bf. */
7762 if (i
>= aux
->table_len
)
7764 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7768 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7769 if (sym_ndx
>= aux
->nsyms
)
7771 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7775 sym
= aux
->symtab
+ sym_ndx
;
7777 switch (rp
->r_offset
/ eh_addr_size
% 3)
7780 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7781 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7784 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7785 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7788 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7789 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7803 ia64_process_unwind (Filedata
* filedata
)
7805 Elf_Internal_Shdr
* sec
;
7806 Elf_Internal_Shdr
* unwsec
= NULL
;
7807 Elf_Internal_Shdr
* strsec
;
7808 unsigned long i
, unwcount
= 0, unwstart
= 0;
7809 struct ia64_unw_aux_info aux
;
7810 bfd_boolean res
= TRUE
;
7812 memset (& aux
, 0, sizeof (aux
));
7814 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7816 if (sec
->sh_type
== SHT_SYMTAB
7817 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7819 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7821 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7822 if (aux
.strtab
!= NULL
)
7824 error (_("Multiple auxillary string tables encountered\n"));
7828 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7831 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7833 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7838 printf (_("\nThere are no unwind sections in this file.\n"));
7840 while (unwcount
-- > 0)
7845 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7846 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7847 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7852 /* We have already counted the number of SHT_IA64_UNWIND
7853 sections so the loop above should never fail. */
7854 assert (unwsec
!= NULL
);
7857 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7859 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7861 /* We need to find which section group it is in. */
7862 struct group_list
* g
;
7864 if (section_headers_groups
== NULL
7865 || section_headers_groups
[i
] == NULL
)
7866 i
= filedata
->file_header
.e_shnum
;
7869 g
= section_headers_groups
[i
]->root
;
7871 for (; g
!= NULL
; g
= g
->next
)
7873 sec
= filedata
->section_headers
+ g
->section_index
;
7875 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7880 i
= filedata
->file_header
.e_shnum
;
7883 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7885 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7886 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7887 suffix
= SECTION_NAME (unwsec
) + len
;
7888 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7890 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7891 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7896 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7897 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7898 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7899 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7901 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7902 suffix
= SECTION_NAME (unwsec
) + len
;
7903 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7905 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7906 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7910 if (i
== filedata
->file_header
.e_shnum
)
7912 printf (_("\nCould not find unwind info section for "));
7914 if (filedata
->string_table
== NULL
)
7915 printf ("%d", unwsec
->sh_name
);
7917 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7921 aux
.info_addr
= sec
->sh_addr
;
7922 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7925 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7927 printf (_("\nUnwind section "));
7929 if (filedata
->string_table
== NULL
)
7930 printf ("%d", unwsec
->sh_name
);
7932 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7934 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7935 (unsigned long) unwsec
->sh_offset
,
7936 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7938 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7939 && aux
.table_len
> 0)
7940 dump_ia64_unwind (filedata
, & aux
);
7943 free ((char *) aux
.table
);
7945 free ((char *) aux
.info
);
7954 free ((char *) aux
.strtab
);
7959 struct hppa_unw_table_entry
7961 struct absaddr start
;
7963 unsigned int Cannot_unwind
:1; /* 0 */
7964 unsigned int Millicode
:1; /* 1 */
7965 unsigned int Millicode_save_sr0
:1; /* 2 */
7966 unsigned int Region_description
:2; /* 3..4 */
7967 unsigned int reserved1
:1; /* 5 */
7968 unsigned int Entry_SR
:1; /* 6 */
7969 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7970 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7971 unsigned int Args_stored
:1; /* 16 */
7972 unsigned int Variable_Frame
:1; /* 17 */
7973 unsigned int Separate_Package_Body
:1; /* 18 */
7974 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7975 unsigned int Stack_Overflow_Check
:1; /* 20 */
7976 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7977 unsigned int Ada_Region
:1; /* 22 */
7978 unsigned int cxx_info
:1; /* 23 */
7979 unsigned int cxx_try_catch
:1; /* 24 */
7980 unsigned int sched_entry_seq
:1; /* 25 */
7981 unsigned int reserved2
:1; /* 26 */
7982 unsigned int Save_SP
:1; /* 27 */
7983 unsigned int Save_RP
:1; /* 28 */
7984 unsigned int Save_MRP_in_frame
:1; /* 29 */
7985 unsigned int extn_ptr_defined
:1; /* 30 */
7986 unsigned int Cleanup_defined
:1; /* 31 */
7988 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7989 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7990 unsigned int Large_frame
:1; /* 2 */
7991 unsigned int Pseudo_SP_Set
:1; /* 3 */
7992 unsigned int reserved4
:1; /* 4 */
7993 unsigned int Total_frame_size
:27; /* 5..31 */
7996 struct hppa_unw_aux_info
7998 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7999 unsigned long table_len
; /* Length of unwind table. */
8000 bfd_vma seg_base
; /* Starting address of segment. */
8001 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8002 unsigned long nsyms
; /* Number of symbols. */
8003 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8004 unsigned long nfuns
; /* Number of entries in funtab. */
8005 char * strtab
; /* The string table. */
8006 unsigned long strtab_size
; /* Size of string table. */
8010 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8012 struct hppa_unw_table_entry
* tp
;
8013 unsigned long j
, nfuns
;
8014 bfd_boolean res
= TRUE
;
8016 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8017 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8018 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8019 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8021 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8023 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8026 const char * procname
;
8028 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8029 aux
->strtab_size
, tp
->start
, &procname
,
8032 fputs ("\n<", stdout
);
8036 fputs (procname
, stdout
);
8039 printf ("+%lx", (unsigned long) offset
);
8042 fputs (">: [", stdout
);
8043 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8044 fputc ('-', stdout
);
8045 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8048 #define PF(_m) if (tp->_m) printf (#_m " ");
8049 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8052 PF(Millicode_save_sr0
);
8053 /* PV(Region_description); */
8059 PF(Separate_Package_Body
);
8060 PF(Frame_Extension_Millicode
);
8061 PF(Stack_Overflow_Check
);
8062 PF(Two_Instruction_SP_Increment
);
8066 PF(sched_entry_seq
);
8069 PF(Save_MRP_in_frame
);
8070 PF(extn_ptr_defined
);
8071 PF(Cleanup_defined
);
8072 PF(MPE_XL_interrupt_marker
);
8073 PF(HP_UX_interrupt_marker
);
8076 PV(Total_frame_size
);
8089 slurp_hppa_unwind_table (Filedata
* filedata
,
8090 struct hppa_unw_aux_info
* aux
,
8091 Elf_Internal_Shdr
* sec
)
8093 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8094 Elf_Internal_Phdr
* seg
;
8095 struct hppa_unw_table_entry
* tep
;
8096 Elf_Internal_Shdr
* relsec
;
8097 Elf_Internal_Rela
* rela
;
8098 Elf_Internal_Rela
* rp
;
8099 unsigned char * table
;
8101 Elf_Internal_Sym
* sym
;
8102 const char * relname
;
8104 /* First, find the starting address of the segment that includes
8106 if (filedata
->file_header
.e_phnum
)
8108 if (! get_program_headers (filedata
))
8111 for (seg
= filedata
->program_headers
;
8112 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8115 if (seg
->p_type
!= PT_LOAD
)
8118 if (sec
->sh_addr
>= seg
->p_vaddr
8119 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8121 aux
->seg_base
= seg
->p_vaddr
;
8127 /* Second, build the unwind table from the contents of the unwind
8129 size
= sec
->sh_size
;
8130 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8136 nentries
= size
/ unw_ent_size
;
8137 size
= unw_ent_size
* nentries
;
8139 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8140 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8142 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8144 unsigned int tmp1
, tmp2
;
8146 tep
->start
.section
= SHN_UNDEF
;
8147 tep
->end
.section
= SHN_UNDEF
;
8149 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8150 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8151 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8152 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8154 tep
->start
.offset
+= aux
->seg_base
;
8155 tep
->end
.offset
+= aux
->seg_base
;
8157 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8158 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8159 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8160 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8161 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8162 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8163 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8164 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8165 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8166 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8167 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8168 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8169 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8170 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8171 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8172 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8173 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8174 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8175 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8176 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8177 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8178 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8179 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8180 tep
->Cleanup_defined
= tmp1
& 0x1;
8182 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8183 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8184 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8185 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8186 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8187 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8191 /* Third, apply any relocations to the unwind table. */
8192 for (relsec
= filedata
->section_headers
;
8193 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8196 if (relsec
->sh_type
!= SHT_RELA
8197 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8198 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8201 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8205 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8207 unsigned int sym_ndx
;
8208 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8209 relname
= elf_hppa_reloc_type (r_type
);
8211 if (relname
== NULL
)
8213 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8217 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8218 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8220 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8224 i
= rp
->r_offset
/ unw_ent_size
;
8225 if (i
>= aux
->table_len
)
8227 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8231 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8232 if (sym_ndx
>= aux
->nsyms
)
8234 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8238 sym
= aux
->symtab
+ sym_ndx
;
8240 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8243 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8244 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8247 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8248 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8258 aux
->table_len
= nentries
;
8264 hppa_process_unwind (Filedata
* filedata
)
8266 struct hppa_unw_aux_info aux
;
8267 Elf_Internal_Shdr
* unwsec
= NULL
;
8268 Elf_Internal_Shdr
* strsec
;
8269 Elf_Internal_Shdr
* sec
;
8271 bfd_boolean res
= TRUE
;
8273 if (filedata
->string_table
== NULL
)
8276 memset (& aux
, 0, sizeof (aux
));
8278 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8280 if (sec
->sh_type
== SHT_SYMTAB
8281 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8283 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8285 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8286 if (aux
.strtab
!= NULL
)
8288 error (_("Multiple auxillary string tables encountered\n"));
8292 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8295 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8297 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8302 printf (_("\nThere are no unwind sections in this file.\n"));
8304 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8306 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8308 unsigned long num_unwind
= sec
->sh_size
/ 16;
8310 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8311 "contains %lu entry:\n",
8312 "\nUnwind section '%s' at offset 0x%lx "
8313 "contains %lu entries:\n",
8315 printable_section_name (filedata
, sec
),
8316 (unsigned long) sec
->sh_offset
,
8319 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8322 if (res
&& aux
.table_len
> 0)
8324 if (! dump_hppa_unwind (filedata
, &aux
))
8329 free ((char *) aux
.table
);
8337 free ((char *) aux
.strtab
);
8344 unsigned char * data
; /* The unwind data. */
8345 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8346 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8347 unsigned long nrelas
; /* The number of relocations. */
8348 unsigned int rel_type
; /* REL or RELA ? */
8349 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8352 struct arm_unw_aux_info
8354 Filedata
* filedata
; /* The file containing the unwind sections. */
8355 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8356 unsigned long nsyms
; /* Number of symbols. */
8357 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8358 unsigned long nfuns
; /* Number of these symbols. */
8359 char * strtab
; /* The file's string table. */
8360 unsigned long strtab_size
; /* Size of string table. */
8364 arm_print_vma_and_name (Filedata
* filedata
,
8365 struct arm_unw_aux_info
* aux
,
8367 struct absaddr addr
)
8369 const char *procname
;
8372 if (addr
.section
== SHN_UNDEF
)
8375 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8376 aux
->strtab_size
, addr
, &procname
,
8379 print_vma (fn
, PREFIX_HEX
);
8383 fputs (" <", stdout
);
8384 fputs (procname
, stdout
);
8387 printf ("+0x%lx", (unsigned long) sym_offset
);
8388 fputc ('>', stdout
);
8395 arm_free_section (struct arm_section
*arm_sec
)
8397 if (arm_sec
->data
!= NULL
)
8398 free (arm_sec
->data
);
8400 if (arm_sec
->rela
!= NULL
)
8401 free (arm_sec
->rela
);
8404 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8405 cached section and install SEC instead.
8406 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8407 and return its valued in * WORDP, relocating if necessary.
8408 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8409 relocation's offset in ADDR.
8410 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8411 into the string table of the symbol associated with the reloc. If no
8412 reloc was applied store -1 there.
8413 5) Return TRUE upon success, FALSE otherwise. */
8416 get_unwind_section_word (Filedata
* filedata
,
8417 struct arm_unw_aux_info
* aux
,
8418 struct arm_section
* arm_sec
,
8419 Elf_Internal_Shdr
* sec
,
8420 bfd_vma word_offset
,
8421 unsigned int * wordp
,
8422 struct absaddr
* addr
,
8425 Elf_Internal_Rela
*rp
;
8426 Elf_Internal_Sym
*sym
;
8427 const char * relname
;
8429 bfd_boolean wrapped
;
8431 if (sec
== NULL
|| arm_sec
== NULL
)
8434 addr
->section
= SHN_UNDEF
;
8437 if (sym_name
!= NULL
)
8438 *sym_name
= (bfd_vma
) -1;
8440 /* If necessary, update the section cache. */
8441 if (sec
!= arm_sec
->sec
)
8443 Elf_Internal_Shdr
*relsec
;
8445 arm_free_section (arm_sec
);
8448 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8449 sec
->sh_size
, _("unwind data"));
8450 arm_sec
->rela
= NULL
;
8451 arm_sec
->nrelas
= 0;
8453 for (relsec
= filedata
->section_headers
;
8454 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8457 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8458 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8459 /* PR 15745: Check the section type as well. */
8460 || (relsec
->sh_type
!= SHT_REL
8461 && relsec
->sh_type
!= SHT_RELA
))
8464 arm_sec
->rel_type
= relsec
->sh_type
;
8465 if (relsec
->sh_type
== SHT_REL
)
8467 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8469 & arm_sec
->rela
, & arm_sec
->nrelas
))
8472 else /* relsec->sh_type == SHT_RELA */
8474 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8476 & arm_sec
->rela
, & arm_sec
->nrelas
))
8482 arm_sec
->next_rela
= arm_sec
->rela
;
8485 /* If there is no unwind data we can do nothing. */
8486 if (arm_sec
->data
== NULL
)
8489 /* If the offset is invalid then fail. */
8490 if (/* PR 21343 *//* PR 18879 */
8492 || word_offset
> (sec
->sh_size
- 4)
8493 || ((bfd_signed_vma
) word_offset
) < 0)
8496 /* Get the word at the required offset. */
8497 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8499 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8500 if (arm_sec
->rela
== NULL
)
8506 /* Look through the relocs to find the one that applies to the provided offset. */
8508 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8510 bfd_vma prelval
, offset
;
8512 if (rp
->r_offset
> word_offset
&& !wrapped
)
8517 if (rp
->r_offset
> word_offset
)
8520 if (rp
->r_offset
& 3)
8522 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8523 (unsigned long) rp
->r_offset
);
8527 if (rp
->r_offset
< word_offset
)
8530 /* PR 17531: file: 027-161405-0.004 */
8531 if (aux
->symtab
== NULL
)
8534 if (arm_sec
->rel_type
== SHT_REL
)
8536 offset
= word
& 0x7fffffff;
8537 if (offset
& 0x40000000)
8538 offset
|= ~ (bfd_vma
) 0x7fffffff;
8540 else if (arm_sec
->rel_type
== SHT_RELA
)
8541 offset
= rp
->r_addend
;
8544 error (_("Unknown section relocation type %d encountered\n"),
8549 /* PR 17531 file: 027-1241568-0.004. */
8550 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8552 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8553 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8557 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8558 offset
+= sym
->st_value
;
8559 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8561 /* Check that we are processing the expected reloc type. */
8562 if (filedata
->file_header
.e_machine
== EM_ARM
)
8564 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8565 if (relname
== NULL
)
8567 warn (_("Skipping unknown ARM relocation type: %d\n"),
8568 (int) ELF32_R_TYPE (rp
->r_info
));
8572 if (streq (relname
, "R_ARM_NONE"))
8575 if (! streq (relname
, "R_ARM_PREL31"))
8577 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8581 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8583 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8584 if (relname
== NULL
)
8586 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8587 (int) ELF32_R_TYPE (rp
->r_info
));
8591 if (streq (relname
, "R_C6000_NONE"))
8594 if (! streq (relname
, "R_C6000_PREL31"))
8596 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8604 /* This function currently only supports ARM and TI unwinders. */
8605 warn (_("Only TI and ARM unwinders are currently supported\n"));
8609 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8610 addr
->section
= sym
->st_shndx
;
8611 addr
->offset
= offset
;
8614 * sym_name
= sym
->st_name
;
8619 arm_sec
->next_rela
= rp
;
8624 static const char *tic6x_unwind_regnames
[16] =
8626 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8627 "A14", "A13", "A12", "A11", "A10",
8628 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8632 decode_tic6x_unwind_regmask (unsigned int mask
)
8636 for (i
= 12; mask
; mask
>>= 1, i
--)
8640 fputs (tic6x_unwind_regnames
[i
], stdout
);
8642 fputs (", ", stdout
);
8648 if (remaining == 0 && more_words) \
8651 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8652 data_offset, & word, & addr, NULL)) \
8658 #define GET_OP(OP) \
8663 (OP) = word >> 24; \
8668 printf (_("[Truncated opcode]\n")); \
8671 printf ("0x%02x ", OP)
8674 decode_arm_unwind_bytecode (Filedata
* filedata
,
8675 struct arm_unw_aux_info
* aux
,
8677 unsigned int remaining
,
8678 unsigned int more_words
,
8679 bfd_vma data_offset
,
8680 Elf_Internal_Shdr
* data_sec
,
8681 struct arm_section
* data_arm_sec
)
8683 struct absaddr addr
;
8684 bfd_boolean res
= TRUE
;
8686 /* Decode the unwinding instructions. */
8689 unsigned int op
, op2
;
8698 printf (" 0x%02x ", op
);
8700 if ((op
& 0xc0) == 0x00)
8702 int offset
= ((op
& 0x3f) << 2) + 4;
8704 printf (" vsp = vsp + %d", offset
);
8706 else if ((op
& 0xc0) == 0x40)
8708 int offset
= ((op
& 0x3f) << 2) + 4;
8710 printf (" vsp = vsp - %d", offset
);
8712 else if ((op
& 0xf0) == 0x80)
8715 if (op
== 0x80 && op2
== 0)
8716 printf (_("Refuse to unwind"));
8719 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8720 bfd_boolean first
= TRUE
;
8724 for (i
= 0; i
< 12; i
++)
8725 if (mask
& (1 << i
))
8731 printf ("r%d", 4 + i
);
8736 else if ((op
& 0xf0) == 0x90)
8738 if (op
== 0x9d || op
== 0x9f)
8739 printf (_(" [Reserved]"));
8741 printf (" vsp = r%d", op
& 0x0f);
8743 else if ((op
& 0xf0) == 0xa0)
8745 int end
= 4 + (op
& 0x07);
8746 bfd_boolean first
= TRUE
;
8750 for (i
= 4; i
<= end
; i
++)
8766 else if (op
== 0xb0)
8767 printf (_(" finish"));
8768 else if (op
== 0xb1)
8771 if (op2
== 0 || (op2
& 0xf0) != 0)
8772 printf (_("[Spare]"));
8775 unsigned int mask
= op2
& 0x0f;
8776 bfd_boolean first
= TRUE
;
8780 for (i
= 0; i
< 12; i
++)
8781 if (mask
& (1 << i
))
8792 else if (op
== 0xb2)
8794 unsigned char buf
[9];
8795 unsigned int i
, len
;
8796 unsigned long offset
;
8798 for (i
= 0; i
< sizeof (buf
); i
++)
8801 if ((buf
[i
] & 0x80) == 0)
8804 if (i
== sizeof (buf
))
8806 error (_("corrupt change to vsp\n"));
8811 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8812 assert (len
== i
+ 1);
8813 offset
= offset
* 4 + 0x204;
8814 printf ("vsp = vsp + %ld", offset
);
8817 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8819 unsigned int first
, last
;
8826 printf ("pop {D%d", first
);
8828 printf ("-D%d", first
+ last
);
8831 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8833 unsigned int count
= op
& 0x07;
8837 printf ("-D%d", 8 + count
);
8840 else if (op
>= 0xc0 && op
<= 0xc5)
8842 unsigned int count
= op
& 0x07;
8844 printf (" pop {wR10");
8846 printf ("-wR%d", 10 + count
);
8849 else if (op
== 0xc6)
8851 unsigned int first
, last
;
8856 printf ("pop {wR%d", first
);
8858 printf ("-wR%d", first
+ last
);
8861 else if (op
== 0xc7)
8864 if (op2
== 0 || (op2
& 0xf0) != 0)
8865 printf (_("[Spare]"));
8868 unsigned int mask
= op2
& 0x0f;
8869 bfd_boolean first
= TRUE
;
8873 for (i
= 0; i
< 4; i
++)
8874 if (mask
& (1 << i
))
8880 printf ("wCGR%d", i
);
8887 printf (_(" [unsupported opcode]"));
8898 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8899 struct arm_unw_aux_info
* aux
,
8901 unsigned int remaining
,
8902 unsigned int more_words
,
8903 bfd_vma data_offset
,
8904 Elf_Internal_Shdr
* data_sec
,
8905 struct arm_section
* data_arm_sec
)
8907 struct absaddr addr
;
8909 /* Decode the unwinding instructions. */
8912 unsigned int op
, op2
;
8921 printf (" 0x%02x ", op
);
8923 if ((op
& 0xc0) == 0x00)
8925 int offset
= ((op
& 0x3f) << 3) + 8;
8926 printf (" sp = sp + %d", offset
);
8928 else if ((op
& 0xc0) == 0x80)
8931 if (op
== 0x80 && op2
== 0)
8932 printf (_("Refuse to unwind"));
8935 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8937 printf ("pop compact {");
8941 decode_tic6x_unwind_regmask (mask
);
8945 else if ((op
& 0xf0) == 0xc0)
8953 unsigned int offset
;
8957 /* Scan entire instruction first so that GET_OP output is not
8958 interleaved with disassembly. */
8960 for (i
= 0; nregs
< (op
& 0xf); i
++)
8966 regpos
[nregs
].offset
= i
* 2;
8967 regpos
[nregs
].reg
= reg
;
8974 regpos
[nregs
].offset
= i
* 2 + 1;
8975 regpos
[nregs
].reg
= reg
;
8980 printf (_("pop frame {"));
8983 printf (_("*corrupt* - no registers specified"));
8988 for (i
= i
* 2; i
> 0; i
--)
8990 if (regpos
[reg
].offset
== i
- 1)
8992 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8999 fputs (name
, stdout
);
9007 else if (op
== 0xd0)
9008 printf (" MOV FP, SP");
9009 else if (op
== 0xd1)
9010 printf (" __c6xabi_pop_rts");
9011 else if (op
== 0xd2)
9013 unsigned char buf
[9];
9014 unsigned int i
, len
;
9015 unsigned long offset
;
9017 for (i
= 0; i
< sizeof (buf
); i
++)
9020 if ((buf
[i
] & 0x80) == 0)
9023 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9024 if (i
== sizeof (buf
))
9026 warn (_("Corrupt stack pointer adjustment detected\n"));
9030 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9031 assert (len
== i
+ 1);
9032 offset
= offset
* 8 + 0x408;
9033 printf (_("sp = sp + %ld"), offset
);
9035 else if ((op
& 0xf0) == 0xe0)
9037 if ((op
& 0x0f) == 7)
9040 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9044 printf (_(" [unsupported opcode]"));
9053 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9057 offset
= word
& 0x7fffffff;
9058 if (offset
& 0x40000000)
9059 offset
|= ~ (bfd_vma
) 0x7fffffff;
9061 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9064 return offset
+ where
;
9068 decode_arm_unwind (Filedata
* filedata
,
9069 struct arm_unw_aux_info
* aux
,
9071 unsigned int remaining
,
9072 bfd_vma data_offset
,
9073 Elf_Internal_Shdr
* data_sec
,
9074 struct arm_section
* data_arm_sec
)
9077 unsigned int more_words
= 0;
9078 struct absaddr addr
;
9079 bfd_vma sym_name
= (bfd_vma
) -1;
9080 bfd_boolean res
= TRUE
;
9084 /* Fetch the first word.
9085 Note - when decoding an object file the address extracted
9086 here will always be 0. So we also pass in the sym_name
9087 parameter so that we can find the symbol associated with
9088 the personality routine. */
9089 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9090 & word
, & addr
, & sym_name
))
9097 addr
.section
= SHN_UNDEF
;
9101 if ((word
& 0x80000000) == 0)
9103 /* Expand prel31 for personality routine. */
9105 const char *procname
;
9107 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9108 printf (_(" Personality routine: "));
9110 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9111 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9113 procname
= aux
->strtab
+ sym_name
;
9114 print_vma (fn
, PREFIX_HEX
);
9117 fputs (" <", stdout
);
9118 fputs (procname
, stdout
);
9119 fputc ('>', stdout
);
9123 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9124 fputc ('\n', stdout
);
9126 /* The GCC personality routines use the standard compact
9127 encoding, starting with one byte giving the number of
9129 if (procname
!= NULL
9130 && (const_strneq (procname
, "__gcc_personality_v0")
9131 || const_strneq (procname
, "__gxx_personality_v0")
9132 || const_strneq (procname
, "__gcj_personality_v0")
9133 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9140 printf (_(" [Truncated data]\n"));
9143 more_words
= word
>> 24;
9153 /* ARM EHABI Section 6.3:
9155 An exception-handling table entry for the compact model looks like:
9159 1 0 index Data for personalityRoutine[index] */
9161 if (filedata
->file_header
.e_machine
== EM_ARM
9162 && (word
& 0x70000000))
9164 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9168 per_index
= (word
>> 24) & 0x7f;
9169 printf (_(" Compact model index: %d\n"), per_index
);
9176 else if (per_index
< 3)
9178 more_words
= (word
>> 16) & 0xff;
9184 switch (filedata
->file_header
.e_machine
)
9189 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9190 data_offset
, data_sec
, data_arm_sec
))
9195 warn (_("Unknown ARM compact model index encountered\n"));
9196 printf (_(" [reserved]\n"));
9204 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9205 data_offset
, data_sec
, data_arm_sec
))
9208 else if (per_index
< 5)
9210 if (((word
>> 17) & 0x7f) == 0x7f)
9211 printf (_(" Restore stack from frame pointer\n"));
9213 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9214 printf (_(" Registers restored: "));
9216 printf (" (compact) ");
9217 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9219 printf (_(" Return register: %s\n"),
9220 tic6x_unwind_regnames
[word
& 0xf]);
9223 printf (_(" [reserved (%d)]\n"), per_index
);
9227 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9228 filedata
->file_header
.e_machine
);
9232 /* Decode the descriptors. Not implemented. */
9238 dump_arm_unwind (Filedata
* filedata
,
9239 struct arm_unw_aux_info
* aux
,
9240 Elf_Internal_Shdr
* exidx_sec
)
9242 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9243 unsigned int i
, exidx_len
;
9244 unsigned long j
, nfuns
;
9245 bfd_boolean res
= TRUE
;
9247 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9248 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9249 exidx_len
= exidx_sec
->sh_size
/ 8;
9251 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9252 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9253 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9254 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9256 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9258 for (i
= 0; i
< exidx_len
; i
++)
9260 unsigned int exidx_fn
, exidx_entry
;
9261 struct absaddr fn_addr
, entry_addr
;
9264 fputc ('\n', stdout
);
9266 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9267 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9268 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9269 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9272 arm_free_section (& exidx_arm_sec
);
9273 arm_free_section (& extab_arm_sec
);
9277 /* ARM EHABI, Section 5:
9278 An index table entry consists of 2 words.
9279 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9280 if (exidx_fn
& 0x80000000)
9282 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9286 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9288 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9289 fputs (": ", stdout
);
9291 if (exidx_entry
== 1)
9293 print_vma (exidx_entry
, PREFIX_HEX
);
9294 fputs (" [cantunwind]\n", stdout
);
9296 else if (exidx_entry
& 0x80000000)
9298 print_vma (exidx_entry
, PREFIX_HEX
);
9299 fputc ('\n', stdout
);
9300 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9304 bfd_vma table
, table_offset
= 0;
9305 Elf_Internal_Shdr
*table_sec
;
9307 fputs ("@", stdout
);
9308 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9309 print_vma (table
, PREFIX_HEX
);
9312 /* Locate the matching .ARM.extab. */
9313 if (entry_addr
.section
!= SHN_UNDEF
9314 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9316 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9317 table_offset
= entry_addr
.offset
;
9319 if (table_offset
> table_sec
->sh_size
9320 || ((bfd_signed_vma
) table_offset
) < 0)
9322 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9323 (unsigned long) table_offset
,
9324 printable_section_name (filedata
, table_sec
));
9331 table_sec
= find_section_by_address (filedata
, table
);
9332 if (table_sec
!= NULL
)
9333 table_offset
= table
- table_sec
->sh_addr
;
9336 if (table_sec
== NULL
)
9338 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9339 (unsigned long) table
);
9344 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9353 arm_free_section (&exidx_arm_sec
);
9354 arm_free_section (&extab_arm_sec
);
9359 /* Used for both ARM and C6X unwinding tables. */
9362 arm_process_unwind (Filedata
* filedata
)
9364 struct arm_unw_aux_info aux
;
9365 Elf_Internal_Shdr
*unwsec
= NULL
;
9366 Elf_Internal_Shdr
*strsec
;
9367 Elf_Internal_Shdr
*sec
;
9369 unsigned int sec_type
;
9370 bfd_boolean res
= TRUE
;
9372 switch (filedata
->file_header
.e_machine
)
9375 sec_type
= SHT_ARM_EXIDX
;
9379 sec_type
= SHT_C6000_UNWIND
;
9383 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9384 filedata
->file_header
.e_machine
);
9388 if (filedata
->string_table
== NULL
)
9391 memset (& aux
, 0, sizeof (aux
));
9392 aux
.filedata
= filedata
;
9394 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9396 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9398 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9400 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9402 /* PR binutils/17531 file: 011-12666-0.004. */
9403 if (aux
.strtab
!= NULL
)
9405 error (_("Multiple string tables found in file.\n"));
9409 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9410 1, strsec
->sh_size
, _("string table"));
9411 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9413 else if (sec
->sh_type
== sec_type
)
9418 printf (_("\nThere are no unwind sections in this file.\n"));
9420 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9422 if (sec
->sh_type
== sec_type
)
9424 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9425 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9426 "contains %lu entry:\n",
9427 "\nUnwind section '%s' at offset 0x%lx "
9428 "contains %lu entries:\n",
9430 printable_section_name (filedata
, sec
),
9431 (unsigned long) sec
->sh_offset
,
9434 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9442 free ((char *) aux
.strtab
);
9448 process_unwind (Filedata
* filedata
)
9450 struct unwind_handler
9452 unsigned int machtype
;
9453 bfd_boolean (* handler
)(Filedata
*);
9456 { EM_ARM
, arm_process_unwind
},
9457 { EM_IA_64
, ia64_process_unwind
},
9458 { EM_PARISC
, hppa_process_unwind
},
9459 { EM_TI_C6000
, arm_process_unwind
},
9467 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9468 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9469 return handlers
[i
].handler (filedata
);
9471 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9472 get_machine_name (filedata
->file_header
.e_machine
));
9477 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9479 switch (entry
->d_tag
)
9481 case DT_AARCH64_BTI_PLT
:
9482 case DT_AARCH64_PAC_PLT
:
9485 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9492 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9494 switch (entry
->d_tag
)
9497 if (entry
->d_un
.d_val
== 0)
9501 static const char * opts
[] =
9503 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9504 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9505 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9506 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9510 bfd_boolean first
= TRUE
;
9512 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9513 if (entry
->d_un
.d_val
& (1 << cnt
))
9515 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9521 case DT_MIPS_IVERSION
:
9522 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9523 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9527 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9528 /* Note: coded this way so that there is a single string for translation. */
9529 printf (_("<corrupt: %s>"), buf
);
9533 case DT_MIPS_TIME_STAMP
:
9537 time_t atime
= entry
->d_un
.d_val
;
9539 tmp
= gmtime (&atime
);
9540 /* PR 17531: file: 6accc532. */
9542 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9544 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9545 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9546 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9547 printf (_("Time Stamp: %s"), timebuf
);
9551 case DT_MIPS_RLD_VERSION
:
9552 case DT_MIPS_LOCAL_GOTNO
:
9553 case DT_MIPS_CONFLICTNO
:
9554 case DT_MIPS_LIBLISTNO
:
9555 case DT_MIPS_SYMTABNO
:
9556 case DT_MIPS_UNREFEXTNO
:
9557 case DT_MIPS_HIPAGENO
:
9558 case DT_MIPS_DELTA_CLASS_NO
:
9559 case DT_MIPS_DELTA_INSTANCE_NO
:
9560 case DT_MIPS_DELTA_RELOC_NO
:
9561 case DT_MIPS_DELTA_SYM_NO
:
9562 case DT_MIPS_DELTA_CLASSSYM_NO
:
9563 case DT_MIPS_COMPACT_SIZE
:
9564 print_vma (entry
->d_un
.d_val
, DEC
);
9568 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9569 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9570 /* Falls through. */
9573 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9579 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9581 switch (entry
->d_tag
)
9583 case DT_HP_DLD_FLAGS
:
9592 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9593 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9594 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9595 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9596 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9597 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9598 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9599 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9600 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9601 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9602 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9603 { DT_HP_GST
, "HP_GST" },
9604 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9605 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9606 { DT_HP_NODELETE
, "HP_NODELETE" },
9607 { DT_HP_GROUP
, "HP_GROUP" },
9608 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9610 bfd_boolean first
= TRUE
;
9612 bfd_vma val
= entry
->d_un
.d_val
;
9614 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9615 if (val
& flags
[cnt
].bit
)
9619 fputs (flags
[cnt
].str
, stdout
);
9621 val
^= flags
[cnt
].bit
;
9624 if (val
!= 0 || first
)
9628 print_vma (val
, HEX
);
9634 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9642 /* VMS vs Unix time offset and factor. */
9644 #define VMS_EPOCH_OFFSET 35067168000000000LL
9645 #define VMS_GRANULARITY_FACTOR 10000000
9647 /* Display a VMS time in a human readable format. */
9650 print_vms_time (bfd_int64_t vmstime
)
9655 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9656 tm
= gmtime (&unxtime
);
9657 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9658 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9659 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9664 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9666 switch (entry
->d_tag
)
9668 case DT_IA_64_PLT_RESERVE
:
9669 /* First 3 slots reserved. */
9670 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9672 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9675 case DT_IA_64_VMS_LINKTIME
:
9677 print_vms_time (entry
->d_un
.d_val
);
9681 case DT_IA_64_VMS_LNKFLAGS
:
9682 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9683 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9684 printf (" CALL_DEBUG");
9685 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9686 printf (" NOP0BUFS");
9687 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9688 printf (" P0IMAGE");
9689 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9690 printf (" MKTHREADS");
9691 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9692 printf (" UPCALLS");
9693 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9695 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9696 printf (" INITIALIZE");
9697 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9699 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9700 printf (" EXE_INIT");
9701 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9702 printf (" TBK_IN_IMG");
9703 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9704 printf (" DBG_IN_IMG");
9705 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9706 printf (" TBK_IN_DSF");
9707 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9708 printf (" DBG_IN_DSF");
9709 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9710 printf (" SIGNATURES");
9711 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9712 printf (" REL_SEG_OFF");
9716 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9723 get_32bit_dynamic_section (Filedata
* filedata
)
9725 Elf32_External_Dyn
* edyn
;
9726 Elf32_External_Dyn
* ext
;
9727 Elf_Internal_Dyn
* entry
;
9729 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9730 dynamic_size
, _("dynamic section"));
9734 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9735 might not have the luxury of section headers. Look for the DT_NULL
9736 terminator to determine the number of entries. */
9737 for (ext
= edyn
, dynamic_nent
= 0;
9738 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9742 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9746 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9748 if (dynamic_section
== NULL
)
9750 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9751 (unsigned long) dynamic_nent
);
9756 for (ext
= edyn
, entry
= dynamic_section
;
9757 entry
< dynamic_section
+ dynamic_nent
;
9760 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9761 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9770 get_64bit_dynamic_section (Filedata
* filedata
)
9772 Elf64_External_Dyn
* edyn
;
9773 Elf64_External_Dyn
* ext
;
9774 Elf_Internal_Dyn
* entry
;
9776 /* Read in the data. */
9777 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9778 dynamic_size
, _("dynamic section"));
9782 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9783 might not have the luxury of section headers. Look for the DT_NULL
9784 terminator to determine the number of entries. */
9785 for (ext
= edyn
, dynamic_nent
= 0;
9786 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9787 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9791 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9795 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9797 if (dynamic_section
== NULL
)
9799 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9800 (unsigned long) dynamic_nent
);
9805 /* Convert from external to internal formats. */
9806 for (ext
= edyn
, entry
= dynamic_section
;
9807 entry
< dynamic_section
+ dynamic_nent
;
9810 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9811 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9820 print_dynamic_flags (bfd_vma flags
)
9822 bfd_boolean first
= TRUE
;
9828 flag
= flags
& - flags
;
9838 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9839 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9840 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9841 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9842 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9843 default: fputs (_("unknown"), stdout
); break;
9849 /* Parse and display the contents of the dynamic section. */
9852 process_dynamic_section (Filedata
* filedata
)
9854 Elf_Internal_Dyn
* entry
;
9856 if (dynamic_size
== 0)
9859 printf (_("\nThere is no dynamic section in this file.\n"));
9866 if (! get_32bit_dynamic_section (filedata
))
9871 if (! get_64bit_dynamic_section (filedata
))
9875 /* Find the appropriate symbol table. */
9876 if (dynamic_symbols
== NULL
)
9878 for (entry
= dynamic_section
;
9879 entry
< dynamic_section
+ dynamic_nent
;
9882 Elf_Internal_Shdr section
;
9884 if (entry
->d_tag
!= DT_SYMTAB
)
9887 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9889 /* Since we do not know how big the symbol table is,
9890 we default to reading in the entire file (!) and
9891 processing that. This is overkill, I know, but it
9893 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9894 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9896 /* See PR 21379 for a reproducer. */
9897 error (_("Invalid DT_SYMTAB entry: %lx\n"),
9898 (long) section
.sh_offset
);
9902 if (archive_file_offset
!= 0)
9903 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9905 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9908 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9910 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9911 section
.sh_name
= filedata
->string_table_length
;
9913 if (dynamic_symbols
!= NULL
)
9915 error (_("Multiple dynamic symbol table sections found\n"));
9916 free (dynamic_symbols
);
9918 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9919 if (num_dynamic_syms
< 1)
9921 error (_("Unable to determine the number of symbols to load\n"));
9927 /* Similarly find a string table. */
9928 if (dynamic_strings
== NULL
)
9930 for (entry
= dynamic_section
;
9931 entry
< dynamic_section
+ dynamic_nent
;
9934 unsigned long offset
;
9937 if (entry
->d_tag
!= DT_STRTAB
)
9940 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9942 /* Since we do not know how big the string table is,
9943 we default to reading in the entire file (!) and
9944 processing that. This is overkill, I know, but it
9947 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9949 if (archive_file_offset
!= 0)
9950 str_tab_len
= archive_file_size
- offset
;
9952 str_tab_len
= filedata
->file_size
- offset
;
9954 if (str_tab_len
< 1)
9957 (_("Unable to determine the length of the dynamic string table\n"));
9961 if (dynamic_strings
!= NULL
)
9963 error (_("Multiple dynamic string tables found\n"));
9964 free (dynamic_strings
);
9967 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9969 _("dynamic string table"));
9970 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9974 /* And find the syminfo section if available. */
9975 if (dynamic_syminfo
== NULL
)
9977 unsigned long syminsz
= 0;
9979 for (entry
= dynamic_section
;
9980 entry
< dynamic_section
+ dynamic_nent
;
9983 if (entry
->d_tag
== DT_SYMINENT
)
9985 /* Note: these braces are necessary to avoid a syntax
9986 error from the SunOS4 C compiler. */
9987 /* PR binutils/17531: A corrupt file can trigger this test.
9988 So do not use an assert, instead generate an error message. */
9989 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9990 error (_("Bad value (%d) for SYMINENT entry\n"),
9991 (int) entry
->d_un
.d_val
);
9993 else if (entry
->d_tag
== DT_SYMINSZ
)
9994 syminsz
= entry
->d_un
.d_val
;
9995 else if (entry
->d_tag
== DT_SYMINFO
)
9996 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
10000 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10002 Elf_External_Syminfo
* extsyminfo
;
10003 Elf_External_Syminfo
* extsym
;
10004 Elf_Internal_Syminfo
* syminfo
;
10006 /* There is a syminfo section. Read the data. */
10007 extsyminfo
= (Elf_External_Syminfo
*)
10008 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
10009 _("symbol information"));
10013 if (dynamic_syminfo
!= NULL
)
10015 error (_("Multiple dynamic symbol information sections found\n"));
10016 free (dynamic_syminfo
);
10018 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10019 if (dynamic_syminfo
== NULL
)
10021 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10022 (unsigned long) syminsz
);
10026 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10027 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10028 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10029 ++syminfo
, ++extsym
)
10031 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10032 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10039 if (do_dynamic
&& dynamic_addr
)
10040 printf (ngettext ("\nDynamic section at offset 0x%lx "
10041 "contains %lu entry:\n",
10042 "\nDynamic section at offset 0x%lx "
10043 "contains %lu entries:\n",
10045 dynamic_addr
, (unsigned long) dynamic_nent
);
10047 printf (_(" Tag Type Name/Value\n"));
10049 for (entry
= dynamic_section
;
10050 entry
< dynamic_section
+ dynamic_nent
;
10055 const char * dtype
;
10058 print_vma (entry
->d_tag
, FULL_HEX
);
10059 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10060 printf (" (%s)%*s", dtype
,
10061 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10064 switch (entry
->d_tag
)
10068 print_dynamic_flags (entry
->d_un
.d_val
);
10078 switch (entry
->d_tag
)
10081 printf (_("Auxiliary library"));
10085 printf (_("Filter library"));
10089 printf (_("Configuration file"));
10093 printf (_("Dependency audit library"));
10097 printf (_("Audit library"));
10101 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10102 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10106 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10115 printf (_("Flags:"));
10117 if (entry
->d_un
.d_val
== 0)
10118 printf (_(" None\n"));
10121 unsigned long int val
= entry
->d_un
.d_val
;
10123 if (val
& DTF_1_PARINIT
)
10125 printf (" PARINIT");
10126 val
^= DTF_1_PARINIT
;
10128 if (val
& DTF_1_CONFEXP
)
10130 printf (" CONFEXP");
10131 val
^= DTF_1_CONFEXP
;
10134 printf (" %lx", val
);
10143 printf (_("Flags:"));
10145 if (entry
->d_un
.d_val
== 0)
10146 printf (_(" None\n"));
10149 unsigned long int val
= entry
->d_un
.d_val
;
10151 if (val
& DF_P1_LAZYLOAD
)
10153 printf (" LAZYLOAD");
10154 val
^= DF_P1_LAZYLOAD
;
10156 if (val
& DF_P1_GROUPPERM
)
10158 printf (" GROUPPERM");
10159 val
^= DF_P1_GROUPPERM
;
10162 printf (" %lx", val
);
10171 printf (_("Flags:"));
10172 if (entry
->d_un
.d_val
== 0)
10173 printf (_(" None\n"));
10176 unsigned long int val
= entry
->d_un
.d_val
;
10178 if (val
& DF_1_NOW
)
10183 if (val
& DF_1_GLOBAL
)
10185 printf (" GLOBAL");
10186 val
^= DF_1_GLOBAL
;
10188 if (val
& DF_1_GROUP
)
10193 if (val
& DF_1_NODELETE
)
10195 printf (" NODELETE");
10196 val
^= DF_1_NODELETE
;
10198 if (val
& DF_1_LOADFLTR
)
10200 printf (" LOADFLTR");
10201 val
^= DF_1_LOADFLTR
;
10203 if (val
& DF_1_INITFIRST
)
10205 printf (" INITFIRST");
10206 val
^= DF_1_INITFIRST
;
10208 if (val
& DF_1_NOOPEN
)
10210 printf (" NOOPEN");
10211 val
^= DF_1_NOOPEN
;
10213 if (val
& DF_1_ORIGIN
)
10215 printf (" ORIGIN");
10216 val
^= DF_1_ORIGIN
;
10218 if (val
& DF_1_DIRECT
)
10220 printf (" DIRECT");
10221 val
^= DF_1_DIRECT
;
10223 if (val
& DF_1_TRANS
)
10228 if (val
& DF_1_INTERPOSE
)
10230 printf (" INTERPOSE");
10231 val
^= DF_1_INTERPOSE
;
10233 if (val
& DF_1_NODEFLIB
)
10235 printf (" NODEFLIB");
10236 val
^= DF_1_NODEFLIB
;
10238 if (val
& DF_1_NODUMP
)
10240 printf (" NODUMP");
10241 val
^= DF_1_NODUMP
;
10243 if (val
& DF_1_CONFALT
)
10245 printf (" CONFALT");
10246 val
^= DF_1_CONFALT
;
10248 if (val
& DF_1_ENDFILTEE
)
10250 printf (" ENDFILTEE");
10251 val
^= DF_1_ENDFILTEE
;
10253 if (val
& DF_1_DISPRELDNE
)
10255 printf (" DISPRELDNE");
10256 val
^= DF_1_DISPRELDNE
;
10258 if (val
& DF_1_DISPRELPND
)
10260 printf (" DISPRELPND");
10261 val
^= DF_1_DISPRELPND
;
10263 if (val
& DF_1_NODIRECT
)
10265 printf (" NODIRECT");
10266 val
^= DF_1_NODIRECT
;
10268 if (val
& DF_1_IGNMULDEF
)
10270 printf (" IGNMULDEF");
10271 val
^= DF_1_IGNMULDEF
;
10273 if (val
& DF_1_NOKSYMS
)
10275 printf (" NOKSYMS");
10276 val
^= DF_1_NOKSYMS
;
10278 if (val
& DF_1_NOHDR
)
10283 if (val
& DF_1_EDITED
)
10285 printf (" EDITED");
10286 val
^= DF_1_EDITED
;
10288 if (val
& DF_1_NORELOC
)
10290 printf (" NORELOC");
10291 val
^= DF_1_NORELOC
;
10293 if (val
& DF_1_SYMINTPOSE
)
10295 printf (" SYMINTPOSE");
10296 val
^= DF_1_SYMINTPOSE
;
10298 if (val
& DF_1_GLOBAUDIT
)
10300 printf (" GLOBAUDIT");
10301 val
^= DF_1_GLOBAUDIT
;
10303 if (val
& DF_1_SINGLETON
)
10305 printf (" SINGLETON");
10306 val
^= DF_1_SINGLETON
;
10308 if (val
& DF_1_STUB
)
10313 if (val
& DF_1_PIE
)
10318 if (val
& DF_1_KMOD
)
10323 if (val
& DF_1_WEAKFILTER
)
10325 printf (" WEAKFILTER");
10326 val
^= DF_1_WEAKFILTER
;
10328 if (val
& DF_1_NOCOMMON
)
10330 printf (" NOCOMMON");
10331 val
^= DF_1_NOCOMMON
;
10334 printf (" %lx", val
);
10341 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10343 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10363 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10369 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10370 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10376 switch (entry
->d_tag
)
10379 printf (_("Shared library: [%s]"), name
);
10381 if (streq (name
, program_interpreter
))
10382 printf (_(" program interpreter"));
10386 printf (_("Library soname: [%s]"), name
);
10390 printf (_("Library rpath: [%s]"), name
);
10394 printf (_("Library runpath: [%s]"), name
);
10398 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10403 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10416 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10417 /* Fall through. */
10421 case DT_INIT_ARRAYSZ
:
10422 case DT_FINI_ARRAYSZ
:
10423 case DT_GNU_CONFLICTSZ
:
10424 case DT_GNU_LIBLISTSZ
:
10427 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10428 printf (_(" (bytes)\n"));
10433 case DT_VERNEEDNUM
:
10438 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10447 case DT_INIT_ARRAY
:
10448 case DT_FINI_ARRAY
:
10451 if (entry
->d_tag
== DT_USED
10452 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10454 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10458 printf (_("Not needed object: [%s]\n"), name
);
10463 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10469 /* The value of this entry is ignored. */
10474 case DT_GNU_PRELINKED
:
10478 time_t atime
= entry
->d_un
.d_val
;
10480 tmp
= gmtime (&atime
);
10481 /* PR 17533 file: 041-1244816-0.004. */
10483 printf (_("<corrupt time val: %lx"),
10484 (unsigned long) atime
);
10486 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10487 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10488 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10494 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10497 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10503 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10504 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10509 switch (filedata
->file_header
.e_machine
)
10512 dynamic_section_aarch64_val (entry
);
10515 case EM_MIPS_RS3_LE
:
10516 dynamic_section_mips_val (entry
);
10519 dynamic_section_parisc_val (entry
);
10522 dynamic_section_ia64_val (entry
);
10525 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10537 get_ver_flags (unsigned int flags
)
10539 static char buff
[128];
10546 if (flags
& VER_FLG_BASE
)
10547 strcat (buff
, "BASE");
10549 if (flags
& VER_FLG_WEAK
)
10551 if (flags
& VER_FLG_BASE
)
10552 strcat (buff
, " | ");
10554 strcat (buff
, "WEAK");
10557 if (flags
& VER_FLG_INFO
)
10559 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10560 strcat (buff
, " | ");
10562 strcat (buff
, "INFO");
10565 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10567 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10568 strcat (buff
, " | ");
10570 strcat (buff
, _("<unknown>"));
10576 /* Display the contents of the version sections. */
10579 process_version_sections (Filedata
* filedata
)
10581 Elf_Internal_Shdr
* section
;
10583 bfd_boolean found
= FALSE
;
10588 for (i
= 0, section
= filedata
->section_headers
;
10589 i
< filedata
->file_header
.e_shnum
;
10592 switch (section
->sh_type
)
10594 case SHT_GNU_verdef
:
10596 Elf_External_Verdef
* edefs
;
10603 printf (ngettext ("\nVersion definition section '%s' "
10604 "contains %u entry:\n",
10605 "\nVersion definition section '%s' "
10606 "contains %u entries:\n",
10608 printable_section_name (filedata
, section
),
10611 printf (_(" Addr: 0x"));
10612 printf_vma (section
->sh_addr
);
10613 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10614 (unsigned long) section
->sh_offset
, section
->sh_link
,
10615 printable_section_name_from_index (filedata
, section
->sh_link
));
10617 edefs
= (Elf_External_Verdef
*)
10618 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10619 _("version definition section"));
10622 endbuf
= (char *) edefs
+ section
->sh_size
;
10624 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10627 Elf_External_Verdef
* edef
;
10628 Elf_Internal_Verdef ent
;
10629 Elf_External_Verdaux
* eaux
;
10630 Elf_Internal_Verdaux aux
;
10631 unsigned long isum
;
10634 vstart
= ((char *) edefs
) + idx
;
10635 if (vstart
+ sizeof (*edef
) > endbuf
)
10638 edef
= (Elf_External_Verdef
*) vstart
;
10640 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10641 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10642 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10643 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10644 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10645 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10646 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10648 printf (_(" %#06lx: Rev: %d Flags: %s"),
10649 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10651 printf (_(" Index: %d Cnt: %d "),
10652 ent
.vd_ndx
, ent
.vd_cnt
);
10654 /* Check for overflow. */
10655 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10658 vstart
+= ent
.vd_aux
;
10660 if (vstart
+ sizeof (*eaux
) > endbuf
)
10662 eaux
= (Elf_External_Verdaux
*) vstart
;
10664 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10665 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10667 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10668 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10670 printf (_("Name index: %ld\n"), aux
.vda_name
);
10672 isum
= idx
+ ent
.vd_aux
;
10674 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10676 if (aux
.vda_next
< sizeof (*eaux
)
10677 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10679 warn (_("Invalid vda_next field of %lx\n"),
10684 /* Check for overflow. */
10685 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10688 isum
+= aux
.vda_next
;
10689 vstart
+= aux
.vda_next
;
10691 if (vstart
+ sizeof (*eaux
) > endbuf
)
10693 eaux
= (Elf_External_Verdaux
*) vstart
;
10695 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10696 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10698 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10699 printf (_(" %#06lx: Parent %d: %s\n"),
10700 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10702 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10703 isum
, j
, aux
.vda_name
);
10706 if (j
< ent
.vd_cnt
)
10707 printf (_(" Version def aux past end of section\n"));
10710 file: id:000001,src:000172+005151,op:splice,rep:2. */
10711 if (ent
.vd_next
< sizeof (*edef
)
10712 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10714 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10715 cnt
= section
->sh_info
;
10718 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10721 idx
+= ent
.vd_next
;
10724 if (cnt
< section
->sh_info
)
10725 printf (_(" Version definition past end of section\n"));
10731 case SHT_GNU_verneed
:
10733 Elf_External_Verneed
* eneed
;
10740 printf (ngettext ("\nVersion needs section '%s' "
10741 "contains %u entry:\n",
10742 "\nVersion needs section '%s' "
10743 "contains %u entries:\n",
10745 printable_section_name (filedata
, section
), section
->sh_info
);
10747 printf (_(" Addr: 0x"));
10748 printf_vma (section
->sh_addr
);
10749 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10750 (unsigned long) section
->sh_offset
, section
->sh_link
,
10751 printable_section_name_from_index (filedata
, section
->sh_link
));
10753 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10754 section
->sh_offset
, 1,
10756 _("Version Needs section"));
10759 endbuf
= (char *) eneed
+ section
->sh_size
;
10761 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10763 Elf_External_Verneed
* entry
;
10764 Elf_Internal_Verneed ent
;
10765 unsigned long isum
;
10769 vstart
= ((char *) eneed
) + idx
;
10770 if (vstart
+ sizeof (*entry
) > endbuf
)
10773 entry
= (Elf_External_Verneed
*) vstart
;
10775 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10776 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10777 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10778 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10779 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10781 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10783 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10784 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10786 printf (_(" File: %lx"), ent
.vn_file
);
10788 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10790 /* Check for overflow. */
10791 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10793 vstart
+= ent
.vn_aux
;
10795 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10797 Elf_External_Vernaux
* eaux
;
10798 Elf_Internal_Vernaux aux
;
10800 if (vstart
+ sizeof (*eaux
) > endbuf
)
10802 eaux
= (Elf_External_Vernaux
*) vstart
;
10804 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10805 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10806 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10807 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10808 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10810 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10811 printf (_(" %#06lx: Name: %s"),
10812 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10814 printf (_(" %#06lx: Name index: %lx"),
10815 isum
, aux
.vna_name
);
10817 printf (_(" Flags: %s Version: %d\n"),
10818 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10820 if (aux
.vna_next
< sizeof (*eaux
)
10821 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10823 warn (_("Invalid vna_next field of %lx\n"),
10828 /* Check for overflow. */
10829 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10831 isum
+= aux
.vna_next
;
10832 vstart
+= aux
.vna_next
;
10835 if (j
< ent
.vn_cnt
)
10836 warn (_("Missing Version Needs auxillary information\n"));
10838 if (ent
.vn_next
< sizeof (*entry
)
10839 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10841 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10842 cnt
= section
->sh_info
;
10845 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10847 idx
+= ent
.vn_next
;
10850 if (cnt
< section
->sh_info
)
10851 warn (_("Missing Version Needs information\n"));
10857 case SHT_GNU_versym
:
10859 Elf_Internal_Shdr
* link_section
;
10862 unsigned char * edata
;
10863 unsigned short * data
;
10865 Elf_Internal_Sym
* symbols
;
10866 Elf_Internal_Shdr
* string_sec
;
10867 unsigned long num_syms
;
10870 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10873 link_section
= filedata
->section_headers
+ section
->sh_link
;
10874 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10876 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10881 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10882 if (symbols
== NULL
)
10885 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10887 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10888 string_sec
->sh_size
,
10889 _("version string table"));
10896 printf (ngettext ("\nVersion symbols section '%s' "
10897 "contains %lu entry:\n",
10898 "\nVersion symbols section '%s' "
10899 "contains %lu entries:\n",
10901 printable_section_name (filedata
, section
), (unsigned long) total
);
10903 printf (_(" Addr: 0x"));
10904 printf_vma (section
->sh_addr
);
10905 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10906 (unsigned long) section
->sh_offset
, section
->sh_link
,
10907 printable_section_name (filedata
, link_section
));
10909 off
= offset_from_vma (filedata
,
10910 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10911 total
* sizeof (short));
10912 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
10913 sizeof (short), total
,
10914 _("version symbol data"));
10922 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10924 for (cnt
= total
; cnt
--;)
10925 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10930 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10934 char *invalid
= _("*invalid*");
10936 printf (" %03x:", cnt
);
10938 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10939 switch (data
[cnt
+ j
])
10942 fputs (_(" 0 (*local*) "), stdout
);
10946 fputs (_(" 1 (*global*) "), stdout
);
10950 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10951 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10953 /* If this index value is greater than the size of the symbols
10954 array, break to avoid an out-of-bounds read. */
10955 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10957 warn (_("invalid index into symbol array\n"));
10962 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10964 Elf_Internal_Verneed ivn
;
10965 unsigned long offset
;
10967 offset
= offset_from_vma
10968 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10969 sizeof (Elf_External_Verneed
));
10973 Elf_Internal_Vernaux ivna
;
10974 Elf_External_Verneed evn
;
10975 Elf_External_Vernaux evna
;
10976 unsigned long a_off
;
10978 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10979 _("version need")) == NULL
)
10982 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10983 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10985 a_off
= offset
+ ivn
.vn_aux
;
10989 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10990 1, _("version need aux (2)")) == NULL
)
10993 ivna
.vna_other
= 0;
10997 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10998 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11001 a_off
+= ivna
.vna_next
;
11003 while (ivna
.vna_other
!= data
[cnt
+ j
]
11004 && ivna
.vna_next
!= 0);
11006 if (ivna
.vna_other
== data
[cnt
+ j
])
11008 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11010 if (ivna
.vna_name
>= string_sec
->sh_size
)
11013 name
= strtab
+ ivna
.vna_name
;
11017 offset
+= ivn
.vn_next
;
11019 while (ivn
.vn_next
);
11022 if (data
[cnt
+ j
] != 0x8001
11023 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11025 Elf_Internal_Verdef ivd
;
11026 Elf_External_Verdef evd
;
11027 unsigned long offset
;
11029 offset
= offset_from_vma
11030 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11035 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11036 _("version def")) == NULL
)
11039 /* PR 17531: file: 046-1082287-0.004. */
11040 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11045 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11046 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11049 offset
+= ivd
.vd_next
;
11051 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11052 && ivd
.vd_next
!= 0);
11054 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11056 Elf_External_Verdaux evda
;
11057 Elf_Internal_Verdaux ivda
;
11059 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11061 if (get_data (&evda
, filedata
,
11062 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11064 _("version def aux")) == NULL
)
11067 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11069 if (ivda
.vda_name
>= string_sec
->sh_size
)
11071 else if (name
!= NULL
&& name
!= invalid
)
11072 name
= _("*both*");
11074 name
= strtab
+ ivda
.vda_name
;
11078 nn
+= printf ("(%s%-*s",
11080 12 - (int) strlen (name
),
11084 printf ("%*c", 18 - nn
, ' ');
11102 printf (_("\nNo version information found in this file.\n"));
11107 static const char *
11108 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11110 static char buff
[32];
11114 case STB_LOCAL
: return "LOCAL";
11115 case STB_GLOBAL
: return "GLOBAL";
11116 case STB_WEAK
: return "WEAK";
11118 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11119 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11121 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11123 if (binding
== STB_GNU_UNIQUE
11124 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11126 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11129 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11134 static const char *
11135 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11137 static char buff
[32];
11141 case STT_NOTYPE
: return "NOTYPE";
11142 case STT_OBJECT
: return "OBJECT";
11143 case STT_FUNC
: return "FUNC";
11144 case STT_SECTION
: return "SECTION";
11145 case STT_FILE
: return "FILE";
11146 case STT_COMMON
: return "COMMON";
11147 case STT_TLS
: return "TLS";
11148 case STT_RELC
: return "RELC";
11149 case STT_SRELC
: return "SRELC";
11151 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11153 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11154 return "THUMB_FUNC";
11156 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11159 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11160 return "PARISC_MILLI";
11162 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11164 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11166 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11168 if (type
== STT_HP_OPAQUE
)
11169 return "HP_OPAQUE";
11170 if (type
== STT_HP_STUB
)
11174 if (type
== STT_GNU_IFUNC
11175 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11176 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11179 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11182 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11187 static const char *
11188 get_symbol_visibility (unsigned int visibility
)
11190 switch (visibility
)
11192 case STV_DEFAULT
: return "DEFAULT";
11193 case STV_INTERNAL
: return "INTERNAL";
11194 case STV_HIDDEN
: return "HIDDEN";
11195 case STV_PROTECTED
: return "PROTECTED";
11197 error (_("Unrecognized visibility value: %u\n"), visibility
);
11198 return _("<unknown>");
11202 static const char *
11203 get_alpha_symbol_other (unsigned int other
)
11207 case STO_ALPHA_NOPV
: return "NOPV";
11208 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11210 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11211 return _("<unknown>");
11215 static const char *
11216 get_solaris_symbol_visibility (unsigned int visibility
)
11218 switch (visibility
)
11220 case 4: return "EXPORTED";
11221 case 5: return "SINGLETON";
11222 case 6: return "ELIMINATE";
11223 default: return get_symbol_visibility (visibility
);
11227 static const char *
11228 get_aarch64_symbol_other (unsigned int other
)
11230 static char buf
[32];
11232 if (other
& STO_AARCH64_VARIANT_PCS
)
11234 other
&= ~STO_AARCH64_VARIANT_PCS
;
11236 return "VARIANT_PCS";
11237 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11243 static const char *
11244 get_mips_symbol_other (unsigned int other
)
11248 case STO_OPTIONAL
: return "OPTIONAL";
11249 case STO_MIPS_PLT
: return "MIPS PLT";
11250 case STO_MIPS_PIC
: return "MIPS PIC";
11251 case STO_MICROMIPS
: return "MICROMIPS";
11252 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11253 case STO_MIPS16
: return "MIPS16";
11254 default: return NULL
;
11258 static const char *
11259 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11261 if (is_ia64_vms (filedata
))
11263 static char res
[32];
11267 /* Function types is for images and .STB files only. */
11268 switch (filedata
->file_header
.e_type
)
11272 switch (VMS_ST_FUNC_TYPE (other
))
11274 case VMS_SFT_CODE_ADDR
:
11275 strcat (res
, " CA");
11277 case VMS_SFT_SYMV_IDX
:
11278 strcat (res
, " VEC");
11281 strcat (res
, " FD");
11283 case VMS_SFT_RESERVE
:
11284 strcat (res
, " RSV");
11287 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11288 VMS_ST_FUNC_TYPE (other
));
11289 strcat (res
, " <unknown>");
11296 switch (VMS_ST_LINKAGE (other
))
11298 case VMS_STL_IGNORE
:
11299 strcat (res
, " IGN");
11301 case VMS_STL_RESERVE
:
11302 strcat (res
, " RSV");
11305 strcat (res
, " STD");
11308 strcat (res
, " LNK");
11311 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11312 VMS_ST_LINKAGE (other
));
11313 strcat (res
, " <unknown>");
11325 static const char *
11326 get_ppc64_symbol_other (unsigned int other
)
11328 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11331 other
>>= STO_PPC64_LOCAL_BIT
;
11334 static char buf
[32];
11336 other
= ppc64_decode_local_entry (other
);
11337 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11343 static const char *
11344 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11346 const char * result
= NULL
;
11347 static char buff
[32];
11352 switch (filedata
->file_header
.e_machine
)
11355 result
= get_alpha_symbol_other (other
);
11358 result
= get_aarch64_symbol_other (other
);
11361 result
= get_mips_symbol_other (other
);
11364 result
= get_ia64_symbol_other (filedata
, other
);
11367 result
= get_ppc64_symbol_other (other
);
11377 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11381 static const char *
11382 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11384 static char buff
[32];
11388 case SHN_UNDEF
: return "UND";
11389 case SHN_ABS
: return "ABS";
11390 case SHN_COMMON
: return "COM";
11392 if (type
== SHN_IA_64_ANSI_COMMON
11393 && filedata
->file_header
.e_machine
== EM_IA_64
11394 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11396 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11397 || filedata
->file_header
.e_machine
== EM_L1OM
11398 || filedata
->file_header
.e_machine
== EM_K1OM
)
11399 && type
== SHN_X86_64_LCOMMON
)
11400 return "LARGE_COM";
11401 else if ((type
== SHN_MIPS_SCOMMON
11402 && filedata
->file_header
.e_machine
== EM_MIPS
)
11403 || (type
== SHN_TIC6X_SCOMMON
11404 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11406 else if (type
== SHN_MIPS_SUNDEFINED
11407 && filedata
->file_header
.e_machine
== EM_MIPS
)
11409 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11410 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11411 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11412 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11413 else if (type
>= SHN_LORESERVE
)
11414 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11415 else if (type
>= filedata
->file_header
.e_shnum
)
11416 sprintf (buff
, _("bad section index[%3d]"), type
);
11418 sprintf (buff
, "%3d", type
);
11426 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11428 unsigned char * e_data
;
11431 /* If the size_t type is smaller than the bfd_size_type, eg because
11432 you are building a 32-bit tool on a 64-bit host, then make sure
11433 that when (number) is cast to (size_t) no information is lost. */
11434 if (sizeof (size_t) < sizeof (bfd_size_type
)
11435 && (bfd_size_type
) ((size_t) number
) != number
)
11437 error (_("Size truncation prevents reading %s elements of size %u\n"),
11438 bfd_vmatoa ("u", number
), ent_size
);
11442 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
11443 attempting to allocate memory when the read is bound to fail. */
11444 if (ent_size
* number
> filedata
->file_size
)
11446 error (_("Invalid number of dynamic entries: %s\n"),
11447 bfd_vmatoa ("u", number
));
11451 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11452 if (e_data
== NULL
)
11454 error (_("Out of memory reading %s dynamic entries\n"),
11455 bfd_vmatoa ("u", number
));
11459 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11461 error (_("Unable to read in %s bytes of dynamic data\n"),
11462 bfd_vmatoa ("u", number
* ent_size
));
11467 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11468 if (i_data
== NULL
)
11470 error (_("Out of memory allocating space for %s dynamic entries\n"),
11471 bfd_vmatoa ("u", number
));
11477 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11485 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11487 Elf_Internal_Sym
* psym
;
11490 n
= print_vma (si
, DEC_5
);
11492 fputs (&" "[n
], stdout
);
11493 printf (" %3lu: ", hn
);
11495 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11497 printf (_("<No info available for dynamic symbol number %lu>\n"),
11498 (unsigned long) si
);
11502 psym
= dynamic_symbols
+ si
;
11503 print_vma (psym
->st_value
, LONG_HEX
);
11505 print_vma (psym
->st_size
, DEC_5
);
11507 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11508 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11510 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11511 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11514 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11516 printf (" %-7s", get_symbol_visibility (vis
));
11517 /* Check to see if any other bits in the st_other field are set.
11518 Note - displaying this information disrupts the layout of the
11519 table being generated, but for the moment this case is very
11521 if (psym
->st_other
^ vis
)
11522 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11525 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11526 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11527 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11529 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11533 static const char *
11534 get_symbol_version_string (Filedata
* filedata
,
11535 bfd_boolean is_dynsym
,
11536 const char * strtab
,
11537 unsigned long int strtab_size
,
11539 Elf_Internal_Sym
* psym
,
11540 enum versioned_symbol_info
* sym_info
,
11541 unsigned short * vna_other
)
11543 unsigned char data
[2];
11544 unsigned short vers_data
;
11545 unsigned long offset
;
11546 unsigned short max_vd_ndx
;
11549 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11552 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11553 sizeof data
+ si
* sizeof (vers_data
));
11555 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11556 sizeof (data
), 1, _("version data")) == NULL
)
11559 vers_data
= byte_get (data
, 2);
11561 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11564 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11567 /* Usually we'd only see verdef for defined symbols, and verneed for
11568 undefined symbols. However, symbols defined by the linker in
11569 .dynbss for variables copied from a shared library in order to
11570 avoid text relocations are defined yet have verneed. We could
11571 use a heuristic to detect the special case, for example, check
11572 for verneed first on symbols defined in SHT_NOBITS sections, but
11573 it is simpler and more reliable to just look for both verdef and
11574 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11576 if (psym
->st_shndx
!= SHN_UNDEF
11577 && vers_data
!= 0x8001
11578 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11580 Elf_Internal_Verdef ivd
;
11581 Elf_Internal_Verdaux ivda
;
11582 Elf_External_Verdaux evda
;
11585 off
= offset_from_vma (filedata
,
11586 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11587 sizeof (Elf_External_Verdef
));
11591 Elf_External_Verdef evd
;
11593 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11594 _("version def")) == NULL
)
11603 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11604 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11605 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11606 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11609 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11610 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11612 off
+= ivd
.vd_next
;
11614 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11616 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11618 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11621 off
-= ivd
.vd_next
;
11624 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11625 _("version def aux")) != NULL
)
11627 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11629 if (psym
->st_name
!= ivda
.vda_name
)
11630 return (ivda
.vda_name
< strtab_size
11631 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11636 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11638 Elf_External_Verneed evn
;
11639 Elf_Internal_Verneed ivn
;
11640 Elf_Internal_Vernaux ivna
;
11642 offset
= offset_from_vma (filedata
,
11643 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11647 unsigned long vna_off
;
11649 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11650 _("version need")) == NULL
)
11653 ivna
.vna_other
= 0;
11658 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11659 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11661 vna_off
= offset
+ ivn
.vn_aux
;
11665 Elf_External_Vernaux evna
;
11667 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11668 _("version need aux (3)")) == NULL
)
11671 ivna
.vna_other
= 0;
11676 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11677 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11678 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11681 vna_off
+= ivna
.vna_next
;
11683 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11685 if (ivna
.vna_other
== vers_data
)
11688 offset
+= ivn
.vn_next
;
11690 while (ivn
.vn_next
!= 0);
11692 if (ivna
.vna_other
== vers_data
)
11694 *sym_info
= symbol_undefined
;
11695 *vna_other
= ivna
.vna_other
;
11696 return (ivna
.vna_name
< strtab_size
11697 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11699 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11700 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11701 return _("<corrupt>");
11706 /* Dump the symbol table. */
11708 process_symbol_table (Filedata
* filedata
)
11710 Elf_Internal_Shdr
* section
;
11711 bfd_size_type nbuckets
= 0;
11712 bfd_size_type nchains
= 0;
11713 bfd_vma
* buckets
= NULL
;
11714 bfd_vma
* chains
= NULL
;
11715 bfd_vma ngnubuckets
= 0;
11716 bfd_vma
* gnubuckets
= NULL
;
11717 bfd_vma
* gnuchains
= NULL
;
11718 bfd_vma
* mipsxlat
= NULL
;
11719 bfd_vma gnusymidx
= 0;
11720 bfd_size_type ngnuchains
= 0;
11722 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11725 if (dynamic_info
[DT_HASH
]
11727 || (do_using_dynamic
11729 && dynamic_strings
!= NULL
)))
11731 unsigned char nb
[8];
11732 unsigned char nc
[8];
11733 unsigned int hash_ent_size
= 4;
11735 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11736 || filedata
->file_header
.e_machine
== EM_S390
11737 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11738 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11741 if (fseek (filedata
->handle
,
11742 (archive_file_offset
11743 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11744 sizeof nb
+ sizeof nc
)),
11747 error (_("Unable to seek to start of dynamic information\n"));
11751 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11753 error (_("Failed to read in number of buckets\n"));
11757 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11759 error (_("Failed to read in number of chains\n"));
11763 nbuckets
= byte_get (nb
, hash_ent_size
);
11764 nchains
= byte_get (nc
, hash_ent_size
);
11766 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11767 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11769 if (buckets
== NULL
|| chains
== NULL
)
11778 if (do_using_dynamic
)
11783 if (dynamic_info_DT_GNU_HASH
11785 || (do_using_dynamic
11787 && dynamic_strings
!= NULL
)))
11789 unsigned char nb
[16];
11790 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11791 bfd_vma buckets_vma
;
11793 if (fseek (filedata
->handle
,
11794 (archive_file_offset
11795 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11799 error (_("Unable to seek to start of dynamic information\n"));
11803 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11805 error (_("Failed to read in number of buckets\n"));
11809 ngnubuckets
= byte_get (nb
, 4);
11810 gnusymidx
= byte_get (nb
+ 4, 4);
11811 bitmaskwords
= byte_get (nb
+ 8, 4);
11812 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11814 buckets_vma
+= bitmaskwords
* 4;
11816 buckets_vma
+= bitmaskwords
* 8;
11818 if (fseek (filedata
->handle
,
11819 (archive_file_offset
11820 + offset_from_vma (filedata
, buckets_vma
, 4)),
11823 error (_("Unable to seek to start of dynamic information\n"));
11827 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11829 if (gnubuckets
== NULL
)
11832 for (i
= 0; i
< ngnubuckets
; i
++)
11833 if (gnubuckets
[i
] != 0)
11835 if (gnubuckets
[i
] < gnusymidx
)
11838 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11839 maxchain
= gnubuckets
[i
];
11842 if (maxchain
== 0xffffffff)
11845 maxchain
-= gnusymidx
;
11847 if (fseek (filedata
->handle
,
11848 (archive_file_offset
11849 + offset_from_vma (filedata
, buckets_vma
11850 + 4 * (ngnubuckets
+ maxchain
), 4)),
11853 error (_("Unable to seek to start of dynamic information\n"));
11859 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11861 error (_("Failed to determine last chain length\n"));
11865 if (maxchain
+ 1 == 0)
11870 while ((byte_get (nb
, 4) & 1) == 0);
11872 if (fseek (filedata
->handle
,
11873 (archive_file_offset
11874 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11877 error (_("Unable to seek to start of dynamic information\n"));
11881 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11882 ngnuchains
= maxchain
;
11884 if (gnuchains
== NULL
)
11887 if (dynamic_info_DT_MIPS_XHASH
)
11889 if (fseek (filedata
->handle
,
11890 (archive_file_offset
11891 + offset_from_vma (filedata
, (buckets_vma
11896 error (_("Unable to seek to start of dynamic information\n"));
11900 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11901 if (mipsxlat
== NULL
)
11909 if (do_using_dynamic
)
11915 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11917 && do_using_dynamic
11918 && dynamic_strings
!= NULL
11919 && dynamic_symbols
!= NULL
)
11923 if (dynamic_info
[DT_HASH
])
11928 printf (_("\nSymbol table for image:\n"));
11930 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11932 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11934 visited
= xcmalloc (nchains
, 1);
11935 memset (visited
, 0, nchains
);
11936 for (hn
= 0; hn
< nbuckets
; hn
++)
11938 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11940 print_dynamic_symbol (filedata
, si
, hn
);
11941 if (si
>= nchains
|| visited
[si
])
11943 error (_("histogram chain is corrupt\n"));
11952 if (dynamic_info_DT_GNU_HASH
)
11954 printf (_("\nSymbol table of `%s' for image:\n"),
11955 GNU_HASH_SECTION_NAME
);
11957 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11959 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11961 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11962 if (gnubuckets
[hn
] != 0)
11964 bfd_vma si
= gnubuckets
[hn
];
11965 bfd_vma off
= si
- gnusymidx
;
11969 if (dynamic_info_DT_MIPS_XHASH
)
11970 print_dynamic_symbol (filedata
, mipsxlat
[off
], hn
);
11972 print_dynamic_symbol (filedata
, si
, hn
);
11975 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11979 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11980 && filedata
->section_headers
!= NULL
)
11984 for (i
= 0, section
= filedata
->section_headers
;
11985 i
< filedata
->file_header
.e_shnum
;
11989 char * strtab
= NULL
;
11990 unsigned long int strtab_size
= 0;
11991 Elf_Internal_Sym
* symtab
;
11992 Elf_Internal_Sym
* psym
;
11993 unsigned long num_syms
;
11995 if ((section
->sh_type
!= SHT_SYMTAB
11996 && section
->sh_type
!= SHT_DYNSYM
)
11998 && section
->sh_type
== SHT_SYMTAB
))
12001 if (section
->sh_entsize
== 0)
12003 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12004 printable_section_name (filedata
, section
));
12008 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12009 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12010 "\nSymbol table '%s' contains %lu entries:\n",
12012 printable_section_name (filedata
, section
),
12016 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12018 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12020 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12021 if (symtab
== NULL
)
12024 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12026 strtab
= filedata
->string_table
;
12027 strtab_size
= filedata
->string_table_length
;
12029 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12031 Elf_Internal_Shdr
* string_sec
;
12033 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12035 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12036 1, string_sec
->sh_size
,
12037 _("string table"));
12038 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12041 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
12043 const char *version_string
;
12044 enum versioned_symbol_info sym_info
;
12045 unsigned short vna_other
;
12047 printf ("%6d: ", si
);
12048 print_vma (psym
->st_value
, LONG_HEX
);
12050 print_vma (psym
->st_size
, DEC_5
);
12051 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12052 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12053 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12054 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12057 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12059 printf (" %-7s", get_symbol_visibility (vis
));
12060 /* Check to see if any other bits in the st_other field are set.
12061 Note - displaying this information disrupts the layout of the
12062 table being generated, but for the moment this case is very rare. */
12063 if (psym
->st_other
^ vis
)
12064 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12066 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12067 print_symbol (25, psym
->st_name
< strtab_size
12068 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12071 = get_symbol_version_string (filedata
,
12072 section
->sh_type
== SHT_DYNSYM
,
12073 strtab
, strtab_size
, si
,
12074 psym
, &sym_info
, &vna_other
);
12075 if (version_string
)
12077 if (sym_info
== symbol_undefined
)
12078 printf ("@%s (%d)", version_string
, vna_other
);
12080 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12086 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12087 && si
>= section
->sh_info
12088 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12089 && filedata
->file_header
.e_machine
!= EM_MIPS
12090 /* Solaris binaries have been found to violate this requirement as
12091 well. Not sure if this is a bug or an ABI requirement. */
12092 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12093 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12094 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12098 if (strtab
!= filedata
->string_table
)
12104 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12106 if (do_histogram
&& buckets
!= NULL
)
12108 unsigned long * lengths
;
12109 unsigned long * counts
;
12112 unsigned long maxlength
= 0;
12113 unsigned long nzero_counts
= 0;
12114 unsigned long nsyms
= 0;
12117 printf (ngettext ("\nHistogram for bucket list length "
12118 "(total of %lu bucket):\n",
12119 "\nHistogram for bucket list length "
12120 "(total of %lu buckets):\n",
12121 (unsigned long) nbuckets
),
12122 (unsigned long) nbuckets
);
12124 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12125 if (lengths
== NULL
)
12127 error (_("Out of memory allocating space for histogram buckets\n"));
12130 visited
= xcmalloc (nchains
, 1);
12131 memset (visited
, 0, nchains
);
12133 printf (_(" Length Number %% of total Coverage\n"));
12134 for (hn
= 0; hn
< nbuckets
; ++hn
)
12136 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12139 if (maxlength
< ++lengths
[hn
])
12141 if (si
>= nchains
|| visited
[si
])
12143 error (_("histogram chain is corrupt\n"));
12151 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12152 if (counts
== NULL
)
12155 error (_("Out of memory allocating space for histogram counts\n"));
12159 for (hn
= 0; hn
< nbuckets
; ++hn
)
12160 ++counts
[lengths
[hn
]];
12165 printf (" 0 %-10lu (%5.1f%%)\n",
12166 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12167 for (i
= 1; i
<= maxlength
; ++i
)
12169 nzero_counts
+= counts
[i
] * i
;
12170 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12171 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12172 (nzero_counts
* 100.0) / nsyms
);
12185 if (do_histogram
&& gnubuckets
!= NULL
)
12187 unsigned long * lengths
;
12188 unsigned long * counts
;
12190 unsigned long maxlength
= 0;
12191 unsigned long nzero_counts
= 0;
12192 unsigned long nsyms
= 0;
12194 printf (ngettext ("\nHistogram for `%s' bucket list length "
12195 "(total of %lu bucket):\n",
12196 "\nHistogram for `%s' bucket list length "
12197 "(total of %lu buckets):\n",
12198 (unsigned long) ngnubuckets
),
12199 GNU_HASH_SECTION_NAME
,
12200 (unsigned long) ngnubuckets
);
12202 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12203 if (lengths
== NULL
)
12205 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12209 printf (_(" Length Number %% of total Coverage\n"));
12211 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12212 if (gnubuckets
[hn
] != 0)
12214 bfd_vma off
, length
= 1;
12216 for (off
= gnubuckets
[hn
] - gnusymidx
;
12217 /* PR 17531 file: 010-77222-0.004. */
12218 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12221 lengths
[hn
] = length
;
12222 if (length
> maxlength
)
12223 maxlength
= length
;
12227 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12228 if (counts
== NULL
)
12231 error (_("Out of memory allocating space for gnu histogram counts\n"));
12235 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12236 ++counts
[lengths
[hn
]];
12238 if (ngnubuckets
> 0)
12241 printf (" 0 %-10lu (%5.1f%%)\n",
12242 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12243 for (j
= 1; j
<= maxlength
; ++j
)
12245 nzero_counts
+= counts
[j
] * j
;
12246 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12247 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12248 (nzero_counts
* 100.0) / nsyms
);
12270 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12274 if (dynamic_syminfo
== NULL
12276 /* No syminfo, this is ok. */
12279 /* There better should be a dynamic symbol section. */
12280 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12284 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12285 "contains %d entry:\n",
12286 "\nDynamic info segment at offset 0x%lx "
12287 "contains %d entries:\n",
12288 dynamic_syminfo_nent
),
12289 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12291 printf (_(" Num: Name BoundTo Flags\n"));
12292 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12294 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12296 printf ("%4d: ", i
);
12297 if (i
>= num_dynamic_syms
)
12298 printf (_("<corrupt index>"));
12299 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12300 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12302 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12305 switch (dynamic_syminfo
[i
].si_boundto
)
12307 case SYMINFO_BT_SELF
:
12308 fputs ("SELF ", stdout
);
12310 case SYMINFO_BT_PARENT
:
12311 fputs ("PARENT ", stdout
);
12314 if (dynamic_syminfo
[i
].si_boundto
> 0
12315 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12316 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12318 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12322 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12326 if (flags
& SYMINFO_FLG_DIRECT
)
12327 printf (" DIRECT");
12328 if (flags
& SYMINFO_FLG_PASSTHRU
)
12329 printf (" PASSTHRU");
12330 if (flags
& SYMINFO_FLG_COPY
)
12332 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12333 printf (" LAZYLOAD");
12341 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12342 is contained by the region START .. END. The types of ADDR, START
12343 and END should all be the same. Note both ADDR + NELEM and END
12344 point to just beyond the end of the regions that are being tested. */
12345 #define IN_RANGE(START,END,ADDR,NELEM) \
12346 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12348 /* Check to see if the given reloc needs to be handled in a target specific
12349 manner. If so then process the reloc and return TRUE otherwise return
12352 If called with reloc == NULL, then this is a signal that reloc processing
12353 for the current section has finished, and any saved state should be
12357 target_specific_reloc_handling (Filedata
* filedata
,
12358 Elf_Internal_Rela
* reloc
,
12359 unsigned char * start
,
12360 unsigned char * end
,
12361 Elf_Internal_Sym
* symtab
,
12362 unsigned long num_syms
)
12364 unsigned int reloc_type
= 0;
12365 unsigned long sym_index
= 0;
12369 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12370 sym_index
= get_reloc_symindex (reloc
->r_info
);
12373 switch (filedata
->file_header
.e_machine
)
12376 case EM_MSP430_OLD
:
12378 static Elf_Internal_Sym
* saved_sym
= NULL
;
12386 switch (reloc_type
)
12388 case 10: /* R_MSP430_SYM_DIFF */
12389 if (uses_msp430x_relocs (filedata
))
12391 /* Fall through. */
12392 case 21: /* R_MSP430X_SYM_DIFF */
12394 if (sym_index
>= num_syms
)
12395 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12398 saved_sym
= symtab
+ sym_index
;
12401 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12402 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12403 goto handle_sym_diff
;
12405 case 5: /* R_MSP430_16_BYTE */
12406 case 9: /* R_MSP430_8 */
12407 if (uses_msp430x_relocs (filedata
))
12409 goto handle_sym_diff
;
12411 case 2: /* R_MSP430_ABS16 */
12412 case 15: /* R_MSP430X_ABS16 */
12413 if (! uses_msp430x_relocs (filedata
))
12415 goto handle_sym_diff
;
12418 if (saved_sym
!= NULL
)
12420 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12423 if (sym_index
>= num_syms
)
12424 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12428 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12429 - saved_sym
->st_value
);
12431 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12432 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12435 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12436 (long) reloc
->r_offset
);
12445 if (saved_sym
!= NULL
)
12446 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12453 case EM_CYGNUS_MN10300
:
12455 static Elf_Internal_Sym
* saved_sym
= NULL
;
12463 switch (reloc_type
)
12465 case 34: /* R_MN10300_ALIGN */
12467 case 33: /* R_MN10300_SYM_DIFF */
12468 if (sym_index
>= num_syms
)
12469 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12472 saved_sym
= symtab
+ sym_index
;
12475 case 1: /* R_MN10300_32 */
12476 case 2: /* R_MN10300_16 */
12477 if (saved_sym
!= NULL
)
12479 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12482 if (sym_index
>= num_syms
)
12483 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12487 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12488 - saved_sym
->st_value
);
12490 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12491 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12493 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12494 (long) reloc
->r_offset
);
12502 if (saved_sym
!= NULL
)
12503 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12511 static bfd_vma saved_sym1
= 0;
12512 static bfd_vma saved_sym2
= 0;
12513 static bfd_vma value
;
12517 saved_sym1
= saved_sym2
= 0;
12521 switch (reloc_type
)
12523 case 0x80: /* R_RL78_SYM. */
12524 saved_sym1
= saved_sym2
;
12525 if (sym_index
>= num_syms
)
12526 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12530 saved_sym2
= symtab
[sym_index
].st_value
;
12531 saved_sym2
+= reloc
->r_addend
;
12535 case 0x83: /* R_RL78_OPsub. */
12536 value
= saved_sym1
- saved_sym2
;
12537 saved_sym2
= saved_sym1
= 0;
12541 case 0x41: /* R_RL78_ABS32. */
12542 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12543 byte_put (start
+ reloc
->r_offset
, value
, 4);
12545 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12546 (long) reloc
->r_offset
);
12550 case 0x43: /* R_RL78_ABS16. */
12551 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12552 byte_put (start
+ reloc
->r_offset
, value
, 2);
12554 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12555 (long) reloc
->r_offset
);
12569 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12570 DWARF debug sections. This is a target specific test. Note - we do not
12571 go through the whole including-target-headers-multiple-times route, (as
12572 we have already done with <elf/h8.h>) because this would become very
12573 messy and even then this function would have to contain target specific
12574 information (the names of the relocs instead of their numeric values).
12575 FIXME: This is not the correct way to solve this problem. The proper way
12576 is to have target specific reloc sizing and typing functions created by
12577 the reloc-macros.h header, in the same way that it already creates the
12578 reloc naming functions. */
12581 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12583 /* Please keep this table alpha-sorted for ease of visual lookup. */
12584 switch (filedata
->file_header
.e_machine
)
12588 return reloc_type
== 1; /* R_386_32. */
12590 return reloc_type
== 1; /* R_68K_32. */
12592 return reloc_type
== 1; /* R_860_32. */
12594 return reloc_type
== 2; /* R_960_32. */
12596 return (reloc_type
== 258
12597 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12599 return reloc_type
== 11; /* R_BPF_DATA_32 */
12600 case EM_ADAPTEVA_EPIPHANY
:
12601 return reloc_type
== 3;
12603 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12605 return reloc_type
== 1; /* R_ARC_32. */
12606 case EM_ARC_COMPACT
:
12607 case EM_ARC_COMPACT2
:
12608 return reloc_type
== 4; /* R_ARC_32. */
12610 return reloc_type
== 2; /* R_ARM_ABS32 */
12613 return reloc_type
== 1;
12615 return reloc_type
== 0x12; /* R_byte4_data. */
12617 return reloc_type
== 3; /* R_CRIS_32. */
12619 return reloc_type
== 3; /* R_CR16_NUM32. */
12621 return reloc_type
== 15; /* R_CRX_NUM32. */
12623 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12624 case EM_CYGNUS_FRV
:
12625 return reloc_type
== 1;
12626 case EM_CYGNUS_D10V
:
12628 return reloc_type
== 6; /* R_D10V_32. */
12629 case EM_CYGNUS_D30V
:
12631 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12633 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12634 case EM_CYGNUS_FR30
:
12636 return reloc_type
== 3; /* R_FR30_32. */
12638 return reloc_type
== 1; /* R_FT32_32. */
12642 return reloc_type
== 1; /* R_H8_DIR32. */
12644 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12645 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12646 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12647 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12650 return reloc_type
== 2; /* R_IP2K_32. */
12652 return reloc_type
== 2; /* R_IQ2000_32. */
12653 case EM_LATTICEMICO32
:
12654 return reloc_type
== 3; /* R_LM32_32. */
12657 return reloc_type
== 3; /* R_M32C_32. */
12659 return reloc_type
== 34; /* R_M32R_32_RELA. */
12662 return reloc_type
== 6; /* R_M68HC11_32. */
12664 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12665 reloc_type
== 6; /* R_S12Z_CW32. */
12667 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12668 case EM_CYGNUS_MEP
:
12669 return reloc_type
== 4; /* R_MEP_32. */
12671 return reloc_type
== 2; /* R_METAG_ADDR32. */
12672 case EM_MICROBLAZE
:
12673 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12675 return reloc_type
== 2; /* R_MIPS_32. */
12677 return reloc_type
== 4; /* R_MMIX_32. */
12678 case EM_CYGNUS_MN10200
:
12680 return reloc_type
== 1; /* R_MN10200_32. */
12681 case EM_CYGNUS_MN10300
:
12683 return reloc_type
== 1; /* R_MN10300_32. */
12685 return reloc_type
== 1; /* R_MOXIE_32. */
12686 case EM_MSP430_OLD
:
12688 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12690 return reloc_type
== 2; /* R_MT_32. */
12692 return reloc_type
== 20; /* R_NDS32_RELA. */
12693 case EM_ALTERA_NIOS2
:
12694 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12696 return reloc_type
== 1; /* R_NIOS_32. */
12698 return reloc_type
== 1; /* R_OR1K_32. */
12700 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12701 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12702 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12705 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12707 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12709 return reloc_type
== 1; /* R_PPC_ADDR32. */
12711 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12713 return reloc_type
== 1; /* R_RISCV_32. */
12715 return reloc_type
== 1; /* R_RL78_DIR32. */
12717 return reloc_type
== 1; /* R_RX_DIR32. */
12719 return reloc_type
== 1; /* R_I370_ADDR31. */
12722 return reloc_type
== 4; /* R_S390_32. */
12724 return reloc_type
== 8; /* R_SCORE_ABS32. */
12726 return reloc_type
== 1; /* R_SH_DIR32. */
12727 case EM_SPARC32PLUS
:
12730 return reloc_type
== 3 /* R_SPARC_32. */
12731 || reloc_type
== 23; /* R_SPARC_UA32. */
12733 return reloc_type
== 6; /* R_SPU_ADDR32 */
12735 return reloc_type
== 1; /* R_C6000_ABS32. */
12737 return reloc_type
== 2; /* R_TILEGX_32. */
12739 return reloc_type
== 1; /* R_TILEPRO_32. */
12740 case EM_CYGNUS_V850
:
12742 return reloc_type
== 6; /* R_V850_ABS32. */
12744 return reloc_type
== 0x33; /* R_V810_WORD. */
12746 return reloc_type
== 1; /* R_VAX_32. */
12748 return reloc_type
== 3; /* R_VISIUM_32. */
12749 case EM_WEBASSEMBLY
:
12750 return reloc_type
== 1; /* R_WASM32_32. */
12754 return reloc_type
== 10; /* R_X86_64_32. */
12757 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12759 return reloc_type
== 4; /* R_XGATE_32. */
12761 return reloc_type
== 1; /* R_XSTROMY16_32. */
12762 case EM_XTENSA_OLD
:
12764 return reloc_type
== 1; /* R_XTENSA_32. */
12766 return reloc_type
== 6; /* R_Z80_32. */
12769 static unsigned int prev_warn
= 0;
12771 /* Avoid repeating the same warning multiple times. */
12772 if (prev_warn
!= filedata
->file_header
.e_machine
)
12773 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12774 filedata
->file_header
.e_machine
);
12775 prev_warn
= filedata
->file_header
.e_machine
;
12781 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12782 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12785 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12787 switch (filedata
->file_header
.e_machine
)
12788 /* Please keep this table alpha-sorted for ease of visual lookup. */
12792 return reloc_type
== 2; /* R_386_PC32. */
12794 return reloc_type
== 4; /* R_68K_PC32. */
12796 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12797 case EM_ADAPTEVA_EPIPHANY
:
12798 return reloc_type
== 6;
12800 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12801 case EM_ARC_COMPACT
:
12802 case EM_ARC_COMPACT2
:
12803 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12805 return reloc_type
== 3; /* R_ARM_REL32 */
12808 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12809 case EM_MICROBLAZE
:
12810 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12812 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12814 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12816 return reloc_type
== 26; /* R_PPC_REL32. */
12818 return reloc_type
== 26; /* R_PPC64_REL32. */
12820 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12823 return reloc_type
== 5; /* R_390_PC32. */
12825 return reloc_type
== 2; /* R_SH_REL32. */
12826 case EM_SPARC32PLUS
:
12829 return reloc_type
== 6; /* R_SPARC_DISP32. */
12831 return reloc_type
== 13; /* R_SPU_REL32. */
12833 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12835 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12837 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12841 return reloc_type
== 2; /* R_X86_64_PC32. */
12843 return reloc_type
== 4; /* R_VAX_PCREL32. */
12844 case EM_XTENSA_OLD
:
12846 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12848 /* Do not abort or issue an error message here. Not all targets use
12849 pc-relative 32-bit relocs in their DWARF debug information and we
12850 have already tested for target coverage in is_32bit_abs_reloc. A
12851 more helpful warning message will be generated by apply_relocations
12852 anyway, so just return. */
12857 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12858 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12861 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12863 switch (filedata
->file_header
.e_machine
)
12866 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12868 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12870 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12871 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12873 return reloc_type
== 80; /* R_PARISC_DIR64. */
12875 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12877 return reloc_type
== 2; /* R_RISCV_64. */
12878 case EM_SPARC32PLUS
:
12881 return reloc_type
== 32 /* R_SPARC_64. */
12882 || reloc_type
== 54; /* R_SPARC_UA64. */
12886 return reloc_type
== 1; /* R_X86_64_64. */
12889 return reloc_type
== 22; /* R_S390_64. */
12891 return reloc_type
== 1; /* R_TILEGX_64. */
12893 return reloc_type
== 18; /* R_MIPS_64. */
12899 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12900 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12903 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12905 switch (filedata
->file_header
.e_machine
)
12908 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12910 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12912 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12913 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12915 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12917 return reloc_type
== 44; /* R_PPC64_REL64. */
12918 case EM_SPARC32PLUS
:
12921 return reloc_type
== 46; /* R_SPARC_DISP64. */
12925 return reloc_type
== 24; /* R_X86_64_PC64. */
12928 return reloc_type
== 23; /* R_S390_PC64. */
12930 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12936 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12937 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12940 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12942 switch (filedata
->file_header
.e_machine
)
12944 case EM_CYGNUS_MN10200
:
12946 return reloc_type
== 4; /* R_MN10200_24. */
12948 return reloc_type
== 5; /* R_FT32_20. */
12950 return reloc_type
== 5; /* R_Z80_24. */
12956 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12957 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12960 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12962 /* Please keep this table alpha-sorted for ease of visual lookup. */
12963 switch (filedata
->file_header
.e_machine
)
12966 case EM_ARC_COMPACT
:
12967 case EM_ARC_COMPACT2
:
12968 return reloc_type
== 2; /* R_ARC_16. */
12969 case EM_ADAPTEVA_EPIPHANY
:
12970 return reloc_type
== 5;
12973 return reloc_type
== 4; /* R_AVR_16. */
12974 case EM_CYGNUS_D10V
:
12976 return reloc_type
== 3; /* R_D10V_16. */
12978 return reloc_type
== 2; /* R_FT32_16. */
12982 return reloc_type
== R_H8_DIR16
;
12985 return reloc_type
== 1; /* R_IP2K_16. */
12988 return reloc_type
== 1; /* R_M32C_16 */
12989 case EM_CYGNUS_MN10200
:
12991 return reloc_type
== 2; /* R_MN10200_16. */
12992 case EM_CYGNUS_MN10300
:
12994 return reloc_type
== 2; /* R_MN10300_16. */
12996 if (uses_msp430x_relocs (filedata
))
12997 return reloc_type
== 2; /* R_MSP430_ABS16. */
12998 /* Fall through. */
12999 case EM_MSP430_OLD
:
13000 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13002 return reloc_type
== 19; /* R_NDS32_RELA. */
13003 case EM_ALTERA_NIOS2
:
13004 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13006 return reloc_type
== 9; /* R_NIOS_16. */
13008 return reloc_type
== 2; /* R_OR1K_16. */
13010 return reloc_type
== 55; /* R_RISCV_SET16. */
13012 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13014 return reloc_type
== 2; /* R_C6000_ABS16. */
13016 return reloc_type
== 2; /* R_VISIUM_16. */
13019 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13021 return reloc_type
== 3; /* R_XGATE_16. */
13023 return reloc_type
== 4; /* R_Z80_16. */
13029 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13030 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13033 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13035 switch (filedata
->file_header
.e_machine
)
13038 return reloc_type
== 54; /* R_RISCV_SET8. */
13040 return reloc_type
== 1; /* R_Z80_8. */
13046 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13047 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13050 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13052 switch (filedata
->file_header
.e_machine
)
13055 return reloc_type
== 53; /* R_RISCV_SET6. */
13061 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13062 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13065 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13067 /* Please keep this table alpha-sorted for ease of visual lookup. */
13068 switch (filedata
->file_header
.e_machine
)
13071 return reloc_type
== 35; /* R_RISCV_ADD32. */
13077 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13078 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13081 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13083 /* Please keep this table alpha-sorted for ease of visual lookup. */
13084 switch (filedata
->file_header
.e_machine
)
13087 return reloc_type
== 39; /* R_RISCV_SUB32. */
13093 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13094 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13097 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13099 /* Please keep this table alpha-sorted for ease of visual lookup. */
13100 switch (filedata
->file_header
.e_machine
)
13103 return reloc_type
== 36; /* R_RISCV_ADD64. */
13109 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13110 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13113 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13115 /* Please keep this table alpha-sorted for ease of visual lookup. */
13116 switch (filedata
->file_header
.e_machine
)
13119 return reloc_type
== 40; /* R_RISCV_SUB64. */
13125 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13126 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13129 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13131 /* Please keep this table alpha-sorted for ease of visual lookup. */
13132 switch (filedata
->file_header
.e_machine
)
13135 return reloc_type
== 34; /* R_RISCV_ADD16. */
13141 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13142 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13145 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13147 /* Please keep this table alpha-sorted for ease of visual lookup. */
13148 switch (filedata
->file_header
.e_machine
)
13151 return reloc_type
== 38; /* R_RISCV_SUB16. */
13157 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13158 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13161 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13163 /* Please keep this table alpha-sorted for ease of visual lookup. */
13164 switch (filedata
->file_header
.e_machine
)
13167 return reloc_type
== 33; /* R_RISCV_ADD8. */
13173 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13174 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13177 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13179 /* Please keep this table alpha-sorted for ease of visual lookup. */
13180 switch (filedata
->file_header
.e_machine
)
13183 return reloc_type
== 37; /* R_RISCV_SUB8. */
13189 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13190 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13193 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13195 switch (filedata
->file_header
.e_machine
)
13198 return reloc_type
== 52; /* R_RISCV_SUB6. */
13204 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13205 relocation entries (possibly formerly used for SHT_GROUP sections). */
13208 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13210 switch (filedata
->file_header
.e_machine
)
13212 case EM_386
: /* R_386_NONE. */
13213 case EM_68K
: /* R_68K_NONE. */
13214 case EM_ADAPTEVA_EPIPHANY
:
13215 case EM_ALPHA
: /* R_ALPHA_NONE. */
13216 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13217 case EM_ARC
: /* R_ARC_NONE. */
13218 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13219 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13220 case EM_ARM
: /* R_ARM_NONE. */
13221 case EM_C166
: /* R_XC16X_NONE. */
13222 case EM_CRIS
: /* R_CRIS_NONE. */
13223 case EM_FT32
: /* R_FT32_NONE. */
13224 case EM_IA_64
: /* R_IA64_NONE. */
13225 case EM_K1OM
: /* R_X86_64_NONE. */
13226 case EM_L1OM
: /* R_X86_64_NONE. */
13227 case EM_M32R
: /* R_M32R_NONE. */
13228 case EM_MIPS
: /* R_MIPS_NONE. */
13229 case EM_MN10300
: /* R_MN10300_NONE. */
13230 case EM_MOXIE
: /* R_MOXIE_NONE. */
13231 case EM_NIOS32
: /* R_NIOS_NONE. */
13232 case EM_OR1K
: /* R_OR1K_NONE. */
13233 case EM_PARISC
: /* R_PARISC_NONE. */
13234 case EM_PPC64
: /* R_PPC64_NONE. */
13235 case EM_PPC
: /* R_PPC_NONE. */
13236 case EM_RISCV
: /* R_RISCV_NONE. */
13237 case EM_S390
: /* R_390_NONE. */
13239 case EM_SH
: /* R_SH_NONE. */
13240 case EM_SPARC32PLUS
:
13241 case EM_SPARC
: /* R_SPARC_NONE. */
13243 case EM_TILEGX
: /* R_TILEGX_NONE. */
13244 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13245 case EM_TI_C6000
:/* R_C6000_NONE. */
13246 case EM_X86_64
: /* R_X86_64_NONE. */
13248 case EM_Z80
: /* R_Z80_NONE. */
13249 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13250 return reloc_type
== 0;
13253 return reloc_type
== 0 || reloc_type
== 256;
13256 return (reloc_type
== 0 /* R_AVR_NONE. */
13257 || reloc_type
== 30 /* R_AVR_DIFF8. */
13258 || reloc_type
== 31 /* R_AVR_DIFF16. */
13259 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13261 return reloc_type
== 3; /* R_METAG_NONE. */
13263 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13264 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13265 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13266 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13267 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13269 return (reloc_type
== 0 /* R_PRU_NONE. */
13270 || reloc_type
== 65 /* R_PRU_DIFF8. */
13271 || reloc_type
== 66 /* R_PRU_DIFF16. */
13272 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13273 case EM_XTENSA_OLD
:
13275 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13276 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13277 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13278 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13283 /* Returns TRUE if there is a relocation against
13284 section NAME at OFFSET bytes. */
13287 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13289 Elf_Internal_Rela
* relocs
;
13290 Elf_Internal_Rela
* rp
;
13292 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13295 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13297 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13298 if (rp
->r_offset
== offset
)
13304 /* Apply relocations to a section.
13305 Returns TRUE upon success, FALSE otherwise.
13306 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13307 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13308 will be set to the number of relocs loaded.
13310 Note: So far support has been added only for those relocations
13311 which can be found in debug sections. FIXME: Add support for
13312 more relocations ? */
13315 apply_relocations (Filedata
* filedata
,
13316 const Elf_Internal_Shdr
* section
,
13317 unsigned char * start
,
13318 bfd_size_type size
,
13319 void ** relocs_return
,
13320 unsigned long * num_relocs_return
)
13322 Elf_Internal_Shdr
* relsec
;
13323 unsigned char * end
= start
+ size
;
13325 if (relocs_return
!= NULL
)
13327 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13328 * num_relocs_return
= 0;
13331 if (filedata
->file_header
.e_type
!= ET_REL
)
13332 /* No relocs to apply. */
13335 /* Find the reloc section associated with the section. */
13336 for (relsec
= filedata
->section_headers
;
13337 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13340 bfd_boolean is_rela
;
13341 unsigned long num_relocs
;
13342 Elf_Internal_Rela
* relocs
;
13343 Elf_Internal_Rela
* rp
;
13344 Elf_Internal_Shdr
* symsec
;
13345 Elf_Internal_Sym
* symtab
;
13346 unsigned long num_syms
;
13347 Elf_Internal_Sym
* sym
;
13349 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13350 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13351 || filedata
->section_headers
+ relsec
->sh_info
!= section
13352 || relsec
->sh_size
== 0
13353 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13356 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13357 if (symsec
->sh_type
!= SHT_SYMTAB
13358 && symsec
->sh_type
!= SHT_DYNSYM
)
13361 is_rela
= relsec
->sh_type
== SHT_RELA
;
13365 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13366 relsec
->sh_size
, & relocs
, & num_relocs
))
13371 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13372 relsec
->sh_size
, & relocs
, & num_relocs
))
13376 /* SH uses RELA but uses in place value instead of the addend field. */
13377 if (filedata
->file_header
.e_machine
== EM_SH
)
13380 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13382 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13385 unsigned int reloc_type
;
13386 unsigned int reloc_size
;
13387 bfd_boolean reloc_inplace
= FALSE
;
13388 bfd_boolean reloc_subtract
= FALSE
;
13389 unsigned char * rloc
;
13390 unsigned long sym_index
;
13392 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13394 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13396 else if (is_none_reloc (filedata
, reloc_type
))
13398 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13399 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13401 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13402 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13404 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13406 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13408 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13409 || is_6bit_abs_reloc (filedata
, reloc_type
))
13411 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13413 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13416 reloc_inplace
= TRUE
;
13418 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13420 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13423 reloc_inplace
= TRUE
;
13425 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13427 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13430 reloc_inplace
= TRUE
;
13432 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13434 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13437 reloc_inplace
= TRUE
;
13439 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13443 reloc_inplace
= TRUE
;
13447 static unsigned int prev_reloc
= 0;
13449 if (reloc_type
!= prev_reloc
)
13450 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13451 reloc_type
, printable_section_name (filedata
, section
));
13452 prev_reloc
= reloc_type
;
13456 rloc
= start
+ rp
->r_offset
;
13457 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13459 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13460 (unsigned long) rp
->r_offset
,
13461 printable_section_name (filedata
, section
));
13465 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13466 if (sym_index
>= num_syms
)
13468 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13469 sym_index
, printable_section_name (filedata
, section
));
13472 sym
= symtab
+ sym_index
;
13474 /* If the reloc has a symbol associated with it,
13475 make sure that it is of an appropriate type.
13477 Relocations against symbols without type can happen.
13478 Gcc -feliminate-dwarf2-dups may generate symbols
13479 without type for debug info.
13481 Icc generates relocations against function symbols
13482 instead of local labels.
13484 Relocations against object symbols can happen, eg when
13485 referencing a global array. For an example of this see
13486 the _clz.o binary in libgcc.a. */
13488 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13489 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13491 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13492 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13493 printable_section_name (filedata
, relsec
),
13494 (long int)(rp
- relocs
));
13500 addend
+= rp
->r_addend
;
13501 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13502 partial_inplace. */
13504 || (filedata
->file_header
.e_machine
== EM_XTENSA
13505 && reloc_type
== 1)
13506 || ((filedata
->file_header
.e_machine
== EM_PJ
13507 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13508 && reloc_type
== 1)
13509 || ((filedata
->file_header
.e_machine
== EM_D30V
13510 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13511 && reloc_type
== 12)
13514 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13515 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13517 addend
+= byte_get (rloc
, reloc_size
);
13520 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13521 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13523 /* On HPPA, all pc-relative relocations are biased by 8. */
13524 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13526 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13529 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13530 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13532 if (reloc_subtract
)
13533 addend
-= sym
->st_value
;
13535 addend
+= sym
->st_value
;
13536 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13537 byte_put (rloc
, addend
, reloc_size
);
13539 else if (reloc_subtract
)
13540 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13542 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13546 /* Let the target specific reloc processing code know that
13547 we have finished with these relocs. */
13548 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13552 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13553 * num_relocs_return
= num_relocs
;
13564 #ifdef SUPPORT_DISASSEMBLY
13566 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13568 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13570 /* FIXME: XXX -- to be done --- XXX */
13576 /* Reads in the contents of SECTION from FILE, returning a pointer
13577 to a malloc'ed buffer or NULL if something went wrong. */
13580 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13582 bfd_size_type num_bytes
= section
->sh_size
;
13584 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13586 printf (_("Section '%s' has no data to dump.\n"),
13587 printable_section_name (filedata
, section
));
13591 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13592 _("section contents"));
13595 /* Uncompresses a section that was compressed using zlib, in place. */
13598 uncompress_section_contents (unsigned char ** buffer
,
13599 dwarf_size_type uncompressed_size
,
13600 dwarf_size_type
* size
)
13602 dwarf_size_type compressed_size
= *size
;
13603 unsigned char * compressed_buffer
= *buffer
;
13604 unsigned char * uncompressed_buffer
;
13608 /* It is possible the section consists of several compressed
13609 buffers concatenated together, so we uncompress in a loop. */
13610 /* PR 18313: The state field in the z_stream structure is supposed
13611 to be invisible to the user (ie us), but some compilers will
13612 still complain about it being used without initialisation. So
13613 we first zero the entire z_stream structure and then set the fields
13615 memset (& strm
, 0, sizeof strm
);
13616 strm
.avail_in
= compressed_size
;
13617 strm
.next_in
= (Bytef
*) compressed_buffer
;
13618 strm
.avail_out
= uncompressed_size
;
13619 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13621 rc
= inflateInit (& strm
);
13622 while (strm
.avail_in
> 0)
13626 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13627 + (uncompressed_size
- strm
.avail_out
));
13628 rc
= inflate (&strm
, Z_FINISH
);
13629 if (rc
!= Z_STREAM_END
)
13631 rc
= inflateReset (& strm
);
13633 rc
= inflateEnd (& strm
);
13635 || strm
.avail_out
!= 0)
13638 *buffer
= uncompressed_buffer
;
13639 *size
= uncompressed_size
;
13643 free (uncompressed_buffer
);
13644 /* Indicate decompression failure. */
13650 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13652 Elf_Internal_Shdr
* relsec
;
13653 bfd_size_type num_bytes
;
13654 unsigned char * data
;
13655 unsigned char * end
;
13656 unsigned char * real_start
;
13657 unsigned char * start
;
13658 bfd_boolean some_strings_shown
;
13660 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13662 /* PR 21820: Do not fail if the section was empty. */
13663 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13665 num_bytes
= section
->sh_size
;
13667 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13669 if (decompress_dumps
)
13671 dwarf_size_type new_size
= num_bytes
;
13672 dwarf_size_type uncompressed_size
= 0;
13674 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13676 Elf_Internal_Chdr chdr
;
13677 unsigned int compression_header_size
13678 = get_compression_header (& chdr
, (unsigned char *) start
,
13681 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13683 warn (_("section '%s' has unsupported compress type: %d\n"),
13684 printable_section_name (filedata
, section
), chdr
.ch_type
);
13687 uncompressed_size
= chdr
.ch_size
;
13688 start
+= compression_header_size
;
13689 new_size
-= compression_header_size
;
13691 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13693 /* Read the zlib header. In this case, it should be "ZLIB"
13694 followed by the uncompressed section size, 8 bytes in
13695 big-endian order. */
13696 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13697 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13698 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13699 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13700 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13701 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13702 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13703 uncompressed_size
+= start
[11];
13708 if (uncompressed_size
)
13710 if (uncompress_section_contents (& start
,
13711 uncompressed_size
, & new_size
))
13712 num_bytes
= new_size
;
13715 error (_("Unable to decompress section %s\n"),
13716 printable_section_name (filedata
, section
));
13721 start
= real_start
;
13724 /* If the section being dumped has relocations against it the user might
13725 be expecting these relocations to have been applied. Check for this
13726 case and issue a warning message in order to avoid confusion.
13727 FIXME: Maybe we ought to have an option that dumps a section with
13728 relocs applied ? */
13729 for (relsec
= filedata
->section_headers
;
13730 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13733 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13734 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13735 || filedata
->section_headers
+ relsec
->sh_info
!= section
13736 || relsec
->sh_size
== 0
13737 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13740 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13745 end
= start
+ num_bytes
;
13746 some_strings_shown
= FALSE
;
13748 #ifdef HAVE_MBSTATE_T
13750 /* Initialise the multibyte conversion state. */
13751 memset (& state
, 0, sizeof (state
));
13754 bfd_boolean continuing
= FALSE
;
13758 while (!ISPRINT (* data
))
13759 if (++ data
>= end
)
13764 size_t maxlen
= end
- data
;
13769 continuing
= FALSE
;
13774 /* PR 11128: Use two separate invocations in order to work
13775 around bugs in the Solaris 8 implementation of printf. */
13776 printf (" [%6tx] ", data
- start
);
13778 printf (" [%6Ix] ", (size_t) (data
- start
));
13793 /* PR 25543: Treat new-lines as string-ending characters. */
13802 /* Do not print control characters directly as they can affect terminal
13803 settings. Such characters usually appear in the names generated
13804 by the assembler for local labels. */
13807 printf ("^%c", c
+ 0x40);
13809 else if (ISPRINT (c
))
13816 #ifdef HAVE_MBSTATE_T
13819 /* Let printf do the hard work of displaying multibyte characters. */
13820 printf ("%.1s", data
- 1);
13821 #ifdef HAVE_MBSTATE_T
13822 /* Try to find out how many bytes made up the character that was
13823 just printed. Advance the symbol pointer past the bytes that
13825 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13829 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13839 printf (_("<corrupt>\n"));
13842 some_strings_shown
= TRUE
;
13846 if (! some_strings_shown
)
13847 printf (_(" No strings found in this section."));
13860 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13861 Filedata
* filedata
,
13862 bfd_boolean relocate
)
13864 Elf_Internal_Shdr
* relsec
;
13865 bfd_size_type bytes
;
13866 bfd_size_type section_size
;
13868 unsigned char * data
;
13869 unsigned char * real_start
;
13870 unsigned char * start
;
13872 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13874 /* PR 21820: Do not fail if the section was empty. */
13875 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13877 section_size
= section
->sh_size
;
13879 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13881 if (decompress_dumps
)
13883 dwarf_size_type new_size
= section_size
;
13884 dwarf_size_type uncompressed_size
= 0;
13886 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13888 Elf_Internal_Chdr chdr
;
13889 unsigned int compression_header_size
13890 = get_compression_header (& chdr
, start
, section_size
);
13892 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13894 warn (_("section '%s' has unsupported compress type: %d\n"),
13895 printable_section_name (filedata
, section
), chdr
.ch_type
);
13898 uncompressed_size
= chdr
.ch_size
;
13899 start
+= compression_header_size
;
13900 new_size
-= compression_header_size
;
13902 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13904 /* Read the zlib header. In this case, it should be "ZLIB"
13905 followed by the uncompressed section size, 8 bytes in
13906 big-endian order. */
13907 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13908 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13909 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13910 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13911 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13912 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13913 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13914 uncompressed_size
+= start
[11];
13919 if (uncompressed_size
)
13921 if (uncompress_section_contents (& start
, uncompressed_size
,
13924 section_size
= new_size
;
13928 error (_("Unable to decompress section %s\n"),
13929 printable_section_name (filedata
, section
));
13930 /* FIXME: Print the section anyway ? */
13935 start
= real_start
;
13940 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13945 /* If the section being dumped has relocations against it the user might
13946 be expecting these relocations to have been applied. Check for this
13947 case and issue a warning message in order to avoid confusion.
13948 FIXME: Maybe we ought to have an option that dumps a section with
13949 relocs applied ? */
13950 for (relsec
= filedata
->section_headers
;
13951 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13954 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13955 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13956 || filedata
->section_headers
+ relsec
->sh_info
!= section
13957 || relsec
->sh_size
== 0
13958 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13961 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13966 addr
= section
->sh_addr
;
13967 bytes
= section_size
;
13976 lbytes
= (bytes
> 16 ? 16 : bytes
);
13978 printf (" 0x%8.8lx ", (unsigned long) addr
);
13980 for (j
= 0; j
< 16; j
++)
13983 printf ("%2.2x", data
[j
]);
13991 for (j
= 0; j
< lbytes
; j
++)
13994 if (k
>= ' ' && k
< 0x7f)
14017 static ctf_sect_t
*
14018 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14020 buf
->cts_name
= SECTION_NAME (shdr
);
14021 buf
->cts_size
= shdr
->sh_size
;
14022 buf
->cts_entsize
= shdr
->sh_entsize
;
14027 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14028 it is passed, or a pointer to newly-allocated storage, in which case
14029 dump_ctf() will free it when it no longer needs it. */
14031 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14032 char *s
, void *arg
)
14034 const char *blanks
= arg
;
14037 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14043 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14045 Elf_Internal_Shdr
* parent_sec
= NULL
;
14046 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14047 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14048 void * data
= NULL
;
14049 void * symdata
= NULL
;
14050 void * strdata
= NULL
;
14051 void * parentdata
= NULL
;
14052 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14053 ctf_sect_t
* symsectp
= NULL
;
14054 ctf_sect_t
* strsectp
= NULL
;
14055 ctf_file_t
* ctf
= NULL
;
14056 ctf_file_t
* parent
= NULL
;
14058 const char *things
[] = {"Header", "Labels", "Data objects",
14059 "Function objects", "Variables", "Types", "Strings",
14061 const char **thing
;
14063 bfd_boolean ret
= FALSE
;
14066 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14067 data
= get_section_contents (section
, filedata
);
14068 ctfsect
.cts_data
= data
;
14070 if (!dump_ctf_symtab_name
)
14071 dump_ctf_symtab_name
= strdup (".symtab");
14073 if (!dump_ctf_strtab_name
)
14074 dump_ctf_strtab_name
= strdup (".strtab");
14076 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14078 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14080 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14083 if ((symdata
= (void *) get_data (NULL
, filedata
,
14084 symtab_sec
->sh_offset
, 1,
14085 symtab_sec
->sh_size
,
14086 _("symbols"))) == NULL
)
14088 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14089 symsect
.cts_data
= symdata
;
14091 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14093 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14095 error (_("No string table section named %s\n"),
14096 dump_ctf_strtab_name
);
14099 if ((strdata
= (void *) get_data (NULL
, filedata
,
14100 strtab_sec
->sh_offset
, 1,
14101 strtab_sec
->sh_size
,
14102 _("strings"))) == NULL
)
14104 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14105 strsect
.cts_data
= strdata
;
14107 if (dump_ctf_parent_name
)
14109 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14111 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14114 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14115 parent_sec
->sh_offset
, 1,
14116 parent_sec
->sh_size
,
14117 _("CTF parent"))) == NULL
)
14119 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14120 parentsect
.cts_data
= parentdata
;
14123 /* Load the CTF file and dump it. */
14125 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14127 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14133 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14135 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14139 ctf_import (ctf
, parent
);
14144 printf (_("\nDump of CTF section '%s':\n"),
14145 printable_section_name (filedata
, section
));
14147 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14149 ctf_dump_state_t
*s
= NULL
;
14152 printf ("\n %s:\n", *thing
);
14153 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14154 (void *) " ")) != NULL
)
14156 printf ("%s\n", item
);
14160 if (ctf_errno (ctf
))
14162 error (_("Iteration failed: %s, %s\n"), *thing
,
14163 ctf_errmsg (ctf_errno (ctf
)));
14169 ctf_file_close (ctf
);
14170 ctf_file_close (parent
);
14179 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14180 const Elf_Internal_Shdr
* sec
,
14183 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14185 Filedata
* filedata
= (Filedata
*) data
;
14187 if (section
->start
!= NULL
)
14189 /* If it is already loaded, do nothing. */
14190 if (streq (section
->filename
, filedata
->file_name
))
14192 free (section
->start
);
14195 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14196 section
->address
= sec
->sh_addr
;
14197 section
->user_data
= NULL
;
14198 section
->filename
= filedata
->file_name
;
14199 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14201 sec
->sh_size
, buf
);
14202 if (section
->start
== NULL
)
14206 unsigned char *start
= section
->start
;
14207 dwarf_size_type size
= sec
->sh_size
;
14208 dwarf_size_type uncompressed_size
= 0;
14210 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14212 Elf_Internal_Chdr chdr
;
14213 unsigned int compression_header_size
;
14215 if (size
< (is_32bit_elf
14216 ? sizeof (Elf32_External_Chdr
)
14217 : sizeof (Elf64_External_Chdr
)))
14219 warn (_("compressed section %s is too small to contain a compression header\n"),
14224 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14226 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14228 warn (_("section '%s' has unsupported compress type: %d\n"),
14229 section
->name
, chdr
.ch_type
);
14232 uncompressed_size
= chdr
.ch_size
;
14233 start
+= compression_header_size
;
14234 size
-= compression_header_size
;
14236 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14238 /* Read the zlib header. In this case, it should be "ZLIB"
14239 followed by the uncompressed section size, 8 bytes in
14240 big-endian order. */
14241 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14242 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14243 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14244 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14245 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14246 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14247 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14248 uncompressed_size
+= start
[11];
14253 if (uncompressed_size
)
14255 if (uncompress_section_contents (&start
, uncompressed_size
,
14258 /* Free the compressed buffer, update the section buffer
14259 and the section size if uncompress is successful. */
14260 free (section
->start
);
14261 section
->start
= start
;
14265 error (_("Unable to decompress section %s\n"),
14266 printable_section_name (filedata
, sec
));
14271 section
->size
= size
;
14274 if (section
->start
== NULL
)
14277 if (debug_displays
[debug
].relocate
)
14279 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14280 & section
->reloc_info
, & section
->num_relocs
))
14285 section
->reloc_info
= NULL
;
14286 section
->num_relocs
= 0;
14292 #if HAVE_LIBDEBUGINFOD
14293 /* Return a hex string representation of the build-id. */
14295 get_build_id (void * data
)
14297 Filedata
* filedata
= (Filedata
*)data
;
14298 Elf_Internal_Shdr
* shdr
;
14301 /* Iterate through notes to find note.gnu.build-id.
14302 FIXME: Only the first note in any note section is examined. */
14303 for (i
= 0, shdr
= filedata
->section_headers
;
14304 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14307 if (shdr
->sh_type
!= SHT_NOTE
)
14312 size_t data_remaining
;
14314 Elf_External_Note
* enote
;
14315 Elf_Internal_Note inote
;
14317 bfd_vma offset
= shdr
->sh_offset
;
14318 bfd_vma align
= shdr
->sh_addralign
;
14319 bfd_vma length
= shdr
->sh_size
;
14321 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14327 else if (align
!= 4 && align
!= 8)
14333 end
= (char *) enote
+ length
;
14334 data_remaining
= end
- (char *) enote
;
14336 if (!is_ia64_vms (filedata
))
14338 min_notesz
= offsetof (Elf_External_Note
, name
);
14339 if (data_remaining
< min_notesz
)
14342 malformed note encountered in section %s whilst scanning for build-id note\n"),
14343 printable_section_name (filedata
, shdr
));
14347 data_remaining
-= min_notesz
;
14349 inote
.type
= BYTE_GET (enote
->type
);
14350 inote
.namesz
= BYTE_GET (enote
->namesz
);
14351 inote
.namedata
= enote
->name
;
14352 inote
.descsz
= BYTE_GET (enote
->descsz
);
14353 inote
.descdata
= ((char *) enote
14354 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14355 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14356 next
= ((char *) enote
14357 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14361 Elf64_External_VMS_Note
*vms_enote
;
14363 /* PR binutils/15191
14364 Make sure that there is enough data to read. */
14365 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14366 if (data_remaining
< min_notesz
)
14369 malformed note encountered in section %s whilst scanning for build-id note\n"),
14370 printable_section_name (filedata
, shdr
));
14374 data_remaining
-= min_notesz
;
14376 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14377 inote
.type
= BYTE_GET (vms_enote
->type
);
14378 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14379 inote
.namedata
= vms_enote
->name
;
14380 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14381 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14382 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14383 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14386 /* Skip malformed notes. */
14387 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14388 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14389 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14390 || ((size_t) (next
- inote
.descdata
)
14391 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14394 malformed note encountered in section %s whilst scanning for build-id note\n"),
14395 printable_section_name (filedata
, shdr
));
14400 /* Check if this is the build-id note. If so then convert the build-id
14401 bytes to a hex string. */
14402 if (inote
.namesz
> 0
14403 && const_strneq (inote
.namedata
, "GNU")
14404 && inote
.type
== NT_GNU_BUILD_ID
)
14409 build_id
= malloc (inote
.descsz
* 2 + 1);
14410 if (build_id
== NULL
)
14416 for (j
= 0; j
< inote
.descsz
; ++j
)
14417 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14418 build_id
[inote
.descsz
* 2] = '\0';
14421 return (unsigned char *) build_id
;
14428 #endif /* HAVE_LIBDEBUGINFOD */
14430 /* If this is not NULL, load_debug_section will only look for sections
14431 within the list of sections given here. */
14432 static unsigned int * section_subset
= NULL
;
14435 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14437 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14438 Elf_Internal_Shdr
* sec
;
14439 Filedata
* filedata
= (Filedata
*) data
;
14441 /* Without section headers we cannot find any sections. */
14442 if (filedata
->section_headers
== NULL
)
14445 if (filedata
->string_table
== NULL
14446 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14447 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14449 Elf_Internal_Shdr
* strs
;
14451 /* Read in the string table, so that we have section names to scan. */
14452 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14454 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14456 filedata
->string_table
14457 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14458 1, strs
->sh_size
, _("string table"));
14460 filedata
->string_table_length
14461 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14465 /* Locate the debug section. */
14466 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14468 section
->name
= section
->uncompressed_name
;
14471 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14473 section
->name
= section
->compressed_name
;
14478 /* If we're loading from a subset of sections, and we've loaded
14479 a section matching this name before, it's likely that it's a
14481 if (section_subset
!= NULL
)
14482 free_debug_section (debug
);
14484 return load_specific_debug_section (debug
, sec
, data
);
14488 free_debug_section (enum dwarf_section_display_enum debug
)
14490 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14492 if (section
->start
== NULL
)
14495 free ((char *) section
->start
);
14496 section
->start
= NULL
;
14497 section
->address
= 0;
14500 if (section
->reloc_info
!= NULL
)
14502 free (section
->reloc_info
);
14503 section
->reloc_info
= NULL
;
14504 section
->num_relocs
= 0;
14509 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14511 char * name
= SECTION_NAME (section
);
14512 const char * print_name
= printable_section_name (filedata
, section
);
14513 bfd_size_type length
;
14514 bfd_boolean result
= TRUE
;
14517 length
= section
->sh_size
;
14520 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14523 if (section
->sh_type
== SHT_NOBITS
)
14525 /* There is no point in dumping the contents of a debugging section
14526 which has the NOBITS type - the bits in the file will be random.
14527 This can happen when a file containing a .eh_frame section is
14528 stripped with the --only-keep-debug command line option. */
14529 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14534 if (const_strneq (name
, ".gnu.linkonce.wi."))
14535 name
= ".debug_info";
14537 /* See if we know how to display the contents of this section. */
14538 for (i
= 0; i
< max
; i
++)
14540 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14541 struct dwarf_section_display
* display
= debug_displays
+ i
;
14542 struct dwarf_section
* sec
= & display
->section
;
14544 if (streq (sec
->uncompressed_name
, name
)
14545 || (id
== line
&& const_strneq (name
, ".debug_line."))
14546 || streq (sec
->compressed_name
, name
))
14548 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14551 free_debug_section (id
);
14553 if (i
== line
&& const_strneq (name
, ".debug_line."))
14555 else if (streq (sec
->uncompressed_name
, name
))
14556 sec
->name
= sec
->uncompressed_name
;
14558 sec
->name
= sec
->compressed_name
;
14560 if (load_specific_debug_section (id
, section
, filedata
))
14562 /* If this debug section is part of a CU/TU set in a .dwp file,
14563 restrict load_debug_section to the sections in that set. */
14564 section_subset
= find_cu_tu_set (filedata
, shndx
);
14566 result
&= display
->display (sec
, filedata
);
14568 section_subset
= NULL
;
14570 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14571 free_debug_section (id
);
14579 printf (_("Unrecognized debug section: %s\n"), print_name
);
14586 /* Set DUMP_SECTS for all sections where dumps were requested
14587 based on section name. */
14590 initialise_dumps_byname (Filedata
* filedata
)
14592 struct dump_list_entry
* cur
;
14594 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14597 bfd_boolean any
= FALSE
;
14599 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14600 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14602 request_dump_bynumber (filedata
, i
, cur
->type
);
14607 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14613 process_section_contents (Filedata
* filedata
)
14615 Elf_Internal_Shdr
* section
;
14617 bfd_boolean res
= TRUE
;
14622 initialise_dumps_byname (filedata
);
14624 for (i
= 0, section
= filedata
->section_headers
;
14625 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14628 dump_type dump
= filedata
->dump_sects
[i
];
14630 #ifdef SUPPORT_DISASSEMBLY
14631 if (dump
& DISASS_DUMP
)
14633 if (! disassemble_section (section
, filedata
))
14637 if (dump
& HEX_DUMP
)
14639 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14643 if (dump
& RELOC_DUMP
)
14645 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14649 if (dump
& STRING_DUMP
)
14651 if (! dump_section_as_strings (section
, filedata
))
14655 if (dump
& DEBUG_DUMP
)
14657 if (! display_debug_section (i
, section
, filedata
))
14661 if (dump
& CTF_DUMP
)
14663 if (! dump_section_as_ctf (section
, filedata
))
14668 /* Check to see if the user requested a
14669 dump of a section that does not exist. */
14670 while (i
< filedata
->num_dump_sects
)
14672 if (filedata
->dump_sects
[i
])
14674 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14684 process_mips_fpe_exception (int mask
)
14688 bfd_boolean first
= TRUE
;
14690 if (mask
& OEX_FPU_INEX
)
14691 fputs ("INEX", stdout
), first
= FALSE
;
14692 if (mask
& OEX_FPU_UFLO
)
14693 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14694 if (mask
& OEX_FPU_OFLO
)
14695 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14696 if (mask
& OEX_FPU_DIV0
)
14697 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14698 if (mask
& OEX_FPU_INVAL
)
14699 printf ("%sINVAL", first
? "" : "|");
14702 fputs ("0", stdout
);
14705 /* Display's the value of TAG at location P. If TAG is
14706 greater than 0 it is assumed to be an unknown tag, and
14707 a message is printed to this effect. Otherwise it is
14708 assumed that a message has already been printed.
14710 If the bottom bit of TAG is set it assumed to have a
14711 string value, otherwise it is assumed to have an integer
14714 Returns an updated P pointing to the first unread byte
14715 beyond the end of TAG's value.
14717 Reads at or beyond END will not be made. */
14719 static unsigned char *
14720 display_tag_value (signed int tag
,
14722 const unsigned char * const end
)
14727 printf (" Tag_unknown_%d: ", tag
);
14731 warn (_("<corrupt tag>\n"));
14735 /* PR 17531 file: 027-19978-0.004. */
14736 size_t maxlen
= (end
- p
) - 1;
14741 print_symbol ((int) maxlen
, (const char *) p
);
14742 p
+= strnlen ((char *) p
, maxlen
) + 1;
14746 printf (_("<corrupt string tag>"));
14747 p
= (unsigned char *) end
;
14753 READ_ULEB (val
, p
, end
);
14754 printf ("%ld (0x%lx)\n", val
, val
);
14761 /* ARC ABI attributes section. */
14763 static unsigned char *
14764 display_arc_attribute (unsigned char * p
,
14765 const unsigned char * const end
)
14770 READ_ULEB (tag
, p
, end
);
14774 case Tag_ARC_PCS_config
:
14775 READ_ULEB (val
, p
, end
);
14776 printf (" Tag_ARC_PCS_config: ");
14780 printf (_("Absent/Non standard\n"));
14783 printf (_("Bare metal/mwdt\n"));
14786 printf (_("Bare metal/newlib\n"));
14789 printf (_("Linux/uclibc\n"));
14792 printf (_("Linux/glibc\n"));
14795 printf (_("Unknown\n"));
14800 case Tag_ARC_CPU_base
:
14801 READ_ULEB (val
, p
, end
);
14802 printf (" Tag_ARC_CPU_base: ");
14807 printf (_("Absent\n"));
14809 case TAG_CPU_ARC6xx
:
14810 printf ("ARC6xx\n");
14812 case TAG_CPU_ARC7xx
:
14813 printf ("ARC7xx\n");
14815 case TAG_CPU_ARCEM
:
14816 printf ("ARCEM\n");
14818 case TAG_CPU_ARCHS
:
14819 printf ("ARCHS\n");
14824 case Tag_ARC_CPU_variation
:
14825 READ_ULEB (val
, p
, end
);
14826 printf (" Tag_ARC_CPU_variation: ");
14830 if (val
> 0 && val
< 16)
14831 printf ("Core%d\n", val
);
14833 printf ("Unknown\n");
14837 printf (_("Absent\n"));
14842 case Tag_ARC_CPU_name
:
14843 printf (" Tag_ARC_CPU_name: ");
14844 p
= display_tag_value (-1, p
, end
);
14847 case Tag_ARC_ABI_rf16
:
14848 READ_ULEB (val
, p
, end
);
14849 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14852 case Tag_ARC_ABI_osver
:
14853 READ_ULEB (val
, p
, end
);
14854 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14857 case Tag_ARC_ABI_pic
:
14858 case Tag_ARC_ABI_sda
:
14859 READ_ULEB (val
, p
, end
);
14860 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14861 : " Tag_ARC_ABI_pic: ");
14865 printf (_("Absent\n"));
14874 printf (_("Unknown\n"));
14879 case Tag_ARC_ABI_tls
:
14880 READ_ULEB (val
, p
, end
);
14881 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14884 case Tag_ARC_ABI_enumsize
:
14885 READ_ULEB (val
, p
, end
);
14886 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14890 case Tag_ARC_ABI_exceptions
:
14891 READ_ULEB (val
, p
, end
);
14892 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14896 case Tag_ARC_ABI_double_size
:
14897 READ_ULEB (val
, p
, end
);
14898 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14901 case Tag_ARC_ISA_config
:
14902 printf (" Tag_ARC_ISA_config: ");
14903 p
= display_tag_value (-1, p
, end
);
14906 case Tag_ARC_ISA_apex
:
14907 printf (" Tag_ARC_ISA_apex: ");
14908 p
= display_tag_value (-1, p
, end
);
14911 case Tag_ARC_ISA_mpy_option
:
14912 READ_ULEB (val
, p
, end
);
14913 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14916 case Tag_ARC_ATR_version
:
14917 READ_ULEB (val
, p
, end
);
14918 printf (" Tag_ARC_ATR_version: %d\n", val
);
14922 return display_tag_value (tag
& 1, p
, end
);
14928 /* ARM EABI attributes section. */
14933 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14935 const char ** table
;
14936 } arm_attr_public_tag
;
14938 static const char * arm_attr_tag_CPU_arch
[] =
14939 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14940 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14941 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14942 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14943 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14944 {"No", "Thumb-1", "Thumb-2", "Yes"};
14945 static const char * arm_attr_tag_FP_arch
[] =
14946 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14947 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14948 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14949 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14950 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14951 "NEON for ARMv8.1"};
14952 static const char * arm_attr_tag_PCS_config
[] =
14953 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14954 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14955 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14956 {"V6", "SB", "TLS", "Unused"};
14957 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14958 {"Absolute", "PC-relative", "SB-relative", "None"};
14959 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14960 {"Absolute", "PC-relative", "None"};
14961 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14962 {"None", "direct", "GOT-indirect"};
14963 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14964 {"None", "??? 1", "2", "??? 3", "4"};
14965 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14966 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14967 {"Unused", "Needed", "Sign only"};
14968 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14969 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14970 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14971 {"Unused", "Finite", "RTABI", "IEEE 754"};
14972 static const char * arm_attr_tag_ABI_enum_size
[] =
14973 {"Unused", "small", "int", "forced to int"};
14974 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14975 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14976 static const char * arm_attr_tag_ABI_VFP_args
[] =
14977 {"AAPCS", "VFP registers", "custom", "compatible"};
14978 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14979 {"AAPCS", "WMMX registers", "custom"};
14980 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14981 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14982 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14983 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14984 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14985 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14986 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14987 static const char * arm_attr_tag_FP_HP_extension
[] =
14988 {"Not Allowed", "Allowed"};
14989 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14990 {"None", "IEEE 754", "Alternative Format"};
14991 static const char * arm_attr_tag_DSP_extension
[] =
14992 {"Follow architecture", "Allowed"};
14993 static const char * arm_attr_tag_MPextension_use
[] =
14994 {"Not Allowed", "Allowed"};
14995 static const char * arm_attr_tag_DIV_use
[] =
14996 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14997 "Allowed in v7-A with integer division extension"};
14998 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14999 static const char * arm_attr_tag_Virtualization_use
[] =
15000 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15001 "TrustZone and Virtualization Extensions"};
15002 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15003 {"Not Allowed", "Allowed"};
15005 static const char * arm_attr_tag_MVE_arch
[] =
15006 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15008 #define LOOKUP(id, name) \
15009 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15010 static arm_attr_public_tag arm_attr_public_tags
[] =
15012 {4, "CPU_raw_name", 1, NULL
},
15013 {5, "CPU_name", 1, NULL
},
15014 LOOKUP(6, CPU_arch
),
15015 {7, "CPU_arch_profile", 0, NULL
},
15016 LOOKUP(8, ARM_ISA_use
),
15017 LOOKUP(9, THUMB_ISA_use
),
15018 LOOKUP(10, FP_arch
),
15019 LOOKUP(11, WMMX_arch
),
15020 LOOKUP(12, Advanced_SIMD_arch
),
15021 LOOKUP(13, PCS_config
),
15022 LOOKUP(14, ABI_PCS_R9_use
),
15023 LOOKUP(15, ABI_PCS_RW_data
),
15024 LOOKUP(16, ABI_PCS_RO_data
),
15025 LOOKUP(17, ABI_PCS_GOT_use
),
15026 LOOKUP(18, ABI_PCS_wchar_t
),
15027 LOOKUP(19, ABI_FP_rounding
),
15028 LOOKUP(20, ABI_FP_denormal
),
15029 LOOKUP(21, ABI_FP_exceptions
),
15030 LOOKUP(22, ABI_FP_user_exceptions
),
15031 LOOKUP(23, ABI_FP_number_model
),
15032 {24, "ABI_align_needed", 0, NULL
},
15033 {25, "ABI_align_preserved", 0, NULL
},
15034 LOOKUP(26, ABI_enum_size
),
15035 LOOKUP(27, ABI_HardFP_use
),
15036 LOOKUP(28, ABI_VFP_args
),
15037 LOOKUP(29, ABI_WMMX_args
),
15038 LOOKUP(30, ABI_optimization_goals
),
15039 LOOKUP(31, ABI_FP_optimization_goals
),
15040 {32, "compatibility", 0, NULL
},
15041 LOOKUP(34, CPU_unaligned_access
),
15042 LOOKUP(36, FP_HP_extension
),
15043 LOOKUP(38, ABI_FP_16bit_format
),
15044 LOOKUP(42, MPextension_use
),
15045 LOOKUP(44, DIV_use
),
15046 LOOKUP(46, DSP_extension
),
15047 LOOKUP(48, MVE_arch
),
15048 {64, "nodefaults", 0, NULL
},
15049 {65, "also_compatible_with", 0, NULL
},
15050 LOOKUP(66, T2EE_use
),
15051 {67, "conformance", 1, NULL
},
15052 LOOKUP(68, Virtualization_use
),
15053 LOOKUP(70, MPextension_use_legacy
)
15057 static unsigned char *
15058 display_arm_attribute (unsigned char * p
,
15059 const unsigned char * const end
)
15063 arm_attr_public_tag
* attr
;
15067 READ_ULEB (tag
, p
, end
);
15069 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15071 if (arm_attr_public_tags
[i
].tag
== tag
)
15073 attr
= &arm_attr_public_tags
[i
];
15080 printf (" Tag_%s: ", attr
->name
);
15081 switch (attr
->type
)
15086 case 7: /* Tag_CPU_arch_profile. */
15087 READ_ULEB (val
, p
, end
);
15090 case 0: printf (_("None\n")); break;
15091 case 'A': printf (_("Application\n")); break;
15092 case 'R': printf (_("Realtime\n")); break;
15093 case 'M': printf (_("Microcontroller\n")); break;
15094 case 'S': printf (_("Application or Realtime\n")); break;
15095 default: printf ("??? (%d)\n", val
); break;
15099 case 24: /* Tag_align_needed. */
15100 READ_ULEB (val
, p
, end
);
15103 case 0: printf (_("None\n")); break;
15104 case 1: printf (_("8-byte\n")); break;
15105 case 2: printf (_("4-byte\n")); break;
15106 case 3: printf ("??? 3\n"); break;
15109 printf (_("8-byte and up to %d-byte extended\n"),
15112 printf ("??? (%d)\n", val
);
15117 case 25: /* Tag_align_preserved. */
15118 READ_ULEB (val
, p
, end
);
15121 case 0: printf (_("None\n")); break;
15122 case 1: printf (_("8-byte, except leaf SP\n")); break;
15123 case 2: printf (_("8-byte\n")); break;
15124 case 3: printf ("??? 3\n"); break;
15127 printf (_("8-byte and up to %d-byte extended\n"),
15130 printf ("??? (%d)\n", val
);
15135 case 32: /* Tag_compatibility. */
15137 READ_ULEB (val
, p
, end
);
15138 printf (_("flag = %d, vendor = "), val
);
15141 size_t maxlen
= (end
- p
) - 1;
15143 print_symbol ((int) maxlen
, (const char *) p
);
15144 p
+= strnlen ((char *) p
, maxlen
) + 1;
15148 printf (_("<corrupt>"));
15149 p
= (unsigned char *) end
;
15155 case 64: /* Tag_nodefaults. */
15156 /* PR 17531: file: 001-505008-0.01. */
15159 printf (_("True\n"));
15162 case 65: /* Tag_also_compatible_with. */
15163 READ_ULEB (val
, p
, end
);
15164 if (val
== 6 /* Tag_CPU_arch. */)
15166 READ_ULEB (val
, p
, end
);
15167 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15168 printf ("??? (%d)\n", val
);
15170 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15174 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15179 printf (_("<unknown: %d>\n"), tag
);
15185 return display_tag_value (-1, p
, end
);
15187 return display_tag_value (0, p
, end
);
15190 assert (attr
->type
& 0x80);
15191 READ_ULEB (val
, p
, end
);
15192 type
= attr
->type
& 0x7f;
15194 printf ("??? (%d)\n", val
);
15196 printf ("%s\n", attr
->table
[val
]);
15201 return display_tag_value (tag
, p
, end
);
15204 static unsigned char *
15205 display_gnu_attribute (unsigned char * p
,
15206 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15207 const unsigned char * const end
)
15212 READ_ULEB (tag
, p
, end
);
15214 /* Tag_compatibility is the only generic GNU attribute defined at
15218 READ_ULEB (val
, p
, end
);
15220 printf (_("flag = %d, vendor = "), val
);
15223 printf (_("<corrupt>\n"));
15224 warn (_("corrupt vendor attribute\n"));
15230 size_t maxlen
= (end
- p
) - 1;
15232 print_symbol ((int) maxlen
, (const char *) p
);
15233 p
+= strnlen ((char *) p
, maxlen
) + 1;
15237 printf (_("<corrupt>"));
15238 p
= (unsigned char *) end
;
15245 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15246 return display_proc_gnu_attribute (p
, tag
, end
);
15248 return display_tag_value (tag
, p
, end
);
15251 static unsigned char *
15252 display_power_gnu_attribute (unsigned char * p
,
15254 const unsigned char * const end
)
15258 if (tag
== Tag_GNU_Power_ABI_FP
)
15260 printf (" Tag_GNU_Power_ABI_FP: ");
15263 printf (_("<corrupt>\n"));
15266 READ_ULEB (val
, p
, end
);
15269 printf ("(%#x), ", val
);
15274 printf (_("unspecified hard/soft float, "));
15277 printf (_("hard float, "));
15280 printf (_("soft float, "));
15283 printf (_("single-precision hard float, "));
15290 printf (_("unspecified long double\n"));
15293 printf (_("128-bit IBM long double\n"));
15296 printf (_("64-bit long double\n"));
15299 printf (_("128-bit IEEE long double\n"));
15305 if (tag
== Tag_GNU_Power_ABI_Vector
)
15307 printf (" Tag_GNU_Power_ABI_Vector: ");
15310 printf (_("<corrupt>\n"));
15313 READ_ULEB (val
, p
, end
);
15316 printf ("(%#x), ", val
);
15321 printf (_("unspecified\n"));
15324 printf (_("generic\n"));
15327 printf ("AltiVec\n");
15336 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15338 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15341 printf (_("<corrupt>\n"));
15344 READ_ULEB (val
, p
, end
);
15347 printf ("(%#x), ", val
);
15352 printf (_("unspecified\n"));
15355 printf ("r3/r4\n");
15358 printf (_("memory\n"));
15367 return display_tag_value (tag
& 1, p
, end
);
15370 static unsigned char *
15371 display_s390_gnu_attribute (unsigned char * p
,
15373 const unsigned char * const end
)
15377 if (tag
== Tag_GNU_S390_ABI_Vector
)
15379 printf (" Tag_GNU_S390_ABI_Vector: ");
15380 READ_ULEB (val
, p
, end
);
15385 printf (_("any\n"));
15388 printf (_("software\n"));
15391 printf (_("hardware\n"));
15394 printf ("??? (%d)\n", val
);
15400 return display_tag_value (tag
& 1, p
, end
);
15404 display_sparc_hwcaps (unsigned int mask
)
15408 bfd_boolean first
= TRUE
;
15410 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15411 fputs ("mul32", stdout
), first
= FALSE
;
15412 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15413 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15414 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15415 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15416 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15417 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15418 if (mask
& ELF_SPARC_HWCAP_POPC
)
15419 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15420 if (mask
& ELF_SPARC_HWCAP_VIS
)
15421 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15422 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15423 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15424 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15425 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15426 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15427 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15428 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15429 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15430 if (mask
& ELF_SPARC_HWCAP_HPC
)
15431 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15432 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15433 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15434 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15435 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15436 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15437 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15438 if (mask
& ELF_SPARC_HWCAP_IMA
)
15439 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15440 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15441 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15444 fputc ('0', stdout
);
15445 fputc ('\n', stdout
);
15449 display_sparc_hwcaps2 (unsigned int mask
)
15453 bfd_boolean first
= TRUE
;
15455 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15456 fputs ("fjathplus", stdout
), first
= FALSE
;
15457 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15458 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15459 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15460 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15461 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15462 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15463 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15464 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15465 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15466 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15467 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15468 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15469 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15470 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15471 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15472 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15473 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15474 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15475 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15476 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15479 fputc ('0', stdout
);
15480 fputc ('\n', stdout
);
15483 static unsigned char *
15484 display_sparc_gnu_attribute (unsigned char * p
,
15486 const unsigned char * const end
)
15490 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15492 READ_ULEB (val
, p
, end
);
15493 printf (" Tag_GNU_Sparc_HWCAPS: ");
15494 display_sparc_hwcaps (val
);
15497 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15499 READ_ULEB (val
, p
, end
);
15500 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15501 display_sparc_hwcaps2 (val
);
15505 return display_tag_value (tag
, p
, end
);
15509 print_mips_fp_abi_value (unsigned int val
)
15513 case Val_GNU_MIPS_ABI_FP_ANY
:
15514 printf (_("Hard or soft float\n"));
15516 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15517 printf (_("Hard float (double precision)\n"));
15519 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15520 printf (_("Hard float (single precision)\n"));
15522 case Val_GNU_MIPS_ABI_FP_SOFT
:
15523 printf (_("Soft float\n"));
15525 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15526 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15528 case Val_GNU_MIPS_ABI_FP_XX
:
15529 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15531 case Val_GNU_MIPS_ABI_FP_64
:
15532 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15534 case Val_GNU_MIPS_ABI_FP_64A
:
15535 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15537 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15538 printf (_("NaN 2008 compatibility\n"));
15541 printf ("??? (%d)\n", val
);
15546 static unsigned char *
15547 display_mips_gnu_attribute (unsigned char * p
,
15549 const unsigned char * const end
)
15551 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15555 printf (" Tag_GNU_MIPS_ABI_FP: ");
15556 READ_ULEB (val
, p
, end
);
15557 print_mips_fp_abi_value (val
);
15561 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15565 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15566 READ_ULEB (val
, p
, end
);
15570 case Val_GNU_MIPS_ABI_MSA_ANY
:
15571 printf (_("Any MSA or not\n"));
15573 case Val_GNU_MIPS_ABI_MSA_128
:
15574 printf (_("128-bit MSA\n"));
15577 printf ("??? (%d)\n", val
);
15583 return display_tag_value (tag
& 1, p
, end
);
15586 static unsigned char *
15587 display_tic6x_attribute (unsigned char * p
,
15588 const unsigned char * const end
)
15593 READ_ULEB (tag
, p
, end
);
15598 printf (" Tag_ISA: ");
15599 READ_ULEB (val
, p
, end
);
15603 case C6XABI_Tag_ISA_none
:
15604 printf (_("None\n"));
15606 case C6XABI_Tag_ISA_C62X
:
15609 case C6XABI_Tag_ISA_C67X
:
15612 case C6XABI_Tag_ISA_C67XP
:
15613 printf ("C67x+\n");
15615 case C6XABI_Tag_ISA_C64X
:
15618 case C6XABI_Tag_ISA_C64XP
:
15619 printf ("C64x+\n");
15621 case C6XABI_Tag_ISA_C674X
:
15622 printf ("C674x\n");
15625 printf ("??? (%d)\n", val
);
15630 case Tag_ABI_wchar_t
:
15631 printf (" Tag_ABI_wchar_t: ");
15632 READ_ULEB (val
, p
, end
);
15636 printf (_("Not used\n"));
15639 printf (_("2 bytes\n"));
15642 printf (_("4 bytes\n"));
15645 printf ("??? (%d)\n", val
);
15650 case Tag_ABI_stack_align_needed
:
15651 printf (" Tag_ABI_stack_align_needed: ");
15652 READ_ULEB (val
, p
, end
);
15656 printf (_("8-byte\n"));
15659 printf (_("16-byte\n"));
15662 printf ("??? (%d)\n", val
);
15667 case Tag_ABI_stack_align_preserved
:
15668 READ_ULEB (val
, p
, end
);
15669 printf (" Tag_ABI_stack_align_preserved: ");
15673 printf (_("8-byte\n"));
15676 printf (_("16-byte\n"));
15679 printf ("??? (%d)\n", val
);
15685 READ_ULEB (val
, p
, end
);
15686 printf (" Tag_ABI_DSBT: ");
15690 printf (_("DSBT addressing not used\n"));
15693 printf (_("DSBT addressing used\n"));
15696 printf ("??? (%d)\n", val
);
15702 READ_ULEB (val
, p
, end
);
15703 printf (" Tag_ABI_PID: ");
15707 printf (_("Data addressing position-dependent\n"));
15710 printf (_("Data addressing position-independent, GOT near DP\n"));
15713 printf (_("Data addressing position-independent, GOT far from DP\n"));
15716 printf ("??? (%d)\n", val
);
15722 READ_ULEB (val
, p
, end
);
15723 printf (" Tag_ABI_PIC: ");
15727 printf (_("Code addressing position-dependent\n"));
15730 printf (_("Code addressing position-independent\n"));
15733 printf ("??? (%d)\n", val
);
15738 case Tag_ABI_array_object_alignment
:
15739 READ_ULEB (val
, p
, end
);
15740 printf (" Tag_ABI_array_object_alignment: ");
15744 printf (_("8-byte\n"));
15747 printf (_("4-byte\n"));
15750 printf (_("16-byte\n"));
15753 printf ("??? (%d)\n", val
);
15758 case Tag_ABI_array_object_align_expected
:
15759 READ_ULEB (val
, p
, end
);
15760 printf (" Tag_ABI_array_object_align_expected: ");
15764 printf (_("8-byte\n"));
15767 printf (_("4-byte\n"));
15770 printf (_("16-byte\n"));
15773 printf ("??? (%d)\n", val
);
15778 case Tag_ABI_compatibility
:
15780 READ_ULEB (val
, p
, end
);
15781 printf (" Tag_ABI_compatibility: ");
15782 printf (_("flag = %d, vendor = "), val
);
15785 size_t maxlen
= (end
- p
) - 1;
15787 print_symbol ((int) maxlen
, (const char *) p
);
15788 p
+= strnlen ((char *) p
, maxlen
) + 1;
15792 printf (_("<corrupt>"));
15793 p
= (unsigned char *) end
;
15799 case Tag_ABI_conformance
:
15801 printf (" Tag_ABI_conformance: \"");
15804 size_t maxlen
= (end
- p
) - 1;
15806 print_symbol ((int) maxlen
, (const char *) p
);
15807 p
+= strnlen ((char *) p
, maxlen
) + 1;
15811 printf (_("<corrupt>"));
15812 p
= (unsigned char *) end
;
15819 return display_tag_value (tag
, p
, end
);
15823 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15825 unsigned long addr
= 0;
15826 size_t bytes
= end
- p
;
15833 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15835 printf (" 0x%8.8lx ", addr
);
15837 for (j
= 0; j
< 16; j
++)
15840 printf ("%2.2x", p
[j
]);
15848 for (j
= 0; j
< lbytes
; j
++)
15851 if (k
>= ' ' && k
< 0x7f)
15867 static unsigned char *
15868 display_msp430x_attribute (unsigned char * p
,
15869 const unsigned char * const end
)
15874 READ_ULEB (tag
, p
, end
);
15878 case OFBA_MSPABI_Tag_ISA
:
15879 printf (" Tag_ISA: ");
15880 READ_ULEB (val
, p
, end
);
15883 case 0: printf (_("None\n")); break;
15884 case 1: printf (_("MSP430\n")); break;
15885 case 2: printf (_("MSP430X\n")); break;
15886 default: printf ("??? (%d)\n", val
); break;
15890 case OFBA_MSPABI_Tag_Code_Model
:
15891 printf (" Tag_Code_Model: ");
15892 READ_ULEB (val
, p
, end
);
15895 case 0: printf (_("None\n")); break;
15896 case 1: printf (_("Small\n")); break;
15897 case 2: printf (_("Large\n")); break;
15898 default: printf ("??? (%d)\n", val
); break;
15902 case OFBA_MSPABI_Tag_Data_Model
:
15903 printf (" Tag_Data_Model: ");
15904 READ_ULEB (val
, p
, end
);
15907 case 0: printf (_("None\n")); break;
15908 case 1: printf (_("Small\n")); break;
15909 case 2: printf (_("Large\n")); break;
15910 case 3: printf (_("Restricted Large\n")); break;
15911 default: printf ("??? (%d)\n", val
); break;
15916 printf (_(" <unknown tag %d>: "), tag
);
15923 size_t maxlen
= (end
- p
) - 1;
15925 print_symbol ((int) maxlen
, (const char *) p
);
15926 p
+= strnlen ((char *) p
, maxlen
) + 1;
15930 printf (_("<corrupt>"));
15931 p
= (unsigned char *) end
;
15937 READ_ULEB (val
, p
, end
);
15938 printf ("%d (0x%x)\n", val
, val
);
15947 static unsigned char *
15948 display_msp430_gnu_attribute (unsigned char * p
,
15950 const unsigned char * const end
)
15952 if (tag
== Tag_GNU_MSP430_Data_Region
)
15956 printf (" Tag_GNU_MSP430_Data_Region: ");
15957 READ_ULEB (val
, p
, end
);
15961 case Val_GNU_MSP430_Data_Region_Any
:
15962 printf (_("Any Region\n"));
15964 case Val_GNU_MSP430_Data_Region_Lower
:
15965 printf (_("Lower Region Only\n"));
15968 printf ("??? (%u)\n", val
);
15972 return display_tag_value (tag
& 1, p
, end
);
15975 struct riscv_attr_tag_t
{
15980 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15982 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15985 T(priv_spec_minor
),
15986 T(priv_spec_revision
),
15987 T(unaligned_access
),
15992 static unsigned char *
15993 display_riscv_attribute (unsigned char *p
,
15994 const unsigned char * const end
)
15998 struct riscv_attr_tag_t
*attr
= NULL
;
16001 READ_ULEB (tag
, p
, end
);
16003 /* Find the name of attribute. */
16004 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16006 if (riscv_attr_tag
[i
].tag
== tag
)
16008 attr
= &riscv_attr_tag
[i
];
16014 printf (" %s: ", attr
->name
);
16016 return display_tag_value (tag
, p
, end
);
16020 case Tag_RISCV_priv_spec
:
16021 case Tag_RISCV_priv_spec_minor
:
16022 case Tag_RISCV_priv_spec_revision
:
16023 READ_ULEB (val
, p
, end
);
16024 printf (_("%u\n"), val
);
16026 case Tag_RISCV_unaligned_access
:
16027 READ_ULEB (val
, p
, end
);
16031 printf (_("No unaligned access\n"));
16034 printf (_("Unaligned access\n"));
16038 case Tag_RISCV_stack_align
:
16039 READ_ULEB (val
, p
, end
);
16040 printf (_("%u-bytes\n"), val
);
16042 case Tag_RISCV_arch
:
16043 p
= display_tag_value (-1, p
, end
);
16046 return display_tag_value (tag
, p
, end
);
16053 process_attributes (Filedata
* filedata
,
16054 const char * public_name
,
16055 unsigned int proc_type
,
16056 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16057 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16059 Elf_Internal_Shdr
* sect
;
16061 bfd_boolean res
= TRUE
;
16063 /* Find the section header so that we get the size. */
16064 for (i
= 0, sect
= filedata
->section_headers
;
16065 i
< filedata
->file_header
.e_shnum
;
16068 unsigned char * contents
;
16071 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16074 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16075 sect
->sh_size
, _("attributes"));
16076 if (contents
== NULL
)
16083 /* The first character is the version of the attributes.
16084 Currently only version 1, (aka 'A') is recognised here. */
16087 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16092 bfd_vma section_len
;
16094 section_len
= sect
->sh_size
- 1;
16097 while (section_len
> 0)
16100 unsigned int namelen
;
16101 bfd_boolean public_section
;
16102 bfd_boolean gnu_section
;
16104 if (section_len
<= 4)
16106 error (_("Tag section ends prematurely\n"));
16110 attr_len
= byte_get (p
, 4);
16113 if (attr_len
> section_len
)
16115 error (_("Bad attribute length (%u > %u)\n"),
16116 (unsigned) attr_len
, (unsigned) section_len
);
16117 attr_len
= section_len
;
16120 /* PR 17531: file: 001-101425-0.004 */
16121 else if (attr_len
< 5)
16123 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16128 section_len
-= attr_len
;
16131 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16132 if (namelen
== 0 || namelen
>= attr_len
)
16134 error (_("Corrupt attribute section name\n"));
16139 printf (_("Attribute Section: "));
16140 print_symbol (INT_MAX
, (const char *) p
);
16143 if (public_name
&& streq ((char *) p
, public_name
))
16144 public_section
= TRUE
;
16146 public_section
= FALSE
;
16148 if (streq ((char *) p
, "gnu"))
16149 gnu_section
= TRUE
;
16151 gnu_section
= FALSE
;
16154 attr_len
-= namelen
;
16156 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16161 unsigned char * end
;
16163 /* PR binutils/17531: Safe handling of corrupt files. */
16166 error (_("Unused bytes at end of section\n"));
16173 size
= byte_get (p
, 4);
16174 if (size
> attr_len
)
16176 error (_("Bad subsection length (%u > %u)\n"),
16177 (unsigned) size
, (unsigned) attr_len
);
16181 /* PR binutils/17531: Safe handling of corrupt files. */
16184 error (_("Bad subsection length (%u < 6)\n"),
16192 end
= p
+ size
- 1;
16193 assert (end
<= contents
+ sect
->sh_size
);
16199 printf (_("File Attributes\n"));
16202 printf (_("Section Attributes:"));
16205 printf (_("Symbol Attributes:"));
16206 /* Fall through. */
16210 READ_ULEB (val
, p
, end
);
16213 printf (" %d", val
);
16218 printf (_("Unknown tag: %d\n"), tag
);
16219 public_section
= FALSE
;
16223 if (public_section
&& display_pub_attribute
!= NULL
)
16226 p
= display_pub_attribute (p
, end
);
16229 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16232 p
= display_gnu_attribute (p
,
16233 display_proc_gnu_attribute
,
16239 printf (_(" Unknown attribute:\n"));
16240 display_raw_attribute (p
, end
);
16255 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16256 Print the Address, Access and Initial fields of an entry at VMA ADDR
16257 and return the VMA of the next entry, or -1 if there was a problem.
16258 Does not read from DATA_END or beyond. */
16261 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16262 unsigned char * data_end
)
16265 print_vma (addr
, LONG_HEX
);
16267 if (addr
< pltgot
+ 0xfff0)
16268 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16270 printf ("%10s", "");
16273 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16277 unsigned char * from
= data
+ addr
- pltgot
;
16279 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16281 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16282 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16283 return (bfd_vma
) -1;
16287 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16288 print_vma (entry
, LONG_HEX
);
16291 return addr
+ (is_32bit_elf
? 4 : 8);
16294 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16295 PLTGOT. Print the Address and Initial fields of an entry at VMA
16296 ADDR and return the VMA of the next entry. */
16299 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16302 print_vma (addr
, LONG_HEX
);
16305 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16310 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16311 print_vma (entry
, LONG_HEX
);
16313 return addr
+ (is_32bit_elf
? 4 : 8);
16317 print_mips_ases (unsigned int mask
)
16319 if (mask
& AFL_ASE_DSP
)
16320 fputs ("\n\tDSP ASE", stdout
);
16321 if (mask
& AFL_ASE_DSPR2
)
16322 fputs ("\n\tDSP R2 ASE", stdout
);
16323 if (mask
& AFL_ASE_DSPR3
)
16324 fputs ("\n\tDSP R3 ASE", stdout
);
16325 if (mask
& AFL_ASE_EVA
)
16326 fputs ("\n\tEnhanced VA Scheme", stdout
);
16327 if (mask
& AFL_ASE_MCU
)
16328 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16329 if (mask
& AFL_ASE_MDMX
)
16330 fputs ("\n\tMDMX ASE", stdout
);
16331 if (mask
& AFL_ASE_MIPS3D
)
16332 fputs ("\n\tMIPS-3D ASE", stdout
);
16333 if (mask
& AFL_ASE_MT
)
16334 fputs ("\n\tMT ASE", stdout
);
16335 if (mask
& AFL_ASE_SMARTMIPS
)
16336 fputs ("\n\tSmartMIPS ASE", stdout
);
16337 if (mask
& AFL_ASE_VIRT
)
16338 fputs ("\n\tVZ ASE", stdout
);
16339 if (mask
& AFL_ASE_MSA
)
16340 fputs ("\n\tMSA ASE", stdout
);
16341 if (mask
& AFL_ASE_MIPS16
)
16342 fputs ("\n\tMIPS16 ASE", stdout
);
16343 if (mask
& AFL_ASE_MICROMIPS
)
16344 fputs ("\n\tMICROMIPS ASE", stdout
);
16345 if (mask
& AFL_ASE_XPA
)
16346 fputs ("\n\tXPA ASE", stdout
);
16347 if (mask
& AFL_ASE_MIPS16E2
)
16348 fputs ("\n\tMIPS16e2 ASE", stdout
);
16349 if (mask
& AFL_ASE_CRC
)
16350 fputs ("\n\tCRC ASE", stdout
);
16351 if (mask
& AFL_ASE_GINV
)
16352 fputs ("\n\tGINV ASE", stdout
);
16353 if (mask
& AFL_ASE_LOONGSON_MMI
)
16354 fputs ("\n\tLoongson MMI ASE", stdout
);
16355 if (mask
& AFL_ASE_LOONGSON_CAM
)
16356 fputs ("\n\tLoongson CAM ASE", stdout
);
16357 if (mask
& AFL_ASE_LOONGSON_EXT
)
16358 fputs ("\n\tLoongson EXT ASE", stdout
);
16359 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16360 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16362 fprintf (stdout
, "\n\t%s", _("None"));
16363 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16364 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16368 print_mips_isa_ext (unsigned int isa_ext
)
16373 fputs (_("None"), stdout
);
16376 fputs ("RMI XLR", stdout
);
16378 case AFL_EXT_OCTEON3
:
16379 fputs ("Cavium Networks Octeon3", stdout
);
16381 case AFL_EXT_OCTEON2
:
16382 fputs ("Cavium Networks Octeon2", stdout
);
16384 case AFL_EXT_OCTEONP
:
16385 fputs ("Cavium Networks OcteonP", stdout
);
16387 case AFL_EXT_OCTEON
:
16388 fputs ("Cavium Networks Octeon", stdout
);
16391 fputs ("Toshiba R5900", stdout
);
16394 fputs ("MIPS R4650", stdout
);
16397 fputs ("LSI R4010", stdout
);
16400 fputs ("NEC VR4100", stdout
);
16403 fputs ("Toshiba R3900", stdout
);
16405 case AFL_EXT_10000
:
16406 fputs ("MIPS R10000", stdout
);
16409 fputs ("Broadcom SB-1", stdout
);
16412 fputs ("NEC VR4111/VR4181", stdout
);
16415 fputs ("NEC VR4120", stdout
);
16418 fputs ("NEC VR5400", stdout
);
16421 fputs ("NEC VR5500", stdout
);
16423 case AFL_EXT_LOONGSON_2E
:
16424 fputs ("ST Microelectronics Loongson 2E", stdout
);
16426 case AFL_EXT_LOONGSON_2F
:
16427 fputs ("ST Microelectronics Loongson 2F", stdout
);
16429 case AFL_EXT_INTERAPTIV_MR2
:
16430 fputs ("Imagination interAptiv MR2", stdout
);
16433 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16438 get_mips_reg_size (int reg_size
)
16440 return (reg_size
== AFL_REG_NONE
) ? 0
16441 : (reg_size
== AFL_REG_32
) ? 32
16442 : (reg_size
== AFL_REG_64
) ? 64
16443 : (reg_size
== AFL_REG_128
) ? 128
16448 process_mips_specific (Filedata
* filedata
)
16450 Elf_Internal_Dyn
* entry
;
16451 Elf_Internal_Shdr
*sect
= NULL
;
16452 size_t liblist_offset
= 0;
16453 size_t liblistno
= 0;
16454 size_t conflictsno
= 0;
16455 size_t options_offset
= 0;
16456 size_t conflicts_offset
= 0;
16457 size_t pltrelsz
= 0;
16459 bfd_vma pltgot
= 0;
16460 bfd_vma mips_pltgot
= 0;
16461 bfd_vma jmprel
= 0;
16462 bfd_vma local_gotno
= 0;
16463 bfd_vma gotsym
= 0;
16464 bfd_vma symtabno
= 0;
16465 bfd_boolean res
= TRUE
;
16467 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16468 display_mips_gnu_attribute
))
16471 sect
= find_section (filedata
, ".MIPS.abiflags");
16475 Elf_External_ABIFlags_v0
*abiflags_ext
;
16476 Elf_Internal_ABIFlags_v0 abiflags_in
;
16478 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16480 error (_("Corrupt MIPS ABI Flags section.\n"));
16485 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16486 sect
->sh_size
, _("MIPS ABI Flags section"));
16489 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16490 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16491 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16492 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16493 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16494 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16495 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16496 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16497 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16498 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16499 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16501 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16502 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16503 if (abiflags_in
.isa_rev
> 1)
16504 printf ("r%d", abiflags_in
.isa_rev
);
16505 printf ("\nGPR size: %d",
16506 get_mips_reg_size (abiflags_in
.gpr_size
));
16507 printf ("\nCPR1 size: %d",
16508 get_mips_reg_size (abiflags_in
.cpr1_size
));
16509 printf ("\nCPR2 size: %d",
16510 get_mips_reg_size (abiflags_in
.cpr2_size
));
16511 fputs ("\nFP ABI: ", stdout
);
16512 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16513 fputs ("ISA Extension: ", stdout
);
16514 print_mips_isa_ext (abiflags_in
.isa_ext
);
16515 fputs ("\nASEs:", stdout
);
16516 print_mips_ases (abiflags_in
.ases
);
16517 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16518 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16519 fputc ('\n', stdout
);
16520 free (abiflags_ext
);
16525 /* We have a lot of special sections. Thanks SGI! */
16526 if (dynamic_section
== NULL
)
16528 /* No dynamic information available. See if there is static GOT. */
16529 sect
= find_section (filedata
, ".got");
16532 unsigned char *data_end
;
16533 unsigned char *data
;
16537 pltgot
= sect
->sh_addr
;
16540 addr_size
= (is_32bit_elf
? 4 : 8);
16541 end
= pltgot
+ sect
->sh_size
;
16543 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16545 _("Global Offset Table data"));
16546 /* PR 12855: Null data is handled gracefully throughout. */
16547 data_end
= data
+ (end
- pltgot
);
16549 printf (_("\nStatic GOT:\n"));
16550 printf (_(" Canonical gp value: "));
16551 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16554 /* In a dynamic binary GOT[0] is reserved for the dynamic
16555 loader to store the lazy resolver pointer, however in
16556 a static binary it may well have been omitted and GOT
16557 reduced to a table of addresses.
16558 PR 21344: Check for the entry being fully available
16559 before fetching it. */
16561 && data
+ ent
- pltgot
+ addr_size
<= data_end
16562 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16564 printf (_(" Reserved entries:\n"));
16565 printf (_(" %*s %10s %*s\n"),
16566 addr_size
* 2, _("Address"), _("Access"),
16567 addr_size
* 2, _("Value"));
16568 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16570 if (ent
== (bfd_vma
) -1)
16571 goto sgot_print_fail
;
16573 /* Check for the MSB of GOT[1] being set, identifying a
16574 GNU object. This entry will be used by some runtime
16575 loaders, to store the module pointer. Otherwise this
16576 is an ordinary local entry.
16577 PR 21344: Check for the entry being fully available
16578 before fetching it. */
16580 && data
+ ent
- pltgot
+ addr_size
<= data_end
16581 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16582 >> (addr_size
* 8 - 1)) != 0)
16584 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16586 if (ent
== (bfd_vma
) -1)
16587 goto sgot_print_fail
;
16592 if (data
!= NULL
&& ent
< end
)
16594 printf (_(" Local entries:\n"));
16595 printf (" %*s %10s %*s\n",
16596 addr_size
* 2, _("Address"), _("Access"),
16597 addr_size
* 2, _("Value"));
16600 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16602 if (ent
== (bfd_vma
) -1)
16603 goto sgot_print_fail
;
16615 for (entry
= dynamic_section
;
16616 /* PR 17531 file: 012-50589-0.004. */
16617 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16619 switch (entry
->d_tag
)
16621 case DT_MIPS_LIBLIST
:
16623 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16624 liblistno
* sizeof (Elf32_External_Lib
));
16626 case DT_MIPS_LIBLISTNO
:
16627 liblistno
= entry
->d_un
.d_val
;
16629 case DT_MIPS_OPTIONS
:
16630 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16632 case DT_MIPS_CONFLICT
:
16634 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16635 conflictsno
* sizeof (Elf32_External_Conflict
));
16637 case DT_MIPS_CONFLICTNO
:
16638 conflictsno
= entry
->d_un
.d_val
;
16641 pltgot
= entry
->d_un
.d_ptr
;
16643 case DT_MIPS_LOCAL_GOTNO
:
16644 local_gotno
= entry
->d_un
.d_val
;
16646 case DT_MIPS_GOTSYM
:
16647 gotsym
= entry
->d_un
.d_val
;
16649 case DT_MIPS_SYMTABNO
:
16650 symtabno
= entry
->d_un
.d_val
;
16652 case DT_MIPS_PLTGOT
:
16653 mips_pltgot
= entry
->d_un
.d_ptr
;
16656 pltrel
= entry
->d_un
.d_val
;
16659 pltrelsz
= entry
->d_un
.d_val
;
16662 jmprel
= entry
->d_un
.d_ptr
;
16668 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16670 Elf32_External_Lib
* elib
;
16673 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16674 sizeof (Elf32_External_Lib
),
16676 _("liblist section data"));
16679 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16680 "\nSection '.liblist' contains %lu entries:\n",
16681 (unsigned long) liblistno
),
16682 (unsigned long) liblistno
);
16683 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16686 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16693 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16694 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16695 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16696 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16697 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16699 tmp
= gmtime (&atime
);
16700 snprintf (timebuf
, sizeof (timebuf
),
16701 "%04u-%02u-%02uT%02u:%02u:%02u",
16702 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16703 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16705 printf ("%3lu: ", (unsigned long) cnt
);
16706 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16707 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16709 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16710 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16711 liblist
.l_version
);
16713 if (liblist
.l_flags
== 0)
16717 static const struct
16724 { " EXACT_MATCH", LL_EXACT_MATCH
},
16725 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16726 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16727 { " EXPORTS", LL_EXPORTS
},
16728 { " DELAY_LOAD", LL_DELAY_LOAD
},
16729 { " DELTA", LL_DELTA
}
16731 int flags
= liblist
.l_flags
;
16734 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16735 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16737 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16738 flags
^= l_flags_vals
[fcnt
].bit
;
16741 printf (" %#x", (unsigned int) flags
);
16753 if (options_offset
!= 0)
16755 Elf_External_Options
* eopt
;
16758 sect
= filedata
->section_headers
;
16760 /* Find the section header so that we get the size. */
16761 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16762 /* PR 17533 file: 012-277276-0.004. */
16765 error (_("No MIPS_OPTIONS header found\n"));
16769 if (sect
->sh_size
< sizeof (* eopt
))
16771 error (_("The MIPS options section is too small.\n"));
16775 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16776 sect
->sh_size
, _("options"));
16779 Elf_Internal_Options
* iopt
;
16780 Elf_Internal_Options
* option
;
16781 Elf_Internal_Options
* iopt_end
;
16783 iopt
= (Elf_Internal_Options
*)
16784 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16787 error (_("Out of memory allocating space for MIPS options\n"));
16793 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16795 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16797 Elf_External_Options
* eoption
;
16799 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16801 option
->kind
= BYTE_GET (eoption
->kind
);
16802 option
->size
= BYTE_GET (eoption
->size
);
16803 option
->section
= BYTE_GET (eoption
->section
);
16804 option
->info
= BYTE_GET (eoption
->info
);
16806 /* PR 17531: file: ffa0fa3b. */
16807 if (option
->size
< sizeof (* eopt
)
16808 || offset
+ option
->size
> sect
->sh_size
)
16810 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16813 offset
+= option
->size
;
16819 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16820 "\nSection '%s' contains %d entries:\n",
16822 printable_section_name (filedata
, sect
), cnt
);
16831 switch (option
->kind
)
16834 /* This shouldn't happen. */
16835 printf (" NULL %d %lx", option
->section
, option
->info
);
16839 printf (" REGINFO ");
16840 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16842 Elf32_External_RegInfo
* ereg
;
16843 Elf32_RegInfo reginfo
;
16846 if (option
+ 2 > iopt_end
)
16848 printf (_("<corrupt>\n"));
16849 error (_("Truncated MIPS REGINFO option\n"));
16854 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16856 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16857 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16858 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16859 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16860 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16861 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16863 printf ("GPR %08lx GP 0x%lx\n",
16864 reginfo
.ri_gprmask
,
16865 (unsigned long) reginfo
.ri_gp_value
);
16866 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16867 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16868 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16873 Elf64_External_RegInfo
* ereg
;
16874 Elf64_Internal_RegInfo reginfo
;
16876 if (option
+ 2 > iopt_end
)
16878 printf (_("<corrupt>\n"));
16879 error (_("Truncated MIPS REGINFO option\n"));
16884 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16885 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16886 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16887 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16888 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16889 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16890 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16892 printf ("GPR %08lx GP 0x",
16893 reginfo
.ri_gprmask
);
16894 printf_vma (reginfo
.ri_gp_value
);
16897 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16898 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16899 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16904 case ODK_EXCEPTIONS
:
16905 fputs (" EXCEPTIONS fpe_min(", stdout
);
16906 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16907 fputs (") fpe_max(", stdout
);
16908 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16909 fputs (")", stdout
);
16911 if (option
->info
& OEX_PAGE0
)
16912 fputs (" PAGE0", stdout
);
16913 if (option
->info
& OEX_SMM
)
16914 fputs (" SMM", stdout
);
16915 if (option
->info
& OEX_FPDBUG
)
16916 fputs (" FPDBUG", stdout
);
16917 if (option
->info
& OEX_DISMISS
)
16918 fputs (" DISMISS", stdout
);
16922 fputs (" PAD ", stdout
);
16923 if (option
->info
& OPAD_PREFIX
)
16924 fputs (" PREFIX", stdout
);
16925 if (option
->info
& OPAD_POSTFIX
)
16926 fputs (" POSTFIX", stdout
);
16927 if (option
->info
& OPAD_SYMBOL
)
16928 fputs (" SYMBOL", stdout
);
16932 fputs (" HWPATCH ", stdout
);
16933 if (option
->info
& OHW_R4KEOP
)
16934 fputs (" R4KEOP", stdout
);
16935 if (option
->info
& OHW_R8KPFETCH
)
16936 fputs (" R8KPFETCH", stdout
);
16937 if (option
->info
& OHW_R5KEOP
)
16938 fputs (" R5KEOP", stdout
);
16939 if (option
->info
& OHW_R5KCVTL
)
16940 fputs (" R5KCVTL", stdout
);
16944 fputs (" FILL ", stdout
);
16945 /* XXX Print content of info word? */
16949 fputs (" TAGS ", stdout
);
16950 /* XXX Print content of info word? */
16954 fputs (" HWAND ", stdout
);
16955 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16956 fputs (" R4KEOP_CHECKED", stdout
);
16957 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16958 fputs (" R4KEOP_CLEAN", stdout
);
16962 fputs (" HWOR ", stdout
);
16963 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16964 fputs (" R4KEOP_CHECKED", stdout
);
16965 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16966 fputs (" R4KEOP_CLEAN", stdout
);
16970 printf (" GP_GROUP %#06lx self-contained %#06lx",
16971 option
->info
& OGP_GROUP
,
16972 (option
->info
& OGP_SELF
) >> 16);
16976 printf (" IDENT %#06lx self-contained %#06lx",
16977 option
->info
& OGP_GROUP
,
16978 (option
->info
& OGP_SELF
) >> 16);
16982 /* This shouldn't happen. */
16983 printf (" %3d ??? %d %lx",
16984 option
->kind
, option
->section
, option
->info
);
16988 len
= sizeof (* eopt
);
16989 while (len
< option
->size
)
16991 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16993 if (ISPRINT (datum
))
16994 printf ("%c", datum
);
16996 printf ("\\%03o", datum
);
16999 fputs ("\n", stdout
);
17001 offset
+= option
->size
;
17011 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17013 Elf32_Conflict
* iconf
;
17016 if (dynamic_symbols
== NULL
)
17018 error (_("conflict list found without a dynamic symbol table\n"));
17022 /* PR 21345 - print a slightly more helpful error message
17023 if we are sure that the cmalloc will fail. */
17024 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
17026 error (_("Overlarge number of conflicts detected: %lx\n"),
17027 (long) conflictsno
);
17031 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17034 error (_("Out of memory allocating space for dynamic conflicts\n"));
17040 Elf32_External_Conflict
* econf32
;
17042 econf32
= (Elf32_External_Conflict
*)
17043 get_data (NULL
, filedata
, conflicts_offset
,
17044 sizeof (*econf32
), conflictsno
, _("conflict"));
17048 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17049 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17055 Elf64_External_Conflict
* econf64
;
17057 econf64
= (Elf64_External_Conflict
*)
17058 get_data (NULL
, filedata
, conflicts_offset
,
17059 sizeof (*econf64
), conflictsno
, _("conflict"));
17063 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17064 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17069 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17070 "\nSection '.conflict' contains %lu entries:\n",
17071 (unsigned long) conflictsno
),
17072 (unsigned long) conflictsno
);
17073 puts (_(" Num: Index Value Name"));
17075 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17077 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17079 if (iconf
[cnt
] >= num_dynamic_syms
)
17080 printf (_("<corrupt symbol index>"));
17083 Elf_Internal_Sym
* psym
;
17085 psym
= & dynamic_symbols
[iconf
[cnt
]];
17086 print_vma (psym
->st_value
, FULL_HEX
);
17088 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17089 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
17091 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17099 if (pltgot
!= 0 && local_gotno
!= 0)
17101 bfd_vma ent
, local_end
, global_end
;
17103 unsigned char * data
;
17104 unsigned char * data_end
;
17108 addr_size
= (is_32bit_elf
? 4 : 8);
17109 local_end
= pltgot
+ local_gotno
* addr_size
;
17111 /* PR binutils/17533 file: 012-111227-0.004 */
17112 if (symtabno
< gotsym
)
17114 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17115 (unsigned long) gotsym
, (unsigned long) symtabno
);
17119 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17120 /* PR 17531: file: 54c91a34. */
17121 if (global_end
< local_end
)
17123 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17127 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17128 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17129 global_end
- pltgot
, 1,
17130 _("Global Offset Table data"));
17131 /* PR 12855: Null data is handled gracefully throughout. */
17132 data_end
= data
+ (global_end
- pltgot
);
17134 printf (_("\nPrimary GOT:\n"));
17135 printf (_(" Canonical gp value: "));
17136 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17139 printf (_(" Reserved entries:\n"));
17140 printf (_(" %*s %10s %*s Purpose\n"),
17141 addr_size
* 2, _("Address"), _("Access"),
17142 addr_size
* 2, _("Initial"));
17143 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17144 printf (_(" Lazy resolver\n"));
17145 if (ent
== (bfd_vma
) -1)
17146 goto got_print_fail
;
17148 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17149 This entry will be used by some runtime loaders, to store the
17150 module pointer. Otherwise this is an ordinary local entry.
17151 PR 21344: Check for the entry being fully available before
17154 && data
+ ent
- pltgot
+ addr_size
<= data_end
17155 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17156 >> (addr_size
* 8 - 1)) != 0)
17158 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17159 printf (_(" Module pointer (GNU extension)\n"));
17160 if (ent
== (bfd_vma
) -1)
17161 goto got_print_fail
;
17165 if (data
!= NULL
&& ent
< local_end
)
17167 printf (_(" Local entries:\n"));
17168 printf (" %*s %10s %*s\n",
17169 addr_size
* 2, _("Address"), _("Access"),
17170 addr_size
* 2, _("Initial"));
17171 while (ent
< local_end
)
17173 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17175 if (ent
== (bfd_vma
) -1)
17176 goto got_print_fail
;
17181 if (data
!= NULL
&& gotsym
< symtabno
)
17185 printf (_(" Global entries:\n"));
17186 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17187 addr_size
* 2, _("Address"),
17189 addr_size
* 2, _("Initial"),
17190 addr_size
* 2, _("Sym.Val."),
17192 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17193 _("Ndx"), _("Name"));
17195 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17197 for (i
= gotsym
; i
< symtabno
; i
++)
17199 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17202 if (dynamic_symbols
== NULL
)
17203 printf (_("<no dynamic symbols>"));
17204 else if (i
< num_dynamic_syms
)
17206 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17208 print_vma (psym
->st_value
, LONG_HEX
);
17209 printf (" %-7s %3s ",
17210 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17211 get_symbol_index_type (filedata
, psym
->st_shndx
));
17213 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17214 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17216 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17219 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17220 (unsigned long) i
);
17223 if (ent
== (bfd_vma
) -1)
17234 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17237 size_t offset
, rel_offset
;
17238 unsigned long count
, i
;
17239 unsigned char * data
;
17240 int addr_size
, sym_width
;
17241 Elf_Internal_Rela
* rels
;
17243 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17244 if (pltrel
== DT_RELA
)
17246 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17251 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17256 addr_size
= (is_32bit_elf
? 4 : 8);
17257 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17259 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17260 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17261 1, _("Procedure Linkage Table data"));
17265 printf ("\nPLT GOT:\n\n");
17266 printf (_(" Reserved entries:\n"));
17267 printf (_(" %*s %*s Purpose\n"),
17268 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17269 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17270 printf (_(" PLT lazy resolver\n"));
17271 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17272 printf (_(" Module pointer\n"));
17275 printf (_(" Entries:\n"));
17276 printf (" %*s %*s %*s %-7s %3s %s\n",
17277 addr_size
* 2, _("Address"),
17278 addr_size
* 2, _("Initial"),
17279 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17280 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17281 for (i
= 0; i
< count
; i
++)
17283 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17285 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17288 if (idx
>= num_dynamic_syms
)
17289 printf (_("<corrupt symbol index: %lu>"), idx
);
17292 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17294 print_vma (psym
->st_value
, LONG_HEX
);
17295 printf (" %-7s %3s ",
17296 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17297 get_symbol_index_type (filedata
, psym
->st_shndx
));
17298 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17299 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17301 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17316 process_nds32_specific (Filedata
* filedata
)
17318 Elf_Internal_Shdr
*sect
= NULL
;
17320 sect
= find_section (filedata
, ".nds32_e_flags");
17323 unsigned int *flag
;
17325 printf ("\nNDS32 elf flags section:\n");
17326 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17327 sect
->sh_size
, _("NDS32 elf flags section"));
17332 switch ((*flag
) & 0x3)
17335 printf ("(VEC_SIZE):\tNo entry.\n");
17338 printf ("(VEC_SIZE):\t4 bytes\n");
17341 printf ("(VEC_SIZE):\t16 bytes\n");
17344 printf ("(VEC_SIZE):\treserved\n");
17353 process_gnu_liblist (Filedata
* filedata
)
17355 Elf_Internal_Shdr
* section
;
17356 Elf_Internal_Shdr
* string_sec
;
17357 Elf32_External_Lib
* elib
;
17359 size_t strtab_size
;
17361 unsigned long num_liblist
;
17363 bfd_boolean res
= TRUE
;
17368 for (i
= 0, section
= filedata
->section_headers
;
17369 i
< filedata
->file_header
.e_shnum
;
17372 switch (section
->sh_type
)
17374 case SHT_GNU_LIBLIST
:
17375 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17378 elib
= (Elf32_External_Lib
*)
17379 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17380 _("liblist section data"));
17388 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17389 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17390 string_sec
->sh_size
,
17391 _("liblist string table"));
17393 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17400 strtab_size
= string_sec
->sh_size
;
17402 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17403 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17404 "\nLibrary list section '%s' contains %lu entries:\n",
17406 printable_section_name (filedata
, section
),
17409 puts (_(" Library Time Stamp Checksum Version Flags"));
17411 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17419 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17420 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17421 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17422 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17423 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17425 tmp
= gmtime (&atime
);
17426 snprintf (timebuf
, sizeof (timebuf
),
17427 "%04u-%02u-%02uT%02u:%02u:%02u",
17428 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17429 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17431 printf ("%3lu: ", (unsigned long) cnt
);
17433 printf ("%-20s", liblist
.l_name
< strtab_size
17434 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17436 printf ("%-20.20s", liblist
.l_name
< strtab_size
17437 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17438 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17439 liblist
.l_version
, liblist
.l_flags
);
17450 static const char *
17451 get_note_type (Filedata
* filedata
, unsigned e_type
)
17453 static char buff
[64];
17455 if (filedata
->file_header
.e_type
== ET_CORE
)
17459 return _("NT_AUXV (auxiliary vector)");
17461 return _("NT_PRSTATUS (prstatus structure)");
17463 return _("NT_FPREGSET (floating point registers)");
17465 return _("NT_PRPSINFO (prpsinfo structure)");
17466 case NT_TASKSTRUCT
:
17467 return _("NT_TASKSTRUCT (task structure)");
17469 return _("NT_PRXFPREG (user_xfpregs structure)");
17471 return _("NT_PPC_VMX (ppc Altivec registers)");
17473 return _("NT_PPC_VSX (ppc VSX registers)");
17475 return _("NT_PPC_TAR (ppc TAR register)");
17477 return _("NT_PPC_PPR (ppc PPR register)");
17479 return _("NT_PPC_DSCR (ppc DSCR register)");
17481 return _("NT_PPC_EBB (ppc EBB registers)");
17483 return _("NT_PPC_PMU (ppc PMU registers)");
17484 case NT_PPC_TM_CGPR
:
17485 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17486 case NT_PPC_TM_CFPR
:
17487 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17488 case NT_PPC_TM_CVMX
:
17489 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17490 case NT_PPC_TM_CVSX
:
17491 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17492 case NT_PPC_TM_SPR
:
17493 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17494 case NT_PPC_TM_CTAR
:
17495 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17496 case NT_PPC_TM_CPPR
:
17497 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17498 case NT_PPC_TM_CDSCR
:
17499 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17501 return _("NT_386_TLS (x86 TLS information)");
17502 case NT_386_IOPERM
:
17503 return _("NT_386_IOPERM (x86 I/O permissions)");
17504 case NT_X86_XSTATE
:
17505 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17506 case NT_S390_HIGH_GPRS
:
17507 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17508 case NT_S390_TIMER
:
17509 return _("NT_S390_TIMER (s390 timer register)");
17510 case NT_S390_TODCMP
:
17511 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17512 case NT_S390_TODPREG
:
17513 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17515 return _("NT_S390_CTRS (s390 control registers)");
17516 case NT_S390_PREFIX
:
17517 return _("NT_S390_PREFIX (s390 prefix register)");
17518 case NT_S390_LAST_BREAK
:
17519 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17520 case NT_S390_SYSTEM_CALL
:
17521 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17523 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17524 case NT_S390_VXRS_LOW
:
17525 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17526 case NT_S390_VXRS_HIGH
:
17527 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17528 case NT_S390_GS_CB
:
17529 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17530 case NT_S390_GS_BC
:
17531 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17533 return _("NT_ARM_VFP (arm VFP registers)");
17535 return _("NT_ARM_TLS (AArch TLS registers)");
17536 case NT_ARM_HW_BREAK
:
17537 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17538 case NT_ARM_HW_WATCH
:
17539 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17541 return _("NT_PSTATUS (pstatus structure)");
17543 return _("NT_FPREGS (floating point registers)");
17545 return _("NT_PSINFO (psinfo structure)");
17547 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17549 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17550 case NT_WIN32PSTATUS
:
17551 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17553 return _("NT_SIGINFO (siginfo_t data)");
17555 return _("NT_FILE (mapped files)");
17563 return _("NT_VERSION (version)");
17565 return _("NT_ARCH (architecture)");
17566 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17568 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17574 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17579 print_core_note (Elf_Internal_Note
*pnote
)
17581 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17582 bfd_vma count
, page_size
;
17583 unsigned char *descdata
, *filenames
, *descend
;
17585 if (pnote
->type
!= NT_FILE
)
17595 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17596 /* Still "successful". */
17601 if (pnote
->descsz
< 2 * addr_size
)
17603 error (_(" Malformed note - too short for header\n"));
17607 descdata
= (unsigned char *) pnote
->descdata
;
17608 descend
= descdata
+ pnote
->descsz
;
17610 if (descdata
[pnote
->descsz
- 1] != '\0')
17612 error (_(" Malformed note - does not end with \\0\n"));
17616 count
= byte_get (descdata
, addr_size
);
17617 descdata
+= addr_size
;
17619 page_size
= byte_get (descdata
, addr_size
);
17620 descdata
+= addr_size
;
17622 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17623 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17625 error (_(" Malformed note - too short for supplied file count\n"));
17629 printf (_(" Page size: "));
17630 print_vma (page_size
, DEC
);
17633 printf (_(" %*s%*s%*s\n"),
17634 (int) (2 + 2 * addr_size
), _("Start"),
17635 (int) (4 + 2 * addr_size
), _("End"),
17636 (int) (4 + 2 * addr_size
), _("Page Offset"));
17637 filenames
= descdata
+ count
* 3 * addr_size
;
17638 while (count
-- > 0)
17640 bfd_vma start
, end
, file_ofs
;
17642 if (filenames
== descend
)
17644 error (_(" Malformed note - filenames end too early\n"));
17648 start
= byte_get (descdata
, addr_size
);
17649 descdata
+= addr_size
;
17650 end
= byte_get (descdata
, addr_size
);
17651 descdata
+= addr_size
;
17652 file_ofs
= byte_get (descdata
, addr_size
);
17653 descdata
+= addr_size
;
17656 print_vma (start
, FULL_HEX
);
17658 print_vma (end
, FULL_HEX
);
17660 print_vma (file_ofs
, FULL_HEX
);
17661 printf ("\n %s\n", filenames
);
17663 filenames
+= 1 + strlen ((char *) filenames
);
17669 static const char *
17670 get_gnu_elf_note_type (unsigned e_type
)
17672 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17675 case NT_GNU_ABI_TAG
:
17676 return _("NT_GNU_ABI_TAG (ABI version tag)");
17678 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17679 case NT_GNU_BUILD_ID
:
17680 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17681 case NT_GNU_GOLD_VERSION
:
17682 return _("NT_GNU_GOLD_VERSION (gold version)");
17683 case NT_GNU_PROPERTY_TYPE_0
:
17684 return _("NT_GNU_PROPERTY_TYPE_0");
17685 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17686 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17687 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17688 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17691 static char buff
[64];
17693 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17700 decode_x86_compat_isa (unsigned int bitmask
)
17704 unsigned int bit
= bitmask
& (- bitmask
);
17709 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17712 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17715 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17718 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17721 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17724 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17727 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17730 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17733 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17736 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17739 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17742 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17743 printf ("AVX512F");
17745 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17746 printf ("AVX512CD");
17748 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17749 printf ("AVX512ER");
17751 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17752 printf ("AVX512PF");
17754 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17755 printf ("AVX512VL");
17757 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17758 printf ("AVX512DQ");
17760 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17761 printf ("AVX512BW");
17764 printf (_("<unknown: %x>"), bit
);
17773 decode_x86_isa (unsigned int bitmask
)
17777 printf (_("<None>"));
17783 unsigned int bit
= bitmask
& (- bitmask
);
17788 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17791 case GNU_PROPERTY_X86_ISA_1_SSE
:
17794 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17797 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17800 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17803 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17806 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17809 case GNU_PROPERTY_X86_ISA_1_AVX
:
17812 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17815 case GNU_PROPERTY_X86_ISA_1_FMA
:
17818 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17819 printf ("AVX512F");
17821 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17822 printf ("AVX512CD");
17824 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17825 printf ("AVX512ER");
17827 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17828 printf ("AVX512PF");
17830 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17831 printf ("AVX512VL");
17833 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17834 printf ("AVX512DQ");
17836 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17837 printf ("AVX512BW");
17839 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17840 printf ("AVX512_4FMAPS");
17842 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17843 printf ("AVX512_4VNNIW");
17845 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17846 printf ("AVX512_BITALG");
17848 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17849 printf ("AVX512_IFMA");
17851 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17852 printf ("AVX512_VBMI");
17854 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17855 printf ("AVX512_VBMI2");
17857 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17858 printf ("AVX512_VNNI");
17860 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17861 printf ("AVX512_BF16");
17864 printf (_("<unknown: %x>"), bit
);
17873 decode_x86_feature_1 (unsigned int bitmask
)
17877 printf (_("<None>"));
17883 unsigned int bit
= bitmask
& (- bitmask
);
17888 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17891 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17895 printf (_("<unknown: %x>"), bit
);
17904 decode_x86_feature_2 (unsigned int bitmask
)
17908 printf (_("<None>"));
17914 unsigned int bit
= bitmask
& (- bitmask
);
17919 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17922 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17925 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17928 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17931 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17934 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17937 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17940 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17943 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17944 printf ("XSAVEOPT");
17946 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17950 printf (_("<unknown: %x>"), bit
);
17959 decode_aarch64_feature_1_and (unsigned int bitmask
)
17963 unsigned int bit
= bitmask
& (- bitmask
);
17968 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17972 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17977 printf (_("<unknown: %x>"), bit
);
17986 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17988 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17989 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17990 unsigned int size
= is_32bit_elf
? 4 : 8;
17992 printf (_(" Properties: "));
17994 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17996 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18000 while (ptr
< ptr_end
)
18004 unsigned int datasz
;
18006 if ((size_t) (ptr_end
- ptr
) < 8)
18008 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18012 type
= byte_get (ptr
, 4);
18013 datasz
= byte_get (ptr
+ 4, 4);
18017 if (datasz
> (size_t) (ptr_end
- ptr
))
18019 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18024 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18026 if (filedata
->file_header
.e_machine
== EM_X86_64
18027 || filedata
->file_header
.e_machine
== EM_IAMCU
18028 || filedata
->file_header
.e_machine
== EM_386
)
18030 unsigned int bitmask
;
18033 bitmask
= byte_get (ptr
, 4);
18039 case GNU_PROPERTY_X86_ISA_1_USED
:
18041 printf (_("x86 ISA used: <corrupt length: %#x> "),
18045 printf ("x86 ISA used: ");
18046 decode_x86_isa (bitmask
);
18050 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18052 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18056 printf ("x86 ISA needed: ");
18057 decode_x86_isa (bitmask
);
18061 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18063 printf (_("x86 feature: <corrupt length: %#x> "),
18067 printf ("x86 feature: ");
18068 decode_x86_feature_1 (bitmask
);
18072 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18074 printf (_("x86 feature used: <corrupt length: %#x> "),
18078 printf ("x86 feature used: ");
18079 decode_x86_feature_2 (bitmask
);
18083 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18085 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18088 printf ("x86 feature needed: ");
18089 decode_x86_feature_2 (bitmask
);
18093 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18095 printf (_("x86 ISA used: <corrupt length: %#x> "),
18099 printf ("x86 ISA used: ");
18100 decode_x86_compat_isa (bitmask
);
18104 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18106 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18110 printf ("x86 ISA needed: ");
18111 decode_x86_compat_isa (bitmask
);
18119 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18121 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18123 printf ("AArch64 feature: ");
18125 printf (_("<corrupt length: %#x> "), datasz
);
18127 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18136 case GNU_PROPERTY_STACK_SIZE
:
18137 printf (_("stack size: "));
18138 if (datasz
!= size
)
18139 printf (_("<corrupt length: %#x> "), datasz
);
18141 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18144 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18145 printf ("no copy on protected ");
18147 printf (_("<corrupt length: %#x> "), datasz
);
18155 if (type
< GNU_PROPERTY_LOPROC
)
18156 printf (_("<unknown type %#x data: "), type
);
18157 else if (type
< GNU_PROPERTY_LOUSER
)
18158 printf (_("<procesor-specific type %#x data: "), type
);
18160 printf (_("<application-specific type %#x data: "), type
);
18161 for (j
= 0; j
< datasz
; ++j
)
18162 printf ("%02x ", ptr
[j
] & 0xff);
18166 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18167 if (ptr
== ptr_end
)
18180 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18182 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18183 switch (pnote
->type
)
18185 case NT_GNU_BUILD_ID
:
18189 printf (_(" Build ID: "));
18190 for (i
= 0; i
< pnote
->descsz
; ++i
)
18191 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18196 case NT_GNU_ABI_TAG
:
18198 unsigned long os
, major
, minor
, subminor
;
18199 const char *osname
;
18201 /* PR 17531: file: 030-599401-0.004. */
18202 if (pnote
->descsz
< 16)
18204 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18208 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18209 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18210 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18211 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18215 case GNU_ABI_TAG_LINUX
:
18218 case GNU_ABI_TAG_HURD
:
18221 case GNU_ABI_TAG_SOLARIS
:
18222 osname
= "Solaris";
18224 case GNU_ABI_TAG_FREEBSD
:
18225 osname
= "FreeBSD";
18227 case GNU_ABI_TAG_NETBSD
:
18230 case GNU_ABI_TAG_SYLLABLE
:
18231 osname
= "Syllable";
18233 case GNU_ABI_TAG_NACL
:
18237 osname
= "Unknown";
18241 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18242 major
, minor
, subminor
);
18246 case NT_GNU_GOLD_VERSION
:
18250 printf (_(" Version: "));
18251 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18252 printf ("%c", pnote
->descdata
[i
]);
18259 unsigned long num_entries
, mask
;
18261 /* Hardware capabilities information. Word 0 is the number of entries.
18262 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18263 is a series of entries, where each entry is a single byte followed
18264 by a nul terminated string. The byte gives the bit number to test
18265 if enabled in the bitmask. */
18266 printf (_(" Hardware Capabilities: "));
18267 if (pnote
->descsz
< 8)
18269 error (_("<corrupt GNU_HWCAP>\n"));
18272 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18273 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18274 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18275 /* FIXME: Add code to display the entries... */
18279 case NT_GNU_PROPERTY_TYPE_0
:
18280 print_gnu_property_note (filedata
, pnote
);
18284 /* Handle unrecognised types. An error message should have already been
18285 created by get_gnu_elf_note_type(), so all that we need to do is to
18286 display the data. */
18290 printf (_(" Description data: "));
18291 for (i
= 0; i
< pnote
->descsz
; ++i
)
18292 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18301 static const char *
18302 get_v850_elf_note_type (enum v850_notes n_type
)
18304 static char buff
[64];
18308 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18309 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18310 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18311 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18312 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18313 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18315 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18321 print_v850_note (Elf_Internal_Note
* pnote
)
18325 if (pnote
->descsz
!= 4)
18328 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18332 printf (_("not set\n"));
18336 switch (pnote
->type
)
18338 case V850_NOTE_ALIGNMENT
:
18341 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18342 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18346 case V850_NOTE_DATA_SIZE
:
18349 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18350 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18354 case V850_NOTE_FPU_INFO
:
18357 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18358 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18362 case V850_NOTE_MMU_INFO
:
18363 case V850_NOTE_CACHE_INFO
:
18364 case V850_NOTE_SIMD_INFO
:
18365 if (val
== EF_RH850_SIMD
)
18367 printf (_("yes\n"));
18373 /* An 'unknown note type' message will already have been displayed. */
18377 printf (_("unknown value: %x\n"), val
);
18382 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18384 unsigned int version
;
18386 switch (pnote
->type
)
18388 case NT_NETBSD_IDENT
:
18389 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18390 if ((version
/ 10000) % 100)
18391 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18392 version
, version
/ 100000000, (version
/ 1000000) % 100,
18393 (version
/ 10000) % 100 > 26 ? "Z" : "",
18394 'A' + (version
/ 10000) % 26);
18396 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18397 version
, version
/ 100000000, (version
/ 1000000) % 100,
18398 (version
/ 100) % 100);
18401 case NT_NETBSD_MARCH
:
18402 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18406 #ifdef NT_NETBSD_PAX
18407 case NT_NETBSD_PAX
:
18408 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18409 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18410 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18411 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18412 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18413 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18414 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18415 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18420 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
18426 static const char *
18427 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18431 case NT_FREEBSD_THRMISC
:
18432 return _("NT_THRMISC (thrmisc structure)");
18433 case NT_FREEBSD_PROCSTAT_PROC
:
18434 return _("NT_PROCSTAT_PROC (proc data)");
18435 case NT_FREEBSD_PROCSTAT_FILES
:
18436 return _("NT_PROCSTAT_FILES (files data)");
18437 case NT_FREEBSD_PROCSTAT_VMMAP
:
18438 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18439 case NT_FREEBSD_PROCSTAT_GROUPS
:
18440 return _("NT_PROCSTAT_GROUPS (groups data)");
18441 case NT_FREEBSD_PROCSTAT_UMASK
:
18442 return _("NT_PROCSTAT_UMASK (umask data)");
18443 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18444 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18445 case NT_FREEBSD_PROCSTAT_OSREL
:
18446 return _("NT_PROCSTAT_OSREL (osreldate data)");
18447 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18448 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18449 case NT_FREEBSD_PROCSTAT_AUXV
:
18450 return _("NT_PROCSTAT_AUXV (auxv data)");
18451 case NT_FREEBSD_PTLWPINFO
:
18452 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18454 return get_note_type (filedata
, e_type
);
18457 static const char *
18458 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18460 static char buff
[64];
18464 case NT_NETBSDCORE_PROCINFO
:
18465 /* NetBSD core "procinfo" structure. */
18466 return _("NetBSD procinfo structure");
18468 #ifdef NT_NETBSDCORE_AUXV
18469 case NT_NETBSDCORE_AUXV
:
18470 return _("NetBSD ELF auxiliary vector data");
18473 #ifdef NT_NETBSDCORE_LWPSTATUS
18474 case NT_NETBSDCORE_LWPSTATUS
:
18475 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18479 /* As of Jan 2020 there are no other machine-independent notes
18480 defined for NetBSD core files. If the note type is less
18481 than the start of the machine-dependent note types, we don't
18484 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18486 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18492 switch (filedata
->file_header
.e_machine
)
18494 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18495 and PT_GETFPREGS == mach+2. */
18500 case EM_SPARC32PLUS
:
18504 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18505 return _("PT_GETREGS (reg structure)");
18506 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18507 return _("PT_GETFPREGS (fpreg structure)");
18513 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18514 There's also old PT___GETREGS40 == mach + 1 for old reg
18515 structure which lacks GBR. */
18519 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18520 return _("PT___GETREGS40 (old reg structure)");
18521 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18522 return _("PT_GETREGS (reg structure)");
18523 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18524 return _("PT_GETFPREGS (fpreg structure)");
18530 /* On all other arch's, PT_GETREGS == mach+1 and
18531 PT_GETFPREGS == mach+3. */
18535 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18536 return _("PT_GETREGS (reg structure)");
18537 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18538 return _("PT_GETFPREGS (fpreg structure)");
18544 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18545 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18549 static const char *
18550 get_stapsdt_note_type (unsigned e_type
)
18552 static char buff
[64];
18557 return _("NT_STAPSDT (SystemTap probe descriptors)");
18563 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18568 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18570 size_t len
, maxlen
;
18571 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18572 char *data
= pnote
->descdata
;
18573 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18574 bfd_vma pc
, base_addr
, semaphore
;
18575 char *provider
, *probe
, *arg_fmt
;
18577 if (pnote
->descsz
< (addr_size
* 3))
18578 goto stapdt_note_too_small
;
18580 pc
= byte_get ((unsigned char *) data
, addr_size
);
18583 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18586 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18589 if (data
>= data_end
)
18590 goto stapdt_note_too_small
;
18591 maxlen
= data_end
- data
;
18592 len
= strnlen (data
, maxlen
);
18599 goto stapdt_note_too_small
;
18601 if (data
>= data_end
)
18602 goto stapdt_note_too_small
;
18603 maxlen
= data_end
- data
;
18604 len
= strnlen (data
, maxlen
);
18611 goto stapdt_note_too_small
;
18613 if (data
>= data_end
)
18614 goto stapdt_note_too_small
;
18615 maxlen
= data_end
- data
;
18616 len
= strnlen (data
, maxlen
);
18623 goto stapdt_note_too_small
;
18625 printf (_(" Provider: %s\n"), provider
);
18626 printf (_(" Name: %s\n"), probe
);
18627 printf (_(" Location: "));
18628 print_vma (pc
, FULL_HEX
);
18629 printf (_(", Base: "));
18630 print_vma (base_addr
, FULL_HEX
);
18631 printf (_(", Semaphore: "));
18632 print_vma (semaphore
, FULL_HEX
);
18634 printf (_(" Arguments: %s\n"), arg_fmt
);
18636 return data
== data_end
;
18638 stapdt_note_too_small
:
18639 printf (_(" <corrupt - note is too small>\n"));
18640 error (_("corrupt stapdt note - the data size is too small\n"));
18644 static const char *
18645 get_ia64_vms_note_type (unsigned e_type
)
18647 static char buff
[64];
18652 return _("NT_VMS_MHD (module header)");
18654 return _("NT_VMS_LNM (language name)");
18656 return _("NT_VMS_SRC (source files)");
18658 return "NT_VMS_TITLE";
18660 return _("NT_VMS_EIDC (consistency check)");
18661 case NT_VMS_FPMODE
:
18662 return _("NT_VMS_FPMODE (FP mode)");
18663 case NT_VMS_LINKTIME
:
18664 return "NT_VMS_LINKTIME";
18665 case NT_VMS_IMGNAM
:
18666 return _("NT_VMS_IMGNAM (image name)");
18668 return _("NT_VMS_IMGID (image id)");
18669 case NT_VMS_LINKID
:
18670 return _("NT_VMS_LINKID (link id)");
18671 case NT_VMS_IMGBID
:
18672 return _("NT_VMS_IMGBID (build id)");
18673 case NT_VMS_GSTNAM
:
18674 return _("NT_VMS_GSTNAM (sym table name)");
18675 case NT_VMS_ORIG_DYN
:
18676 return "NT_VMS_ORIG_DYN";
18677 case NT_VMS_PATCHTIME
:
18678 return "NT_VMS_PATCHTIME";
18680 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18686 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18688 int maxlen
= pnote
->descsz
;
18690 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18691 goto desc_size_fail
;
18693 switch (pnote
->type
)
18697 goto desc_size_fail
;
18699 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18701 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18702 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18703 if (l
+ 34 < maxlen
)
18705 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18706 if (l
+ 35 < maxlen
)
18707 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18709 printf (_(" Module version : <missing>\n"));
18713 printf (_(" Module name : <missing>\n"));
18714 printf (_(" Module version : <missing>\n"));
18719 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18723 case NT_VMS_FPMODE
:
18724 printf (_(" Floating Point mode: "));
18726 goto desc_size_fail
;
18727 /* FIXME: Generate an error if descsz > 8 ? */
18729 printf ("0x%016" BFD_VMA_FMT
"x\n",
18730 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18733 case NT_VMS_LINKTIME
:
18734 printf (_(" Link time: "));
18736 goto desc_size_fail
;
18737 /* FIXME: Generate an error if descsz > 8 ? */
18740 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18744 case NT_VMS_PATCHTIME
:
18745 printf (_(" Patch time: "));
18747 goto desc_size_fail
;
18748 /* FIXME: Generate an error if descsz > 8 ? */
18751 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18755 case NT_VMS_ORIG_DYN
:
18757 goto desc_size_fail
;
18759 printf (_(" Major id: %u, minor id: %u\n"),
18760 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18761 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18762 printf (_(" Last modified : "));
18764 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18765 printf (_("\n Link flags : "));
18766 printf ("0x%016" BFD_VMA_FMT
"x\n",
18767 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18768 printf (_(" Header flags: 0x%08x\n"),
18769 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18770 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18774 case NT_VMS_IMGNAM
:
18775 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18778 case NT_VMS_GSTNAM
:
18779 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18783 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18786 case NT_VMS_LINKID
:
18787 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18797 printf (_(" <corrupt - data size is too small>\n"));
18798 error (_("corrupt IA64 note: data size is too small\n"));
18802 struct build_attr_cache
{
18803 Filedata
*filedata
;
18805 unsigned long strtablen
;
18806 Elf_Internal_Sym
*symtab
;
18807 unsigned long nsyms
;
18810 /* Find the symbol associated with a build attribute that is attached
18811 to address OFFSET. If PNAME is non-NULL then store the name of
18812 the symbol (if found) in the provided pointer, Returns NULL if a
18813 symbol could not be found. */
18815 static Elf_Internal_Sym
*
18816 get_symbol_for_build_attribute (Filedata
* filedata
,
18817 unsigned long offset
,
18818 bfd_boolean is_open_attr
,
18819 const char ** pname
)
18821 Elf_Internal_Sym
*saved_sym
= NULL
;
18822 Elf_Internal_Sym
*sym
;
18824 if (filedata
->section_headers
!= NULL
18825 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18827 Elf_Internal_Shdr
* symsec
;
18829 free (ba_cache
.strtab
);
18830 ba_cache
.strtab
= NULL
;
18831 free (ba_cache
.symtab
);
18832 ba_cache
.symtab
= NULL
;
18834 /* Load the symbol and string sections. */
18835 for (symsec
= filedata
->section_headers
;
18836 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18839 if (symsec
->sh_type
== SHT_SYMTAB
)
18841 ba_cache
.symtab
= GET_ELF_SYMBOLS (filedata
, symsec
,
18844 if (ba_cache
.symtab
!= NULL
18845 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18847 Elf_Internal_Shdr
*strtab_sec
18848 = filedata
->section_headers
+ symsec
->sh_link
;
18851 = (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18852 1, strtab_sec
->sh_size
,
18853 _("string table"));
18854 ba_cache
.strtablen
= strtab_sec
->sh_size
;
18856 if (ba_cache
.strtab
== NULL
)
18858 free (ba_cache
.symtab
);
18859 ba_cache
.symtab
= NULL
;
18861 if (ba_cache
.symtab
!= NULL
)
18865 ba_cache
.filedata
= filedata
;
18868 if (ba_cache
.symtab
== NULL
)
18871 /* Find a symbol whose value matches offset. */
18872 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18873 if (sym
->st_value
== offset
)
18875 if (sym
->st_name
>= ba_cache
.strtablen
)
18876 /* Huh ? This should not happen. */
18879 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18882 /* The AArch64 and ARM architectures define mapping symbols
18883 (eg $d, $x, $t) which we want to ignore. */
18884 if (ba_cache
.strtab
[sym
->st_name
] == '$'
18885 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
18886 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
18891 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18892 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18893 FUNC symbols entirely. */
18894 switch (ELF_ST_TYPE (sym
->st_info
))
18901 /* If the symbol has a size associated
18902 with it then we can stop searching. */
18903 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
18908 /* Ignore function symbols. */
18915 switch (ELF_ST_BIND (sym
->st_info
))
18918 if (saved_sym
== NULL
18919 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18924 if (saved_sym
== NULL
)
18934 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18942 if (saved_sym
&& pname
)
18943 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
18948 /* Returns true iff addr1 and addr2 are in the same section. */
18951 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18953 Elf_Internal_Shdr
* a1
;
18954 Elf_Internal_Shdr
* a2
;
18956 a1
= find_section_by_address (filedata
, addr1
);
18957 a2
= find_section_by_address (filedata
, addr2
);
18959 return a1
== a2
&& a1
!= NULL
;
18963 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18964 Filedata
* filedata
)
18966 static unsigned long global_offset
= 0;
18967 static unsigned long global_end
= 0;
18968 static unsigned long func_offset
= 0;
18969 static unsigned long func_end
= 0;
18971 Elf_Internal_Sym
* sym
;
18973 unsigned long start
;
18975 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18977 switch (pnote
->descsz
)
18980 /* A zero-length description means that the range of
18981 the previous note of the same type should be used. */
18984 if (global_end
> global_offset
)
18985 printf (_(" Applies to region from %#lx to %#lx\n"),
18986 global_offset
, global_end
);
18988 printf (_(" Applies to region from %#lx\n"), global_offset
);
18992 if (func_end
> func_offset
)
18993 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18995 printf (_(" Applies to region from %#lx\n"), func_offset
);
19000 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19007 /* FIXME: We should check that version 3+ notes are being used here... */
19008 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19009 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19013 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19019 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19020 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19024 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19025 printf (_(" <invalid descsz>"));
19030 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19031 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19032 in order to avoid them being confused with the start address of the
19033 first function in the file... */
19034 if (sym
== NULL
&& is_open_attr
)
19035 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19038 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19039 end
= start
+ sym
->st_size
;
19043 /* FIXME: Need to properly allow for section alignment.
19044 16 is just the alignment used on x86_64. */
19046 && start
> BFD_ALIGN (global_end
, 16)
19047 /* Build notes are not guaranteed to be organised in order of
19048 increasing address, but we should find the all of the notes
19049 for one section in the same place. */
19050 && same_section (filedata
, start
, global_end
))
19051 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19052 global_end
+ 1, start
- 1);
19054 printf (_(" Applies to region from %#lx"), start
);
19055 global_offset
= start
;
19059 printf (_(" to %#lx"), end
);
19065 printf (_(" Applies to region from %#lx"), start
);
19066 func_offset
= start
;
19070 printf (_(" to %#lx"), end
);
19076 printf (_(" (%s)"), name
);
19083 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19085 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19086 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19087 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19089 char name_attribute
;
19090 const char * expected_types
;
19091 const char * name
= pnote
->namedata
;
19095 if (name
== NULL
|| pnote
->namesz
< 2)
19097 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19098 print_symbol (-20, _(" <corrupt name>"));
19107 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19108 if (name
[0] == 'G' && name
[1] == 'A')
19110 if (pnote
->namesz
< 4)
19112 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19113 print_symbol (-20, _(" <corrupt name>"));
19122 switch ((name_type
= * name
))
19124 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19125 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19126 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19127 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19128 printf ("%c", * name
);
19132 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19133 print_symbol (-20, _("<unknown name type>"));
19140 switch ((name_attribute
= * name
))
19142 case GNU_BUILD_ATTRIBUTE_VERSION
:
19143 text
= _("<version>");
19144 expected_types
= string_expected
;
19147 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19148 text
= _("<stack prot>");
19149 expected_types
= "!+*";
19152 case GNU_BUILD_ATTRIBUTE_RELRO
:
19153 text
= _("<relro>");
19154 expected_types
= bool_expected
;
19157 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19158 text
= _("<stack size>");
19159 expected_types
= number_expected
;
19162 case GNU_BUILD_ATTRIBUTE_TOOL
:
19163 text
= _("<tool>");
19164 expected_types
= string_expected
;
19167 case GNU_BUILD_ATTRIBUTE_ABI
:
19169 expected_types
= "$*";
19172 case GNU_BUILD_ATTRIBUTE_PIC
:
19174 expected_types
= number_expected
;
19177 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19178 text
= _("<short enum>");
19179 expected_types
= bool_expected
;
19183 if (ISPRINT (* name
))
19185 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19187 if (len
> left
&& ! do_wide
)
19189 printf ("%.*s:", len
, name
);
19195 static char tmpbuf
[128];
19197 error (_("unrecognised byte in name field: %d\n"), * name
);
19198 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19202 expected_types
= "*$!+";
19207 left
-= printf ("%s", text
);
19209 if (strchr (expected_types
, name_type
) == NULL
)
19210 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19212 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19214 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19215 (unsigned long) pnote
->namesz
,
19216 (long) (name
- pnote
->namedata
));
19220 if (left
< 1 && ! do_wide
)
19225 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19227 unsigned int bytes
;
19228 unsigned long long val
= 0;
19229 unsigned int shift
= 0;
19230 char * decoded
= NULL
;
19232 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19234 /* The -1 is because the name field is always 0 terminated, and we
19235 want to be able to ensure that the shift in the while loop below
19236 will not overflow. */
19239 if (bytes
> sizeof (val
))
19241 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19243 bytes
= sizeof (val
);
19245 /* We do not bother to warn if bytes == 0 as this can
19246 happen with some early versions of the gcc plugin. */
19250 unsigned long byte
= (* name
++) & 0xff;
19252 val
|= byte
<< shift
;
19256 switch (name_attribute
)
19258 case GNU_BUILD_ATTRIBUTE_PIC
:
19261 case 0: decoded
= "static"; break;
19262 case 1: decoded
= "pic"; break;
19263 case 2: decoded
= "PIC"; break;
19264 case 3: decoded
= "pie"; break;
19265 case 4: decoded
= "PIE"; break;
19269 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19272 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19273 case 0: decoded
= "off"; break;
19274 case 1: decoded
= "on"; break;
19275 case 2: decoded
= "all"; break;
19276 case 3: decoded
= "strong"; break;
19277 case 4: decoded
= "explicit"; break;
19285 if (decoded
!= NULL
)
19287 print_symbol (-left
, decoded
);
19298 left
-= printf ("0x%llx", val
);
19300 left
-= printf ("0x%-.*llx", left
, val
);
19304 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19305 left
-= print_symbol (- left
, name
);
19307 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19308 left
-= print_symbol (- left
, "true");
19310 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19311 left
-= print_symbol (- left
, "false");
19315 if (do_wide
&& left
> 0)
19316 printf ("%-*s", left
, " ");
19321 /* Note that by the ELF standard, the name field is already null byte
19322 terminated, and namesz includes the terminating null byte.
19323 I.E. the value of namesz for the name "FSF" is 4.
19325 If the value of namesz is zero, there is no name present. */
19328 process_note (Elf_Internal_Note
* pnote
,
19329 Filedata
* filedata
)
19331 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19334 if (pnote
->namesz
== 0)
19335 /* If there is no note name, then use the default set of
19336 note type strings. */
19337 nt
= get_note_type (filedata
, pnote
->type
);
19339 else if (const_strneq (pnote
->namedata
, "GNU"))
19340 /* GNU-specific object file notes. */
19341 nt
= get_gnu_elf_note_type (pnote
->type
);
19343 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19344 /* FreeBSD-specific core file notes. */
19345 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19347 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19348 /* NetBSD-specific core file notes. */
19349 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19351 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19352 /* NetBSD-specific core file notes. */
19353 return process_netbsd_elf_note (pnote
);
19355 else if (const_strneq (pnote
->namedata
, "PaX"))
19356 /* NetBSD-specific core file notes. */
19357 return process_netbsd_elf_note (pnote
);
19359 else if (strneq (pnote
->namedata
, "SPU/", 4))
19361 /* SPU-specific core file notes. */
19362 nt
= pnote
->namedata
+ 4;
19366 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19367 /* VMS/ia64-specific file notes. */
19368 nt
= get_ia64_vms_note_type (pnote
->type
);
19370 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19371 nt
= get_stapsdt_note_type (pnote
->type
);
19374 /* Don't recognize this note name; just use the default set of
19375 note type strings. */
19376 nt
= get_note_type (filedata
, pnote
->type
);
19380 if (((const_strneq (pnote
->namedata
, "GA")
19381 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19382 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19383 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19384 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19385 print_gnu_build_attribute_name (pnote
);
19387 print_symbol (-20, name
);
19390 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19392 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19394 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19395 return print_ia64_vms_note (pnote
);
19396 else if (const_strneq (pnote
->namedata
, "GNU"))
19397 return print_gnu_note (filedata
, pnote
);
19398 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19399 return print_stapsdt_note (pnote
);
19400 else if (const_strneq (pnote
->namedata
, "CORE"))
19401 return print_core_note (pnote
);
19402 else if (((const_strneq (pnote
->namedata
, "GA")
19403 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19404 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19405 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19406 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19407 return print_gnu_build_attribute_description (pnote
, filedata
);
19413 printf (_(" description data: "));
19414 for (i
= 0; i
< pnote
->descsz
; i
++)
19415 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19427 process_notes_at (Filedata
* filedata
,
19428 Elf_Internal_Shdr
* section
,
19433 Elf_External_Note
* pnotes
;
19434 Elf_External_Note
* external
;
19436 bfd_boolean res
= TRUE
;
19443 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19446 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19454 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19457 if (pnotes
== NULL
)
19463 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19465 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19466 (unsigned long) offset
, (unsigned long) length
);
19468 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19469 specifies that notes should be aligned to 4 bytes in 32-bit
19470 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19471 we also support 4 byte alignment in 64-bit objects. If section
19472 alignment is less than 4, we treate alignment as 4 bytes. */
19475 else if (align
!= 4 && align
!= 8)
19477 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19483 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19485 end
= (char *) pnotes
+ length
;
19486 while ((char *) external
< end
)
19488 Elf_Internal_Note inote
;
19491 char * temp
= NULL
;
19492 size_t data_remaining
= end
- (char *) external
;
19494 if (!is_ia64_vms (filedata
))
19496 /* PR binutils/15191
19497 Make sure that there is enough data to read. */
19498 min_notesz
= offsetof (Elf_External_Note
, name
);
19499 if (data_remaining
< min_notesz
)
19501 warn (ngettext ("Corrupt note: only %ld byte remains, "
19502 "not enough for a full note\n",
19503 "Corrupt note: only %ld bytes remain, "
19504 "not enough for a full note\n",
19506 (long) data_remaining
);
19509 data_remaining
-= min_notesz
;
19511 inote
.type
= BYTE_GET (external
->type
);
19512 inote
.namesz
= BYTE_GET (external
->namesz
);
19513 inote
.namedata
= external
->name
;
19514 inote
.descsz
= BYTE_GET (external
->descsz
);
19515 inote
.descdata
= ((char *) external
19516 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19517 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19518 next
= ((char *) external
19519 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19523 Elf64_External_VMS_Note
*vms_external
;
19525 /* PR binutils/15191
19526 Make sure that there is enough data to read. */
19527 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19528 if (data_remaining
< min_notesz
)
19530 warn (ngettext ("Corrupt note: only %ld byte remains, "
19531 "not enough for a full note\n",
19532 "Corrupt note: only %ld bytes remain, "
19533 "not enough for a full note\n",
19535 (long) data_remaining
);
19538 data_remaining
-= min_notesz
;
19540 vms_external
= (Elf64_External_VMS_Note
*) external
;
19541 inote
.type
= BYTE_GET (vms_external
->type
);
19542 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19543 inote
.namedata
= vms_external
->name
;
19544 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19545 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19546 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19547 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19550 /* PR 17531: file: 3443835e. */
19551 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19552 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19553 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19554 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19555 || ((size_t) (next
- inote
.descdata
)
19556 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19558 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19559 (unsigned long) ((char *) external
- (char *) pnotes
));
19560 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19561 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19565 external
= (Elf_External_Note
*) next
;
19567 /* Verify that name is null terminated. It appears that at least
19568 one version of Linux (RedHat 6.0) generates corefiles that don't
19569 comply with the ELF spec by failing to include the null byte in
19571 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19573 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19575 temp
= (char *) malloc (inote
.namesz
+ 1);
19578 error (_("Out of memory allocating space for inote name\n"));
19583 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19584 inote
.namedata
= temp
;
19586 inote
.namedata
[inote
.namesz
] = 0;
19589 if (! process_note (& inote
, filedata
))
19605 process_corefile_note_segments (Filedata
* filedata
)
19607 Elf_Internal_Phdr
* segment
;
19609 bfd_boolean res
= TRUE
;
19611 if (! get_program_headers (filedata
))
19614 for (i
= 0, segment
= filedata
->program_headers
;
19615 i
< filedata
->file_header
.e_phnum
;
19618 if (segment
->p_type
== PT_NOTE
)
19619 if (! process_notes_at (filedata
, NULL
,
19620 (bfd_vma
) segment
->p_offset
,
19621 (bfd_vma
) segment
->p_filesz
,
19622 (bfd_vma
) segment
->p_align
))
19630 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19632 Elf_External_Note
* pnotes
;
19633 Elf_External_Note
* external
;
19635 bfd_boolean res
= TRUE
;
19640 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19642 if (pnotes
== NULL
)
19646 end
= (char*) pnotes
+ length
;
19648 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19649 (unsigned long) offset
, (unsigned long) length
);
19651 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19653 Elf_External_Note
* next
;
19654 Elf_Internal_Note inote
;
19656 inote
.type
= BYTE_GET (external
->type
);
19657 inote
.namesz
= BYTE_GET (external
->namesz
);
19658 inote
.namedata
= external
->name
;
19659 inote
.descsz
= BYTE_GET (external
->descsz
);
19660 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19661 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19663 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19665 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19666 inote
.descdata
= inote
.namedata
;
19670 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19672 if ( ((char *) next
> end
)
19673 || ((char *) next
< (char *) pnotes
))
19675 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19676 (unsigned long) ((char *) external
- (char *) pnotes
));
19677 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19678 inote
.type
, inote
.namesz
, inote
.descsz
);
19684 /* Prevent out-of-bounds indexing. */
19685 if ( inote
.namedata
+ inote
.namesz
> end
19686 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19688 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19689 (unsigned long) ((char *) external
- (char *) pnotes
));
19690 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19691 inote
.type
, inote
.namesz
, inote
.descsz
);
19695 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19697 if (! print_v850_note (& inote
))
19700 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19701 inote
.namesz
, inote
.descsz
);
19711 process_note_sections (Filedata
* filedata
)
19713 Elf_Internal_Shdr
* section
;
19715 unsigned int n
= 0;
19716 bfd_boolean res
= TRUE
;
19718 for (i
= 0, section
= filedata
->section_headers
;
19719 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19722 if (section
->sh_type
== SHT_NOTE
)
19724 if (! process_notes_at (filedata
, section
,
19725 (bfd_vma
) section
->sh_offset
,
19726 (bfd_vma
) section
->sh_size
,
19727 (bfd_vma
) section
->sh_addralign
))
19732 if (( filedata
->file_header
.e_machine
== EM_V800
19733 || filedata
->file_header
.e_machine
== EM_V850
19734 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19735 && section
->sh_type
== SHT_RENESAS_INFO
)
19737 if (! process_v850_notes (filedata
,
19738 (bfd_vma
) section
->sh_offset
,
19739 (bfd_vma
) section
->sh_size
))
19746 /* Try processing NOTE segments instead. */
19747 return process_corefile_note_segments (filedata
);
19753 process_notes (Filedata
* filedata
)
19755 /* If we have not been asked to display the notes then do nothing. */
19759 if (filedata
->file_header
.e_type
!= ET_CORE
)
19760 return process_note_sections (filedata
);
19762 /* No program headers means no NOTE segment. */
19763 if (filedata
->file_header
.e_phnum
> 0)
19764 return process_corefile_note_segments (filedata
);
19766 printf (_("No note segments present in the core file.\n"));
19770 static unsigned char *
19771 display_public_gnu_attributes (unsigned char * start
,
19772 const unsigned char * const end
)
19774 printf (_(" Unknown GNU attribute: %s\n"), start
);
19776 start
+= strnlen ((char *) start
, end
- start
);
19777 display_raw_attribute (start
, end
);
19779 return (unsigned char *) end
;
19782 static unsigned char *
19783 display_generic_attribute (unsigned char * start
,
19785 const unsigned char * const end
)
19788 return (unsigned char *) end
;
19790 return display_tag_value (tag
, start
, end
);
19794 process_arch_specific (Filedata
* filedata
)
19799 switch (filedata
->file_header
.e_machine
)
19802 case EM_ARC_COMPACT
:
19803 case EM_ARC_COMPACT2
:
19804 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19805 display_arc_attribute
,
19806 display_generic_attribute
);
19808 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19809 display_arm_attribute
,
19810 display_generic_attribute
);
19813 case EM_MIPS_RS3_LE
:
19814 return process_mips_specific (filedata
);
19817 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19818 display_msp430x_attribute
,
19819 display_msp430_gnu_attribute
);
19822 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19823 display_riscv_attribute
,
19824 display_generic_attribute
);
19827 return process_nds32_specific (filedata
);
19831 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19832 display_power_gnu_attribute
);
19836 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19837 display_s390_gnu_attribute
);
19840 case EM_SPARC32PLUS
:
19842 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19843 display_sparc_gnu_attribute
);
19846 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19847 display_tic6x_attribute
,
19848 display_generic_attribute
);
19851 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19852 display_public_gnu_attributes
,
19853 display_generic_attribute
);
19858 get_file_header (Filedata
* filedata
)
19860 /* Read in the identity array. */
19861 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19864 /* Determine how to read the rest of the header. */
19865 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19870 byte_get
= byte_get_little_endian
;
19871 byte_put
= byte_put_little_endian
;
19874 byte_get
= byte_get_big_endian
;
19875 byte_put
= byte_put_big_endian
;
19879 /* For now we only support 32 bit and 64 bit ELF files. */
19880 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19882 /* Read in the rest of the header. */
19885 Elf32_External_Ehdr ehdr32
;
19887 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19890 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19891 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19892 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19893 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19894 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19895 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19896 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19897 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19898 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19899 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19900 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19901 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19902 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19906 Elf64_External_Ehdr ehdr64
;
19908 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19909 we will not be able to cope with the 64bit data found in
19910 64 ELF files. Detect this now and abort before we start
19911 overwriting things. */
19912 if (sizeof (bfd_vma
) < 8)
19914 error (_("This instance of readelf has been built without support for a\n\
19915 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19919 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19922 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19923 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19924 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19925 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19926 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19927 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19928 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19929 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19930 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19931 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19932 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19933 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19934 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19937 if (filedata
->file_header
.e_shoff
)
19939 /* There may be some extensions in the first section header. Don't
19940 bomb if we can't read it. */
19942 get_32bit_section_headers (filedata
, TRUE
);
19944 get_64bit_section_headers (filedata
, TRUE
);
19951 close_file (Filedata
* filedata
)
19955 if (filedata
->handle
)
19956 fclose (filedata
->handle
);
19962 close_debug_file (void * data
)
19964 close_file ((Filedata
*) data
);
19968 open_file (const char * pathname
)
19970 struct stat statbuf
;
19971 Filedata
* filedata
= NULL
;
19973 if (stat (pathname
, & statbuf
) < 0
19974 || ! S_ISREG (statbuf
.st_mode
))
19977 filedata
= calloc (1, sizeof * filedata
);
19978 if (filedata
== NULL
)
19981 filedata
->handle
= fopen (pathname
, "rb");
19982 if (filedata
->handle
== NULL
)
19985 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19986 filedata
->file_name
= pathname
;
19988 if (! get_file_header (filedata
))
19991 if (filedata
->file_header
.e_shoff
)
19995 /* Read the section headers again, this time for real. */
19997 res
= get_32bit_section_headers (filedata
, FALSE
);
19999 res
= get_64bit_section_headers (filedata
, FALSE
);
20010 if (filedata
->handle
)
20011 fclose (filedata
->handle
);
20018 open_debug_file (const char * pathname
)
20020 return open_file (pathname
);
20023 /* Process one ELF object file according to the command line options.
20024 This file may actually be stored in an archive. The file is
20025 positioned at the start of the ELF object. Returns TRUE if no
20026 problems were encountered, FALSE otherwise. */
20029 process_object (Filedata
* filedata
)
20031 bfd_boolean have_separate_files
;
20033 bfd_boolean res
= TRUE
;
20035 if (! get_file_header (filedata
))
20037 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20041 /* Initialise per file variables. */
20042 for (i
= ARRAY_SIZE (version_info
); i
--;)
20043 version_info
[i
] = 0;
20045 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
20046 dynamic_info
[i
] = 0;
20047 dynamic_info_DT_GNU_HASH
= 0;
20048 dynamic_info_DT_MIPS_XHASH
= 0;
20050 /* Process the file. */
20052 printf (_("\nFile: %s\n"), filedata
->file_name
);
20054 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20055 Note we do this even if cmdline_dump_sects is empty because we
20056 must make sure that the dump_sets array is zeroed out before each
20057 object file is processed. */
20058 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
20059 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
20061 if (cmdline
.num_dump_sects
> 0)
20063 if (filedata
->num_dump_sects
== 0)
20064 /* A sneaky way of allocating the dump_sects array. */
20065 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
20067 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
20068 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
20069 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
20072 if (! process_file_header (filedata
))
20075 if (! process_section_headers (filedata
))
20077 /* Without loaded section headers we cannot process lots of things. */
20078 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20080 if (! do_using_dynamic
)
20081 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20084 if (! process_section_groups (filedata
))
20085 /* Without loaded section groups we cannot process unwind. */
20088 if (process_program_headers (filedata
))
20089 process_dynamic_section (filedata
);
20093 if (! process_relocs (filedata
))
20096 if (! process_unwind (filedata
))
20099 if (! process_symbol_table (filedata
))
20102 if (! process_syminfo (filedata
))
20105 if (! process_version_sections (filedata
))
20108 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20109 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20111 have_separate_files
= FALSE
;
20113 if (! process_section_contents (filedata
))
20116 if (have_separate_files
)
20120 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20122 if (! process_section_headers (d
->handle
))
20124 else if (! process_section_contents (d
->handle
))
20128 /* The file handles are closed by the call to free_debug_memory() below. */
20131 if (! process_notes (filedata
))
20134 if (! process_gnu_liblist (filedata
))
20137 if (! process_arch_specific (filedata
))
20140 free (filedata
->program_headers
);
20141 filedata
->program_headers
= NULL
;
20143 free (filedata
->section_headers
);
20144 filedata
->section_headers
= NULL
;
20146 free (filedata
->string_table
);
20147 filedata
->string_table
= NULL
;
20148 filedata
->string_table_length
= 0;
20150 if (filedata
->dump_sects
!= NULL
)
20152 free (filedata
->dump_sects
);
20153 filedata
->dump_sects
= NULL
;
20154 filedata
->num_dump_sects
= 0;
20157 if (dynamic_strings
)
20159 free (dynamic_strings
);
20160 dynamic_strings
= NULL
;
20161 dynamic_strings_length
= 0;
20164 if (dynamic_symbols
)
20166 free (dynamic_symbols
);
20167 dynamic_symbols
= NULL
;
20168 num_dynamic_syms
= 0;
20171 if (dynamic_syminfo
)
20173 free (dynamic_syminfo
);
20174 dynamic_syminfo
= NULL
;
20177 if (dynamic_section
)
20179 free (dynamic_section
);
20180 dynamic_section
= NULL
;
20183 while (symtab_shndx_list
!= NULL
)
20185 elf_section_list
*next
= symtab_shndx_list
->next
;
20186 free (symtab_shndx_list
);
20187 symtab_shndx_list
= next
;
20190 if (section_headers_groups
)
20192 free (section_headers_groups
);
20193 section_headers_groups
= NULL
;
20196 if (section_groups
)
20198 struct group_list
* g
;
20199 struct group_list
* next
;
20201 for (i
= 0; i
< group_count
; i
++)
20203 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
20210 free (section_groups
);
20211 section_groups
= NULL
;
20214 free_debug_memory ();
20219 /* Process an ELF archive.
20220 On entry the file is positioned just after the ARMAG string.
20221 Returns TRUE upon success, FALSE otherwise. */
20224 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20226 struct archive_info arch
;
20227 struct archive_info nested_arch
;
20229 bfd_boolean ret
= TRUE
;
20233 /* The ARCH structure is used to hold information about this archive. */
20234 arch
.file_name
= NULL
;
20236 arch
.index_array
= NULL
;
20237 arch
.sym_table
= NULL
;
20238 arch
.longnames
= NULL
;
20240 /* The NESTED_ARCH structure is used as a single-item cache of information
20241 about a nested archive (when members of a thin archive reside within
20242 another regular archive file). */
20243 nested_arch
.file_name
= NULL
;
20244 nested_arch
.file
= NULL
;
20245 nested_arch
.index_array
= NULL
;
20246 nested_arch
.sym_table
= NULL
;
20247 nested_arch
.longnames
= NULL
;
20249 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20250 filedata
->file_size
, is_thin_archive
,
20251 do_archive_index
) != 0)
20257 if (do_archive_index
)
20259 if (arch
.sym_table
== NULL
)
20260 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
20263 unsigned long i
, l
;
20264 unsigned long current_pos
;
20266 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20267 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
20269 current_pos
= ftell (filedata
->handle
);
20271 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20273 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
20275 char * member_name
;
20277 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
20279 if (member_name
!= NULL
)
20281 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
20283 if (qualified_name
!= NULL
)
20285 printf (_("Contents of binary %s at offset "), qualified_name
);
20286 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20288 free (qualified_name
);
20290 free (member_name
);
20294 if (l
>= arch
.sym_size
)
20296 error (_("%s: end of the symbol table reached before the end of the index\n"),
20297 filedata
->file_name
);
20301 /* PR 17531: file: 0b6630b2. */
20302 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20303 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20306 if (arch
.uses_64bit_indices
)
20311 if (l
< arch
.sym_size
)
20313 error (ngettext ("%s: %ld byte remains in the symbol table, "
20314 "but without corresponding entries in "
20315 "the index table\n",
20316 "%s: %ld bytes remain in the symbol table, "
20317 "but without corresponding entries in "
20318 "the index table\n",
20319 arch
.sym_size
- l
),
20320 filedata
->file_name
, arch
.sym_size
- l
);
20324 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20326 error (_("%s: failed to seek back to start of object files in the archive\n"),
20327 filedata
->file_name
);
20333 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20334 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20335 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20336 && !do_section_groups
&& !do_dyn_syms
)
20338 ret
= TRUE
; /* Archive index only. */
20347 char * qualified_name
;
20349 /* Read the next archive header. */
20350 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20352 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
20355 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20356 if (got
!= sizeof arch
.arhdr
)
20360 /* PR 24049 - we cannot use filedata->file_name as this will
20361 have already been freed. */
20362 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20367 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20369 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
20374 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20376 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20377 if (archive_file_size
& 01)
20378 ++archive_file_size
;
20380 name
= get_archive_member_name (&arch
, &nested_arch
);
20383 error (_("%s: bad archive file name\n"), arch
.file_name
);
20387 namelen
= strlen (name
);
20389 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20390 if (qualified_name
== NULL
)
20392 error (_("%s: bad archive file name\n"), arch
.file_name
);
20398 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20400 /* This is a proxy for an external member of a thin archive. */
20401 Filedata
* member_filedata
;
20402 char * member_file_name
= adjust_relative_path
20403 (filedata
->file_name
, name
, namelen
);
20406 if (member_file_name
== NULL
)
20408 free (qualified_name
);
20413 member_filedata
= open_file (member_file_name
);
20414 if (member_filedata
== NULL
)
20416 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20417 free (member_file_name
);
20418 free (qualified_name
);
20423 archive_file_offset
= arch
.nested_member_origin
;
20424 member_filedata
->file_name
= qualified_name
;
20426 if (! process_object (member_filedata
))
20429 close_file (member_filedata
);
20430 free (member_file_name
);
20431 free (qualified_name
);
20433 else if (is_thin_archive
)
20435 Filedata thin_filedata
;
20437 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20439 /* PR 15140: Allow for corrupt thin archives. */
20440 if (nested_arch
.file
== NULL
)
20442 error (_("%s: contains corrupt thin archive: %s\n"),
20443 qualified_name
, name
);
20444 free (qualified_name
);
20451 /* This is a proxy for a member of a nested archive. */
20452 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20454 /* The nested archive file will have been opened and setup by
20455 get_archive_member_name. */
20456 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20458 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
20459 free (qualified_name
);
20464 thin_filedata
.handle
= nested_arch
.file
;
20465 thin_filedata
.file_name
= qualified_name
;
20467 if (! process_object (& thin_filedata
))
20473 archive_file_offset
= arch
.next_arhdr_offset
;
20474 arch
.next_arhdr_offset
+= archive_file_size
;
20476 filedata
->file_name
= qualified_name
;
20477 if (! process_object (filedata
))
20481 free (qualified_name
);
20485 if (nested_arch
.file
!= NULL
)
20486 fclose (nested_arch
.file
);
20487 release_archive (&nested_arch
);
20488 release_archive (&arch
);
20494 process_file (char * file_name
)
20496 Filedata
* filedata
= NULL
;
20497 struct stat statbuf
;
20498 char armag
[SARMAG
];
20499 bfd_boolean ret
= TRUE
;
20501 if (stat (file_name
, &statbuf
) < 0)
20503 if (errno
== ENOENT
)
20504 error (_("'%s': No such file\n"), file_name
);
20506 error (_("Could not locate '%s'. System error message: %s\n"),
20507 file_name
, strerror (errno
));
20511 if (! S_ISREG (statbuf
.st_mode
))
20513 error (_("'%s' is not an ordinary file\n"), file_name
);
20517 filedata
= calloc (1, sizeof * filedata
);
20518 if (filedata
== NULL
)
20520 error (_("Out of memory allocating file data structure\n"));
20524 filedata
->file_name
= file_name
;
20525 filedata
->handle
= fopen (file_name
, "rb");
20526 if (filedata
->handle
== NULL
)
20528 error (_("Input file '%s' is not readable.\n"), file_name
);
20533 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20535 error (_("%s: Failed to read file's magic number\n"), file_name
);
20536 fclose (filedata
->handle
);
20541 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20543 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20545 if (! process_archive (filedata
, FALSE
))
20548 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20550 if ( ! process_archive (filedata
, TRUE
))
20555 if (do_archive_index
)
20556 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20559 rewind (filedata
->handle
);
20560 archive_file_size
= archive_file_offset
= 0;
20562 if (! process_object (filedata
))
20566 fclose (filedata
->handle
);
20567 free (filedata
->section_headers
);
20568 free (filedata
->program_headers
);
20569 free (filedata
->string_table
);
20570 free (filedata
->dump_sects
);
20573 free (ba_cache
.strtab
);
20574 ba_cache
.strtab
= NULL
;
20575 free (ba_cache
.symtab
);
20576 ba_cache
.symtab
= NULL
;
20577 ba_cache
.filedata
= NULL
;
20582 #ifdef SUPPORT_DISASSEMBLY
20583 /* Needed by the i386 disassembler. For extra credit, someone could
20584 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20588 print_address (unsigned int addr
, FILE * outfile
)
20590 fprintf (outfile
,"0x%8.8x", addr
);
20593 /* Needed by the i386 disassembler. */
20596 db_task_printsym (unsigned int addr
)
20598 print_address (addr
, stderr
);
20603 main (int argc
, char ** argv
)
20607 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20608 setlocale (LC_MESSAGES
, "");
20610 #if defined (HAVE_SETLOCALE)
20611 setlocale (LC_CTYPE
, "");
20613 bindtextdomain (PACKAGE
, LOCALEDIR
);
20614 textdomain (PACKAGE
);
20616 expandargv (&argc
, &argv
);
20618 cmdline
.file_name
= "<cmdline>";
20619 parse_args (& cmdline
, argc
, argv
);
20621 if (optind
< (argc
- 1))
20623 else if (optind
>= argc
)
20625 warn (_("Nothing to do.\n"));
20630 while (optind
< argc
)
20631 if (! process_file (argv
[optind
++]))
20634 if (cmdline
.dump_sects
!= NULL
)
20635 free (cmdline
.dump_sects
);
20637 free (dump_ctf_symtab_name
);
20638 free (dump_ctf_strtab_name
);
20639 free (dump_ctf_parent_name
);
20641 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;