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_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6770 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6771 char **strtab
, unsigned long *strtablen
)
6775 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6777 if (*symtab
== NULL
)
6780 if (symsec
->sh_link
!= 0)
6782 Elf_Internal_Shdr
*strsec
;
6784 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6786 error (_("Bad sh_link in symbol table section\n"));
6793 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6795 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6796 1, strsec
->sh_size
, _("string table"));
6797 if (*strtab
== NULL
)
6804 *strtablen
= strsec
->sh_size
;
6810 get_group_flags (unsigned int flags
)
6812 static char buff
[128];
6816 else if (flags
== GRP_COMDAT
)
6819 snprintf (buff
, 14, _("[0x%x: "), flags
);
6821 flags
&= ~ GRP_COMDAT
;
6822 if (flags
& GRP_MASKOS
)
6824 strcat (buff
, "<OS specific>");
6825 flags
&= ~ GRP_MASKOS
;
6828 if (flags
& GRP_MASKPROC
)
6830 strcat (buff
, "<PROC specific>");
6831 flags
&= ~ GRP_MASKPROC
;
6835 strcat (buff
, "<unknown>");
6842 process_section_groups (Filedata
* filedata
)
6844 Elf_Internal_Shdr
* section
;
6846 struct group
* group
;
6847 Elf_Internal_Shdr
* symtab_sec
;
6848 Elf_Internal_Shdr
* strtab_sec
;
6849 Elf_Internal_Sym
* symtab
;
6850 unsigned long num_syms
;
6854 /* Don't process section groups unless needed. */
6855 if (!do_unwind
&& !do_section_groups
)
6858 if (filedata
->file_header
.e_shnum
== 0)
6860 if (do_section_groups
)
6861 printf (_("\nThere are no sections to group in this file.\n"));
6866 if (filedata
->section_headers
== NULL
)
6868 error (_("Section headers are not available!\n"));
6869 /* PR 13622: This can happen with a corrupt ELF header. */
6873 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6874 sizeof (struct group
*));
6876 if (section_headers_groups
== NULL
)
6878 error (_("Out of memory reading %u section group headers\n"),
6879 filedata
->file_header
.e_shnum
);
6883 /* Scan the sections for the group section. */
6885 for (i
= 0, section
= filedata
->section_headers
;
6886 i
< filedata
->file_header
.e_shnum
;
6888 if (section
->sh_type
== SHT_GROUP
)
6891 if (group_count
== 0)
6893 if (do_section_groups
)
6894 printf (_("\nThere are no section groups in this file.\n"));
6899 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6901 if (section_groups
== NULL
)
6903 error (_("Out of memory reading %lu groups\n"),
6904 (unsigned long) group_count
);
6914 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6915 i
< filedata
->file_header
.e_shnum
;
6918 if (section
->sh_type
== SHT_GROUP
)
6920 const char * name
= printable_section_name (filedata
, section
);
6921 const char * group_name
;
6922 unsigned char * start
;
6923 unsigned char * indices
;
6924 unsigned int entry
, j
, size
;
6925 Elf_Internal_Shdr
* sec
;
6926 Elf_Internal_Sym
* sym
;
6928 /* Get the symbol table. */
6929 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6930 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6933 error (_("Bad sh_link in group section `%s'\n"), name
);
6937 if (symtab_sec
!= sec
)
6942 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6947 error (_("Corrupt header in group section `%s'\n"), name
);
6951 if (section
->sh_info
>= num_syms
)
6953 error (_("Bad sh_info in group section `%s'\n"), name
);
6957 sym
= symtab
+ section
->sh_info
;
6959 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6961 if (sym
->st_shndx
== 0
6962 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6964 error (_("Bad sh_info in group section `%s'\n"), name
);
6968 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6977 /* Get the string table. */
6978 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6987 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6993 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6994 1, strtab_sec
->sh_size
,
6996 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6998 group_name
= sym
->st_name
< strtab_size
6999 ? strtab
+ sym
->st_name
: _("<corrupt>");
7002 /* PR 17531: file: loop. */
7003 if (section
->sh_entsize
> section
->sh_size
)
7005 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7006 printable_section_name (filedata
, section
),
7007 (unsigned long) section
->sh_entsize
,
7008 (unsigned long) section
->sh_size
);
7012 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7013 1, section
->sh_size
,
7019 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7020 entry
= byte_get (indices
, 4);
7023 if (do_section_groups
)
7025 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7026 get_group_flags (entry
), i
, name
, group_name
, size
);
7028 printf (_(" [Index] Name\n"));
7031 group
->group_index
= i
;
7033 for (j
= 0; j
< size
; j
++)
7035 struct group_list
* g
;
7037 entry
= byte_get (indices
, 4);
7040 if (entry
>= filedata
->file_header
.e_shnum
)
7042 static unsigned num_group_errors
= 0;
7044 if (num_group_errors
++ < 10)
7046 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7047 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7048 if (num_group_errors
== 10)
7049 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7054 if (section_headers_groups
[entry
] != NULL
)
7058 static unsigned num_errs
= 0;
7060 if (num_errs
++ < 10)
7062 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7064 section_headers_groups
[entry
]->group_index
);
7066 warn (_("Further error messages about already contained group sections suppressed\n"));
7072 /* Intel C/C++ compiler may put section 0 in a
7073 section group. We just warn it the first time
7074 and ignore it afterwards. */
7075 static bfd_boolean warned
= FALSE
;
7078 error (_("section 0 in group section [%5u]\n"),
7079 section_headers_groups
[entry
]->group_index
);
7085 section_headers_groups
[entry
] = group
;
7087 if (do_section_groups
)
7089 sec
= filedata
->section_headers
+ entry
;
7090 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7093 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7094 g
->section_index
= entry
;
7095 g
->next
= group
->root
;
7113 /* Data used to display dynamic fixups. */
7115 struct ia64_vms_dynfixup
7117 bfd_vma needed_ident
; /* Library ident number. */
7118 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7119 bfd_vma fixup_needed
; /* Index of the library. */
7120 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7121 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7124 /* Data used to display dynamic relocations. */
7126 struct ia64_vms_dynimgrela
7128 bfd_vma img_rela_cnt
; /* Number of relocations. */
7129 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7132 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7136 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7137 struct ia64_vms_dynfixup
* fixup
,
7138 const char * strtab
,
7139 unsigned int strtab_sz
)
7141 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7143 const char * lib_name
;
7145 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7146 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7147 _("dynamic section image fixups"));
7151 if (fixup
->needed
< strtab_sz
)
7152 lib_name
= strtab
+ fixup
->needed
;
7155 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7156 (unsigned long) fixup
->needed
);
7160 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7161 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7163 (_("Seg Offset Type SymVec DataType\n"));
7165 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7170 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7171 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7172 type
= BYTE_GET (imfs
[i
].type
);
7173 rtype
= elf_ia64_reloc_type (type
);
7175 printf (" 0x%08x ", type
);
7177 printf (" %-32s ", rtype
);
7178 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7179 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7186 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7189 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7191 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7194 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7195 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7196 _("dynamic section image relocations"));
7200 printf (_("\nImage relocs\n"));
7202 (_("Seg Offset Type Addend Seg Sym Off\n"));
7204 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7209 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7210 printf ("%08" BFD_VMA_FMT
"x ",
7211 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7212 type
= BYTE_GET (imrs
[i
].type
);
7213 rtype
= elf_ia64_reloc_type (type
);
7215 printf ("0x%08x ", type
);
7217 printf ("%-31s ", rtype
);
7218 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7219 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7220 printf ("%08" BFD_VMA_FMT
"x\n",
7221 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7228 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7231 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7233 struct ia64_vms_dynfixup fixup
;
7234 struct ia64_vms_dynimgrela imgrela
;
7235 Elf_Internal_Dyn
*entry
;
7236 bfd_vma strtab_off
= 0;
7237 bfd_vma strtab_sz
= 0;
7238 char *strtab
= NULL
;
7239 bfd_boolean res
= TRUE
;
7241 memset (&fixup
, 0, sizeof (fixup
));
7242 memset (&imgrela
, 0, sizeof (imgrela
));
7244 /* Note: the order of the entries is specified by the OpenVMS specs. */
7245 for (entry
= dynamic_section
;
7246 entry
< dynamic_section
+ dynamic_nent
;
7249 switch (entry
->d_tag
)
7251 case DT_IA_64_VMS_STRTAB_OFFSET
:
7252 strtab_off
= entry
->d_un
.d_val
;
7255 strtab_sz
= entry
->d_un
.d_val
;
7257 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7258 1, strtab_sz
, _("dynamic string section"));
7263 case DT_IA_64_VMS_NEEDED_IDENT
:
7264 fixup
.needed_ident
= entry
->d_un
.d_val
;
7267 fixup
.needed
= entry
->d_un
.d_val
;
7269 case DT_IA_64_VMS_FIXUP_NEEDED
:
7270 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7272 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7273 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7275 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7276 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7277 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7280 case DT_IA_64_VMS_IMG_RELA_CNT
:
7281 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7283 case DT_IA_64_VMS_IMG_RELA_OFF
:
7284 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7285 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7307 dynamic_relocations
[] =
7309 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7310 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7311 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7314 /* Process the reloc section. */
7317 process_relocs (Filedata
* filedata
)
7319 unsigned long rel_size
;
7320 unsigned long rel_offset
;
7325 if (do_using_dynamic
)
7329 bfd_boolean has_dynamic_reloc
;
7332 has_dynamic_reloc
= FALSE
;
7334 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7336 is_rela
= dynamic_relocations
[i
].rela
;
7337 name
= dynamic_relocations
[i
].name
;
7338 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7339 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7342 has_dynamic_reloc
= TRUE
;
7344 if (is_rela
== UNKNOWN
)
7346 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7347 switch (dynamic_info
[DT_PLTREL
])
7361 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7362 name
, rel_offset
, rel_size
);
7364 dump_relocations (filedata
,
7365 offset_from_vma (filedata
, rel_offset
, rel_size
),
7367 dynamic_symbols
, num_dynamic_syms
,
7368 dynamic_strings
, dynamic_strings_length
,
7369 is_rela
, TRUE
/* is_dynamic */);
7373 if (is_ia64_vms (filedata
))
7374 if (process_ia64_vms_dynamic_relocs (filedata
))
7375 has_dynamic_reloc
= TRUE
;
7377 if (! has_dynamic_reloc
)
7378 printf (_("\nThere are no dynamic relocations in this file.\n"));
7382 Elf_Internal_Shdr
* section
;
7384 bfd_boolean found
= FALSE
;
7386 for (i
= 0, section
= filedata
->section_headers
;
7387 i
< filedata
->file_header
.e_shnum
;
7390 if ( section
->sh_type
!= SHT_RELA
7391 && section
->sh_type
!= SHT_REL
)
7394 rel_offset
= section
->sh_offset
;
7395 rel_size
= section
->sh_size
;
7400 unsigned long num_rela
;
7402 printf (_("\nRelocation section "));
7404 if (filedata
->string_table
== NULL
)
7405 printf ("%d", section
->sh_name
);
7407 printf ("'%s'", printable_section_name (filedata
, section
));
7409 num_rela
= rel_size
/ section
->sh_entsize
;
7410 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7411 " at offset 0x%lx contains %lu entries:\n",
7413 rel_offset
, num_rela
);
7415 is_rela
= section
->sh_type
== SHT_RELA
;
7417 if (section
->sh_link
!= 0
7418 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7420 Elf_Internal_Shdr
* symsec
;
7421 Elf_Internal_Sym
* symtab
;
7422 unsigned long nsyms
;
7423 unsigned long strtablen
= 0;
7424 char * strtab
= NULL
;
7426 symsec
= filedata
->section_headers
+ section
->sh_link
;
7427 if (symsec
->sh_type
!= SHT_SYMTAB
7428 && symsec
->sh_type
!= SHT_DYNSYM
)
7431 if (!get_symtab (filedata
, symsec
,
7432 &symtab
, &nsyms
, &strtab
, &strtablen
))
7435 dump_relocations (filedata
, rel_offset
, rel_size
,
7436 symtab
, nsyms
, strtab
, strtablen
,
7438 symsec
->sh_type
== SHT_DYNSYM
);
7444 dump_relocations (filedata
, rel_offset
, rel_size
,
7445 NULL
, 0, NULL
, 0, is_rela
,
7446 FALSE
/* is_dynamic */);
7454 /* Users sometimes forget the -D option, so try to be helpful. */
7455 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7457 if (dynamic_info
[dynamic_relocations
[i
].size
])
7459 printf (_("\nThere are no static relocations in this file."));
7460 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7465 if (i
== ARRAY_SIZE (dynamic_relocations
))
7466 printf (_("\nThere are no relocations in this file.\n"));
7473 /* An absolute address consists of a section and an offset. If the
7474 section is NULL, the offset itself is the address, otherwise, the
7475 address equals to LOAD_ADDRESS(section) + offset. */
7479 unsigned short section
;
7483 /* Find the nearest symbol at or below ADDR. Returns the symbol
7484 name, if found, and the offset from the symbol to ADDR. */
7487 find_symbol_for_address (Filedata
* filedata
,
7488 Elf_Internal_Sym
* symtab
,
7489 unsigned long nsyms
,
7490 const char * strtab
,
7491 unsigned long strtab_size
,
7492 struct absaddr addr
,
7493 const char ** symname
,
7496 bfd_vma dist
= 0x100000;
7497 Elf_Internal_Sym
* sym
;
7498 Elf_Internal_Sym
* beg
;
7499 Elf_Internal_Sym
* end
;
7500 Elf_Internal_Sym
* best
= NULL
;
7502 REMOVE_ARCH_BITS (addr
.offset
);
7504 end
= symtab
+ nsyms
;
7510 sym
= beg
+ (end
- beg
) / 2;
7512 value
= sym
->st_value
;
7513 REMOVE_ARCH_BITS (value
);
7515 if (sym
->st_name
!= 0
7516 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7517 && addr
.offset
>= value
7518 && addr
.offset
- value
< dist
)
7521 dist
= addr
.offset
- value
;
7526 if (addr
.offset
< value
)
7534 *symname
= (best
->st_name
>= strtab_size
7535 ? _("<corrupt>") : strtab
+ best
->st_name
);
7541 *offset
= addr
.offset
;
7544 static /* signed */ int
7545 symcmp (const void *p
, const void *q
)
7547 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7548 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7550 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7553 /* Process the unwind section. */
7555 #include "unwind-ia64.h"
7557 struct ia64_unw_table_entry
7559 struct absaddr start
;
7561 struct absaddr info
;
7564 struct ia64_unw_aux_info
7566 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7567 unsigned long table_len
; /* Length of unwind table. */
7568 unsigned char * info
; /* Unwind info. */
7569 unsigned long info_size
; /* Size of unwind info. */
7570 bfd_vma info_addr
; /* Starting address of unwind info. */
7571 bfd_vma seg_base
; /* Starting address of segment. */
7572 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7573 unsigned long nsyms
; /* Number of symbols. */
7574 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7575 unsigned long nfuns
; /* Number of entries in funtab. */
7576 char * strtab
; /* The string table. */
7577 unsigned long strtab_size
; /* Size of string table. */
7581 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7583 struct ia64_unw_table_entry
* tp
;
7584 unsigned long j
, nfuns
;
7586 bfd_boolean res
= TRUE
;
7588 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7589 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7590 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7591 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7593 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7595 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7599 const unsigned char * dp
;
7600 const unsigned char * head
;
7601 const unsigned char * end
;
7602 const char * procname
;
7604 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7605 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7607 fputs ("\n<", stdout
);
7611 fputs (procname
, stdout
);
7614 printf ("+%lx", (unsigned long) offset
);
7617 fputs (">: [", stdout
);
7618 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7619 fputc ('-', stdout
);
7620 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7621 printf ("], info at +0x%lx\n",
7622 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7624 /* PR 17531: file: 86232b32. */
7625 if (aux
->info
== NULL
)
7628 offset
= tp
->info
.offset
;
7629 if (tp
->info
.section
)
7631 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7633 warn (_("Invalid section %u in table entry %ld\n"),
7634 tp
->info
.section
, (long) (tp
- aux
->table
));
7638 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7640 offset
-= aux
->info_addr
;
7641 /* PR 17531: file: 0997b4d1. */
7642 if (offset
>= aux
->info_size
7643 || aux
->info_size
- offset
< 8)
7645 warn (_("Invalid offset %lx in table entry %ld\n"),
7646 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7651 head
= aux
->info
+ offset
;
7652 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7654 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7655 (unsigned) UNW_VER (stamp
),
7656 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7657 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7658 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7659 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7661 if (UNW_VER (stamp
) != 1)
7663 printf (_("\tUnknown version.\n"));
7668 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7669 /* PR 17531: file: 16ceda89. */
7670 if (end
> aux
->info
+ aux
->info_size
)
7671 end
= aux
->info
+ aux
->info_size
;
7672 for (dp
= head
+ 8; dp
< end
;)
7673 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7682 slurp_ia64_unwind_table (Filedata
* filedata
,
7683 struct ia64_unw_aux_info
* aux
,
7684 Elf_Internal_Shdr
* sec
)
7686 unsigned long size
, nrelas
, i
;
7687 Elf_Internal_Phdr
* seg
;
7688 struct ia64_unw_table_entry
* tep
;
7689 Elf_Internal_Shdr
* relsec
;
7690 Elf_Internal_Rela
* rela
;
7691 Elf_Internal_Rela
* rp
;
7692 unsigned char * table
;
7694 Elf_Internal_Sym
* sym
;
7695 const char * relname
;
7699 /* First, find the starting address of the segment that includes
7702 if (filedata
->file_header
.e_phnum
)
7704 if (! get_program_headers (filedata
))
7707 for (seg
= filedata
->program_headers
;
7708 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7711 if (seg
->p_type
!= PT_LOAD
)
7714 if (sec
->sh_addr
>= seg
->p_vaddr
7715 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7717 aux
->seg_base
= seg
->p_vaddr
;
7723 /* Second, build the unwind table from the contents of the unwind section: */
7724 size
= sec
->sh_size
;
7725 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7730 aux
->table_len
= size
/ (3 * eh_addr_size
);
7731 aux
->table
= (struct ia64_unw_table_entry
*)
7732 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7735 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7737 tep
->start
.section
= SHN_UNDEF
;
7738 tep
->end
.section
= SHN_UNDEF
;
7739 tep
->info
.section
= SHN_UNDEF
;
7740 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7741 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7742 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7743 tep
->start
.offset
+= aux
->seg_base
;
7744 tep
->end
.offset
+= aux
->seg_base
;
7745 tep
->info
.offset
+= aux
->seg_base
;
7749 /* Third, apply any relocations to the unwind table: */
7750 for (relsec
= filedata
->section_headers
;
7751 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7754 if (relsec
->sh_type
!= SHT_RELA
7755 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7756 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7759 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7768 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7770 unsigned int sym_ndx
;
7771 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7772 relname
= elf_ia64_reloc_type (r_type
);
7774 /* PR 17531: file: 9fa67536. */
7775 if (relname
== NULL
)
7777 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7781 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7783 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7787 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7789 /* PR 17531: file: 5bc8d9bf. */
7790 if (i
>= aux
->table_len
)
7792 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7796 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7797 if (sym_ndx
>= aux
->nsyms
)
7799 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7803 sym
= aux
->symtab
+ sym_ndx
;
7805 switch (rp
->r_offset
/ eh_addr_size
% 3)
7808 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7809 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7812 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7813 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7816 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7817 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7831 ia64_process_unwind (Filedata
* filedata
)
7833 Elf_Internal_Shdr
* sec
;
7834 Elf_Internal_Shdr
* unwsec
= NULL
;
7835 unsigned long i
, unwcount
= 0, unwstart
= 0;
7836 struct ia64_unw_aux_info aux
;
7837 bfd_boolean res
= TRUE
;
7839 memset (& aux
, 0, sizeof (aux
));
7841 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7843 if (sec
->sh_type
== SHT_SYMTAB
)
7847 error (_("Multiple symbol tables encountered\n"));
7853 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7854 &aux
.strtab
, &aux
.strtab_size
))
7857 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7862 printf (_("\nThere are no unwind sections in this file.\n"));
7864 while (unwcount
-- > 0)
7869 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7870 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7871 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7876 /* We have already counted the number of SHT_IA64_UNWIND
7877 sections so the loop above should never fail. */
7878 assert (unwsec
!= NULL
);
7881 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7883 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7885 /* We need to find which section group it is in. */
7886 struct group_list
* g
;
7888 if (section_headers_groups
== NULL
7889 || section_headers_groups
[i
] == NULL
)
7890 i
= filedata
->file_header
.e_shnum
;
7893 g
= section_headers_groups
[i
]->root
;
7895 for (; g
!= NULL
; g
= g
->next
)
7897 sec
= filedata
->section_headers
+ g
->section_index
;
7899 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7904 i
= filedata
->file_header
.e_shnum
;
7907 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7909 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7910 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7911 suffix
= SECTION_NAME (unwsec
) + len
;
7912 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7914 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7915 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7920 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7921 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7922 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7923 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7925 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7926 suffix
= SECTION_NAME (unwsec
) + len
;
7927 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7929 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7930 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7934 if (i
== filedata
->file_header
.e_shnum
)
7936 printf (_("\nCould not find unwind info section for "));
7938 if (filedata
->string_table
== NULL
)
7939 printf ("%d", unwsec
->sh_name
);
7941 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7945 aux
.info_addr
= sec
->sh_addr
;
7946 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7949 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7951 printf (_("\nUnwind section "));
7953 if (filedata
->string_table
== NULL
)
7954 printf ("%d", unwsec
->sh_name
);
7956 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7958 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7959 (unsigned long) unwsec
->sh_offset
,
7960 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7962 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7963 && aux
.table_len
> 0)
7964 dump_ia64_unwind (filedata
, & aux
);
7967 free ((char *) aux
.table
);
7969 free ((char *) aux
.info
);
7978 free ((char *) aux
.strtab
);
7983 struct hppa_unw_table_entry
7985 struct absaddr start
;
7987 unsigned int Cannot_unwind
:1; /* 0 */
7988 unsigned int Millicode
:1; /* 1 */
7989 unsigned int Millicode_save_sr0
:1; /* 2 */
7990 unsigned int Region_description
:2; /* 3..4 */
7991 unsigned int reserved1
:1; /* 5 */
7992 unsigned int Entry_SR
:1; /* 6 */
7993 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7994 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7995 unsigned int Args_stored
:1; /* 16 */
7996 unsigned int Variable_Frame
:1; /* 17 */
7997 unsigned int Separate_Package_Body
:1; /* 18 */
7998 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7999 unsigned int Stack_Overflow_Check
:1; /* 20 */
8000 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8001 unsigned int Ada_Region
:1; /* 22 */
8002 unsigned int cxx_info
:1; /* 23 */
8003 unsigned int cxx_try_catch
:1; /* 24 */
8004 unsigned int sched_entry_seq
:1; /* 25 */
8005 unsigned int reserved2
:1; /* 26 */
8006 unsigned int Save_SP
:1; /* 27 */
8007 unsigned int Save_RP
:1; /* 28 */
8008 unsigned int Save_MRP_in_frame
:1; /* 29 */
8009 unsigned int extn_ptr_defined
:1; /* 30 */
8010 unsigned int Cleanup_defined
:1; /* 31 */
8012 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8013 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8014 unsigned int Large_frame
:1; /* 2 */
8015 unsigned int Pseudo_SP_Set
:1; /* 3 */
8016 unsigned int reserved4
:1; /* 4 */
8017 unsigned int Total_frame_size
:27; /* 5..31 */
8020 struct hppa_unw_aux_info
8022 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8023 unsigned long table_len
; /* Length of unwind table. */
8024 bfd_vma seg_base
; /* Starting address of segment. */
8025 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8026 unsigned long nsyms
; /* Number of symbols. */
8027 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8028 unsigned long nfuns
; /* Number of entries in funtab. */
8029 char * strtab
; /* The string table. */
8030 unsigned long strtab_size
; /* Size of string table. */
8034 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8036 struct hppa_unw_table_entry
* tp
;
8037 unsigned long j
, nfuns
;
8038 bfd_boolean res
= TRUE
;
8040 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8041 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8042 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8043 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8045 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8047 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8050 const char * procname
;
8052 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8053 aux
->strtab_size
, tp
->start
, &procname
,
8056 fputs ("\n<", stdout
);
8060 fputs (procname
, stdout
);
8063 printf ("+%lx", (unsigned long) offset
);
8066 fputs (">: [", stdout
);
8067 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8068 fputc ('-', stdout
);
8069 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8072 #define PF(_m) if (tp->_m) printf (#_m " ");
8073 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8076 PF(Millicode_save_sr0
);
8077 /* PV(Region_description); */
8083 PF(Separate_Package_Body
);
8084 PF(Frame_Extension_Millicode
);
8085 PF(Stack_Overflow_Check
);
8086 PF(Two_Instruction_SP_Increment
);
8090 PF(sched_entry_seq
);
8093 PF(Save_MRP_in_frame
);
8094 PF(extn_ptr_defined
);
8095 PF(Cleanup_defined
);
8096 PF(MPE_XL_interrupt_marker
);
8097 PF(HP_UX_interrupt_marker
);
8100 PV(Total_frame_size
);
8113 slurp_hppa_unwind_table (Filedata
* filedata
,
8114 struct hppa_unw_aux_info
* aux
,
8115 Elf_Internal_Shdr
* sec
)
8117 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8118 Elf_Internal_Phdr
* seg
;
8119 struct hppa_unw_table_entry
* tep
;
8120 Elf_Internal_Shdr
* relsec
;
8121 Elf_Internal_Rela
* rela
;
8122 Elf_Internal_Rela
* rp
;
8123 unsigned char * table
;
8125 Elf_Internal_Sym
* sym
;
8126 const char * relname
;
8128 /* First, find the starting address of the segment that includes
8130 if (filedata
->file_header
.e_phnum
)
8132 if (! get_program_headers (filedata
))
8135 for (seg
= filedata
->program_headers
;
8136 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8139 if (seg
->p_type
!= PT_LOAD
)
8142 if (sec
->sh_addr
>= seg
->p_vaddr
8143 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8145 aux
->seg_base
= seg
->p_vaddr
;
8151 /* Second, build the unwind table from the contents of the unwind
8153 size
= sec
->sh_size
;
8154 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8160 nentries
= size
/ unw_ent_size
;
8161 size
= unw_ent_size
* nentries
;
8163 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8164 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8166 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8168 unsigned int tmp1
, tmp2
;
8170 tep
->start
.section
= SHN_UNDEF
;
8171 tep
->end
.section
= SHN_UNDEF
;
8173 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8174 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8175 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8176 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8178 tep
->start
.offset
+= aux
->seg_base
;
8179 tep
->end
.offset
+= aux
->seg_base
;
8181 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8182 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8183 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8184 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8185 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8186 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8187 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8188 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8189 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8190 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8191 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8192 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8193 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8194 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8195 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8196 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8197 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8198 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8199 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8200 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8201 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8202 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8203 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8204 tep
->Cleanup_defined
= tmp1
& 0x1;
8206 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8207 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8208 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8209 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8210 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8211 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8215 /* Third, apply any relocations to the unwind table. */
8216 for (relsec
= filedata
->section_headers
;
8217 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8220 if (relsec
->sh_type
!= SHT_RELA
8221 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8222 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8225 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8229 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8231 unsigned int sym_ndx
;
8232 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8233 relname
= elf_hppa_reloc_type (r_type
);
8235 if (relname
== NULL
)
8237 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8241 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8242 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8244 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8248 i
= rp
->r_offset
/ unw_ent_size
;
8249 if (i
>= aux
->table_len
)
8251 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8255 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8256 if (sym_ndx
>= aux
->nsyms
)
8258 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8262 sym
= aux
->symtab
+ sym_ndx
;
8264 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8267 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8268 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8271 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8272 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8282 aux
->table_len
= nentries
;
8288 hppa_process_unwind (Filedata
* filedata
)
8290 struct hppa_unw_aux_info aux
;
8291 Elf_Internal_Shdr
* unwsec
= NULL
;
8292 Elf_Internal_Shdr
* sec
;
8294 bfd_boolean res
= TRUE
;
8296 if (filedata
->string_table
== NULL
)
8299 memset (& aux
, 0, sizeof (aux
));
8301 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8303 if (sec
->sh_type
== SHT_SYMTAB
)
8307 error (_("Multiple symbol tables encountered\n"));
8313 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8314 &aux
.strtab
, &aux
.strtab_size
))
8317 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8322 printf (_("\nThere are no unwind sections in this file.\n"));
8324 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8326 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8328 unsigned long num_unwind
= sec
->sh_size
/ 16;
8330 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8331 "contains %lu entry:\n",
8332 "\nUnwind section '%s' at offset 0x%lx "
8333 "contains %lu entries:\n",
8335 printable_section_name (filedata
, sec
),
8336 (unsigned long) sec
->sh_offset
,
8339 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8342 if (res
&& aux
.table_len
> 0)
8344 if (! dump_hppa_unwind (filedata
, &aux
))
8349 free ((char *) aux
.table
);
8357 free ((char *) aux
.strtab
);
8364 unsigned char * data
; /* The unwind data. */
8365 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8366 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8367 unsigned long nrelas
; /* The number of relocations. */
8368 unsigned int rel_type
; /* REL or RELA ? */
8369 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8372 struct arm_unw_aux_info
8374 Filedata
* filedata
; /* The file containing the unwind sections. */
8375 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8376 unsigned long nsyms
; /* Number of symbols. */
8377 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8378 unsigned long nfuns
; /* Number of these symbols. */
8379 char * strtab
; /* The file's string table. */
8380 unsigned long strtab_size
; /* Size of string table. */
8384 arm_print_vma_and_name (Filedata
* filedata
,
8385 struct arm_unw_aux_info
* aux
,
8387 struct absaddr addr
)
8389 const char *procname
;
8392 if (addr
.section
== SHN_UNDEF
)
8395 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8396 aux
->strtab_size
, addr
, &procname
,
8399 print_vma (fn
, PREFIX_HEX
);
8403 fputs (" <", stdout
);
8404 fputs (procname
, stdout
);
8407 printf ("+0x%lx", (unsigned long) sym_offset
);
8408 fputc ('>', stdout
);
8415 arm_free_section (struct arm_section
*arm_sec
)
8417 if (arm_sec
->data
!= NULL
)
8418 free (arm_sec
->data
);
8420 if (arm_sec
->rela
!= NULL
)
8421 free (arm_sec
->rela
);
8424 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8425 cached section and install SEC instead.
8426 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8427 and return its valued in * WORDP, relocating if necessary.
8428 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8429 relocation's offset in ADDR.
8430 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8431 into the string table of the symbol associated with the reloc. If no
8432 reloc was applied store -1 there.
8433 5) Return TRUE upon success, FALSE otherwise. */
8436 get_unwind_section_word (Filedata
* filedata
,
8437 struct arm_unw_aux_info
* aux
,
8438 struct arm_section
* arm_sec
,
8439 Elf_Internal_Shdr
* sec
,
8440 bfd_vma word_offset
,
8441 unsigned int * wordp
,
8442 struct absaddr
* addr
,
8445 Elf_Internal_Rela
*rp
;
8446 Elf_Internal_Sym
*sym
;
8447 const char * relname
;
8449 bfd_boolean wrapped
;
8451 if (sec
== NULL
|| arm_sec
== NULL
)
8454 addr
->section
= SHN_UNDEF
;
8457 if (sym_name
!= NULL
)
8458 *sym_name
= (bfd_vma
) -1;
8460 /* If necessary, update the section cache. */
8461 if (sec
!= arm_sec
->sec
)
8463 Elf_Internal_Shdr
*relsec
;
8465 arm_free_section (arm_sec
);
8468 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8469 sec
->sh_size
, _("unwind data"));
8470 arm_sec
->rela
= NULL
;
8471 arm_sec
->nrelas
= 0;
8473 for (relsec
= filedata
->section_headers
;
8474 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8477 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8478 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8479 /* PR 15745: Check the section type as well. */
8480 || (relsec
->sh_type
!= SHT_REL
8481 && relsec
->sh_type
!= SHT_RELA
))
8484 arm_sec
->rel_type
= relsec
->sh_type
;
8485 if (relsec
->sh_type
== SHT_REL
)
8487 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8489 & arm_sec
->rela
, & arm_sec
->nrelas
))
8492 else /* relsec->sh_type == SHT_RELA */
8494 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8496 & arm_sec
->rela
, & arm_sec
->nrelas
))
8502 arm_sec
->next_rela
= arm_sec
->rela
;
8505 /* If there is no unwind data we can do nothing. */
8506 if (arm_sec
->data
== NULL
)
8509 /* If the offset is invalid then fail. */
8510 if (/* PR 21343 *//* PR 18879 */
8512 || word_offset
> (sec
->sh_size
- 4)
8513 || ((bfd_signed_vma
) word_offset
) < 0)
8516 /* Get the word at the required offset. */
8517 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8519 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8520 if (arm_sec
->rela
== NULL
)
8526 /* Look through the relocs to find the one that applies to the provided offset. */
8528 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8530 bfd_vma prelval
, offset
;
8532 if (rp
->r_offset
> word_offset
&& !wrapped
)
8537 if (rp
->r_offset
> word_offset
)
8540 if (rp
->r_offset
& 3)
8542 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8543 (unsigned long) rp
->r_offset
);
8547 if (rp
->r_offset
< word_offset
)
8550 /* PR 17531: file: 027-161405-0.004 */
8551 if (aux
->symtab
== NULL
)
8554 if (arm_sec
->rel_type
== SHT_REL
)
8556 offset
= word
& 0x7fffffff;
8557 if (offset
& 0x40000000)
8558 offset
|= ~ (bfd_vma
) 0x7fffffff;
8560 else if (arm_sec
->rel_type
== SHT_RELA
)
8561 offset
= rp
->r_addend
;
8564 error (_("Unknown section relocation type %d encountered\n"),
8569 /* PR 17531 file: 027-1241568-0.004. */
8570 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8572 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8573 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8577 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8578 offset
+= sym
->st_value
;
8579 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8581 /* Check that we are processing the expected reloc type. */
8582 if (filedata
->file_header
.e_machine
== EM_ARM
)
8584 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8585 if (relname
== NULL
)
8587 warn (_("Skipping unknown ARM relocation type: %d\n"),
8588 (int) ELF32_R_TYPE (rp
->r_info
));
8592 if (streq (relname
, "R_ARM_NONE"))
8595 if (! streq (relname
, "R_ARM_PREL31"))
8597 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8601 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8603 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8604 if (relname
== NULL
)
8606 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8607 (int) ELF32_R_TYPE (rp
->r_info
));
8611 if (streq (relname
, "R_C6000_NONE"))
8614 if (! streq (relname
, "R_C6000_PREL31"))
8616 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8624 /* This function currently only supports ARM and TI unwinders. */
8625 warn (_("Only TI and ARM unwinders are currently supported\n"));
8629 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8630 addr
->section
= sym
->st_shndx
;
8631 addr
->offset
= offset
;
8634 * sym_name
= sym
->st_name
;
8639 arm_sec
->next_rela
= rp
;
8644 static const char *tic6x_unwind_regnames
[16] =
8646 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8647 "A14", "A13", "A12", "A11", "A10",
8648 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8652 decode_tic6x_unwind_regmask (unsigned int mask
)
8656 for (i
= 12; mask
; mask
>>= 1, i
--)
8660 fputs (tic6x_unwind_regnames
[i
], stdout
);
8662 fputs (", ", stdout
);
8668 if (remaining == 0 && more_words) \
8671 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8672 data_offset, & word, & addr, NULL)) \
8678 #define GET_OP(OP) \
8683 (OP) = word >> 24; \
8688 printf (_("[Truncated opcode]\n")); \
8691 printf ("0x%02x ", OP)
8694 decode_arm_unwind_bytecode (Filedata
* filedata
,
8695 struct arm_unw_aux_info
* aux
,
8697 unsigned int remaining
,
8698 unsigned int more_words
,
8699 bfd_vma data_offset
,
8700 Elf_Internal_Shdr
* data_sec
,
8701 struct arm_section
* data_arm_sec
)
8703 struct absaddr addr
;
8704 bfd_boolean res
= TRUE
;
8706 /* Decode the unwinding instructions. */
8709 unsigned int op
, op2
;
8718 printf (" 0x%02x ", op
);
8720 if ((op
& 0xc0) == 0x00)
8722 int offset
= ((op
& 0x3f) << 2) + 4;
8724 printf (" vsp = vsp + %d", offset
);
8726 else if ((op
& 0xc0) == 0x40)
8728 int offset
= ((op
& 0x3f) << 2) + 4;
8730 printf (" vsp = vsp - %d", offset
);
8732 else if ((op
& 0xf0) == 0x80)
8735 if (op
== 0x80 && op2
== 0)
8736 printf (_("Refuse to unwind"));
8739 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8740 bfd_boolean first
= TRUE
;
8744 for (i
= 0; i
< 12; i
++)
8745 if (mask
& (1 << i
))
8751 printf ("r%d", 4 + i
);
8756 else if ((op
& 0xf0) == 0x90)
8758 if (op
== 0x9d || op
== 0x9f)
8759 printf (_(" [Reserved]"));
8761 printf (" vsp = r%d", op
& 0x0f);
8763 else if ((op
& 0xf0) == 0xa0)
8765 int end
= 4 + (op
& 0x07);
8766 bfd_boolean first
= TRUE
;
8770 for (i
= 4; i
<= end
; i
++)
8786 else if (op
== 0xb0)
8787 printf (_(" finish"));
8788 else if (op
== 0xb1)
8791 if (op2
== 0 || (op2
& 0xf0) != 0)
8792 printf (_("[Spare]"));
8795 unsigned int mask
= op2
& 0x0f;
8796 bfd_boolean first
= TRUE
;
8800 for (i
= 0; i
< 12; i
++)
8801 if (mask
& (1 << i
))
8812 else if (op
== 0xb2)
8814 unsigned char buf
[9];
8815 unsigned int i
, len
;
8816 unsigned long offset
;
8818 for (i
= 0; i
< sizeof (buf
); i
++)
8821 if ((buf
[i
] & 0x80) == 0)
8824 if (i
== sizeof (buf
))
8826 error (_("corrupt change to vsp\n"));
8831 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8832 assert (len
== i
+ 1);
8833 offset
= offset
* 4 + 0x204;
8834 printf ("vsp = vsp + %ld", offset
);
8837 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8839 unsigned int first
, last
;
8846 printf ("pop {D%d", first
);
8848 printf ("-D%d", first
+ last
);
8851 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8853 unsigned int count
= op
& 0x07;
8857 printf ("-D%d", 8 + count
);
8860 else if (op
>= 0xc0 && op
<= 0xc5)
8862 unsigned int count
= op
& 0x07;
8864 printf (" pop {wR10");
8866 printf ("-wR%d", 10 + count
);
8869 else if (op
== 0xc6)
8871 unsigned int first
, last
;
8876 printf ("pop {wR%d", first
);
8878 printf ("-wR%d", first
+ last
);
8881 else if (op
== 0xc7)
8884 if (op2
== 0 || (op2
& 0xf0) != 0)
8885 printf (_("[Spare]"));
8888 unsigned int mask
= op2
& 0x0f;
8889 bfd_boolean first
= TRUE
;
8893 for (i
= 0; i
< 4; i
++)
8894 if (mask
& (1 << i
))
8900 printf ("wCGR%d", i
);
8907 printf (_(" [unsupported opcode]"));
8918 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8919 struct arm_unw_aux_info
* aux
,
8921 unsigned int remaining
,
8922 unsigned int more_words
,
8923 bfd_vma data_offset
,
8924 Elf_Internal_Shdr
* data_sec
,
8925 struct arm_section
* data_arm_sec
)
8927 struct absaddr addr
;
8929 /* Decode the unwinding instructions. */
8932 unsigned int op
, op2
;
8941 printf (" 0x%02x ", op
);
8943 if ((op
& 0xc0) == 0x00)
8945 int offset
= ((op
& 0x3f) << 3) + 8;
8946 printf (" sp = sp + %d", offset
);
8948 else if ((op
& 0xc0) == 0x80)
8951 if (op
== 0x80 && op2
== 0)
8952 printf (_("Refuse to unwind"));
8955 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8957 printf ("pop compact {");
8961 decode_tic6x_unwind_regmask (mask
);
8965 else if ((op
& 0xf0) == 0xc0)
8973 unsigned int offset
;
8977 /* Scan entire instruction first so that GET_OP output is not
8978 interleaved with disassembly. */
8980 for (i
= 0; nregs
< (op
& 0xf); i
++)
8986 regpos
[nregs
].offset
= i
* 2;
8987 regpos
[nregs
].reg
= reg
;
8994 regpos
[nregs
].offset
= i
* 2 + 1;
8995 regpos
[nregs
].reg
= reg
;
9000 printf (_("pop frame {"));
9003 printf (_("*corrupt* - no registers specified"));
9008 for (i
= i
* 2; i
> 0; i
--)
9010 if (regpos
[reg
].offset
== i
- 1)
9012 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9019 fputs (name
, stdout
);
9027 else if (op
== 0xd0)
9028 printf (" MOV FP, SP");
9029 else if (op
== 0xd1)
9030 printf (" __c6xabi_pop_rts");
9031 else if (op
== 0xd2)
9033 unsigned char buf
[9];
9034 unsigned int i
, len
;
9035 unsigned long offset
;
9037 for (i
= 0; i
< sizeof (buf
); i
++)
9040 if ((buf
[i
] & 0x80) == 0)
9043 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9044 if (i
== sizeof (buf
))
9046 warn (_("Corrupt stack pointer adjustment detected\n"));
9050 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9051 assert (len
== i
+ 1);
9052 offset
= offset
* 8 + 0x408;
9053 printf (_("sp = sp + %ld"), offset
);
9055 else if ((op
& 0xf0) == 0xe0)
9057 if ((op
& 0x0f) == 7)
9060 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9064 printf (_(" [unsupported opcode]"));
9073 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9077 offset
= word
& 0x7fffffff;
9078 if (offset
& 0x40000000)
9079 offset
|= ~ (bfd_vma
) 0x7fffffff;
9081 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9084 return offset
+ where
;
9088 decode_arm_unwind (Filedata
* filedata
,
9089 struct arm_unw_aux_info
* aux
,
9091 unsigned int remaining
,
9092 bfd_vma data_offset
,
9093 Elf_Internal_Shdr
* data_sec
,
9094 struct arm_section
* data_arm_sec
)
9097 unsigned int more_words
= 0;
9098 struct absaddr addr
;
9099 bfd_vma sym_name
= (bfd_vma
) -1;
9100 bfd_boolean res
= TRUE
;
9104 /* Fetch the first word.
9105 Note - when decoding an object file the address extracted
9106 here will always be 0. So we also pass in the sym_name
9107 parameter so that we can find the symbol associated with
9108 the personality routine. */
9109 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9110 & word
, & addr
, & sym_name
))
9117 addr
.section
= SHN_UNDEF
;
9121 if ((word
& 0x80000000) == 0)
9123 /* Expand prel31 for personality routine. */
9125 const char *procname
;
9127 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9128 printf (_(" Personality routine: "));
9130 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9131 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9133 procname
= aux
->strtab
+ sym_name
;
9134 print_vma (fn
, PREFIX_HEX
);
9137 fputs (" <", stdout
);
9138 fputs (procname
, stdout
);
9139 fputc ('>', stdout
);
9143 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9144 fputc ('\n', stdout
);
9146 /* The GCC personality routines use the standard compact
9147 encoding, starting with one byte giving the number of
9149 if (procname
!= NULL
9150 && (const_strneq (procname
, "__gcc_personality_v0")
9151 || const_strneq (procname
, "__gxx_personality_v0")
9152 || const_strneq (procname
, "__gcj_personality_v0")
9153 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9160 printf (_(" [Truncated data]\n"));
9163 more_words
= word
>> 24;
9173 /* ARM EHABI Section 6.3:
9175 An exception-handling table entry for the compact model looks like:
9179 1 0 index Data for personalityRoutine[index] */
9181 if (filedata
->file_header
.e_machine
== EM_ARM
9182 && (word
& 0x70000000))
9184 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9188 per_index
= (word
>> 24) & 0x7f;
9189 printf (_(" Compact model index: %d\n"), per_index
);
9196 else if (per_index
< 3)
9198 more_words
= (word
>> 16) & 0xff;
9204 switch (filedata
->file_header
.e_machine
)
9209 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9210 data_offset
, data_sec
, data_arm_sec
))
9215 warn (_("Unknown ARM compact model index encountered\n"));
9216 printf (_(" [reserved]\n"));
9224 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9225 data_offset
, data_sec
, data_arm_sec
))
9228 else if (per_index
< 5)
9230 if (((word
>> 17) & 0x7f) == 0x7f)
9231 printf (_(" Restore stack from frame pointer\n"));
9233 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9234 printf (_(" Registers restored: "));
9236 printf (" (compact) ");
9237 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9239 printf (_(" Return register: %s\n"),
9240 tic6x_unwind_regnames
[word
& 0xf]);
9243 printf (_(" [reserved (%d)]\n"), per_index
);
9247 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9248 filedata
->file_header
.e_machine
);
9252 /* Decode the descriptors. Not implemented. */
9258 dump_arm_unwind (Filedata
* filedata
,
9259 struct arm_unw_aux_info
* aux
,
9260 Elf_Internal_Shdr
* exidx_sec
)
9262 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9263 unsigned int i
, exidx_len
;
9264 unsigned long j
, nfuns
;
9265 bfd_boolean res
= TRUE
;
9267 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9268 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9269 exidx_len
= exidx_sec
->sh_size
/ 8;
9271 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9272 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9273 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9274 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9276 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9278 for (i
= 0; i
< exidx_len
; i
++)
9280 unsigned int exidx_fn
, exidx_entry
;
9281 struct absaddr fn_addr
, entry_addr
;
9284 fputc ('\n', stdout
);
9286 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9287 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9288 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9289 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9292 arm_free_section (& exidx_arm_sec
);
9293 arm_free_section (& extab_arm_sec
);
9297 /* ARM EHABI, Section 5:
9298 An index table entry consists of 2 words.
9299 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9300 if (exidx_fn
& 0x80000000)
9302 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9306 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9308 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9309 fputs (": ", stdout
);
9311 if (exidx_entry
== 1)
9313 print_vma (exidx_entry
, PREFIX_HEX
);
9314 fputs (" [cantunwind]\n", stdout
);
9316 else if (exidx_entry
& 0x80000000)
9318 print_vma (exidx_entry
, PREFIX_HEX
);
9319 fputc ('\n', stdout
);
9320 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9324 bfd_vma table
, table_offset
= 0;
9325 Elf_Internal_Shdr
*table_sec
;
9327 fputs ("@", stdout
);
9328 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9329 print_vma (table
, PREFIX_HEX
);
9332 /* Locate the matching .ARM.extab. */
9333 if (entry_addr
.section
!= SHN_UNDEF
9334 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9336 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9337 table_offset
= entry_addr
.offset
;
9339 if (table_offset
> table_sec
->sh_size
9340 || ((bfd_signed_vma
) table_offset
) < 0)
9342 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9343 (unsigned long) table_offset
,
9344 printable_section_name (filedata
, table_sec
));
9351 table_sec
= find_section_by_address (filedata
, table
);
9352 if (table_sec
!= NULL
)
9353 table_offset
= table
- table_sec
->sh_addr
;
9356 if (table_sec
== NULL
)
9358 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9359 (unsigned long) table
);
9364 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9373 arm_free_section (&exidx_arm_sec
);
9374 arm_free_section (&extab_arm_sec
);
9379 /* Used for both ARM and C6X unwinding tables. */
9382 arm_process_unwind (Filedata
* filedata
)
9384 struct arm_unw_aux_info aux
;
9385 Elf_Internal_Shdr
*unwsec
= NULL
;
9386 Elf_Internal_Shdr
*sec
;
9388 unsigned int sec_type
;
9389 bfd_boolean res
= TRUE
;
9391 switch (filedata
->file_header
.e_machine
)
9394 sec_type
= SHT_ARM_EXIDX
;
9398 sec_type
= SHT_C6000_UNWIND
;
9402 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9403 filedata
->file_header
.e_machine
);
9407 if (filedata
->string_table
== NULL
)
9410 memset (& aux
, 0, sizeof (aux
));
9411 aux
.filedata
= filedata
;
9413 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9415 if (sec
->sh_type
== SHT_SYMTAB
)
9419 error (_("Multiple symbol tables encountered\n"));
9425 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9426 &aux
.strtab
, &aux
.strtab_size
))
9429 else if (sec
->sh_type
== sec_type
)
9434 printf (_("\nThere are no unwind sections in this file.\n"));
9436 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9438 if (sec
->sh_type
== sec_type
)
9440 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9441 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9442 "contains %lu entry:\n",
9443 "\nUnwind section '%s' at offset 0x%lx "
9444 "contains %lu entries:\n",
9446 printable_section_name (filedata
, sec
),
9447 (unsigned long) sec
->sh_offset
,
9450 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9458 free ((char *) aux
.strtab
);
9464 process_unwind (Filedata
* filedata
)
9466 struct unwind_handler
9468 unsigned int machtype
;
9469 bfd_boolean (* handler
)(Filedata
*);
9472 { EM_ARM
, arm_process_unwind
},
9473 { EM_IA_64
, ia64_process_unwind
},
9474 { EM_PARISC
, hppa_process_unwind
},
9475 { EM_TI_C6000
, arm_process_unwind
},
9483 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9484 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9485 return handlers
[i
].handler (filedata
);
9487 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9488 get_machine_name (filedata
->file_header
.e_machine
));
9493 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9495 switch (entry
->d_tag
)
9497 case DT_AARCH64_BTI_PLT
:
9498 case DT_AARCH64_PAC_PLT
:
9501 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9508 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9510 switch (entry
->d_tag
)
9513 if (entry
->d_un
.d_val
== 0)
9517 static const char * opts
[] =
9519 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9520 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9521 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9522 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9526 bfd_boolean first
= TRUE
;
9528 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9529 if (entry
->d_un
.d_val
& (1 << cnt
))
9531 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9537 case DT_MIPS_IVERSION
:
9538 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9539 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9543 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9544 /* Note: coded this way so that there is a single string for translation. */
9545 printf (_("<corrupt: %s>"), buf
);
9549 case DT_MIPS_TIME_STAMP
:
9553 time_t atime
= entry
->d_un
.d_val
;
9555 tmp
= gmtime (&atime
);
9556 /* PR 17531: file: 6accc532. */
9558 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9560 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9561 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9562 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9563 printf (_("Time Stamp: %s"), timebuf
);
9567 case DT_MIPS_RLD_VERSION
:
9568 case DT_MIPS_LOCAL_GOTNO
:
9569 case DT_MIPS_CONFLICTNO
:
9570 case DT_MIPS_LIBLISTNO
:
9571 case DT_MIPS_SYMTABNO
:
9572 case DT_MIPS_UNREFEXTNO
:
9573 case DT_MIPS_HIPAGENO
:
9574 case DT_MIPS_DELTA_CLASS_NO
:
9575 case DT_MIPS_DELTA_INSTANCE_NO
:
9576 case DT_MIPS_DELTA_RELOC_NO
:
9577 case DT_MIPS_DELTA_SYM_NO
:
9578 case DT_MIPS_DELTA_CLASSSYM_NO
:
9579 case DT_MIPS_COMPACT_SIZE
:
9580 print_vma (entry
->d_un
.d_val
, DEC
);
9584 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9585 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9586 /* Falls through. */
9589 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9595 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9597 switch (entry
->d_tag
)
9599 case DT_HP_DLD_FLAGS
:
9608 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9609 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9610 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9611 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9612 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9613 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9614 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9615 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9616 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9617 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9618 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9619 { DT_HP_GST
, "HP_GST" },
9620 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9621 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9622 { DT_HP_NODELETE
, "HP_NODELETE" },
9623 { DT_HP_GROUP
, "HP_GROUP" },
9624 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9626 bfd_boolean first
= TRUE
;
9628 bfd_vma val
= entry
->d_un
.d_val
;
9630 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9631 if (val
& flags
[cnt
].bit
)
9635 fputs (flags
[cnt
].str
, stdout
);
9637 val
^= flags
[cnt
].bit
;
9640 if (val
!= 0 || first
)
9644 print_vma (val
, HEX
);
9650 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9658 /* VMS vs Unix time offset and factor. */
9660 #define VMS_EPOCH_OFFSET 35067168000000000LL
9661 #define VMS_GRANULARITY_FACTOR 10000000
9663 /* Display a VMS time in a human readable format. */
9666 print_vms_time (bfd_int64_t vmstime
)
9671 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9672 tm
= gmtime (&unxtime
);
9673 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9674 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9675 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9680 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9682 switch (entry
->d_tag
)
9684 case DT_IA_64_PLT_RESERVE
:
9685 /* First 3 slots reserved. */
9686 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9688 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9691 case DT_IA_64_VMS_LINKTIME
:
9693 print_vms_time (entry
->d_un
.d_val
);
9697 case DT_IA_64_VMS_LNKFLAGS
:
9698 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9699 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9700 printf (" CALL_DEBUG");
9701 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9702 printf (" NOP0BUFS");
9703 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9704 printf (" P0IMAGE");
9705 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9706 printf (" MKTHREADS");
9707 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9708 printf (" UPCALLS");
9709 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9711 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9712 printf (" INITIALIZE");
9713 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9715 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9716 printf (" EXE_INIT");
9717 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9718 printf (" TBK_IN_IMG");
9719 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9720 printf (" DBG_IN_IMG");
9721 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9722 printf (" TBK_IN_DSF");
9723 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9724 printf (" DBG_IN_DSF");
9725 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9726 printf (" SIGNATURES");
9727 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9728 printf (" REL_SEG_OFF");
9732 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9739 get_32bit_dynamic_section (Filedata
* filedata
)
9741 Elf32_External_Dyn
* edyn
;
9742 Elf32_External_Dyn
* ext
;
9743 Elf_Internal_Dyn
* entry
;
9745 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9746 dynamic_size
, _("dynamic section"));
9750 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9751 might not have the luxury of section headers. Look for the DT_NULL
9752 terminator to determine the number of entries. */
9753 for (ext
= edyn
, dynamic_nent
= 0;
9754 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9758 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9762 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9764 if (dynamic_section
== NULL
)
9766 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9767 (unsigned long) dynamic_nent
);
9772 for (ext
= edyn
, entry
= dynamic_section
;
9773 entry
< dynamic_section
+ dynamic_nent
;
9776 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9777 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9786 get_64bit_dynamic_section (Filedata
* filedata
)
9788 Elf64_External_Dyn
* edyn
;
9789 Elf64_External_Dyn
* ext
;
9790 Elf_Internal_Dyn
* entry
;
9792 /* Read in the data. */
9793 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9794 dynamic_size
, _("dynamic section"));
9798 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9799 might not have the luxury of section headers. Look for the DT_NULL
9800 terminator to determine the number of entries. */
9801 for (ext
= edyn
, dynamic_nent
= 0;
9802 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9803 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9807 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9811 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9813 if (dynamic_section
== NULL
)
9815 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9816 (unsigned long) dynamic_nent
);
9821 /* Convert from external to internal formats. */
9822 for (ext
= edyn
, entry
= dynamic_section
;
9823 entry
< dynamic_section
+ dynamic_nent
;
9826 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9827 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9836 print_dynamic_flags (bfd_vma flags
)
9838 bfd_boolean first
= TRUE
;
9844 flag
= flags
& - flags
;
9854 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9855 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9856 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9857 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9858 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9859 default: fputs (_("unknown"), stdout
); break;
9865 /* Parse and display the contents of the dynamic section. */
9868 process_dynamic_section (Filedata
* filedata
)
9870 Elf_Internal_Dyn
* entry
;
9872 if (dynamic_size
== 0)
9875 printf (_("\nThere is no dynamic section in this file.\n"));
9882 if (! get_32bit_dynamic_section (filedata
))
9887 if (! get_64bit_dynamic_section (filedata
))
9891 /* Find the appropriate symbol table. */
9892 if (dynamic_symbols
== NULL
)
9894 for (entry
= dynamic_section
;
9895 entry
< dynamic_section
+ dynamic_nent
;
9898 Elf_Internal_Shdr section
;
9900 if (entry
->d_tag
!= DT_SYMTAB
)
9903 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9905 /* Since we do not know how big the symbol table is,
9906 we default to reading in the entire file (!) and
9907 processing that. This is overkill, I know, but it
9909 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9910 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9912 /* See PR 21379 for a reproducer. */
9913 error (_("Invalid DT_SYMTAB entry: %lx\n"),
9914 (long) section
.sh_offset
);
9918 if (archive_file_offset
!= 0)
9919 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9921 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9924 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9926 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9927 section
.sh_name
= filedata
->string_table_length
;
9929 if (dynamic_symbols
!= NULL
)
9931 error (_("Multiple dynamic symbol table sections found\n"));
9932 free (dynamic_symbols
);
9934 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9935 if (num_dynamic_syms
< 1)
9937 error (_("Unable to determine the number of symbols to load\n"));
9943 /* Similarly find a string table. */
9944 if (dynamic_strings
== NULL
)
9946 for (entry
= dynamic_section
;
9947 entry
< dynamic_section
+ dynamic_nent
;
9950 unsigned long offset
;
9953 if (entry
->d_tag
!= DT_STRTAB
)
9956 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9958 /* Since we do not know how big the string table is,
9959 we default to reading in the entire file (!) and
9960 processing that. This is overkill, I know, but it
9963 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9965 if (archive_file_offset
!= 0)
9966 str_tab_len
= archive_file_size
- offset
;
9968 str_tab_len
= filedata
->file_size
- offset
;
9970 if (str_tab_len
< 1)
9973 (_("Unable to determine the length of the dynamic string table\n"));
9977 if (dynamic_strings
!= NULL
)
9979 error (_("Multiple dynamic string tables found\n"));
9980 free (dynamic_strings
);
9983 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9985 _("dynamic string table"));
9986 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9990 /* And find the syminfo section if available. */
9991 if (dynamic_syminfo
== NULL
)
9993 unsigned long syminsz
= 0;
9995 for (entry
= dynamic_section
;
9996 entry
< dynamic_section
+ dynamic_nent
;
9999 if (entry
->d_tag
== DT_SYMINENT
)
10001 /* Note: these braces are necessary to avoid a syntax
10002 error from the SunOS4 C compiler. */
10003 /* PR binutils/17531: A corrupt file can trigger this test.
10004 So do not use an assert, instead generate an error message. */
10005 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10006 error (_("Bad value (%d) for SYMINENT entry\n"),
10007 (int) entry
->d_un
.d_val
);
10009 else if (entry
->d_tag
== DT_SYMINSZ
)
10010 syminsz
= entry
->d_un
.d_val
;
10011 else if (entry
->d_tag
== DT_SYMINFO
)
10012 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
10016 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10018 Elf_External_Syminfo
* extsyminfo
;
10019 Elf_External_Syminfo
* extsym
;
10020 Elf_Internal_Syminfo
* syminfo
;
10022 /* There is a syminfo section. Read the data. */
10023 extsyminfo
= (Elf_External_Syminfo
*)
10024 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
10025 _("symbol information"));
10029 if (dynamic_syminfo
!= NULL
)
10031 error (_("Multiple dynamic symbol information sections found\n"));
10032 free (dynamic_syminfo
);
10034 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10035 if (dynamic_syminfo
== NULL
)
10037 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10038 (unsigned long) syminsz
);
10042 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10043 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10044 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10045 ++syminfo
, ++extsym
)
10047 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10048 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10055 if (do_dynamic
&& dynamic_addr
)
10056 printf (ngettext ("\nDynamic section at offset 0x%lx "
10057 "contains %lu entry:\n",
10058 "\nDynamic section at offset 0x%lx "
10059 "contains %lu entries:\n",
10061 dynamic_addr
, (unsigned long) dynamic_nent
);
10063 printf (_(" Tag Type Name/Value\n"));
10065 for (entry
= dynamic_section
;
10066 entry
< dynamic_section
+ dynamic_nent
;
10071 const char * dtype
;
10074 print_vma (entry
->d_tag
, FULL_HEX
);
10075 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10076 printf (" (%s)%*s", dtype
,
10077 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10080 switch (entry
->d_tag
)
10084 print_dynamic_flags (entry
->d_un
.d_val
);
10094 switch (entry
->d_tag
)
10097 printf (_("Auxiliary library"));
10101 printf (_("Filter library"));
10105 printf (_("Configuration file"));
10109 printf (_("Dependency audit library"));
10113 printf (_("Audit library"));
10117 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10118 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10122 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10131 printf (_("Flags:"));
10133 if (entry
->d_un
.d_val
== 0)
10134 printf (_(" None\n"));
10137 unsigned long int val
= entry
->d_un
.d_val
;
10139 if (val
& DTF_1_PARINIT
)
10141 printf (" PARINIT");
10142 val
^= DTF_1_PARINIT
;
10144 if (val
& DTF_1_CONFEXP
)
10146 printf (" CONFEXP");
10147 val
^= DTF_1_CONFEXP
;
10150 printf (" %lx", val
);
10159 printf (_("Flags:"));
10161 if (entry
->d_un
.d_val
== 0)
10162 printf (_(" None\n"));
10165 unsigned long int val
= entry
->d_un
.d_val
;
10167 if (val
& DF_P1_LAZYLOAD
)
10169 printf (" LAZYLOAD");
10170 val
^= DF_P1_LAZYLOAD
;
10172 if (val
& DF_P1_GROUPPERM
)
10174 printf (" GROUPPERM");
10175 val
^= DF_P1_GROUPPERM
;
10178 printf (" %lx", val
);
10187 printf (_("Flags:"));
10188 if (entry
->d_un
.d_val
== 0)
10189 printf (_(" None\n"));
10192 unsigned long int val
= entry
->d_un
.d_val
;
10194 if (val
& DF_1_NOW
)
10199 if (val
& DF_1_GLOBAL
)
10201 printf (" GLOBAL");
10202 val
^= DF_1_GLOBAL
;
10204 if (val
& DF_1_GROUP
)
10209 if (val
& DF_1_NODELETE
)
10211 printf (" NODELETE");
10212 val
^= DF_1_NODELETE
;
10214 if (val
& DF_1_LOADFLTR
)
10216 printf (" LOADFLTR");
10217 val
^= DF_1_LOADFLTR
;
10219 if (val
& DF_1_INITFIRST
)
10221 printf (" INITFIRST");
10222 val
^= DF_1_INITFIRST
;
10224 if (val
& DF_1_NOOPEN
)
10226 printf (" NOOPEN");
10227 val
^= DF_1_NOOPEN
;
10229 if (val
& DF_1_ORIGIN
)
10231 printf (" ORIGIN");
10232 val
^= DF_1_ORIGIN
;
10234 if (val
& DF_1_DIRECT
)
10236 printf (" DIRECT");
10237 val
^= DF_1_DIRECT
;
10239 if (val
& DF_1_TRANS
)
10244 if (val
& DF_1_INTERPOSE
)
10246 printf (" INTERPOSE");
10247 val
^= DF_1_INTERPOSE
;
10249 if (val
& DF_1_NODEFLIB
)
10251 printf (" NODEFLIB");
10252 val
^= DF_1_NODEFLIB
;
10254 if (val
& DF_1_NODUMP
)
10256 printf (" NODUMP");
10257 val
^= DF_1_NODUMP
;
10259 if (val
& DF_1_CONFALT
)
10261 printf (" CONFALT");
10262 val
^= DF_1_CONFALT
;
10264 if (val
& DF_1_ENDFILTEE
)
10266 printf (" ENDFILTEE");
10267 val
^= DF_1_ENDFILTEE
;
10269 if (val
& DF_1_DISPRELDNE
)
10271 printf (" DISPRELDNE");
10272 val
^= DF_1_DISPRELDNE
;
10274 if (val
& DF_1_DISPRELPND
)
10276 printf (" DISPRELPND");
10277 val
^= DF_1_DISPRELPND
;
10279 if (val
& DF_1_NODIRECT
)
10281 printf (" NODIRECT");
10282 val
^= DF_1_NODIRECT
;
10284 if (val
& DF_1_IGNMULDEF
)
10286 printf (" IGNMULDEF");
10287 val
^= DF_1_IGNMULDEF
;
10289 if (val
& DF_1_NOKSYMS
)
10291 printf (" NOKSYMS");
10292 val
^= DF_1_NOKSYMS
;
10294 if (val
& DF_1_NOHDR
)
10299 if (val
& DF_1_EDITED
)
10301 printf (" EDITED");
10302 val
^= DF_1_EDITED
;
10304 if (val
& DF_1_NORELOC
)
10306 printf (" NORELOC");
10307 val
^= DF_1_NORELOC
;
10309 if (val
& DF_1_SYMINTPOSE
)
10311 printf (" SYMINTPOSE");
10312 val
^= DF_1_SYMINTPOSE
;
10314 if (val
& DF_1_GLOBAUDIT
)
10316 printf (" GLOBAUDIT");
10317 val
^= DF_1_GLOBAUDIT
;
10319 if (val
& DF_1_SINGLETON
)
10321 printf (" SINGLETON");
10322 val
^= DF_1_SINGLETON
;
10324 if (val
& DF_1_STUB
)
10329 if (val
& DF_1_PIE
)
10334 if (val
& DF_1_KMOD
)
10339 if (val
& DF_1_WEAKFILTER
)
10341 printf (" WEAKFILTER");
10342 val
^= DF_1_WEAKFILTER
;
10344 if (val
& DF_1_NOCOMMON
)
10346 printf (" NOCOMMON");
10347 val
^= DF_1_NOCOMMON
;
10350 printf (" %lx", val
);
10357 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10359 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10379 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10385 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10386 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10392 switch (entry
->d_tag
)
10395 printf (_("Shared library: [%s]"), name
);
10397 if (streq (name
, program_interpreter
))
10398 printf (_(" program interpreter"));
10402 printf (_("Library soname: [%s]"), name
);
10406 printf (_("Library rpath: [%s]"), name
);
10410 printf (_("Library runpath: [%s]"), name
);
10414 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10419 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10432 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10433 /* Fall through. */
10437 case DT_INIT_ARRAYSZ
:
10438 case DT_FINI_ARRAYSZ
:
10439 case DT_GNU_CONFLICTSZ
:
10440 case DT_GNU_LIBLISTSZ
:
10443 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10444 printf (_(" (bytes)\n"));
10449 case DT_VERNEEDNUM
:
10454 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10463 case DT_INIT_ARRAY
:
10464 case DT_FINI_ARRAY
:
10467 if (entry
->d_tag
== DT_USED
10468 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10470 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10474 printf (_("Not needed object: [%s]\n"), name
);
10479 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10485 /* The value of this entry is ignored. */
10490 case DT_GNU_PRELINKED
:
10494 time_t atime
= entry
->d_un
.d_val
;
10496 tmp
= gmtime (&atime
);
10497 /* PR 17533 file: 041-1244816-0.004. */
10499 printf (_("<corrupt time val: %lx"),
10500 (unsigned long) atime
);
10502 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10503 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10504 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10510 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10513 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10519 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10520 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10525 switch (filedata
->file_header
.e_machine
)
10528 dynamic_section_aarch64_val (entry
);
10531 case EM_MIPS_RS3_LE
:
10532 dynamic_section_mips_val (entry
);
10535 dynamic_section_parisc_val (entry
);
10538 dynamic_section_ia64_val (entry
);
10541 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10553 get_ver_flags (unsigned int flags
)
10555 static char buff
[128];
10562 if (flags
& VER_FLG_BASE
)
10563 strcat (buff
, "BASE");
10565 if (flags
& VER_FLG_WEAK
)
10567 if (flags
& VER_FLG_BASE
)
10568 strcat (buff
, " | ");
10570 strcat (buff
, "WEAK");
10573 if (flags
& VER_FLG_INFO
)
10575 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10576 strcat (buff
, " | ");
10578 strcat (buff
, "INFO");
10581 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10583 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10584 strcat (buff
, " | ");
10586 strcat (buff
, _("<unknown>"));
10592 /* Display the contents of the version sections. */
10595 process_version_sections (Filedata
* filedata
)
10597 Elf_Internal_Shdr
* section
;
10599 bfd_boolean found
= FALSE
;
10604 for (i
= 0, section
= filedata
->section_headers
;
10605 i
< filedata
->file_header
.e_shnum
;
10608 switch (section
->sh_type
)
10610 case SHT_GNU_verdef
:
10612 Elf_External_Verdef
* edefs
;
10619 printf (ngettext ("\nVersion definition section '%s' "
10620 "contains %u entry:\n",
10621 "\nVersion definition section '%s' "
10622 "contains %u entries:\n",
10624 printable_section_name (filedata
, section
),
10627 printf (_(" Addr: 0x"));
10628 printf_vma (section
->sh_addr
);
10629 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10630 (unsigned long) section
->sh_offset
, section
->sh_link
,
10631 printable_section_name_from_index (filedata
, section
->sh_link
));
10633 edefs
= (Elf_External_Verdef
*)
10634 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10635 _("version definition section"));
10638 endbuf
= (char *) edefs
+ section
->sh_size
;
10640 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10643 Elf_External_Verdef
* edef
;
10644 Elf_Internal_Verdef ent
;
10645 Elf_External_Verdaux
* eaux
;
10646 Elf_Internal_Verdaux aux
;
10647 unsigned long isum
;
10650 vstart
= ((char *) edefs
) + idx
;
10651 if (vstart
+ sizeof (*edef
) > endbuf
)
10654 edef
= (Elf_External_Verdef
*) vstart
;
10656 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10657 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10658 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10659 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10660 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10661 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10662 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10664 printf (_(" %#06lx: Rev: %d Flags: %s"),
10665 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10667 printf (_(" Index: %d Cnt: %d "),
10668 ent
.vd_ndx
, ent
.vd_cnt
);
10670 /* Check for overflow. */
10671 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10674 vstart
+= ent
.vd_aux
;
10676 if (vstart
+ sizeof (*eaux
) > endbuf
)
10678 eaux
= (Elf_External_Verdaux
*) vstart
;
10680 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10681 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10683 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10684 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10686 printf (_("Name index: %ld\n"), aux
.vda_name
);
10688 isum
= idx
+ ent
.vd_aux
;
10690 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10692 if (aux
.vda_next
< sizeof (*eaux
)
10693 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10695 warn (_("Invalid vda_next field of %lx\n"),
10700 /* Check for overflow. */
10701 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10704 isum
+= aux
.vda_next
;
10705 vstart
+= aux
.vda_next
;
10707 if (vstart
+ sizeof (*eaux
) > endbuf
)
10709 eaux
= (Elf_External_Verdaux
*) vstart
;
10711 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10712 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10714 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10715 printf (_(" %#06lx: Parent %d: %s\n"),
10716 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10718 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10719 isum
, j
, aux
.vda_name
);
10722 if (j
< ent
.vd_cnt
)
10723 printf (_(" Version def aux past end of section\n"));
10726 file: id:000001,src:000172+005151,op:splice,rep:2. */
10727 if (ent
.vd_next
< sizeof (*edef
)
10728 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10730 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10731 cnt
= section
->sh_info
;
10734 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10737 idx
+= ent
.vd_next
;
10740 if (cnt
< section
->sh_info
)
10741 printf (_(" Version definition past end of section\n"));
10747 case SHT_GNU_verneed
:
10749 Elf_External_Verneed
* eneed
;
10756 printf (ngettext ("\nVersion needs section '%s' "
10757 "contains %u entry:\n",
10758 "\nVersion needs section '%s' "
10759 "contains %u entries:\n",
10761 printable_section_name (filedata
, section
), section
->sh_info
);
10763 printf (_(" Addr: 0x"));
10764 printf_vma (section
->sh_addr
);
10765 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10766 (unsigned long) section
->sh_offset
, section
->sh_link
,
10767 printable_section_name_from_index (filedata
, section
->sh_link
));
10769 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10770 section
->sh_offset
, 1,
10772 _("Version Needs section"));
10775 endbuf
= (char *) eneed
+ section
->sh_size
;
10777 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10779 Elf_External_Verneed
* entry
;
10780 Elf_Internal_Verneed ent
;
10781 unsigned long isum
;
10785 vstart
= ((char *) eneed
) + idx
;
10786 if (vstart
+ sizeof (*entry
) > endbuf
)
10789 entry
= (Elf_External_Verneed
*) vstart
;
10791 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10792 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10793 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10794 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10795 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10797 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10799 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10800 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10802 printf (_(" File: %lx"), ent
.vn_file
);
10804 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10806 /* Check for overflow. */
10807 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10809 vstart
+= ent
.vn_aux
;
10811 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10813 Elf_External_Vernaux
* eaux
;
10814 Elf_Internal_Vernaux aux
;
10816 if (vstart
+ sizeof (*eaux
) > endbuf
)
10818 eaux
= (Elf_External_Vernaux
*) vstart
;
10820 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10821 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10822 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10823 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10824 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10826 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10827 printf (_(" %#06lx: Name: %s"),
10828 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10830 printf (_(" %#06lx: Name index: %lx"),
10831 isum
, aux
.vna_name
);
10833 printf (_(" Flags: %s Version: %d\n"),
10834 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10836 if (aux
.vna_next
< sizeof (*eaux
)
10837 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10839 warn (_("Invalid vna_next field of %lx\n"),
10844 /* Check for overflow. */
10845 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10847 isum
+= aux
.vna_next
;
10848 vstart
+= aux
.vna_next
;
10851 if (j
< ent
.vn_cnt
)
10852 warn (_("Missing Version Needs auxillary information\n"));
10854 if (ent
.vn_next
< sizeof (*entry
)
10855 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10857 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10858 cnt
= section
->sh_info
;
10861 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10863 idx
+= ent
.vn_next
;
10866 if (cnt
< section
->sh_info
)
10867 warn (_("Missing Version Needs information\n"));
10873 case SHT_GNU_versym
:
10875 Elf_Internal_Shdr
* link_section
;
10878 unsigned char * edata
;
10879 unsigned short * data
;
10881 Elf_Internal_Sym
* symbols
;
10882 Elf_Internal_Shdr
* string_sec
;
10883 unsigned long num_syms
;
10886 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10889 link_section
= filedata
->section_headers
+ section
->sh_link
;
10890 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10892 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10897 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10898 if (symbols
== NULL
)
10901 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10903 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10904 string_sec
->sh_size
,
10905 _("version string table"));
10912 printf (ngettext ("\nVersion symbols section '%s' "
10913 "contains %lu entry:\n",
10914 "\nVersion symbols section '%s' "
10915 "contains %lu entries:\n",
10917 printable_section_name (filedata
, section
), (unsigned long) total
);
10919 printf (_(" Addr: 0x"));
10920 printf_vma (section
->sh_addr
);
10921 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10922 (unsigned long) section
->sh_offset
, section
->sh_link
,
10923 printable_section_name (filedata
, link_section
));
10925 off
= offset_from_vma (filedata
,
10926 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10927 total
* sizeof (short));
10928 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
10929 sizeof (short), total
,
10930 _("version symbol data"));
10938 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10940 for (cnt
= total
; cnt
--;)
10941 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10946 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10950 char *invalid
= _("*invalid*");
10952 printf (" %03x:", cnt
);
10954 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10955 switch (data
[cnt
+ j
])
10958 fputs (_(" 0 (*local*) "), stdout
);
10962 fputs (_(" 1 (*global*) "), stdout
);
10966 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10967 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10969 /* If this index value is greater than the size of the symbols
10970 array, break to avoid an out-of-bounds read. */
10971 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10973 warn (_("invalid index into symbol array\n"));
10978 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10980 Elf_Internal_Verneed ivn
;
10981 unsigned long offset
;
10983 offset
= offset_from_vma
10984 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10985 sizeof (Elf_External_Verneed
));
10989 Elf_Internal_Vernaux ivna
;
10990 Elf_External_Verneed evn
;
10991 Elf_External_Vernaux evna
;
10992 unsigned long a_off
;
10994 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10995 _("version need")) == NULL
)
10998 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10999 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11001 a_off
= offset
+ ivn
.vn_aux
;
11005 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11006 1, _("version need aux (2)")) == NULL
)
11009 ivna
.vna_other
= 0;
11013 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11014 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11017 a_off
+= ivna
.vna_next
;
11019 while (ivna
.vna_other
!= data
[cnt
+ j
]
11020 && ivna
.vna_next
!= 0);
11022 if (ivna
.vna_other
== data
[cnt
+ j
])
11024 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11026 if (ivna
.vna_name
>= string_sec
->sh_size
)
11029 name
= strtab
+ ivna
.vna_name
;
11033 offset
+= ivn
.vn_next
;
11035 while (ivn
.vn_next
);
11038 if (data
[cnt
+ j
] != 0x8001
11039 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11041 Elf_Internal_Verdef ivd
;
11042 Elf_External_Verdef evd
;
11043 unsigned long offset
;
11045 offset
= offset_from_vma
11046 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11051 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11052 _("version def")) == NULL
)
11055 /* PR 17531: file: 046-1082287-0.004. */
11056 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11061 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11062 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11065 offset
+= ivd
.vd_next
;
11067 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11068 && ivd
.vd_next
!= 0);
11070 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11072 Elf_External_Verdaux evda
;
11073 Elf_Internal_Verdaux ivda
;
11075 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11077 if (get_data (&evda
, filedata
,
11078 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11080 _("version def aux")) == NULL
)
11083 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11085 if (ivda
.vda_name
>= string_sec
->sh_size
)
11087 else if (name
!= NULL
&& name
!= invalid
)
11088 name
= _("*both*");
11090 name
= strtab
+ ivda
.vda_name
;
11094 nn
+= printf ("(%s%-*s",
11096 12 - (int) strlen (name
),
11100 printf ("%*c", 18 - nn
, ' ');
11118 printf (_("\nNo version information found in this file.\n"));
11123 static const char *
11124 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11126 static char buff
[32];
11130 case STB_LOCAL
: return "LOCAL";
11131 case STB_GLOBAL
: return "GLOBAL";
11132 case STB_WEAK
: return "WEAK";
11134 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11135 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11137 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11139 if (binding
== STB_GNU_UNIQUE
11140 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11142 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11145 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11150 static const char *
11151 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11153 static char buff
[32];
11157 case STT_NOTYPE
: return "NOTYPE";
11158 case STT_OBJECT
: return "OBJECT";
11159 case STT_FUNC
: return "FUNC";
11160 case STT_SECTION
: return "SECTION";
11161 case STT_FILE
: return "FILE";
11162 case STT_COMMON
: return "COMMON";
11163 case STT_TLS
: return "TLS";
11164 case STT_RELC
: return "RELC";
11165 case STT_SRELC
: return "SRELC";
11167 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11169 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11170 return "THUMB_FUNC";
11172 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11175 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11176 return "PARISC_MILLI";
11178 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11180 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11182 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11184 if (type
== STT_HP_OPAQUE
)
11185 return "HP_OPAQUE";
11186 if (type
== STT_HP_STUB
)
11190 if (type
== STT_GNU_IFUNC
11191 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11192 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11195 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11198 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11203 static const char *
11204 get_symbol_visibility (unsigned int visibility
)
11206 switch (visibility
)
11208 case STV_DEFAULT
: return "DEFAULT";
11209 case STV_INTERNAL
: return "INTERNAL";
11210 case STV_HIDDEN
: return "HIDDEN";
11211 case STV_PROTECTED
: return "PROTECTED";
11213 error (_("Unrecognized visibility value: %u\n"), visibility
);
11214 return _("<unknown>");
11218 static const char *
11219 get_alpha_symbol_other (unsigned int other
)
11223 case STO_ALPHA_NOPV
: return "NOPV";
11224 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11226 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11227 return _("<unknown>");
11231 static const char *
11232 get_solaris_symbol_visibility (unsigned int visibility
)
11234 switch (visibility
)
11236 case 4: return "EXPORTED";
11237 case 5: return "SINGLETON";
11238 case 6: return "ELIMINATE";
11239 default: return get_symbol_visibility (visibility
);
11243 static const char *
11244 get_aarch64_symbol_other (unsigned int other
)
11246 static char buf
[32];
11248 if (other
& STO_AARCH64_VARIANT_PCS
)
11250 other
&= ~STO_AARCH64_VARIANT_PCS
;
11252 return "VARIANT_PCS";
11253 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11259 static const char *
11260 get_mips_symbol_other (unsigned int other
)
11264 case STO_OPTIONAL
: return "OPTIONAL";
11265 case STO_MIPS_PLT
: return "MIPS PLT";
11266 case STO_MIPS_PIC
: return "MIPS PIC";
11267 case STO_MICROMIPS
: return "MICROMIPS";
11268 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11269 case STO_MIPS16
: return "MIPS16";
11270 default: return NULL
;
11274 static const char *
11275 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11277 if (is_ia64_vms (filedata
))
11279 static char res
[32];
11283 /* Function types is for images and .STB files only. */
11284 switch (filedata
->file_header
.e_type
)
11288 switch (VMS_ST_FUNC_TYPE (other
))
11290 case VMS_SFT_CODE_ADDR
:
11291 strcat (res
, " CA");
11293 case VMS_SFT_SYMV_IDX
:
11294 strcat (res
, " VEC");
11297 strcat (res
, " FD");
11299 case VMS_SFT_RESERVE
:
11300 strcat (res
, " RSV");
11303 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11304 VMS_ST_FUNC_TYPE (other
));
11305 strcat (res
, " <unknown>");
11312 switch (VMS_ST_LINKAGE (other
))
11314 case VMS_STL_IGNORE
:
11315 strcat (res
, " IGN");
11317 case VMS_STL_RESERVE
:
11318 strcat (res
, " RSV");
11321 strcat (res
, " STD");
11324 strcat (res
, " LNK");
11327 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11328 VMS_ST_LINKAGE (other
));
11329 strcat (res
, " <unknown>");
11341 static const char *
11342 get_ppc64_symbol_other (unsigned int other
)
11344 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11347 other
>>= STO_PPC64_LOCAL_BIT
;
11350 static char buf
[32];
11352 other
= ppc64_decode_local_entry (other
);
11353 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11359 static const char *
11360 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11362 const char * result
= NULL
;
11363 static char buff
[32];
11368 switch (filedata
->file_header
.e_machine
)
11371 result
= get_alpha_symbol_other (other
);
11374 result
= get_aarch64_symbol_other (other
);
11377 result
= get_mips_symbol_other (other
);
11380 result
= get_ia64_symbol_other (filedata
, other
);
11383 result
= get_ppc64_symbol_other (other
);
11393 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11397 static const char *
11398 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11400 static char buff
[32];
11404 case SHN_UNDEF
: return "UND";
11405 case SHN_ABS
: return "ABS";
11406 case SHN_COMMON
: return "COM";
11408 if (type
== SHN_IA_64_ANSI_COMMON
11409 && filedata
->file_header
.e_machine
== EM_IA_64
11410 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11412 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11413 || filedata
->file_header
.e_machine
== EM_L1OM
11414 || filedata
->file_header
.e_machine
== EM_K1OM
)
11415 && type
== SHN_X86_64_LCOMMON
)
11416 return "LARGE_COM";
11417 else if ((type
== SHN_MIPS_SCOMMON
11418 && filedata
->file_header
.e_machine
== EM_MIPS
)
11419 || (type
== SHN_TIC6X_SCOMMON
11420 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11422 else if (type
== SHN_MIPS_SUNDEFINED
11423 && filedata
->file_header
.e_machine
== EM_MIPS
)
11425 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11426 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11427 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11428 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11429 else if (type
>= SHN_LORESERVE
)
11430 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11431 else if (type
>= filedata
->file_header
.e_shnum
)
11432 sprintf (buff
, _("bad section index[%3d]"), type
);
11434 sprintf (buff
, "%3d", type
);
11442 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11444 unsigned char * e_data
;
11447 /* If the size_t type is smaller than the bfd_size_type, eg because
11448 you are building a 32-bit tool on a 64-bit host, then make sure
11449 that when (number) is cast to (size_t) no information is lost. */
11450 if (sizeof (size_t) < sizeof (bfd_size_type
)
11451 && (bfd_size_type
) ((size_t) number
) != number
)
11453 error (_("Size truncation prevents reading %s elements of size %u\n"),
11454 bfd_vmatoa ("u", number
), ent_size
);
11458 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
11459 attempting to allocate memory when the read is bound to fail. */
11460 if (ent_size
* number
> filedata
->file_size
)
11462 error (_("Invalid number of dynamic entries: %s\n"),
11463 bfd_vmatoa ("u", number
));
11467 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11468 if (e_data
== NULL
)
11470 error (_("Out of memory reading %s dynamic entries\n"),
11471 bfd_vmatoa ("u", number
));
11475 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11477 error (_("Unable to read in %s bytes of dynamic data\n"),
11478 bfd_vmatoa ("u", number
* ent_size
));
11483 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11484 if (i_data
== NULL
)
11486 error (_("Out of memory allocating space for %s dynamic entries\n"),
11487 bfd_vmatoa ("u", number
));
11493 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11501 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11503 Elf_Internal_Sym
* psym
;
11506 n
= print_vma (si
, DEC_5
);
11508 fputs (&" "[n
], stdout
);
11509 printf (" %3lu: ", hn
);
11511 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11513 printf (_("<No info available for dynamic symbol number %lu>\n"),
11514 (unsigned long) si
);
11518 psym
= dynamic_symbols
+ si
;
11519 print_vma (psym
->st_value
, LONG_HEX
);
11521 print_vma (psym
->st_size
, DEC_5
);
11523 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11524 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11526 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11527 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11530 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11532 printf (" %-7s", get_symbol_visibility (vis
));
11533 /* Check to see if any other bits in the st_other field are set.
11534 Note - displaying this information disrupts the layout of the
11535 table being generated, but for the moment this case is very
11537 if (psym
->st_other
^ vis
)
11538 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11541 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11542 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11543 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11545 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11549 static const char *
11550 get_symbol_version_string (Filedata
* filedata
,
11551 bfd_boolean is_dynsym
,
11552 const char * strtab
,
11553 unsigned long int strtab_size
,
11555 Elf_Internal_Sym
* psym
,
11556 enum versioned_symbol_info
* sym_info
,
11557 unsigned short * vna_other
)
11559 unsigned char data
[2];
11560 unsigned short vers_data
;
11561 unsigned long offset
;
11562 unsigned short max_vd_ndx
;
11565 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11568 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11569 sizeof data
+ si
* sizeof (vers_data
));
11571 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11572 sizeof (data
), 1, _("version data")) == NULL
)
11575 vers_data
= byte_get (data
, 2);
11577 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11580 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11583 /* Usually we'd only see verdef for defined symbols, and verneed for
11584 undefined symbols. However, symbols defined by the linker in
11585 .dynbss for variables copied from a shared library in order to
11586 avoid text relocations are defined yet have verneed. We could
11587 use a heuristic to detect the special case, for example, check
11588 for verneed first on symbols defined in SHT_NOBITS sections, but
11589 it is simpler and more reliable to just look for both verdef and
11590 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11592 if (psym
->st_shndx
!= SHN_UNDEF
11593 && vers_data
!= 0x8001
11594 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11596 Elf_Internal_Verdef ivd
;
11597 Elf_Internal_Verdaux ivda
;
11598 Elf_External_Verdaux evda
;
11601 off
= offset_from_vma (filedata
,
11602 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11603 sizeof (Elf_External_Verdef
));
11607 Elf_External_Verdef evd
;
11609 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11610 _("version def")) == NULL
)
11619 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11620 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11621 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11622 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11625 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11626 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11628 off
+= ivd
.vd_next
;
11630 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11632 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11634 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11637 off
-= ivd
.vd_next
;
11640 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11641 _("version def aux")) != NULL
)
11643 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11645 if (psym
->st_name
!= ivda
.vda_name
)
11646 return (ivda
.vda_name
< strtab_size
11647 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11652 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11654 Elf_External_Verneed evn
;
11655 Elf_Internal_Verneed ivn
;
11656 Elf_Internal_Vernaux ivna
;
11658 offset
= offset_from_vma (filedata
,
11659 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11663 unsigned long vna_off
;
11665 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11666 _("version need")) == NULL
)
11669 ivna
.vna_other
= 0;
11674 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11675 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11677 vna_off
= offset
+ ivn
.vn_aux
;
11681 Elf_External_Vernaux evna
;
11683 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11684 _("version need aux (3)")) == NULL
)
11687 ivna
.vna_other
= 0;
11692 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11693 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11694 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11697 vna_off
+= ivna
.vna_next
;
11699 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11701 if (ivna
.vna_other
== vers_data
)
11704 offset
+= ivn
.vn_next
;
11706 while (ivn
.vn_next
!= 0);
11708 if (ivna
.vna_other
== vers_data
)
11710 *sym_info
= symbol_undefined
;
11711 *vna_other
= ivna
.vna_other
;
11712 return (ivna
.vna_name
< strtab_size
11713 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11715 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11716 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11717 return _("<corrupt>");
11722 /* Dump the symbol table. */
11724 process_symbol_table (Filedata
* filedata
)
11726 Elf_Internal_Shdr
* section
;
11727 bfd_size_type nbuckets
= 0;
11728 bfd_size_type nchains
= 0;
11729 bfd_vma
* buckets
= NULL
;
11730 bfd_vma
* chains
= NULL
;
11731 bfd_vma ngnubuckets
= 0;
11732 bfd_vma
* gnubuckets
= NULL
;
11733 bfd_vma
* gnuchains
= NULL
;
11734 bfd_vma
* mipsxlat
= NULL
;
11735 bfd_vma gnusymidx
= 0;
11736 bfd_size_type ngnuchains
= 0;
11738 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11741 if (dynamic_info
[DT_HASH
]
11743 || (do_using_dynamic
11745 && dynamic_strings
!= NULL
)))
11747 unsigned char nb
[8];
11748 unsigned char nc
[8];
11749 unsigned int hash_ent_size
= 4;
11751 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11752 || filedata
->file_header
.e_machine
== EM_S390
11753 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11754 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11757 if (fseek (filedata
->handle
,
11758 (archive_file_offset
11759 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11760 sizeof nb
+ sizeof nc
)),
11763 error (_("Unable to seek to start of dynamic information\n"));
11767 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11769 error (_("Failed to read in number of buckets\n"));
11773 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11775 error (_("Failed to read in number of chains\n"));
11779 nbuckets
= byte_get (nb
, hash_ent_size
);
11780 nchains
= byte_get (nc
, hash_ent_size
);
11782 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11783 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11785 if (buckets
== NULL
|| chains
== NULL
)
11794 if (do_using_dynamic
)
11799 if (dynamic_info_DT_GNU_HASH
11801 || (do_using_dynamic
11803 && dynamic_strings
!= NULL
)))
11805 unsigned char nb
[16];
11806 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11807 bfd_vma buckets_vma
;
11809 if (fseek (filedata
->handle
,
11810 (archive_file_offset
11811 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11815 error (_("Unable to seek to start of dynamic information\n"));
11819 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11821 error (_("Failed to read in number of buckets\n"));
11825 ngnubuckets
= byte_get (nb
, 4);
11826 gnusymidx
= byte_get (nb
+ 4, 4);
11827 bitmaskwords
= byte_get (nb
+ 8, 4);
11828 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11830 buckets_vma
+= bitmaskwords
* 4;
11832 buckets_vma
+= bitmaskwords
* 8;
11834 if (fseek (filedata
->handle
,
11835 (archive_file_offset
11836 + offset_from_vma (filedata
, buckets_vma
, 4)),
11839 error (_("Unable to seek to start of dynamic information\n"));
11843 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11845 if (gnubuckets
== NULL
)
11848 for (i
= 0; i
< ngnubuckets
; i
++)
11849 if (gnubuckets
[i
] != 0)
11851 if (gnubuckets
[i
] < gnusymidx
)
11854 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11855 maxchain
= gnubuckets
[i
];
11858 if (maxchain
== 0xffffffff)
11861 maxchain
-= gnusymidx
;
11863 if (fseek (filedata
->handle
,
11864 (archive_file_offset
11865 + offset_from_vma (filedata
, buckets_vma
11866 + 4 * (ngnubuckets
+ maxchain
), 4)),
11869 error (_("Unable to seek to start of dynamic information\n"));
11875 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11877 error (_("Failed to determine last chain length\n"));
11881 if (maxchain
+ 1 == 0)
11886 while ((byte_get (nb
, 4) & 1) == 0);
11888 if (fseek (filedata
->handle
,
11889 (archive_file_offset
11890 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11893 error (_("Unable to seek to start of dynamic information\n"));
11897 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11898 ngnuchains
= maxchain
;
11900 if (gnuchains
== NULL
)
11903 if (dynamic_info_DT_MIPS_XHASH
)
11905 if (fseek (filedata
->handle
,
11906 (archive_file_offset
11907 + offset_from_vma (filedata
, (buckets_vma
11912 error (_("Unable to seek to start of dynamic information\n"));
11916 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11917 if (mipsxlat
== NULL
)
11925 if (do_using_dynamic
)
11931 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11933 && do_using_dynamic
11934 && dynamic_strings
!= NULL
11935 && dynamic_symbols
!= NULL
)
11939 if (dynamic_info
[DT_HASH
])
11944 printf (_("\nSymbol table for image:\n"));
11946 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11948 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11950 visited
= xcmalloc (nchains
, 1);
11951 memset (visited
, 0, nchains
);
11952 for (hn
= 0; hn
< nbuckets
; hn
++)
11954 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11956 print_dynamic_symbol (filedata
, si
, hn
);
11957 if (si
>= nchains
|| visited
[si
])
11959 error (_("histogram chain is corrupt\n"));
11968 if (dynamic_info_DT_GNU_HASH
)
11970 printf (_("\nSymbol table of `%s' for image:\n"),
11971 GNU_HASH_SECTION_NAME
);
11973 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11975 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11977 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11978 if (gnubuckets
[hn
] != 0)
11980 bfd_vma si
= gnubuckets
[hn
];
11981 bfd_vma off
= si
- gnusymidx
;
11985 if (dynamic_info_DT_MIPS_XHASH
)
11986 print_dynamic_symbol (filedata
, mipsxlat
[off
], hn
);
11988 print_dynamic_symbol (filedata
, si
, hn
);
11991 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11995 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11996 && filedata
->section_headers
!= NULL
)
12000 for (i
= 0, section
= filedata
->section_headers
;
12001 i
< filedata
->file_header
.e_shnum
;
12004 char * strtab
= NULL
;
12005 unsigned long int strtab_size
= 0;
12006 Elf_Internal_Sym
* symtab
;
12007 Elf_Internal_Sym
* psym
;
12008 unsigned long si
, num_syms
;
12010 if ((section
->sh_type
!= SHT_SYMTAB
12011 && section
->sh_type
!= SHT_DYNSYM
)
12013 && section
->sh_type
== SHT_SYMTAB
))
12016 if (section
->sh_entsize
== 0)
12018 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12019 printable_section_name (filedata
, section
));
12023 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12024 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12025 "\nSymbol table '%s' contains %lu entries:\n",
12027 printable_section_name (filedata
, section
),
12031 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12033 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12035 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12036 if (symtab
== NULL
)
12039 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12041 strtab
= filedata
->string_table
;
12042 strtab_size
= filedata
->string_table_length
;
12044 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12046 Elf_Internal_Shdr
* string_sec
;
12048 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12050 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12051 1, string_sec
->sh_size
,
12052 _("string table"));
12053 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12056 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
12058 const char *version_string
;
12059 enum versioned_symbol_info sym_info
;
12060 unsigned short vna_other
;
12062 printf ("%6ld: ", si
);
12063 print_vma (psym
->st_value
, LONG_HEX
);
12065 print_vma (psym
->st_size
, DEC_5
);
12066 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12067 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12068 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12069 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12072 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12074 printf (" %-7s", get_symbol_visibility (vis
));
12075 /* Check to see if any other bits in the st_other field are set.
12076 Note - displaying this information disrupts the layout of the
12077 table being generated, but for the moment this case is very rare. */
12078 if (psym
->st_other
^ vis
)
12079 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12081 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12082 print_symbol (25, psym
->st_name
< strtab_size
12083 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12086 = get_symbol_version_string (filedata
,
12087 section
->sh_type
== SHT_DYNSYM
,
12088 strtab
, strtab_size
, si
,
12089 psym
, &sym_info
, &vna_other
);
12090 if (version_string
)
12092 if (sym_info
== symbol_undefined
)
12093 printf ("@%s (%d)", version_string
, vna_other
);
12095 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12101 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12102 && si
>= section
->sh_info
12103 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12104 && filedata
->file_header
.e_machine
!= EM_MIPS
12105 /* Solaris binaries have been found to violate this requirement as
12106 well. Not sure if this is a bug or an ABI requirement. */
12107 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12108 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12109 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12113 if (strtab
!= filedata
->string_table
)
12119 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12121 if (do_histogram
&& buckets
!= NULL
)
12123 unsigned long * lengths
;
12124 unsigned long * counts
;
12127 unsigned long maxlength
= 0;
12128 unsigned long nzero_counts
= 0;
12129 unsigned long nsyms
= 0;
12132 printf (ngettext ("\nHistogram for bucket list length "
12133 "(total of %lu bucket):\n",
12134 "\nHistogram for bucket list length "
12135 "(total of %lu buckets):\n",
12136 (unsigned long) nbuckets
),
12137 (unsigned long) nbuckets
);
12139 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12140 if (lengths
== NULL
)
12142 error (_("Out of memory allocating space for histogram buckets\n"));
12145 visited
= xcmalloc (nchains
, 1);
12146 memset (visited
, 0, nchains
);
12148 printf (_(" Length Number %% of total Coverage\n"));
12149 for (hn
= 0; hn
< nbuckets
; ++hn
)
12151 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12154 if (maxlength
< ++lengths
[hn
])
12156 if (si
>= nchains
|| visited
[si
])
12158 error (_("histogram chain is corrupt\n"));
12166 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12167 if (counts
== NULL
)
12170 error (_("Out of memory allocating space for histogram counts\n"));
12174 for (hn
= 0; hn
< nbuckets
; ++hn
)
12175 ++counts
[lengths
[hn
]];
12180 printf (" 0 %-10lu (%5.1f%%)\n",
12181 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12182 for (i
= 1; i
<= maxlength
; ++i
)
12184 nzero_counts
+= counts
[i
] * i
;
12185 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12186 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12187 (nzero_counts
* 100.0) / nsyms
);
12200 if (do_histogram
&& gnubuckets
!= NULL
)
12202 unsigned long * lengths
;
12203 unsigned long * counts
;
12205 unsigned long maxlength
= 0;
12206 unsigned long nzero_counts
= 0;
12207 unsigned long nsyms
= 0;
12209 printf (ngettext ("\nHistogram for `%s' bucket list length "
12210 "(total of %lu bucket):\n",
12211 "\nHistogram for `%s' bucket list length "
12212 "(total of %lu buckets):\n",
12213 (unsigned long) ngnubuckets
),
12214 GNU_HASH_SECTION_NAME
,
12215 (unsigned long) ngnubuckets
);
12217 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12218 if (lengths
== NULL
)
12220 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12224 printf (_(" Length Number %% of total Coverage\n"));
12226 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12227 if (gnubuckets
[hn
] != 0)
12229 bfd_vma off
, length
= 1;
12231 for (off
= gnubuckets
[hn
] - gnusymidx
;
12232 /* PR 17531 file: 010-77222-0.004. */
12233 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12236 lengths
[hn
] = length
;
12237 if (length
> maxlength
)
12238 maxlength
= length
;
12242 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12243 if (counts
== NULL
)
12246 error (_("Out of memory allocating space for gnu histogram counts\n"));
12250 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12251 ++counts
[lengths
[hn
]];
12253 if (ngnubuckets
> 0)
12256 printf (" 0 %-10lu (%5.1f%%)\n",
12257 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12258 for (j
= 1; j
<= maxlength
; ++j
)
12260 nzero_counts
+= counts
[j
] * j
;
12261 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12262 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12263 (nzero_counts
* 100.0) / nsyms
);
12285 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12289 if (dynamic_syminfo
== NULL
12291 /* No syminfo, this is ok. */
12294 /* There better should be a dynamic symbol section. */
12295 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12299 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12300 "contains %d entry:\n",
12301 "\nDynamic info segment at offset 0x%lx "
12302 "contains %d entries:\n",
12303 dynamic_syminfo_nent
),
12304 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12306 printf (_(" Num: Name BoundTo Flags\n"));
12307 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12309 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12311 printf ("%4d: ", i
);
12312 if (i
>= num_dynamic_syms
)
12313 printf (_("<corrupt index>"));
12314 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12315 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12317 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12320 switch (dynamic_syminfo
[i
].si_boundto
)
12322 case SYMINFO_BT_SELF
:
12323 fputs ("SELF ", stdout
);
12325 case SYMINFO_BT_PARENT
:
12326 fputs ("PARENT ", stdout
);
12329 if (dynamic_syminfo
[i
].si_boundto
> 0
12330 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12331 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12333 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12337 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12341 if (flags
& SYMINFO_FLG_DIRECT
)
12342 printf (" DIRECT");
12343 if (flags
& SYMINFO_FLG_PASSTHRU
)
12344 printf (" PASSTHRU");
12345 if (flags
& SYMINFO_FLG_COPY
)
12347 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12348 printf (" LAZYLOAD");
12356 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12357 is contained by the region START .. END. The types of ADDR, START
12358 and END should all be the same. Note both ADDR + NELEM and END
12359 point to just beyond the end of the regions that are being tested. */
12360 #define IN_RANGE(START,END,ADDR,NELEM) \
12361 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12363 /* Check to see if the given reloc needs to be handled in a target specific
12364 manner. If so then process the reloc and return TRUE otherwise return
12367 If called with reloc == NULL, then this is a signal that reloc processing
12368 for the current section has finished, and any saved state should be
12372 target_specific_reloc_handling (Filedata
* filedata
,
12373 Elf_Internal_Rela
* reloc
,
12374 unsigned char * start
,
12375 unsigned char * end
,
12376 Elf_Internal_Sym
* symtab
,
12377 unsigned long num_syms
)
12379 unsigned int reloc_type
= 0;
12380 unsigned long sym_index
= 0;
12384 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12385 sym_index
= get_reloc_symindex (reloc
->r_info
);
12388 switch (filedata
->file_header
.e_machine
)
12391 case EM_MSP430_OLD
:
12393 static Elf_Internal_Sym
* saved_sym
= NULL
;
12401 switch (reloc_type
)
12403 case 10: /* R_MSP430_SYM_DIFF */
12404 if (uses_msp430x_relocs (filedata
))
12406 /* Fall through. */
12407 case 21: /* R_MSP430X_SYM_DIFF */
12409 if (sym_index
>= num_syms
)
12410 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12413 saved_sym
= symtab
+ sym_index
;
12416 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12417 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12418 goto handle_sym_diff
;
12420 case 5: /* R_MSP430_16_BYTE */
12421 case 9: /* R_MSP430_8 */
12422 if (uses_msp430x_relocs (filedata
))
12424 goto handle_sym_diff
;
12426 case 2: /* R_MSP430_ABS16 */
12427 case 15: /* R_MSP430X_ABS16 */
12428 if (! uses_msp430x_relocs (filedata
))
12430 goto handle_sym_diff
;
12433 if (saved_sym
!= NULL
)
12435 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12438 if (sym_index
>= num_syms
)
12439 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12443 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12444 - saved_sym
->st_value
);
12446 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12447 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12450 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12451 (long) reloc
->r_offset
);
12460 if (saved_sym
!= NULL
)
12461 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12468 case EM_CYGNUS_MN10300
:
12470 static Elf_Internal_Sym
* saved_sym
= NULL
;
12478 switch (reloc_type
)
12480 case 34: /* R_MN10300_ALIGN */
12482 case 33: /* R_MN10300_SYM_DIFF */
12483 if (sym_index
>= num_syms
)
12484 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12487 saved_sym
= symtab
+ sym_index
;
12490 case 1: /* R_MN10300_32 */
12491 case 2: /* R_MN10300_16 */
12492 if (saved_sym
!= NULL
)
12494 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12497 if (sym_index
>= num_syms
)
12498 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12502 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12503 - saved_sym
->st_value
);
12505 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12506 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12508 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12509 (long) reloc
->r_offset
);
12517 if (saved_sym
!= NULL
)
12518 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12526 static bfd_vma saved_sym1
= 0;
12527 static bfd_vma saved_sym2
= 0;
12528 static bfd_vma value
;
12532 saved_sym1
= saved_sym2
= 0;
12536 switch (reloc_type
)
12538 case 0x80: /* R_RL78_SYM. */
12539 saved_sym1
= saved_sym2
;
12540 if (sym_index
>= num_syms
)
12541 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12545 saved_sym2
= symtab
[sym_index
].st_value
;
12546 saved_sym2
+= reloc
->r_addend
;
12550 case 0x83: /* R_RL78_OPsub. */
12551 value
= saved_sym1
- saved_sym2
;
12552 saved_sym2
= saved_sym1
= 0;
12556 case 0x41: /* R_RL78_ABS32. */
12557 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12558 byte_put (start
+ reloc
->r_offset
, value
, 4);
12560 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12561 (long) reloc
->r_offset
);
12565 case 0x43: /* R_RL78_ABS16. */
12566 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12567 byte_put (start
+ reloc
->r_offset
, value
, 2);
12569 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12570 (long) reloc
->r_offset
);
12584 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12585 DWARF debug sections. This is a target specific test. Note - we do not
12586 go through the whole including-target-headers-multiple-times route, (as
12587 we have already done with <elf/h8.h>) because this would become very
12588 messy and even then this function would have to contain target specific
12589 information (the names of the relocs instead of their numeric values).
12590 FIXME: This is not the correct way to solve this problem. The proper way
12591 is to have target specific reloc sizing and typing functions created by
12592 the reloc-macros.h header, in the same way that it already creates the
12593 reloc naming functions. */
12596 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12598 /* Please keep this table alpha-sorted for ease of visual lookup. */
12599 switch (filedata
->file_header
.e_machine
)
12603 return reloc_type
== 1; /* R_386_32. */
12605 return reloc_type
== 1; /* R_68K_32. */
12607 return reloc_type
== 1; /* R_860_32. */
12609 return reloc_type
== 2; /* R_960_32. */
12611 return (reloc_type
== 258
12612 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12614 return reloc_type
== 11; /* R_BPF_DATA_32 */
12615 case EM_ADAPTEVA_EPIPHANY
:
12616 return reloc_type
== 3;
12618 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12620 return reloc_type
== 1; /* R_ARC_32. */
12621 case EM_ARC_COMPACT
:
12622 case EM_ARC_COMPACT2
:
12623 return reloc_type
== 4; /* R_ARC_32. */
12625 return reloc_type
== 2; /* R_ARM_ABS32 */
12628 return reloc_type
== 1;
12630 return reloc_type
== 0x12; /* R_byte4_data. */
12632 return reloc_type
== 3; /* R_CRIS_32. */
12634 return reloc_type
== 3; /* R_CR16_NUM32. */
12636 return reloc_type
== 15; /* R_CRX_NUM32. */
12638 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12639 case EM_CYGNUS_FRV
:
12640 return reloc_type
== 1;
12641 case EM_CYGNUS_D10V
:
12643 return reloc_type
== 6; /* R_D10V_32. */
12644 case EM_CYGNUS_D30V
:
12646 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12648 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12649 case EM_CYGNUS_FR30
:
12651 return reloc_type
== 3; /* R_FR30_32. */
12653 return reloc_type
== 1; /* R_FT32_32. */
12657 return reloc_type
== 1; /* R_H8_DIR32. */
12659 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12660 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12661 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12662 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12665 return reloc_type
== 2; /* R_IP2K_32. */
12667 return reloc_type
== 2; /* R_IQ2000_32. */
12668 case EM_LATTICEMICO32
:
12669 return reloc_type
== 3; /* R_LM32_32. */
12672 return reloc_type
== 3; /* R_M32C_32. */
12674 return reloc_type
== 34; /* R_M32R_32_RELA. */
12677 return reloc_type
== 6; /* R_M68HC11_32. */
12679 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12680 reloc_type
== 6; /* R_S12Z_CW32. */
12682 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12683 case EM_CYGNUS_MEP
:
12684 return reloc_type
== 4; /* R_MEP_32. */
12686 return reloc_type
== 2; /* R_METAG_ADDR32. */
12687 case EM_MICROBLAZE
:
12688 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12690 return reloc_type
== 2; /* R_MIPS_32. */
12692 return reloc_type
== 4; /* R_MMIX_32. */
12693 case EM_CYGNUS_MN10200
:
12695 return reloc_type
== 1; /* R_MN10200_32. */
12696 case EM_CYGNUS_MN10300
:
12698 return reloc_type
== 1; /* R_MN10300_32. */
12700 return reloc_type
== 1; /* R_MOXIE_32. */
12701 case EM_MSP430_OLD
:
12703 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12705 return reloc_type
== 2; /* R_MT_32. */
12707 return reloc_type
== 20; /* R_NDS32_RELA. */
12708 case EM_ALTERA_NIOS2
:
12709 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12711 return reloc_type
== 1; /* R_NIOS_32. */
12713 return reloc_type
== 1; /* R_OR1K_32. */
12715 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12716 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12717 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12720 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12722 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12724 return reloc_type
== 1; /* R_PPC_ADDR32. */
12726 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12728 return reloc_type
== 1; /* R_RISCV_32. */
12730 return reloc_type
== 1; /* R_RL78_DIR32. */
12732 return reloc_type
== 1; /* R_RX_DIR32. */
12734 return reloc_type
== 1; /* R_I370_ADDR31. */
12737 return reloc_type
== 4; /* R_S390_32. */
12739 return reloc_type
== 8; /* R_SCORE_ABS32. */
12741 return reloc_type
== 1; /* R_SH_DIR32. */
12742 case EM_SPARC32PLUS
:
12745 return reloc_type
== 3 /* R_SPARC_32. */
12746 || reloc_type
== 23; /* R_SPARC_UA32. */
12748 return reloc_type
== 6; /* R_SPU_ADDR32 */
12750 return reloc_type
== 1; /* R_C6000_ABS32. */
12752 return reloc_type
== 2; /* R_TILEGX_32. */
12754 return reloc_type
== 1; /* R_TILEPRO_32. */
12755 case EM_CYGNUS_V850
:
12757 return reloc_type
== 6; /* R_V850_ABS32. */
12759 return reloc_type
== 0x33; /* R_V810_WORD. */
12761 return reloc_type
== 1; /* R_VAX_32. */
12763 return reloc_type
== 3; /* R_VISIUM_32. */
12764 case EM_WEBASSEMBLY
:
12765 return reloc_type
== 1; /* R_WASM32_32. */
12769 return reloc_type
== 10; /* R_X86_64_32. */
12772 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12774 return reloc_type
== 4; /* R_XGATE_32. */
12776 return reloc_type
== 1; /* R_XSTROMY16_32. */
12777 case EM_XTENSA_OLD
:
12779 return reloc_type
== 1; /* R_XTENSA_32. */
12781 return reloc_type
== 6; /* R_Z80_32. */
12784 static unsigned int prev_warn
= 0;
12786 /* Avoid repeating the same warning multiple times. */
12787 if (prev_warn
!= filedata
->file_header
.e_machine
)
12788 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12789 filedata
->file_header
.e_machine
);
12790 prev_warn
= filedata
->file_header
.e_machine
;
12796 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12797 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12800 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12802 switch (filedata
->file_header
.e_machine
)
12803 /* Please keep this table alpha-sorted for ease of visual lookup. */
12807 return reloc_type
== 2; /* R_386_PC32. */
12809 return reloc_type
== 4; /* R_68K_PC32. */
12811 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12812 case EM_ADAPTEVA_EPIPHANY
:
12813 return reloc_type
== 6;
12815 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12816 case EM_ARC_COMPACT
:
12817 case EM_ARC_COMPACT2
:
12818 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12820 return reloc_type
== 3; /* R_ARM_REL32 */
12823 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12824 case EM_MICROBLAZE
:
12825 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12827 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12829 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12831 return reloc_type
== 26; /* R_PPC_REL32. */
12833 return reloc_type
== 26; /* R_PPC64_REL32. */
12835 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12838 return reloc_type
== 5; /* R_390_PC32. */
12840 return reloc_type
== 2; /* R_SH_REL32. */
12841 case EM_SPARC32PLUS
:
12844 return reloc_type
== 6; /* R_SPARC_DISP32. */
12846 return reloc_type
== 13; /* R_SPU_REL32. */
12848 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12850 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12852 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12856 return reloc_type
== 2; /* R_X86_64_PC32. */
12858 return reloc_type
== 4; /* R_VAX_PCREL32. */
12859 case EM_XTENSA_OLD
:
12861 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12863 /* Do not abort or issue an error message here. Not all targets use
12864 pc-relative 32-bit relocs in their DWARF debug information and we
12865 have already tested for target coverage in is_32bit_abs_reloc. A
12866 more helpful warning message will be generated by apply_relocations
12867 anyway, so just return. */
12872 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12873 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12876 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12878 switch (filedata
->file_header
.e_machine
)
12881 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12883 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12885 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12886 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12888 return reloc_type
== 80; /* R_PARISC_DIR64. */
12890 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12892 return reloc_type
== 2; /* R_RISCV_64. */
12893 case EM_SPARC32PLUS
:
12896 return reloc_type
== 32 /* R_SPARC_64. */
12897 || reloc_type
== 54; /* R_SPARC_UA64. */
12901 return reloc_type
== 1; /* R_X86_64_64. */
12904 return reloc_type
== 22; /* R_S390_64. */
12906 return reloc_type
== 1; /* R_TILEGX_64. */
12908 return reloc_type
== 18; /* R_MIPS_64. */
12914 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12915 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12918 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12920 switch (filedata
->file_header
.e_machine
)
12923 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12925 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12927 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12928 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12930 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12932 return reloc_type
== 44; /* R_PPC64_REL64. */
12933 case EM_SPARC32PLUS
:
12936 return reloc_type
== 46; /* R_SPARC_DISP64. */
12940 return reloc_type
== 24; /* R_X86_64_PC64. */
12943 return reloc_type
== 23; /* R_S390_PC64. */
12945 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12951 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12952 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12955 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12957 switch (filedata
->file_header
.e_machine
)
12959 case EM_CYGNUS_MN10200
:
12961 return reloc_type
== 4; /* R_MN10200_24. */
12963 return reloc_type
== 5; /* R_FT32_20. */
12965 return reloc_type
== 5; /* R_Z80_24. */
12971 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12972 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12975 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12977 /* Please keep this table alpha-sorted for ease of visual lookup. */
12978 switch (filedata
->file_header
.e_machine
)
12981 case EM_ARC_COMPACT
:
12982 case EM_ARC_COMPACT2
:
12983 return reloc_type
== 2; /* R_ARC_16. */
12984 case EM_ADAPTEVA_EPIPHANY
:
12985 return reloc_type
== 5;
12988 return reloc_type
== 4; /* R_AVR_16. */
12989 case EM_CYGNUS_D10V
:
12991 return reloc_type
== 3; /* R_D10V_16. */
12993 return reloc_type
== 2; /* R_FT32_16. */
12997 return reloc_type
== R_H8_DIR16
;
13000 return reloc_type
== 1; /* R_IP2K_16. */
13003 return reloc_type
== 1; /* R_M32C_16 */
13004 case EM_CYGNUS_MN10200
:
13006 return reloc_type
== 2; /* R_MN10200_16. */
13007 case EM_CYGNUS_MN10300
:
13009 return reloc_type
== 2; /* R_MN10300_16. */
13011 if (uses_msp430x_relocs (filedata
))
13012 return reloc_type
== 2; /* R_MSP430_ABS16. */
13013 /* Fall through. */
13014 case EM_MSP430_OLD
:
13015 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13017 return reloc_type
== 19; /* R_NDS32_RELA. */
13018 case EM_ALTERA_NIOS2
:
13019 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13021 return reloc_type
== 9; /* R_NIOS_16. */
13023 return reloc_type
== 2; /* R_OR1K_16. */
13025 return reloc_type
== 55; /* R_RISCV_SET16. */
13027 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13029 return reloc_type
== 2; /* R_C6000_ABS16. */
13031 return reloc_type
== 2; /* R_VISIUM_16. */
13034 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13036 return reloc_type
== 3; /* R_XGATE_16. */
13038 return reloc_type
== 4; /* R_Z80_16. */
13044 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13045 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13048 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13050 switch (filedata
->file_header
.e_machine
)
13053 return reloc_type
== 54; /* R_RISCV_SET8. */
13055 return reloc_type
== 1; /* R_Z80_8. */
13061 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13062 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13065 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13067 switch (filedata
->file_header
.e_machine
)
13070 return reloc_type
== 53; /* R_RISCV_SET6. */
13076 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13077 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13080 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13082 /* Please keep this table alpha-sorted for ease of visual lookup. */
13083 switch (filedata
->file_header
.e_machine
)
13086 return reloc_type
== 35; /* R_RISCV_ADD32. */
13092 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13093 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13096 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13098 /* Please keep this table alpha-sorted for ease of visual lookup. */
13099 switch (filedata
->file_header
.e_machine
)
13102 return reloc_type
== 39; /* R_RISCV_SUB32. */
13108 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13109 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13112 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13114 /* Please keep this table alpha-sorted for ease of visual lookup. */
13115 switch (filedata
->file_header
.e_machine
)
13118 return reloc_type
== 36; /* R_RISCV_ADD64. */
13124 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13125 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13128 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13130 /* Please keep this table alpha-sorted for ease of visual lookup. */
13131 switch (filedata
->file_header
.e_machine
)
13134 return reloc_type
== 40; /* R_RISCV_SUB64. */
13140 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13141 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13144 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13146 /* Please keep this table alpha-sorted for ease of visual lookup. */
13147 switch (filedata
->file_header
.e_machine
)
13150 return reloc_type
== 34; /* R_RISCV_ADD16. */
13156 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13157 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13160 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13162 /* Please keep this table alpha-sorted for ease of visual lookup. */
13163 switch (filedata
->file_header
.e_machine
)
13166 return reloc_type
== 38; /* R_RISCV_SUB16. */
13172 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13173 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13176 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13178 /* Please keep this table alpha-sorted for ease of visual lookup. */
13179 switch (filedata
->file_header
.e_machine
)
13182 return reloc_type
== 33; /* R_RISCV_ADD8. */
13188 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13189 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13192 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13194 /* Please keep this table alpha-sorted for ease of visual lookup. */
13195 switch (filedata
->file_header
.e_machine
)
13198 return reloc_type
== 37; /* R_RISCV_SUB8. */
13204 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13205 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13208 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13210 switch (filedata
->file_header
.e_machine
)
13213 return reloc_type
== 52; /* R_RISCV_SUB6. */
13219 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13220 relocation entries (possibly formerly used for SHT_GROUP sections). */
13223 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13225 switch (filedata
->file_header
.e_machine
)
13227 case EM_386
: /* R_386_NONE. */
13228 case EM_68K
: /* R_68K_NONE. */
13229 case EM_ADAPTEVA_EPIPHANY
:
13230 case EM_ALPHA
: /* R_ALPHA_NONE. */
13231 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13232 case EM_ARC
: /* R_ARC_NONE. */
13233 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13234 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13235 case EM_ARM
: /* R_ARM_NONE. */
13236 case EM_C166
: /* R_XC16X_NONE. */
13237 case EM_CRIS
: /* R_CRIS_NONE. */
13238 case EM_FT32
: /* R_FT32_NONE. */
13239 case EM_IA_64
: /* R_IA64_NONE. */
13240 case EM_K1OM
: /* R_X86_64_NONE. */
13241 case EM_L1OM
: /* R_X86_64_NONE. */
13242 case EM_M32R
: /* R_M32R_NONE. */
13243 case EM_MIPS
: /* R_MIPS_NONE. */
13244 case EM_MN10300
: /* R_MN10300_NONE. */
13245 case EM_MOXIE
: /* R_MOXIE_NONE. */
13246 case EM_NIOS32
: /* R_NIOS_NONE. */
13247 case EM_OR1K
: /* R_OR1K_NONE. */
13248 case EM_PARISC
: /* R_PARISC_NONE. */
13249 case EM_PPC64
: /* R_PPC64_NONE. */
13250 case EM_PPC
: /* R_PPC_NONE. */
13251 case EM_RISCV
: /* R_RISCV_NONE. */
13252 case EM_S390
: /* R_390_NONE. */
13254 case EM_SH
: /* R_SH_NONE. */
13255 case EM_SPARC32PLUS
:
13256 case EM_SPARC
: /* R_SPARC_NONE. */
13258 case EM_TILEGX
: /* R_TILEGX_NONE. */
13259 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13260 case EM_TI_C6000
:/* R_C6000_NONE. */
13261 case EM_X86_64
: /* R_X86_64_NONE. */
13263 case EM_Z80
: /* R_Z80_NONE. */
13264 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13265 return reloc_type
== 0;
13268 return reloc_type
== 0 || reloc_type
== 256;
13271 return (reloc_type
== 0 /* R_AVR_NONE. */
13272 || reloc_type
== 30 /* R_AVR_DIFF8. */
13273 || reloc_type
== 31 /* R_AVR_DIFF16. */
13274 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13276 return reloc_type
== 3; /* R_METAG_NONE. */
13278 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13279 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13280 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13281 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13282 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13284 return (reloc_type
== 0 /* R_PRU_NONE. */
13285 || reloc_type
== 65 /* R_PRU_DIFF8. */
13286 || reloc_type
== 66 /* R_PRU_DIFF16. */
13287 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13288 case EM_XTENSA_OLD
:
13290 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13291 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13292 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13293 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13298 /* Returns TRUE if there is a relocation against
13299 section NAME at OFFSET bytes. */
13302 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13304 Elf_Internal_Rela
* relocs
;
13305 Elf_Internal_Rela
* rp
;
13307 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13310 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13312 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13313 if (rp
->r_offset
== offset
)
13319 /* Apply relocations to a section.
13320 Returns TRUE upon success, FALSE otherwise.
13321 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13322 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13323 will be set to the number of relocs loaded.
13325 Note: So far support has been added only for those relocations
13326 which can be found in debug sections. FIXME: Add support for
13327 more relocations ? */
13330 apply_relocations (Filedata
* filedata
,
13331 const Elf_Internal_Shdr
* section
,
13332 unsigned char * start
,
13333 bfd_size_type size
,
13334 void ** relocs_return
,
13335 unsigned long * num_relocs_return
)
13337 Elf_Internal_Shdr
* relsec
;
13338 unsigned char * end
= start
+ size
;
13340 if (relocs_return
!= NULL
)
13342 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13343 * num_relocs_return
= 0;
13346 if (filedata
->file_header
.e_type
!= ET_REL
)
13347 /* No relocs to apply. */
13350 /* Find the reloc section associated with the section. */
13351 for (relsec
= filedata
->section_headers
;
13352 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13355 bfd_boolean is_rela
;
13356 unsigned long num_relocs
;
13357 Elf_Internal_Rela
* relocs
;
13358 Elf_Internal_Rela
* rp
;
13359 Elf_Internal_Shdr
* symsec
;
13360 Elf_Internal_Sym
* symtab
;
13361 unsigned long num_syms
;
13362 Elf_Internal_Sym
* sym
;
13364 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13365 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13366 || filedata
->section_headers
+ relsec
->sh_info
!= section
13367 || relsec
->sh_size
== 0
13368 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13371 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13372 if (symsec
->sh_type
!= SHT_SYMTAB
13373 && symsec
->sh_type
!= SHT_DYNSYM
)
13376 is_rela
= relsec
->sh_type
== SHT_RELA
;
13380 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13381 relsec
->sh_size
, & relocs
, & num_relocs
))
13386 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13387 relsec
->sh_size
, & relocs
, & num_relocs
))
13391 /* SH uses RELA but uses in place value instead of the addend field. */
13392 if (filedata
->file_header
.e_machine
== EM_SH
)
13395 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13397 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13400 unsigned int reloc_type
;
13401 unsigned int reloc_size
;
13402 bfd_boolean reloc_inplace
= FALSE
;
13403 bfd_boolean reloc_subtract
= FALSE
;
13404 unsigned char * rloc
;
13405 unsigned long sym_index
;
13407 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13409 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13411 else if (is_none_reloc (filedata
, reloc_type
))
13413 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13414 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13416 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13417 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13419 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13421 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13423 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13424 || is_6bit_abs_reloc (filedata
, reloc_type
))
13426 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13428 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13431 reloc_inplace
= TRUE
;
13433 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13435 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13438 reloc_inplace
= TRUE
;
13440 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13442 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13445 reloc_inplace
= TRUE
;
13447 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13449 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13452 reloc_inplace
= TRUE
;
13454 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13458 reloc_inplace
= TRUE
;
13462 static unsigned int prev_reloc
= 0;
13464 if (reloc_type
!= prev_reloc
)
13465 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13466 reloc_type
, printable_section_name (filedata
, section
));
13467 prev_reloc
= reloc_type
;
13471 rloc
= start
+ rp
->r_offset
;
13472 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13474 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13475 (unsigned long) rp
->r_offset
,
13476 printable_section_name (filedata
, section
));
13480 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13481 if (sym_index
>= num_syms
)
13483 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13484 sym_index
, printable_section_name (filedata
, section
));
13487 sym
= symtab
+ sym_index
;
13489 /* If the reloc has a symbol associated with it,
13490 make sure that it is of an appropriate type.
13492 Relocations against symbols without type can happen.
13493 Gcc -feliminate-dwarf2-dups may generate symbols
13494 without type for debug info.
13496 Icc generates relocations against function symbols
13497 instead of local labels.
13499 Relocations against object symbols can happen, eg when
13500 referencing a global array. For an example of this see
13501 the _clz.o binary in libgcc.a. */
13503 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13504 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13506 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13507 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13508 printable_section_name (filedata
, relsec
),
13509 (long int)(rp
- relocs
));
13515 addend
+= rp
->r_addend
;
13516 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13517 partial_inplace. */
13519 || (filedata
->file_header
.e_machine
== EM_XTENSA
13520 && reloc_type
== 1)
13521 || ((filedata
->file_header
.e_machine
== EM_PJ
13522 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13523 && reloc_type
== 1)
13524 || ((filedata
->file_header
.e_machine
== EM_D30V
13525 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13526 && reloc_type
== 12)
13529 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13530 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13532 addend
+= byte_get (rloc
, reloc_size
);
13535 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13536 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13538 /* On HPPA, all pc-relative relocations are biased by 8. */
13539 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13541 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13544 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13545 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13547 if (reloc_subtract
)
13548 addend
-= sym
->st_value
;
13550 addend
+= sym
->st_value
;
13551 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13552 byte_put (rloc
, addend
, reloc_size
);
13554 else if (reloc_subtract
)
13555 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13557 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13561 /* Let the target specific reloc processing code know that
13562 we have finished with these relocs. */
13563 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13567 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13568 * num_relocs_return
= num_relocs
;
13579 #ifdef SUPPORT_DISASSEMBLY
13581 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13583 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13585 /* FIXME: XXX -- to be done --- XXX */
13591 /* Reads in the contents of SECTION from FILE, returning a pointer
13592 to a malloc'ed buffer or NULL if something went wrong. */
13595 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13597 bfd_size_type num_bytes
= section
->sh_size
;
13599 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13601 printf (_("Section '%s' has no data to dump.\n"),
13602 printable_section_name (filedata
, section
));
13606 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13607 _("section contents"));
13610 /* Uncompresses a section that was compressed using zlib, in place. */
13613 uncompress_section_contents (unsigned char ** buffer
,
13614 dwarf_size_type uncompressed_size
,
13615 dwarf_size_type
* size
)
13617 dwarf_size_type compressed_size
= *size
;
13618 unsigned char * compressed_buffer
= *buffer
;
13619 unsigned char * uncompressed_buffer
;
13623 /* It is possible the section consists of several compressed
13624 buffers concatenated together, so we uncompress in a loop. */
13625 /* PR 18313: The state field in the z_stream structure is supposed
13626 to be invisible to the user (ie us), but some compilers will
13627 still complain about it being used without initialisation. So
13628 we first zero the entire z_stream structure and then set the fields
13630 memset (& strm
, 0, sizeof strm
);
13631 strm
.avail_in
= compressed_size
;
13632 strm
.next_in
= (Bytef
*) compressed_buffer
;
13633 strm
.avail_out
= uncompressed_size
;
13634 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13636 rc
= inflateInit (& strm
);
13637 while (strm
.avail_in
> 0)
13641 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13642 + (uncompressed_size
- strm
.avail_out
));
13643 rc
= inflate (&strm
, Z_FINISH
);
13644 if (rc
!= Z_STREAM_END
)
13646 rc
= inflateReset (& strm
);
13648 rc
= inflateEnd (& strm
);
13650 || strm
.avail_out
!= 0)
13653 *buffer
= uncompressed_buffer
;
13654 *size
= uncompressed_size
;
13658 free (uncompressed_buffer
);
13659 /* Indicate decompression failure. */
13665 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13667 Elf_Internal_Shdr
* relsec
;
13668 bfd_size_type num_bytes
;
13669 unsigned char * data
;
13670 unsigned char * end
;
13671 unsigned char * real_start
;
13672 unsigned char * start
;
13673 bfd_boolean some_strings_shown
;
13675 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13677 /* PR 21820: Do not fail if the section was empty. */
13678 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13680 num_bytes
= section
->sh_size
;
13682 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13684 if (decompress_dumps
)
13686 dwarf_size_type new_size
= num_bytes
;
13687 dwarf_size_type uncompressed_size
= 0;
13689 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13691 Elf_Internal_Chdr chdr
;
13692 unsigned int compression_header_size
13693 = get_compression_header (& chdr
, (unsigned char *) start
,
13696 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13698 warn (_("section '%s' has unsupported compress type: %d\n"),
13699 printable_section_name (filedata
, section
), chdr
.ch_type
);
13702 uncompressed_size
= chdr
.ch_size
;
13703 start
+= compression_header_size
;
13704 new_size
-= compression_header_size
;
13706 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13708 /* Read the zlib header. In this case, it should be "ZLIB"
13709 followed by the uncompressed section size, 8 bytes in
13710 big-endian order. */
13711 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13712 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13713 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13714 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13715 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13716 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13717 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13718 uncompressed_size
+= start
[11];
13723 if (uncompressed_size
)
13725 if (uncompress_section_contents (& start
,
13726 uncompressed_size
, & new_size
))
13727 num_bytes
= new_size
;
13730 error (_("Unable to decompress section %s\n"),
13731 printable_section_name (filedata
, section
));
13736 start
= real_start
;
13739 /* If the section being dumped has relocations against it the user might
13740 be expecting these relocations to have been applied. Check for this
13741 case and issue a warning message in order to avoid confusion.
13742 FIXME: Maybe we ought to have an option that dumps a section with
13743 relocs applied ? */
13744 for (relsec
= filedata
->section_headers
;
13745 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13748 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13749 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13750 || filedata
->section_headers
+ relsec
->sh_info
!= section
13751 || relsec
->sh_size
== 0
13752 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13755 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13760 end
= start
+ num_bytes
;
13761 some_strings_shown
= FALSE
;
13763 #ifdef HAVE_MBSTATE_T
13765 /* Initialise the multibyte conversion state. */
13766 memset (& state
, 0, sizeof (state
));
13769 bfd_boolean continuing
= FALSE
;
13773 while (!ISPRINT (* data
))
13774 if (++ data
>= end
)
13779 size_t maxlen
= end
- data
;
13784 continuing
= FALSE
;
13789 /* PR 11128: Use two separate invocations in order to work
13790 around bugs in the Solaris 8 implementation of printf. */
13791 printf (" [%6tx] ", data
- start
);
13793 printf (" [%6Ix] ", (size_t) (data
- start
));
13808 /* PR 25543: Treat new-lines as string-ending characters. */
13817 /* Do not print control characters directly as they can affect terminal
13818 settings. Such characters usually appear in the names generated
13819 by the assembler for local labels. */
13822 printf ("^%c", c
+ 0x40);
13824 else if (ISPRINT (c
))
13831 #ifdef HAVE_MBSTATE_T
13834 /* Let printf do the hard work of displaying multibyte characters. */
13835 printf ("%.1s", data
- 1);
13836 #ifdef HAVE_MBSTATE_T
13837 /* Try to find out how many bytes made up the character that was
13838 just printed. Advance the symbol pointer past the bytes that
13840 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13844 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13854 printf (_("<corrupt>\n"));
13857 some_strings_shown
= TRUE
;
13861 if (! some_strings_shown
)
13862 printf (_(" No strings found in this section."));
13875 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13876 Filedata
* filedata
,
13877 bfd_boolean relocate
)
13879 Elf_Internal_Shdr
* relsec
;
13880 bfd_size_type bytes
;
13881 bfd_size_type section_size
;
13883 unsigned char * data
;
13884 unsigned char * real_start
;
13885 unsigned char * start
;
13887 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13889 /* PR 21820: Do not fail if the section was empty. */
13890 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13892 section_size
= section
->sh_size
;
13894 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13896 if (decompress_dumps
)
13898 dwarf_size_type new_size
= section_size
;
13899 dwarf_size_type uncompressed_size
= 0;
13901 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13903 Elf_Internal_Chdr chdr
;
13904 unsigned int compression_header_size
13905 = get_compression_header (& chdr
, start
, section_size
);
13907 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13909 warn (_("section '%s' has unsupported compress type: %d\n"),
13910 printable_section_name (filedata
, section
), chdr
.ch_type
);
13913 uncompressed_size
= chdr
.ch_size
;
13914 start
+= compression_header_size
;
13915 new_size
-= compression_header_size
;
13917 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13919 /* Read the zlib header. In this case, it should be "ZLIB"
13920 followed by the uncompressed section size, 8 bytes in
13921 big-endian order. */
13922 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13923 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13924 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13925 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13926 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13927 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13928 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13929 uncompressed_size
+= start
[11];
13934 if (uncompressed_size
)
13936 if (uncompress_section_contents (& start
, uncompressed_size
,
13939 section_size
= new_size
;
13943 error (_("Unable to decompress section %s\n"),
13944 printable_section_name (filedata
, section
));
13945 /* FIXME: Print the section anyway ? */
13950 start
= real_start
;
13955 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13960 /* If the section being dumped has relocations against it the user might
13961 be expecting these relocations to have been applied. Check for this
13962 case and issue a warning message in order to avoid confusion.
13963 FIXME: Maybe we ought to have an option that dumps a section with
13964 relocs applied ? */
13965 for (relsec
= filedata
->section_headers
;
13966 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13969 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13970 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13971 || filedata
->section_headers
+ relsec
->sh_info
!= section
13972 || relsec
->sh_size
== 0
13973 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13976 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13981 addr
= section
->sh_addr
;
13982 bytes
= section_size
;
13991 lbytes
= (bytes
> 16 ? 16 : bytes
);
13993 printf (" 0x%8.8lx ", (unsigned long) addr
);
13995 for (j
= 0; j
< 16; j
++)
13998 printf ("%2.2x", data
[j
]);
14006 for (j
= 0; j
< lbytes
; j
++)
14009 if (k
>= ' ' && k
< 0x7f)
14032 static ctf_sect_t
*
14033 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14035 buf
->cts_name
= SECTION_NAME (shdr
);
14036 buf
->cts_size
= shdr
->sh_size
;
14037 buf
->cts_entsize
= shdr
->sh_entsize
;
14042 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14043 it is passed, or a pointer to newly-allocated storage, in which case
14044 dump_ctf() will free it when it no longer needs it. */
14046 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14047 char *s
, void *arg
)
14049 const char *blanks
= arg
;
14052 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14058 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14060 Elf_Internal_Shdr
* parent_sec
= NULL
;
14061 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14062 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14063 void * data
= NULL
;
14064 void * symdata
= NULL
;
14065 void * strdata
= NULL
;
14066 void * parentdata
= NULL
;
14067 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14068 ctf_sect_t
* symsectp
= NULL
;
14069 ctf_sect_t
* strsectp
= NULL
;
14070 ctf_file_t
* ctf
= NULL
;
14071 ctf_file_t
* parent
= NULL
;
14073 const char *things
[] = {"Header", "Labels", "Data objects",
14074 "Function objects", "Variables", "Types", "Strings",
14076 const char **thing
;
14078 bfd_boolean ret
= FALSE
;
14081 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14082 data
= get_section_contents (section
, filedata
);
14083 ctfsect
.cts_data
= data
;
14085 if (!dump_ctf_symtab_name
)
14086 dump_ctf_symtab_name
= strdup (".symtab");
14088 if (!dump_ctf_strtab_name
)
14089 dump_ctf_strtab_name
= strdup (".strtab");
14091 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14093 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14095 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14098 if ((symdata
= (void *) get_data (NULL
, filedata
,
14099 symtab_sec
->sh_offset
, 1,
14100 symtab_sec
->sh_size
,
14101 _("symbols"))) == NULL
)
14103 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14104 symsect
.cts_data
= symdata
;
14106 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14108 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14110 error (_("No string table section named %s\n"),
14111 dump_ctf_strtab_name
);
14114 if ((strdata
= (void *) get_data (NULL
, filedata
,
14115 strtab_sec
->sh_offset
, 1,
14116 strtab_sec
->sh_size
,
14117 _("strings"))) == NULL
)
14119 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14120 strsect
.cts_data
= strdata
;
14122 if (dump_ctf_parent_name
)
14124 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14126 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14129 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14130 parent_sec
->sh_offset
, 1,
14131 parent_sec
->sh_size
,
14132 _("CTF parent"))) == NULL
)
14134 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14135 parentsect
.cts_data
= parentdata
;
14138 /* Load the CTF file and dump it. */
14140 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14142 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14148 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14150 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14154 ctf_import (ctf
, parent
);
14159 printf (_("\nDump of CTF section '%s':\n"),
14160 printable_section_name (filedata
, section
));
14162 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14164 ctf_dump_state_t
*s
= NULL
;
14167 printf ("\n %s:\n", *thing
);
14168 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14169 (void *) " ")) != NULL
)
14171 printf ("%s\n", item
);
14175 if (ctf_errno (ctf
))
14177 error (_("Iteration failed: %s, %s\n"), *thing
,
14178 ctf_errmsg (ctf_errno (ctf
)));
14184 ctf_file_close (ctf
);
14185 ctf_file_close (parent
);
14194 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14195 const Elf_Internal_Shdr
* sec
,
14198 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14200 Filedata
* filedata
= (Filedata
*) data
;
14202 if (section
->start
!= NULL
)
14204 /* If it is already loaded, do nothing. */
14205 if (streq (section
->filename
, filedata
->file_name
))
14207 free (section
->start
);
14210 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14211 section
->address
= sec
->sh_addr
;
14212 section
->user_data
= NULL
;
14213 section
->filename
= filedata
->file_name
;
14214 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14216 sec
->sh_size
, buf
);
14217 if (section
->start
== NULL
)
14221 unsigned char *start
= section
->start
;
14222 dwarf_size_type size
= sec
->sh_size
;
14223 dwarf_size_type uncompressed_size
= 0;
14225 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14227 Elf_Internal_Chdr chdr
;
14228 unsigned int compression_header_size
;
14230 if (size
< (is_32bit_elf
14231 ? sizeof (Elf32_External_Chdr
)
14232 : sizeof (Elf64_External_Chdr
)))
14234 warn (_("compressed section %s is too small to contain a compression header\n"),
14239 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14241 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14243 warn (_("section '%s' has unsupported compress type: %d\n"),
14244 section
->name
, chdr
.ch_type
);
14247 uncompressed_size
= chdr
.ch_size
;
14248 start
+= compression_header_size
;
14249 size
-= compression_header_size
;
14251 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14253 /* Read the zlib header. In this case, it should be "ZLIB"
14254 followed by the uncompressed section size, 8 bytes in
14255 big-endian order. */
14256 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14257 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14258 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14259 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14260 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14261 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14262 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14263 uncompressed_size
+= start
[11];
14268 if (uncompressed_size
)
14270 if (uncompress_section_contents (&start
, uncompressed_size
,
14273 /* Free the compressed buffer, update the section buffer
14274 and the section size if uncompress is successful. */
14275 free (section
->start
);
14276 section
->start
= start
;
14280 error (_("Unable to decompress section %s\n"),
14281 printable_section_name (filedata
, sec
));
14286 section
->size
= size
;
14289 if (section
->start
== NULL
)
14292 if (debug_displays
[debug
].relocate
)
14294 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14295 & section
->reloc_info
, & section
->num_relocs
))
14300 section
->reloc_info
= NULL
;
14301 section
->num_relocs
= 0;
14307 #if HAVE_LIBDEBUGINFOD
14308 /* Return a hex string representation of the build-id. */
14310 get_build_id (void * data
)
14312 Filedata
* filedata
= (Filedata
*)data
;
14313 Elf_Internal_Shdr
* shdr
;
14316 /* Iterate through notes to find note.gnu.build-id.
14317 FIXME: Only the first note in any note section is examined. */
14318 for (i
= 0, shdr
= filedata
->section_headers
;
14319 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14322 if (shdr
->sh_type
!= SHT_NOTE
)
14327 size_t data_remaining
;
14329 Elf_External_Note
* enote
;
14330 Elf_Internal_Note inote
;
14332 bfd_vma offset
= shdr
->sh_offset
;
14333 bfd_vma align
= shdr
->sh_addralign
;
14334 bfd_vma length
= shdr
->sh_size
;
14336 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14342 else if (align
!= 4 && align
!= 8)
14348 end
= (char *) enote
+ length
;
14349 data_remaining
= end
- (char *) enote
;
14351 if (!is_ia64_vms (filedata
))
14353 min_notesz
= offsetof (Elf_External_Note
, name
);
14354 if (data_remaining
< min_notesz
)
14357 malformed note encountered in section %s whilst scanning for build-id note\n"),
14358 printable_section_name (filedata
, shdr
));
14362 data_remaining
-= min_notesz
;
14364 inote
.type
= BYTE_GET (enote
->type
);
14365 inote
.namesz
= BYTE_GET (enote
->namesz
);
14366 inote
.namedata
= enote
->name
;
14367 inote
.descsz
= BYTE_GET (enote
->descsz
);
14368 inote
.descdata
= ((char *) enote
14369 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14370 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14371 next
= ((char *) enote
14372 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14376 Elf64_External_VMS_Note
*vms_enote
;
14378 /* PR binutils/15191
14379 Make sure that there is enough data to read. */
14380 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14381 if (data_remaining
< min_notesz
)
14384 malformed note encountered in section %s whilst scanning for build-id note\n"),
14385 printable_section_name (filedata
, shdr
));
14389 data_remaining
-= min_notesz
;
14391 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14392 inote
.type
= BYTE_GET (vms_enote
->type
);
14393 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14394 inote
.namedata
= vms_enote
->name
;
14395 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14396 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14397 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14398 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14401 /* Skip malformed notes. */
14402 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14403 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14404 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14405 || ((size_t) (next
- inote
.descdata
)
14406 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14409 malformed note encountered in section %s whilst scanning for build-id note\n"),
14410 printable_section_name (filedata
, shdr
));
14415 /* Check if this is the build-id note. If so then convert the build-id
14416 bytes to a hex string. */
14417 if (inote
.namesz
> 0
14418 && const_strneq (inote
.namedata
, "GNU")
14419 && inote
.type
== NT_GNU_BUILD_ID
)
14424 build_id
= malloc (inote
.descsz
* 2 + 1);
14425 if (build_id
== NULL
)
14431 for (j
= 0; j
< inote
.descsz
; ++j
)
14432 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14433 build_id
[inote
.descsz
* 2] = '\0';
14436 return (unsigned char *) build_id
;
14443 #endif /* HAVE_LIBDEBUGINFOD */
14445 /* If this is not NULL, load_debug_section will only look for sections
14446 within the list of sections given here. */
14447 static unsigned int * section_subset
= NULL
;
14450 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14452 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14453 Elf_Internal_Shdr
* sec
;
14454 Filedata
* filedata
= (Filedata
*) data
;
14456 /* Without section headers we cannot find any sections. */
14457 if (filedata
->section_headers
== NULL
)
14460 if (filedata
->string_table
== NULL
14461 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14462 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14464 Elf_Internal_Shdr
* strs
;
14466 /* Read in the string table, so that we have section names to scan. */
14467 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14469 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14471 filedata
->string_table
14472 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14473 1, strs
->sh_size
, _("string table"));
14475 filedata
->string_table_length
14476 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14480 /* Locate the debug section. */
14481 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14483 section
->name
= section
->uncompressed_name
;
14486 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14488 section
->name
= section
->compressed_name
;
14493 /* If we're loading from a subset of sections, and we've loaded
14494 a section matching this name before, it's likely that it's a
14496 if (section_subset
!= NULL
)
14497 free_debug_section (debug
);
14499 return load_specific_debug_section (debug
, sec
, data
);
14503 free_debug_section (enum dwarf_section_display_enum debug
)
14505 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14507 if (section
->start
== NULL
)
14510 free ((char *) section
->start
);
14511 section
->start
= NULL
;
14512 section
->address
= 0;
14515 if (section
->reloc_info
!= NULL
)
14517 free (section
->reloc_info
);
14518 section
->reloc_info
= NULL
;
14519 section
->num_relocs
= 0;
14524 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14526 char * name
= SECTION_NAME (section
);
14527 const char * print_name
= printable_section_name (filedata
, section
);
14528 bfd_size_type length
;
14529 bfd_boolean result
= TRUE
;
14532 length
= section
->sh_size
;
14535 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14538 if (section
->sh_type
== SHT_NOBITS
)
14540 /* There is no point in dumping the contents of a debugging section
14541 which has the NOBITS type - the bits in the file will be random.
14542 This can happen when a file containing a .eh_frame section is
14543 stripped with the --only-keep-debug command line option. */
14544 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14549 if (const_strneq (name
, ".gnu.linkonce.wi."))
14550 name
= ".debug_info";
14552 /* See if we know how to display the contents of this section. */
14553 for (i
= 0; i
< max
; i
++)
14555 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14556 struct dwarf_section_display
* display
= debug_displays
+ i
;
14557 struct dwarf_section
* sec
= & display
->section
;
14559 if (streq (sec
->uncompressed_name
, name
)
14560 || (id
== line
&& const_strneq (name
, ".debug_line."))
14561 || streq (sec
->compressed_name
, name
))
14563 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14566 free_debug_section (id
);
14568 if (i
== line
&& const_strneq (name
, ".debug_line."))
14570 else if (streq (sec
->uncompressed_name
, name
))
14571 sec
->name
= sec
->uncompressed_name
;
14573 sec
->name
= sec
->compressed_name
;
14575 if (load_specific_debug_section (id
, section
, filedata
))
14577 /* If this debug section is part of a CU/TU set in a .dwp file,
14578 restrict load_debug_section to the sections in that set. */
14579 section_subset
= find_cu_tu_set (filedata
, shndx
);
14581 result
&= display
->display (sec
, filedata
);
14583 section_subset
= NULL
;
14585 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14586 free_debug_section (id
);
14594 printf (_("Unrecognized debug section: %s\n"), print_name
);
14601 /* Set DUMP_SECTS for all sections where dumps were requested
14602 based on section name. */
14605 initialise_dumps_byname (Filedata
* filedata
)
14607 struct dump_list_entry
* cur
;
14609 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14612 bfd_boolean any
= FALSE
;
14614 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14615 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14617 request_dump_bynumber (filedata
, i
, cur
->type
);
14622 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14628 process_section_contents (Filedata
* filedata
)
14630 Elf_Internal_Shdr
* section
;
14632 bfd_boolean res
= TRUE
;
14637 initialise_dumps_byname (filedata
);
14639 for (i
= 0, section
= filedata
->section_headers
;
14640 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14643 dump_type dump
= filedata
->dump_sects
[i
];
14645 #ifdef SUPPORT_DISASSEMBLY
14646 if (dump
& DISASS_DUMP
)
14648 if (! disassemble_section (section
, filedata
))
14652 if (dump
& HEX_DUMP
)
14654 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14658 if (dump
& RELOC_DUMP
)
14660 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14664 if (dump
& STRING_DUMP
)
14666 if (! dump_section_as_strings (section
, filedata
))
14670 if (dump
& DEBUG_DUMP
)
14672 if (! display_debug_section (i
, section
, filedata
))
14676 if (dump
& CTF_DUMP
)
14678 if (! dump_section_as_ctf (section
, filedata
))
14683 /* Check to see if the user requested a
14684 dump of a section that does not exist. */
14685 while (i
< filedata
->num_dump_sects
)
14687 if (filedata
->dump_sects
[i
])
14689 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14699 process_mips_fpe_exception (int mask
)
14703 bfd_boolean first
= TRUE
;
14705 if (mask
& OEX_FPU_INEX
)
14706 fputs ("INEX", stdout
), first
= FALSE
;
14707 if (mask
& OEX_FPU_UFLO
)
14708 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14709 if (mask
& OEX_FPU_OFLO
)
14710 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14711 if (mask
& OEX_FPU_DIV0
)
14712 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14713 if (mask
& OEX_FPU_INVAL
)
14714 printf ("%sINVAL", first
? "" : "|");
14717 fputs ("0", stdout
);
14720 /* Display's the value of TAG at location P. If TAG is
14721 greater than 0 it is assumed to be an unknown tag, and
14722 a message is printed to this effect. Otherwise it is
14723 assumed that a message has already been printed.
14725 If the bottom bit of TAG is set it assumed to have a
14726 string value, otherwise it is assumed to have an integer
14729 Returns an updated P pointing to the first unread byte
14730 beyond the end of TAG's value.
14732 Reads at or beyond END will not be made. */
14734 static unsigned char *
14735 display_tag_value (signed int tag
,
14737 const unsigned char * const end
)
14742 printf (" Tag_unknown_%d: ", tag
);
14746 warn (_("<corrupt tag>\n"));
14750 /* PR 17531 file: 027-19978-0.004. */
14751 size_t maxlen
= (end
- p
) - 1;
14756 print_symbol ((int) maxlen
, (const char *) p
);
14757 p
+= strnlen ((char *) p
, maxlen
) + 1;
14761 printf (_("<corrupt string tag>"));
14762 p
= (unsigned char *) end
;
14768 READ_ULEB (val
, p
, end
);
14769 printf ("%ld (0x%lx)\n", val
, val
);
14776 /* ARC ABI attributes section. */
14778 static unsigned char *
14779 display_arc_attribute (unsigned char * p
,
14780 const unsigned char * const end
)
14785 READ_ULEB (tag
, p
, end
);
14789 case Tag_ARC_PCS_config
:
14790 READ_ULEB (val
, p
, end
);
14791 printf (" Tag_ARC_PCS_config: ");
14795 printf (_("Absent/Non standard\n"));
14798 printf (_("Bare metal/mwdt\n"));
14801 printf (_("Bare metal/newlib\n"));
14804 printf (_("Linux/uclibc\n"));
14807 printf (_("Linux/glibc\n"));
14810 printf (_("Unknown\n"));
14815 case Tag_ARC_CPU_base
:
14816 READ_ULEB (val
, p
, end
);
14817 printf (" Tag_ARC_CPU_base: ");
14822 printf (_("Absent\n"));
14824 case TAG_CPU_ARC6xx
:
14825 printf ("ARC6xx\n");
14827 case TAG_CPU_ARC7xx
:
14828 printf ("ARC7xx\n");
14830 case TAG_CPU_ARCEM
:
14831 printf ("ARCEM\n");
14833 case TAG_CPU_ARCHS
:
14834 printf ("ARCHS\n");
14839 case Tag_ARC_CPU_variation
:
14840 READ_ULEB (val
, p
, end
);
14841 printf (" Tag_ARC_CPU_variation: ");
14845 if (val
> 0 && val
< 16)
14846 printf ("Core%d\n", val
);
14848 printf ("Unknown\n");
14852 printf (_("Absent\n"));
14857 case Tag_ARC_CPU_name
:
14858 printf (" Tag_ARC_CPU_name: ");
14859 p
= display_tag_value (-1, p
, end
);
14862 case Tag_ARC_ABI_rf16
:
14863 READ_ULEB (val
, p
, end
);
14864 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14867 case Tag_ARC_ABI_osver
:
14868 READ_ULEB (val
, p
, end
);
14869 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14872 case Tag_ARC_ABI_pic
:
14873 case Tag_ARC_ABI_sda
:
14874 READ_ULEB (val
, p
, end
);
14875 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14876 : " Tag_ARC_ABI_pic: ");
14880 printf (_("Absent\n"));
14889 printf (_("Unknown\n"));
14894 case Tag_ARC_ABI_tls
:
14895 READ_ULEB (val
, p
, end
);
14896 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14899 case Tag_ARC_ABI_enumsize
:
14900 READ_ULEB (val
, p
, end
);
14901 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14905 case Tag_ARC_ABI_exceptions
:
14906 READ_ULEB (val
, p
, end
);
14907 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14911 case Tag_ARC_ABI_double_size
:
14912 READ_ULEB (val
, p
, end
);
14913 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14916 case Tag_ARC_ISA_config
:
14917 printf (" Tag_ARC_ISA_config: ");
14918 p
= display_tag_value (-1, p
, end
);
14921 case Tag_ARC_ISA_apex
:
14922 printf (" Tag_ARC_ISA_apex: ");
14923 p
= display_tag_value (-1, p
, end
);
14926 case Tag_ARC_ISA_mpy_option
:
14927 READ_ULEB (val
, p
, end
);
14928 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14931 case Tag_ARC_ATR_version
:
14932 READ_ULEB (val
, p
, end
);
14933 printf (" Tag_ARC_ATR_version: %d\n", val
);
14937 return display_tag_value (tag
& 1, p
, end
);
14943 /* ARM EABI attributes section. */
14948 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14950 const char ** table
;
14951 } arm_attr_public_tag
;
14953 static const char * arm_attr_tag_CPU_arch
[] =
14954 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14955 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14956 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14957 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14958 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14959 {"No", "Thumb-1", "Thumb-2", "Yes"};
14960 static const char * arm_attr_tag_FP_arch
[] =
14961 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14962 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14963 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14964 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14965 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14966 "NEON for ARMv8.1"};
14967 static const char * arm_attr_tag_PCS_config
[] =
14968 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14969 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14970 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14971 {"V6", "SB", "TLS", "Unused"};
14972 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14973 {"Absolute", "PC-relative", "SB-relative", "None"};
14974 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14975 {"Absolute", "PC-relative", "None"};
14976 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14977 {"None", "direct", "GOT-indirect"};
14978 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14979 {"None", "??? 1", "2", "??? 3", "4"};
14980 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14981 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14982 {"Unused", "Needed", "Sign only"};
14983 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14984 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14985 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14986 {"Unused", "Finite", "RTABI", "IEEE 754"};
14987 static const char * arm_attr_tag_ABI_enum_size
[] =
14988 {"Unused", "small", "int", "forced to int"};
14989 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14990 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14991 static const char * arm_attr_tag_ABI_VFP_args
[] =
14992 {"AAPCS", "VFP registers", "custom", "compatible"};
14993 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14994 {"AAPCS", "WMMX registers", "custom"};
14995 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14996 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14997 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14998 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14999 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15000 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15001 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15002 static const char * arm_attr_tag_FP_HP_extension
[] =
15003 {"Not Allowed", "Allowed"};
15004 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15005 {"None", "IEEE 754", "Alternative Format"};
15006 static const char * arm_attr_tag_DSP_extension
[] =
15007 {"Follow architecture", "Allowed"};
15008 static const char * arm_attr_tag_MPextension_use
[] =
15009 {"Not Allowed", "Allowed"};
15010 static const char * arm_attr_tag_DIV_use
[] =
15011 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15012 "Allowed in v7-A with integer division extension"};
15013 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15014 static const char * arm_attr_tag_Virtualization_use
[] =
15015 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15016 "TrustZone and Virtualization Extensions"};
15017 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15018 {"Not Allowed", "Allowed"};
15020 static const char * arm_attr_tag_MVE_arch
[] =
15021 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15023 #define LOOKUP(id, name) \
15024 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15025 static arm_attr_public_tag arm_attr_public_tags
[] =
15027 {4, "CPU_raw_name", 1, NULL
},
15028 {5, "CPU_name", 1, NULL
},
15029 LOOKUP(6, CPU_arch
),
15030 {7, "CPU_arch_profile", 0, NULL
},
15031 LOOKUP(8, ARM_ISA_use
),
15032 LOOKUP(9, THUMB_ISA_use
),
15033 LOOKUP(10, FP_arch
),
15034 LOOKUP(11, WMMX_arch
),
15035 LOOKUP(12, Advanced_SIMD_arch
),
15036 LOOKUP(13, PCS_config
),
15037 LOOKUP(14, ABI_PCS_R9_use
),
15038 LOOKUP(15, ABI_PCS_RW_data
),
15039 LOOKUP(16, ABI_PCS_RO_data
),
15040 LOOKUP(17, ABI_PCS_GOT_use
),
15041 LOOKUP(18, ABI_PCS_wchar_t
),
15042 LOOKUP(19, ABI_FP_rounding
),
15043 LOOKUP(20, ABI_FP_denormal
),
15044 LOOKUP(21, ABI_FP_exceptions
),
15045 LOOKUP(22, ABI_FP_user_exceptions
),
15046 LOOKUP(23, ABI_FP_number_model
),
15047 {24, "ABI_align_needed", 0, NULL
},
15048 {25, "ABI_align_preserved", 0, NULL
},
15049 LOOKUP(26, ABI_enum_size
),
15050 LOOKUP(27, ABI_HardFP_use
),
15051 LOOKUP(28, ABI_VFP_args
),
15052 LOOKUP(29, ABI_WMMX_args
),
15053 LOOKUP(30, ABI_optimization_goals
),
15054 LOOKUP(31, ABI_FP_optimization_goals
),
15055 {32, "compatibility", 0, NULL
},
15056 LOOKUP(34, CPU_unaligned_access
),
15057 LOOKUP(36, FP_HP_extension
),
15058 LOOKUP(38, ABI_FP_16bit_format
),
15059 LOOKUP(42, MPextension_use
),
15060 LOOKUP(44, DIV_use
),
15061 LOOKUP(46, DSP_extension
),
15062 LOOKUP(48, MVE_arch
),
15063 {64, "nodefaults", 0, NULL
},
15064 {65, "also_compatible_with", 0, NULL
},
15065 LOOKUP(66, T2EE_use
),
15066 {67, "conformance", 1, NULL
},
15067 LOOKUP(68, Virtualization_use
),
15068 LOOKUP(70, MPextension_use_legacy
)
15072 static unsigned char *
15073 display_arm_attribute (unsigned char * p
,
15074 const unsigned char * const end
)
15078 arm_attr_public_tag
* attr
;
15082 READ_ULEB (tag
, p
, end
);
15084 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15086 if (arm_attr_public_tags
[i
].tag
== tag
)
15088 attr
= &arm_attr_public_tags
[i
];
15095 printf (" Tag_%s: ", attr
->name
);
15096 switch (attr
->type
)
15101 case 7: /* Tag_CPU_arch_profile. */
15102 READ_ULEB (val
, p
, end
);
15105 case 0: printf (_("None\n")); break;
15106 case 'A': printf (_("Application\n")); break;
15107 case 'R': printf (_("Realtime\n")); break;
15108 case 'M': printf (_("Microcontroller\n")); break;
15109 case 'S': printf (_("Application or Realtime\n")); break;
15110 default: printf ("??? (%d)\n", val
); break;
15114 case 24: /* Tag_align_needed. */
15115 READ_ULEB (val
, p
, end
);
15118 case 0: printf (_("None\n")); break;
15119 case 1: printf (_("8-byte\n")); break;
15120 case 2: printf (_("4-byte\n")); break;
15121 case 3: printf ("??? 3\n"); break;
15124 printf (_("8-byte and up to %d-byte extended\n"),
15127 printf ("??? (%d)\n", val
);
15132 case 25: /* Tag_align_preserved. */
15133 READ_ULEB (val
, p
, end
);
15136 case 0: printf (_("None\n")); break;
15137 case 1: printf (_("8-byte, except leaf SP\n")); break;
15138 case 2: printf (_("8-byte\n")); break;
15139 case 3: printf ("??? 3\n"); break;
15142 printf (_("8-byte and up to %d-byte extended\n"),
15145 printf ("??? (%d)\n", val
);
15150 case 32: /* Tag_compatibility. */
15152 READ_ULEB (val
, p
, end
);
15153 printf (_("flag = %d, vendor = "), val
);
15156 size_t maxlen
= (end
- p
) - 1;
15158 print_symbol ((int) maxlen
, (const char *) p
);
15159 p
+= strnlen ((char *) p
, maxlen
) + 1;
15163 printf (_("<corrupt>"));
15164 p
= (unsigned char *) end
;
15170 case 64: /* Tag_nodefaults. */
15171 /* PR 17531: file: 001-505008-0.01. */
15174 printf (_("True\n"));
15177 case 65: /* Tag_also_compatible_with. */
15178 READ_ULEB (val
, p
, end
);
15179 if (val
== 6 /* Tag_CPU_arch. */)
15181 READ_ULEB (val
, p
, end
);
15182 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15183 printf ("??? (%d)\n", val
);
15185 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15189 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15194 printf (_("<unknown: %d>\n"), tag
);
15200 return display_tag_value (-1, p
, end
);
15202 return display_tag_value (0, p
, end
);
15205 assert (attr
->type
& 0x80);
15206 READ_ULEB (val
, p
, end
);
15207 type
= attr
->type
& 0x7f;
15209 printf ("??? (%d)\n", val
);
15211 printf ("%s\n", attr
->table
[val
]);
15216 return display_tag_value (tag
, p
, end
);
15219 static unsigned char *
15220 display_gnu_attribute (unsigned char * p
,
15221 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15222 const unsigned char * const end
)
15227 READ_ULEB (tag
, p
, end
);
15229 /* Tag_compatibility is the only generic GNU attribute defined at
15233 READ_ULEB (val
, p
, end
);
15235 printf (_("flag = %d, vendor = "), val
);
15238 printf (_("<corrupt>\n"));
15239 warn (_("corrupt vendor attribute\n"));
15245 size_t maxlen
= (end
- p
) - 1;
15247 print_symbol ((int) maxlen
, (const char *) p
);
15248 p
+= strnlen ((char *) p
, maxlen
) + 1;
15252 printf (_("<corrupt>"));
15253 p
= (unsigned char *) end
;
15260 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15261 return display_proc_gnu_attribute (p
, tag
, end
);
15263 return display_tag_value (tag
, p
, end
);
15266 static unsigned char *
15267 display_power_gnu_attribute (unsigned char * p
,
15269 const unsigned char * const end
)
15273 if (tag
== Tag_GNU_Power_ABI_FP
)
15275 printf (" Tag_GNU_Power_ABI_FP: ");
15278 printf (_("<corrupt>\n"));
15281 READ_ULEB (val
, p
, end
);
15284 printf ("(%#x), ", val
);
15289 printf (_("unspecified hard/soft float, "));
15292 printf (_("hard float, "));
15295 printf (_("soft float, "));
15298 printf (_("single-precision hard float, "));
15305 printf (_("unspecified long double\n"));
15308 printf (_("128-bit IBM long double\n"));
15311 printf (_("64-bit long double\n"));
15314 printf (_("128-bit IEEE long double\n"));
15320 if (tag
== Tag_GNU_Power_ABI_Vector
)
15322 printf (" Tag_GNU_Power_ABI_Vector: ");
15325 printf (_("<corrupt>\n"));
15328 READ_ULEB (val
, p
, end
);
15331 printf ("(%#x), ", val
);
15336 printf (_("unspecified\n"));
15339 printf (_("generic\n"));
15342 printf ("AltiVec\n");
15351 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15353 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15356 printf (_("<corrupt>\n"));
15359 READ_ULEB (val
, p
, end
);
15362 printf ("(%#x), ", val
);
15367 printf (_("unspecified\n"));
15370 printf ("r3/r4\n");
15373 printf (_("memory\n"));
15382 return display_tag_value (tag
& 1, p
, end
);
15385 static unsigned char *
15386 display_s390_gnu_attribute (unsigned char * p
,
15388 const unsigned char * const end
)
15392 if (tag
== Tag_GNU_S390_ABI_Vector
)
15394 printf (" Tag_GNU_S390_ABI_Vector: ");
15395 READ_ULEB (val
, p
, end
);
15400 printf (_("any\n"));
15403 printf (_("software\n"));
15406 printf (_("hardware\n"));
15409 printf ("??? (%d)\n", val
);
15415 return display_tag_value (tag
& 1, p
, end
);
15419 display_sparc_hwcaps (unsigned int mask
)
15423 bfd_boolean first
= TRUE
;
15425 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15426 fputs ("mul32", stdout
), first
= FALSE
;
15427 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15428 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15429 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15430 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15431 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15432 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15433 if (mask
& ELF_SPARC_HWCAP_POPC
)
15434 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15435 if (mask
& ELF_SPARC_HWCAP_VIS
)
15436 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15437 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15438 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15439 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15440 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15441 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15442 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15443 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15444 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15445 if (mask
& ELF_SPARC_HWCAP_HPC
)
15446 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15447 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15448 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15449 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15450 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15451 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15452 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15453 if (mask
& ELF_SPARC_HWCAP_IMA
)
15454 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15455 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15456 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15459 fputc ('0', stdout
);
15460 fputc ('\n', stdout
);
15464 display_sparc_hwcaps2 (unsigned int mask
)
15468 bfd_boolean first
= TRUE
;
15470 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15471 fputs ("fjathplus", stdout
), first
= FALSE
;
15472 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15473 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15474 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15475 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15476 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15477 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15478 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15479 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15480 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15481 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15482 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15483 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15484 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15485 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15486 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15487 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15488 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15489 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15490 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15491 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15494 fputc ('0', stdout
);
15495 fputc ('\n', stdout
);
15498 static unsigned char *
15499 display_sparc_gnu_attribute (unsigned char * p
,
15501 const unsigned char * const end
)
15505 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15507 READ_ULEB (val
, p
, end
);
15508 printf (" Tag_GNU_Sparc_HWCAPS: ");
15509 display_sparc_hwcaps (val
);
15512 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15514 READ_ULEB (val
, p
, end
);
15515 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15516 display_sparc_hwcaps2 (val
);
15520 return display_tag_value (tag
, p
, end
);
15524 print_mips_fp_abi_value (unsigned int val
)
15528 case Val_GNU_MIPS_ABI_FP_ANY
:
15529 printf (_("Hard or soft float\n"));
15531 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15532 printf (_("Hard float (double precision)\n"));
15534 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15535 printf (_("Hard float (single precision)\n"));
15537 case Val_GNU_MIPS_ABI_FP_SOFT
:
15538 printf (_("Soft float\n"));
15540 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15541 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15543 case Val_GNU_MIPS_ABI_FP_XX
:
15544 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15546 case Val_GNU_MIPS_ABI_FP_64
:
15547 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15549 case Val_GNU_MIPS_ABI_FP_64A
:
15550 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15552 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15553 printf (_("NaN 2008 compatibility\n"));
15556 printf ("??? (%d)\n", val
);
15561 static unsigned char *
15562 display_mips_gnu_attribute (unsigned char * p
,
15564 const unsigned char * const end
)
15566 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15570 printf (" Tag_GNU_MIPS_ABI_FP: ");
15571 READ_ULEB (val
, p
, end
);
15572 print_mips_fp_abi_value (val
);
15576 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15580 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15581 READ_ULEB (val
, p
, end
);
15585 case Val_GNU_MIPS_ABI_MSA_ANY
:
15586 printf (_("Any MSA or not\n"));
15588 case Val_GNU_MIPS_ABI_MSA_128
:
15589 printf (_("128-bit MSA\n"));
15592 printf ("??? (%d)\n", val
);
15598 return display_tag_value (tag
& 1, p
, end
);
15601 static unsigned char *
15602 display_tic6x_attribute (unsigned char * p
,
15603 const unsigned char * const end
)
15608 READ_ULEB (tag
, p
, end
);
15613 printf (" Tag_ISA: ");
15614 READ_ULEB (val
, p
, end
);
15618 case C6XABI_Tag_ISA_none
:
15619 printf (_("None\n"));
15621 case C6XABI_Tag_ISA_C62X
:
15624 case C6XABI_Tag_ISA_C67X
:
15627 case C6XABI_Tag_ISA_C67XP
:
15628 printf ("C67x+\n");
15630 case C6XABI_Tag_ISA_C64X
:
15633 case C6XABI_Tag_ISA_C64XP
:
15634 printf ("C64x+\n");
15636 case C6XABI_Tag_ISA_C674X
:
15637 printf ("C674x\n");
15640 printf ("??? (%d)\n", val
);
15645 case Tag_ABI_wchar_t
:
15646 printf (" Tag_ABI_wchar_t: ");
15647 READ_ULEB (val
, p
, end
);
15651 printf (_("Not used\n"));
15654 printf (_("2 bytes\n"));
15657 printf (_("4 bytes\n"));
15660 printf ("??? (%d)\n", val
);
15665 case Tag_ABI_stack_align_needed
:
15666 printf (" Tag_ABI_stack_align_needed: ");
15667 READ_ULEB (val
, p
, end
);
15671 printf (_("8-byte\n"));
15674 printf (_("16-byte\n"));
15677 printf ("??? (%d)\n", val
);
15682 case Tag_ABI_stack_align_preserved
:
15683 READ_ULEB (val
, p
, end
);
15684 printf (" Tag_ABI_stack_align_preserved: ");
15688 printf (_("8-byte\n"));
15691 printf (_("16-byte\n"));
15694 printf ("??? (%d)\n", val
);
15700 READ_ULEB (val
, p
, end
);
15701 printf (" Tag_ABI_DSBT: ");
15705 printf (_("DSBT addressing not used\n"));
15708 printf (_("DSBT addressing used\n"));
15711 printf ("??? (%d)\n", val
);
15717 READ_ULEB (val
, p
, end
);
15718 printf (" Tag_ABI_PID: ");
15722 printf (_("Data addressing position-dependent\n"));
15725 printf (_("Data addressing position-independent, GOT near DP\n"));
15728 printf (_("Data addressing position-independent, GOT far from DP\n"));
15731 printf ("??? (%d)\n", val
);
15737 READ_ULEB (val
, p
, end
);
15738 printf (" Tag_ABI_PIC: ");
15742 printf (_("Code addressing position-dependent\n"));
15745 printf (_("Code addressing position-independent\n"));
15748 printf ("??? (%d)\n", val
);
15753 case Tag_ABI_array_object_alignment
:
15754 READ_ULEB (val
, p
, end
);
15755 printf (" Tag_ABI_array_object_alignment: ");
15759 printf (_("8-byte\n"));
15762 printf (_("4-byte\n"));
15765 printf (_("16-byte\n"));
15768 printf ("??? (%d)\n", val
);
15773 case Tag_ABI_array_object_align_expected
:
15774 READ_ULEB (val
, p
, end
);
15775 printf (" Tag_ABI_array_object_align_expected: ");
15779 printf (_("8-byte\n"));
15782 printf (_("4-byte\n"));
15785 printf (_("16-byte\n"));
15788 printf ("??? (%d)\n", val
);
15793 case Tag_ABI_compatibility
:
15795 READ_ULEB (val
, p
, end
);
15796 printf (" Tag_ABI_compatibility: ");
15797 printf (_("flag = %d, vendor = "), val
);
15800 size_t maxlen
= (end
- p
) - 1;
15802 print_symbol ((int) maxlen
, (const char *) p
);
15803 p
+= strnlen ((char *) p
, maxlen
) + 1;
15807 printf (_("<corrupt>"));
15808 p
= (unsigned char *) end
;
15814 case Tag_ABI_conformance
:
15816 printf (" Tag_ABI_conformance: \"");
15819 size_t maxlen
= (end
- p
) - 1;
15821 print_symbol ((int) maxlen
, (const char *) p
);
15822 p
+= strnlen ((char *) p
, maxlen
) + 1;
15826 printf (_("<corrupt>"));
15827 p
= (unsigned char *) end
;
15834 return display_tag_value (tag
, p
, end
);
15838 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15840 unsigned long addr
= 0;
15841 size_t bytes
= end
- p
;
15848 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15850 printf (" 0x%8.8lx ", addr
);
15852 for (j
= 0; j
< 16; j
++)
15855 printf ("%2.2x", p
[j
]);
15863 for (j
= 0; j
< lbytes
; j
++)
15866 if (k
>= ' ' && k
< 0x7f)
15882 static unsigned char *
15883 display_msp430x_attribute (unsigned char * p
,
15884 const unsigned char * const end
)
15889 READ_ULEB (tag
, p
, end
);
15893 case OFBA_MSPABI_Tag_ISA
:
15894 printf (" Tag_ISA: ");
15895 READ_ULEB (val
, p
, end
);
15898 case 0: printf (_("None\n")); break;
15899 case 1: printf (_("MSP430\n")); break;
15900 case 2: printf (_("MSP430X\n")); break;
15901 default: printf ("??? (%d)\n", val
); break;
15905 case OFBA_MSPABI_Tag_Code_Model
:
15906 printf (" Tag_Code_Model: ");
15907 READ_ULEB (val
, p
, end
);
15910 case 0: printf (_("None\n")); break;
15911 case 1: printf (_("Small\n")); break;
15912 case 2: printf (_("Large\n")); break;
15913 default: printf ("??? (%d)\n", val
); break;
15917 case OFBA_MSPABI_Tag_Data_Model
:
15918 printf (" Tag_Data_Model: ");
15919 READ_ULEB (val
, p
, end
);
15922 case 0: printf (_("None\n")); break;
15923 case 1: printf (_("Small\n")); break;
15924 case 2: printf (_("Large\n")); break;
15925 case 3: printf (_("Restricted Large\n")); break;
15926 default: printf ("??? (%d)\n", val
); break;
15931 printf (_(" <unknown tag %d>: "), tag
);
15938 size_t maxlen
= (end
- p
) - 1;
15940 print_symbol ((int) maxlen
, (const char *) p
);
15941 p
+= strnlen ((char *) p
, maxlen
) + 1;
15945 printf (_("<corrupt>"));
15946 p
= (unsigned char *) end
;
15952 READ_ULEB (val
, p
, end
);
15953 printf ("%d (0x%x)\n", val
, val
);
15962 static unsigned char *
15963 display_msp430_gnu_attribute (unsigned char * p
,
15965 const unsigned char * const end
)
15967 if (tag
== Tag_GNU_MSP430_Data_Region
)
15971 printf (" Tag_GNU_MSP430_Data_Region: ");
15972 READ_ULEB (val
, p
, end
);
15976 case Val_GNU_MSP430_Data_Region_Any
:
15977 printf (_("Any Region\n"));
15979 case Val_GNU_MSP430_Data_Region_Lower
:
15980 printf (_("Lower Region Only\n"));
15983 printf ("??? (%u)\n", val
);
15987 return display_tag_value (tag
& 1, p
, end
);
15990 struct riscv_attr_tag_t
{
15995 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15997 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16000 T(priv_spec_minor
),
16001 T(priv_spec_revision
),
16002 T(unaligned_access
),
16007 static unsigned char *
16008 display_riscv_attribute (unsigned char *p
,
16009 const unsigned char * const end
)
16013 struct riscv_attr_tag_t
*attr
= NULL
;
16016 READ_ULEB (tag
, p
, end
);
16018 /* Find the name of attribute. */
16019 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16021 if (riscv_attr_tag
[i
].tag
== tag
)
16023 attr
= &riscv_attr_tag
[i
];
16029 printf (" %s: ", attr
->name
);
16031 return display_tag_value (tag
, p
, end
);
16035 case Tag_RISCV_priv_spec
:
16036 case Tag_RISCV_priv_spec_minor
:
16037 case Tag_RISCV_priv_spec_revision
:
16038 READ_ULEB (val
, p
, end
);
16039 printf (_("%u\n"), val
);
16041 case Tag_RISCV_unaligned_access
:
16042 READ_ULEB (val
, p
, end
);
16046 printf (_("No unaligned access\n"));
16049 printf (_("Unaligned access\n"));
16053 case Tag_RISCV_stack_align
:
16054 READ_ULEB (val
, p
, end
);
16055 printf (_("%u-bytes\n"), val
);
16057 case Tag_RISCV_arch
:
16058 p
= display_tag_value (-1, p
, end
);
16061 return display_tag_value (tag
, p
, end
);
16068 process_attributes (Filedata
* filedata
,
16069 const char * public_name
,
16070 unsigned int proc_type
,
16071 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16072 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16074 Elf_Internal_Shdr
* sect
;
16076 bfd_boolean res
= TRUE
;
16078 /* Find the section header so that we get the size. */
16079 for (i
= 0, sect
= filedata
->section_headers
;
16080 i
< filedata
->file_header
.e_shnum
;
16083 unsigned char * contents
;
16086 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16089 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16090 sect
->sh_size
, _("attributes"));
16091 if (contents
== NULL
)
16098 /* The first character is the version of the attributes.
16099 Currently only version 1, (aka 'A') is recognised here. */
16102 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16107 bfd_vma section_len
;
16109 section_len
= sect
->sh_size
- 1;
16112 while (section_len
> 0)
16115 unsigned int namelen
;
16116 bfd_boolean public_section
;
16117 bfd_boolean gnu_section
;
16119 if (section_len
<= 4)
16121 error (_("Tag section ends prematurely\n"));
16125 attr_len
= byte_get (p
, 4);
16128 if (attr_len
> section_len
)
16130 error (_("Bad attribute length (%u > %u)\n"),
16131 (unsigned) attr_len
, (unsigned) section_len
);
16132 attr_len
= section_len
;
16135 /* PR 17531: file: 001-101425-0.004 */
16136 else if (attr_len
< 5)
16138 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16143 section_len
-= attr_len
;
16146 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16147 if (namelen
== 0 || namelen
>= attr_len
)
16149 error (_("Corrupt attribute section name\n"));
16154 printf (_("Attribute Section: "));
16155 print_symbol (INT_MAX
, (const char *) p
);
16158 if (public_name
&& streq ((char *) p
, public_name
))
16159 public_section
= TRUE
;
16161 public_section
= FALSE
;
16163 if (streq ((char *) p
, "gnu"))
16164 gnu_section
= TRUE
;
16166 gnu_section
= FALSE
;
16169 attr_len
-= namelen
;
16171 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16176 unsigned char * end
;
16178 /* PR binutils/17531: Safe handling of corrupt files. */
16181 error (_("Unused bytes at end of section\n"));
16188 size
= byte_get (p
, 4);
16189 if (size
> attr_len
)
16191 error (_("Bad subsection length (%u > %u)\n"),
16192 (unsigned) size
, (unsigned) attr_len
);
16196 /* PR binutils/17531: Safe handling of corrupt files. */
16199 error (_("Bad subsection length (%u < 6)\n"),
16207 end
= p
+ size
- 1;
16208 assert (end
<= contents
+ sect
->sh_size
);
16214 printf (_("File Attributes\n"));
16217 printf (_("Section Attributes:"));
16220 printf (_("Symbol Attributes:"));
16221 /* Fall through. */
16225 READ_ULEB (val
, p
, end
);
16228 printf (" %d", val
);
16233 printf (_("Unknown tag: %d\n"), tag
);
16234 public_section
= FALSE
;
16238 if (public_section
&& display_pub_attribute
!= NULL
)
16241 p
= display_pub_attribute (p
, end
);
16244 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16247 p
= display_gnu_attribute (p
,
16248 display_proc_gnu_attribute
,
16254 printf (_(" Unknown attribute:\n"));
16255 display_raw_attribute (p
, end
);
16270 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16271 Print the Address, Access and Initial fields of an entry at VMA ADDR
16272 and return the VMA of the next entry, or -1 if there was a problem.
16273 Does not read from DATA_END or beyond. */
16276 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16277 unsigned char * data_end
)
16280 print_vma (addr
, LONG_HEX
);
16282 if (addr
< pltgot
+ 0xfff0)
16283 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16285 printf ("%10s", "");
16288 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16292 unsigned char * from
= data
+ addr
- pltgot
;
16294 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16296 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16297 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16298 return (bfd_vma
) -1;
16302 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16303 print_vma (entry
, LONG_HEX
);
16306 return addr
+ (is_32bit_elf
? 4 : 8);
16309 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16310 PLTGOT. Print the Address and Initial fields of an entry at VMA
16311 ADDR and return the VMA of the next entry. */
16314 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16317 print_vma (addr
, LONG_HEX
);
16320 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16325 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16326 print_vma (entry
, LONG_HEX
);
16328 return addr
+ (is_32bit_elf
? 4 : 8);
16332 print_mips_ases (unsigned int mask
)
16334 if (mask
& AFL_ASE_DSP
)
16335 fputs ("\n\tDSP ASE", stdout
);
16336 if (mask
& AFL_ASE_DSPR2
)
16337 fputs ("\n\tDSP R2 ASE", stdout
);
16338 if (mask
& AFL_ASE_DSPR3
)
16339 fputs ("\n\tDSP R3 ASE", stdout
);
16340 if (mask
& AFL_ASE_EVA
)
16341 fputs ("\n\tEnhanced VA Scheme", stdout
);
16342 if (mask
& AFL_ASE_MCU
)
16343 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16344 if (mask
& AFL_ASE_MDMX
)
16345 fputs ("\n\tMDMX ASE", stdout
);
16346 if (mask
& AFL_ASE_MIPS3D
)
16347 fputs ("\n\tMIPS-3D ASE", stdout
);
16348 if (mask
& AFL_ASE_MT
)
16349 fputs ("\n\tMT ASE", stdout
);
16350 if (mask
& AFL_ASE_SMARTMIPS
)
16351 fputs ("\n\tSmartMIPS ASE", stdout
);
16352 if (mask
& AFL_ASE_VIRT
)
16353 fputs ("\n\tVZ ASE", stdout
);
16354 if (mask
& AFL_ASE_MSA
)
16355 fputs ("\n\tMSA ASE", stdout
);
16356 if (mask
& AFL_ASE_MIPS16
)
16357 fputs ("\n\tMIPS16 ASE", stdout
);
16358 if (mask
& AFL_ASE_MICROMIPS
)
16359 fputs ("\n\tMICROMIPS ASE", stdout
);
16360 if (mask
& AFL_ASE_XPA
)
16361 fputs ("\n\tXPA ASE", stdout
);
16362 if (mask
& AFL_ASE_MIPS16E2
)
16363 fputs ("\n\tMIPS16e2 ASE", stdout
);
16364 if (mask
& AFL_ASE_CRC
)
16365 fputs ("\n\tCRC ASE", stdout
);
16366 if (mask
& AFL_ASE_GINV
)
16367 fputs ("\n\tGINV ASE", stdout
);
16368 if (mask
& AFL_ASE_LOONGSON_MMI
)
16369 fputs ("\n\tLoongson MMI ASE", stdout
);
16370 if (mask
& AFL_ASE_LOONGSON_CAM
)
16371 fputs ("\n\tLoongson CAM ASE", stdout
);
16372 if (mask
& AFL_ASE_LOONGSON_EXT
)
16373 fputs ("\n\tLoongson EXT ASE", stdout
);
16374 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16375 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16377 fprintf (stdout
, "\n\t%s", _("None"));
16378 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16379 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16383 print_mips_isa_ext (unsigned int isa_ext
)
16388 fputs (_("None"), stdout
);
16391 fputs ("RMI XLR", stdout
);
16393 case AFL_EXT_OCTEON3
:
16394 fputs ("Cavium Networks Octeon3", stdout
);
16396 case AFL_EXT_OCTEON2
:
16397 fputs ("Cavium Networks Octeon2", stdout
);
16399 case AFL_EXT_OCTEONP
:
16400 fputs ("Cavium Networks OcteonP", stdout
);
16402 case AFL_EXT_OCTEON
:
16403 fputs ("Cavium Networks Octeon", stdout
);
16406 fputs ("Toshiba R5900", stdout
);
16409 fputs ("MIPS R4650", stdout
);
16412 fputs ("LSI R4010", stdout
);
16415 fputs ("NEC VR4100", stdout
);
16418 fputs ("Toshiba R3900", stdout
);
16420 case AFL_EXT_10000
:
16421 fputs ("MIPS R10000", stdout
);
16424 fputs ("Broadcom SB-1", stdout
);
16427 fputs ("NEC VR4111/VR4181", stdout
);
16430 fputs ("NEC VR4120", stdout
);
16433 fputs ("NEC VR5400", stdout
);
16436 fputs ("NEC VR5500", stdout
);
16438 case AFL_EXT_LOONGSON_2E
:
16439 fputs ("ST Microelectronics Loongson 2E", stdout
);
16441 case AFL_EXT_LOONGSON_2F
:
16442 fputs ("ST Microelectronics Loongson 2F", stdout
);
16444 case AFL_EXT_INTERAPTIV_MR2
:
16445 fputs ("Imagination interAptiv MR2", stdout
);
16448 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16453 get_mips_reg_size (int reg_size
)
16455 return (reg_size
== AFL_REG_NONE
) ? 0
16456 : (reg_size
== AFL_REG_32
) ? 32
16457 : (reg_size
== AFL_REG_64
) ? 64
16458 : (reg_size
== AFL_REG_128
) ? 128
16463 process_mips_specific (Filedata
* filedata
)
16465 Elf_Internal_Dyn
* entry
;
16466 Elf_Internal_Shdr
*sect
= NULL
;
16467 size_t liblist_offset
= 0;
16468 size_t liblistno
= 0;
16469 size_t conflictsno
= 0;
16470 size_t options_offset
= 0;
16471 size_t conflicts_offset
= 0;
16472 size_t pltrelsz
= 0;
16474 bfd_vma pltgot
= 0;
16475 bfd_vma mips_pltgot
= 0;
16476 bfd_vma jmprel
= 0;
16477 bfd_vma local_gotno
= 0;
16478 bfd_vma gotsym
= 0;
16479 bfd_vma symtabno
= 0;
16480 bfd_boolean res
= TRUE
;
16482 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16483 display_mips_gnu_attribute
))
16486 sect
= find_section (filedata
, ".MIPS.abiflags");
16490 Elf_External_ABIFlags_v0
*abiflags_ext
;
16491 Elf_Internal_ABIFlags_v0 abiflags_in
;
16493 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16495 error (_("Corrupt MIPS ABI Flags section.\n"));
16500 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16501 sect
->sh_size
, _("MIPS ABI Flags section"));
16504 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16505 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16506 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16507 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16508 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16509 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16510 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16511 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16512 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16513 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16514 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16516 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16517 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16518 if (abiflags_in
.isa_rev
> 1)
16519 printf ("r%d", abiflags_in
.isa_rev
);
16520 printf ("\nGPR size: %d",
16521 get_mips_reg_size (abiflags_in
.gpr_size
));
16522 printf ("\nCPR1 size: %d",
16523 get_mips_reg_size (abiflags_in
.cpr1_size
));
16524 printf ("\nCPR2 size: %d",
16525 get_mips_reg_size (abiflags_in
.cpr2_size
));
16526 fputs ("\nFP ABI: ", stdout
);
16527 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16528 fputs ("ISA Extension: ", stdout
);
16529 print_mips_isa_ext (abiflags_in
.isa_ext
);
16530 fputs ("\nASEs:", stdout
);
16531 print_mips_ases (abiflags_in
.ases
);
16532 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16533 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16534 fputc ('\n', stdout
);
16535 free (abiflags_ext
);
16540 /* We have a lot of special sections. Thanks SGI! */
16541 if (dynamic_section
== NULL
)
16543 /* No dynamic information available. See if there is static GOT. */
16544 sect
= find_section (filedata
, ".got");
16547 unsigned char *data_end
;
16548 unsigned char *data
;
16552 pltgot
= sect
->sh_addr
;
16555 addr_size
= (is_32bit_elf
? 4 : 8);
16556 end
= pltgot
+ sect
->sh_size
;
16558 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16560 _("Global Offset Table data"));
16561 /* PR 12855: Null data is handled gracefully throughout. */
16562 data_end
= data
+ (end
- pltgot
);
16564 printf (_("\nStatic GOT:\n"));
16565 printf (_(" Canonical gp value: "));
16566 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16569 /* In a dynamic binary GOT[0] is reserved for the dynamic
16570 loader to store the lazy resolver pointer, however in
16571 a static binary it may well have been omitted and GOT
16572 reduced to a table of addresses.
16573 PR 21344: Check for the entry being fully available
16574 before fetching it. */
16576 && data
+ ent
- pltgot
+ addr_size
<= data_end
16577 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16579 printf (_(" Reserved entries:\n"));
16580 printf (_(" %*s %10s %*s\n"),
16581 addr_size
* 2, _("Address"), _("Access"),
16582 addr_size
* 2, _("Value"));
16583 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16585 if (ent
== (bfd_vma
) -1)
16586 goto sgot_print_fail
;
16588 /* Check for the MSB of GOT[1] being set, identifying a
16589 GNU object. This entry will be used by some runtime
16590 loaders, to store the module pointer. Otherwise this
16591 is an ordinary local entry.
16592 PR 21344: Check for the entry being fully available
16593 before fetching it. */
16595 && data
+ ent
- pltgot
+ addr_size
<= data_end
16596 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16597 >> (addr_size
* 8 - 1)) != 0)
16599 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16601 if (ent
== (bfd_vma
) -1)
16602 goto sgot_print_fail
;
16607 if (data
!= NULL
&& ent
< end
)
16609 printf (_(" Local entries:\n"));
16610 printf (" %*s %10s %*s\n",
16611 addr_size
* 2, _("Address"), _("Access"),
16612 addr_size
* 2, _("Value"));
16615 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16617 if (ent
== (bfd_vma
) -1)
16618 goto sgot_print_fail
;
16630 for (entry
= dynamic_section
;
16631 /* PR 17531 file: 012-50589-0.004. */
16632 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16634 switch (entry
->d_tag
)
16636 case DT_MIPS_LIBLIST
:
16638 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16639 liblistno
* sizeof (Elf32_External_Lib
));
16641 case DT_MIPS_LIBLISTNO
:
16642 liblistno
= entry
->d_un
.d_val
;
16644 case DT_MIPS_OPTIONS
:
16645 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16647 case DT_MIPS_CONFLICT
:
16649 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16650 conflictsno
* sizeof (Elf32_External_Conflict
));
16652 case DT_MIPS_CONFLICTNO
:
16653 conflictsno
= entry
->d_un
.d_val
;
16656 pltgot
= entry
->d_un
.d_ptr
;
16658 case DT_MIPS_LOCAL_GOTNO
:
16659 local_gotno
= entry
->d_un
.d_val
;
16661 case DT_MIPS_GOTSYM
:
16662 gotsym
= entry
->d_un
.d_val
;
16664 case DT_MIPS_SYMTABNO
:
16665 symtabno
= entry
->d_un
.d_val
;
16667 case DT_MIPS_PLTGOT
:
16668 mips_pltgot
= entry
->d_un
.d_ptr
;
16671 pltrel
= entry
->d_un
.d_val
;
16674 pltrelsz
= entry
->d_un
.d_val
;
16677 jmprel
= entry
->d_un
.d_ptr
;
16683 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16685 Elf32_External_Lib
* elib
;
16688 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16689 sizeof (Elf32_External_Lib
),
16691 _("liblist section data"));
16694 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16695 "\nSection '.liblist' contains %lu entries:\n",
16696 (unsigned long) liblistno
),
16697 (unsigned long) liblistno
);
16698 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16701 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16708 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16709 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16710 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16711 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16712 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16714 tmp
= gmtime (&atime
);
16715 snprintf (timebuf
, sizeof (timebuf
),
16716 "%04u-%02u-%02uT%02u:%02u:%02u",
16717 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16718 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16720 printf ("%3lu: ", (unsigned long) cnt
);
16721 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16722 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16724 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16725 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16726 liblist
.l_version
);
16728 if (liblist
.l_flags
== 0)
16732 static const struct
16739 { " EXACT_MATCH", LL_EXACT_MATCH
},
16740 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16741 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16742 { " EXPORTS", LL_EXPORTS
},
16743 { " DELAY_LOAD", LL_DELAY_LOAD
},
16744 { " DELTA", LL_DELTA
}
16746 int flags
= liblist
.l_flags
;
16749 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16750 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16752 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16753 flags
^= l_flags_vals
[fcnt
].bit
;
16756 printf (" %#x", (unsigned int) flags
);
16768 if (options_offset
!= 0)
16770 Elf_External_Options
* eopt
;
16773 sect
= filedata
->section_headers
;
16775 /* Find the section header so that we get the size. */
16776 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16777 /* PR 17533 file: 012-277276-0.004. */
16780 error (_("No MIPS_OPTIONS header found\n"));
16784 if (sect
->sh_size
< sizeof (* eopt
))
16786 error (_("The MIPS options section is too small.\n"));
16790 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16791 sect
->sh_size
, _("options"));
16794 Elf_Internal_Options
* iopt
;
16795 Elf_Internal_Options
* option
;
16796 Elf_Internal_Options
* iopt_end
;
16798 iopt
= (Elf_Internal_Options
*)
16799 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16802 error (_("Out of memory allocating space for MIPS options\n"));
16808 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16810 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16812 Elf_External_Options
* eoption
;
16814 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16816 option
->kind
= BYTE_GET (eoption
->kind
);
16817 option
->size
= BYTE_GET (eoption
->size
);
16818 option
->section
= BYTE_GET (eoption
->section
);
16819 option
->info
= BYTE_GET (eoption
->info
);
16821 /* PR 17531: file: ffa0fa3b. */
16822 if (option
->size
< sizeof (* eopt
)
16823 || offset
+ option
->size
> sect
->sh_size
)
16825 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16828 offset
+= option
->size
;
16834 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16835 "\nSection '%s' contains %d entries:\n",
16837 printable_section_name (filedata
, sect
), cnt
);
16846 switch (option
->kind
)
16849 /* This shouldn't happen. */
16850 printf (" NULL %d %lx", option
->section
, option
->info
);
16854 printf (" REGINFO ");
16855 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16857 Elf32_External_RegInfo
* ereg
;
16858 Elf32_RegInfo reginfo
;
16861 if (option
+ 2 > iopt_end
)
16863 printf (_("<corrupt>\n"));
16864 error (_("Truncated MIPS REGINFO option\n"));
16869 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16871 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16872 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16873 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16874 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16875 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16876 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16878 printf ("GPR %08lx GP 0x%lx\n",
16879 reginfo
.ri_gprmask
,
16880 (unsigned long) reginfo
.ri_gp_value
);
16881 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16882 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16883 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16888 Elf64_External_RegInfo
* ereg
;
16889 Elf64_Internal_RegInfo reginfo
;
16891 if (option
+ 2 > iopt_end
)
16893 printf (_("<corrupt>\n"));
16894 error (_("Truncated MIPS REGINFO option\n"));
16899 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16900 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16901 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16902 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16903 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16904 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16905 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16907 printf ("GPR %08lx GP 0x",
16908 reginfo
.ri_gprmask
);
16909 printf_vma (reginfo
.ri_gp_value
);
16912 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16913 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16914 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16919 case ODK_EXCEPTIONS
:
16920 fputs (" EXCEPTIONS fpe_min(", stdout
);
16921 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16922 fputs (") fpe_max(", stdout
);
16923 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16924 fputs (")", stdout
);
16926 if (option
->info
& OEX_PAGE0
)
16927 fputs (" PAGE0", stdout
);
16928 if (option
->info
& OEX_SMM
)
16929 fputs (" SMM", stdout
);
16930 if (option
->info
& OEX_FPDBUG
)
16931 fputs (" FPDBUG", stdout
);
16932 if (option
->info
& OEX_DISMISS
)
16933 fputs (" DISMISS", stdout
);
16937 fputs (" PAD ", stdout
);
16938 if (option
->info
& OPAD_PREFIX
)
16939 fputs (" PREFIX", stdout
);
16940 if (option
->info
& OPAD_POSTFIX
)
16941 fputs (" POSTFIX", stdout
);
16942 if (option
->info
& OPAD_SYMBOL
)
16943 fputs (" SYMBOL", stdout
);
16947 fputs (" HWPATCH ", stdout
);
16948 if (option
->info
& OHW_R4KEOP
)
16949 fputs (" R4KEOP", stdout
);
16950 if (option
->info
& OHW_R8KPFETCH
)
16951 fputs (" R8KPFETCH", stdout
);
16952 if (option
->info
& OHW_R5KEOP
)
16953 fputs (" R5KEOP", stdout
);
16954 if (option
->info
& OHW_R5KCVTL
)
16955 fputs (" R5KCVTL", stdout
);
16959 fputs (" FILL ", stdout
);
16960 /* XXX Print content of info word? */
16964 fputs (" TAGS ", stdout
);
16965 /* XXX Print content of info word? */
16969 fputs (" HWAND ", stdout
);
16970 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16971 fputs (" R4KEOP_CHECKED", stdout
);
16972 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16973 fputs (" R4KEOP_CLEAN", stdout
);
16977 fputs (" HWOR ", stdout
);
16978 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16979 fputs (" R4KEOP_CHECKED", stdout
);
16980 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16981 fputs (" R4KEOP_CLEAN", stdout
);
16985 printf (" GP_GROUP %#06lx self-contained %#06lx",
16986 option
->info
& OGP_GROUP
,
16987 (option
->info
& OGP_SELF
) >> 16);
16991 printf (" IDENT %#06lx self-contained %#06lx",
16992 option
->info
& OGP_GROUP
,
16993 (option
->info
& OGP_SELF
) >> 16);
16997 /* This shouldn't happen. */
16998 printf (" %3d ??? %d %lx",
16999 option
->kind
, option
->section
, option
->info
);
17003 len
= sizeof (* eopt
);
17004 while (len
< option
->size
)
17006 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17008 if (ISPRINT (datum
))
17009 printf ("%c", datum
);
17011 printf ("\\%03o", datum
);
17014 fputs ("\n", stdout
);
17016 offset
+= option
->size
;
17026 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17028 Elf32_Conflict
* iconf
;
17031 if (dynamic_symbols
== NULL
)
17033 error (_("conflict list found without a dynamic symbol table\n"));
17037 /* PR 21345 - print a slightly more helpful error message
17038 if we are sure that the cmalloc will fail. */
17039 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
17041 error (_("Overlarge number of conflicts detected: %lx\n"),
17042 (long) conflictsno
);
17046 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17049 error (_("Out of memory allocating space for dynamic conflicts\n"));
17055 Elf32_External_Conflict
* econf32
;
17057 econf32
= (Elf32_External_Conflict
*)
17058 get_data (NULL
, filedata
, conflicts_offset
,
17059 sizeof (*econf32
), conflictsno
, _("conflict"));
17063 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17064 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17070 Elf64_External_Conflict
* econf64
;
17072 econf64
= (Elf64_External_Conflict
*)
17073 get_data (NULL
, filedata
, conflicts_offset
,
17074 sizeof (*econf64
), conflictsno
, _("conflict"));
17078 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17079 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17084 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17085 "\nSection '.conflict' contains %lu entries:\n",
17086 (unsigned long) conflictsno
),
17087 (unsigned long) conflictsno
);
17088 puts (_(" Num: Index Value Name"));
17090 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17092 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17094 if (iconf
[cnt
] >= num_dynamic_syms
)
17095 printf (_("<corrupt symbol index>"));
17098 Elf_Internal_Sym
* psym
;
17100 psym
= & dynamic_symbols
[iconf
[cnt
]];
17101 print_vma (psym
->st_value
, FULL_HEX
);
17103 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17104 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
17106 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17114 if (pltgot
!= 0 && local_gotno
!= 0)
17116 bfd_vma ent
, local_end
, global_end
;
17118 unsigned char * data
;
17119 unsigned char * data_end
;
17123 addr_size
= (is_32bit_elf
? 4 : 8);
17124 local_end
= pltgot
+ local_gotno
* addr_size
;
17126 /* PR binutils/17533 file: 012-111227-0.004 */
17127 if (symtabno
< gotsym
)
17129 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17130 (unsigned long) gotsym
, (unsigned long) symtabno
);
17134 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17135 /* PR 17531: file: 54c91a34. */
17136 if (global_end
< local_end
)
17138 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17142 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17143 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17144 global_end
- pltgot
, 1,
17145 _("Global Offset Table data"));
17146 /* PR 12855: Null data is handled gracefully throughout. */
17147 data_end
= data
+ (global_end
- pltgot
);
17149 printf (_("\nPrimary GOT:\n"));
17150 printf (_(" Canonical gp value: "));
17151 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17154 printf (_(" Reserved entries:\n"));
17155 printf (_(" %*s %10s %*s Purpose\n"),
17156 addr_size
* 2, _("Address"), _("Access"),
17157 addr_size
* 2, _("Initial"));
17158 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17159 printf (_(" Lazy resolver\n"));
17160 if (ent
== (bfd_vma
) -1)
17161 goto got_print_fail
;
17163 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17164 This entry will be used by some runtime loaders, to store the
17165 module pointer. Otherwise this is an ordinary local entry.
17166 PR 21344: Check for the entry being fully available before
17169 && data
+ ent
- pltgot
+ addr_size
<= data_end
17170 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17171 >> (addr_size
* 8 - 1)) != 0)
17173 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17174 printf (_(" Module pointer (GNU extension)\n"));
17175 if (ent
== (bfd_vma
) -1)
17176 goto got_print_fail
;
17180 if (data
!= NULL
&& ent
< local_end
)
17182 printf (_(" Local entries:\n"));
17183 printf (" %*s %10s %*s\n",
17184 addr_size
* 2, _("Address"), _("Access"),
17185 addr_size
* 2, _("Initial"));
17186 while (ent
< local_end
)
17188 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17190 if (ent
== (bfd_vma
) -1)
17191 goto got_print_fail
;
17196 if (data
!= NULL
&& gotsym
< symtabno
)
17200 printf (_(" Global entries:\n"));
17201 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17202 addr_size
* 2, _("Address"),
17204 addr_size
* 2, _("Initial"),
17205 addr_size
* 2, _("Sym.Val."),
17207 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17208 _("Ndx"), _("Name"));
17210 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17212 for (i
= gotsym
; i
< symtabno
; i
++)
17214 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17217 if (dynamic_symbols
== NULL
)
17218 printf (_("<no dynamic symbols>"));
17219 else if (i
< num_dynamic_syms
)
17221 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17223 print_vma (psym
->st_value
, LONG_HEX
);
17224 printf (" %-7s %3s ",
17225 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17226 get_symbol_index_type (filedata
, psym
->st_shndx
));
17228 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17229 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17231 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17234 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17235 (unsigned long) i
);
17238 if (ent
== (bfd_vma
) -1)
17249 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17252 size_t offset
, rel_offset
;
17253 unsigned long count
, i
;
17254 unsigned char * data
;
17255 int addr_size
, sym_width
;
17256 Elf_Internal_Rela
* rels
;
17258 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17259 if (pltrel
== DT_RELA
)
17261 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17266 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17271 addr_size
= (is_32bit_elf
? 4 : 8);
17272 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17274 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17275 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17276 1, _("Procedure Linkage Table data"));
17280 printf ("\nPLT GOT:\n\n");
17281 printf (_(" Reserved entries:\n"));
17282 printf (_(" %*s %*s Purpose\n"),
17283 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17284 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17285 printf (_(" PLT lazy resolver\n"));
17286 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17287 printf (_(" Module pointer\n"));
17290 printf (_(" Entries:\n"));
17291 printf (" %*s %*s %*s %-7s %3s %s\n",
17292 addr_size
* 2, _("Address"),
17293 addr_size
* 2, _("Initial"),
17294 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17295 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17296 for (i
= 0; i
< count
; i
++)
17298 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17300 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17303 if (idx
>= num_dynamic_syms
)
17304 printf (_("<corrupt symbol index: %lu>"), idx
);
17307 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17309 print_vma (psym
->st_value
, LONG_HEX
);
17310 printf (" %-7s %3s ",
17311 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17312 get_symbol_index_type (filedata
, psym
->st_shndx
));
17313 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17314 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17316 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17331 process_nds32_specific (Filedata
* filedata
)
17333 Elf_Internal_Shdr
*sect
= NULL
;
17335 sect
= find_section (filedata
, ".nds32_e_flags");
17338 unsigned int *flag
;
17340 printf ("\nNDS32 elf flags section:\n");
17341 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17342 sect
->sh_size
, _("NDS32 elf flags section"));
17347 switch ((*flag
) & 0x3)
17350 printf ("(VEC_SIZE):\tNo entry.\n");
17353 printf ("(VEC_SIZE):\t4 bytes\n");
17356 printf ("(VEC_SIZE):\t16 bytes\n");
17359 printf ("(VEC_SIZE):\treserved\n");
17368 process_gnu_liblist (Filedata
* filedata
)
17370 Elf_Internal_Shdr
* section
;
17371 Elf_Internal_Shdr
* string_sec
;
17372 Elf32_External_Lib
* elib
;
17374 size_t strtab_size
;
17376 unsigned long num_liblist
;
17378 bfd_boolean res
= TRUE
;
17383 for (i
= 0, section
= filedata
->section_headers
;
17384 i
< filedata
->file_header
.e_shnum
;
17387 switch (section
->sh_type
)
17389 case SHT_GNU_LIBLIST
:
17390 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17393 elib
= (Elf32_External_Lib
*)
17394 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17395 _("liblist section data"));
17403 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17404 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17405 string_sec
->sh_size
,
17406 _("liblist string table"));
17408 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17415 strtab_size
= string_sec
->sh_size
;
17417 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17418 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17419 "\nLibrary list section '%s' contains %lu entries:\n",
17421 printable_section_name (filedata
, section
),
17424 puts (_(" Library Time Stamp Checksum Version Flags"));
17426 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17434 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17435 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17436 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17437 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17438 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17440 tmp
= gmtime (&atime
);
17441 snprintf (timebuf
, sizeof (timebuf
),
17442 "%04u-%02u-%02uT%02u:%02u:%02u",
17443 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17444 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17446 printf ("%3lu: ", (unsigned long) cnt
);
17448 printf ("%-20s", liblist
.l_name
< strtab_size
17449 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17451 printf ("%-20.20s", liblist
.l_name
< strtab_size
17452 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17453 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17454 liblist
.l_version
, liblist
.l_flags
);
17465 static const char *
17466 get_note_type (Filedata
* filedata
, unsigned e_type
)
17468 static char buff
[64];
17470 if (filedata
->file_header
.e_type
== ET_CORE
)
17474 return _("NT_AUXV (auxiliary vector)");
17476 return _("NT_PRSTATUS (prstatus structure)");
17478 return _("NT_FPREGSET (floating point registers)");
17480 return _("NT_PRPSINFO (prpsinfo structure)");
17481 case NT_TASKSTRUCT
:
17482 return _("NT_TASKSTRUCT (task structure)");
17484 return _("NT_PRXFPREG (user_xfpregs structure)");
17486 return _("NT_PPC_VMX (ppc Altivec registers)");
17488 return _("NT_PPC_VSX (ppc VSX registers)");
17490 return _("NT_PPC_TAR (ppc TAR register)");
17492 return _("NT_PPC_PPR (ppc PPR register)");
17494 return _("NT_PPC_DSCR (ppc DSCR register)");
17496 return _("NT_PPC_EBB (ppc EBB registers)");
17498 return _("NT_PPC_PMU (ppc PMU registers)");
17499 case NT_PPC_TM_CGPR
:
17500 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17501 case NT_PPC_TM_CFPR
:
17502 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17503 case NT_PPC_TM_CVMX
:
17504 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17505 case NT_PPC_TM_CVSX
:
17506 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17507 case NT_PPC_TM_SPR
:
17508 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17509 case NT_PPC_TM_CTAR
:
17510 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17511 case NT_PPC_TM_CPPR
:
17512 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17513 case NT_PPC_TM_CDSCR
:
17514 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17516 return _("NT_386_TLS (x86 TLS information)");
17517 case NT_386_IOPERM
:
17518 return _("NT_386_IOPERM (x86 I/O permissions)");
17519 case NT_X86_XSTATE
:
17520 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17521 case NT_S390_HIGH_GPRS
:
17522 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17523 case NT_S390_TIMER
:
17524 return _("NT_S390_TIMER (s390 timer register)");
17525 case NT_S390_TODCMP
:
17526 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17527 case NT_S390_TODPREG
:
17528 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17530 return _("NT_S390_CTRS (s390 control registers)");
17531 case NT_S390_PREFIX
:
17532 return _("NT_S390_PREFIX (s390 prefix register)");
17533 case NT_S390_LAST_BREAK
:
17534 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17535 case NT_S390_SYSTEM_CALL
:
17536 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17538 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17539 case NT_S390_VXRS_LOW
:
17540 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17541 case NT_S390_VXRS_HIGH
:
17542 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17543 case NT_S390_GS_CB
:
17544 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17545 case NT_S390_GS_BC
:
17546 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17548 return _("NT_ARM_VFP (arm VFP registers)");
17550 return _("NT_ARM_TLS (AArch TLS registers)");
17551 case NT_ARM_HW_BREAK
:
17552 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17553 case NT_ARM_HW_WATCH
:
17554 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17556 return _("NT_PSTATUS (pstatus structure)");
17558 return _("NT_FPREGS (floating point registers)");
17560 return _("NT_PSINFO (psinfo structure)");
17562 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17564 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17565 case NT_WIN32PSTATUS
:
17566 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17568 return _("NT_SIGINFO (siginfo_t data)");
17570 return _("NT_FILE (mapped files)");
17578 return _("NT_VERSION (version)");
17580 return _("NT_ARCH (architecture)");
17581 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17583 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17589 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17594 print_core_note (Elf_Internal_Note
*pnote
)
17596 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17597 bfd_vma count
, page_size
;
17598 unsigned char *descdata
, *filenames
, *descend
;
17600 if (pnote
->type
!= NT_FILE
)
17610 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17611 /* Still "successful". */
17616 if (pnote
->descsz
< 2 * addr_size
)
17618 error (_(" Malformed note - too short for header\n"));
17622 descdata
= (unsigned char *) pnote
->descdata
;
17623 descend
= descdata
+ pnote
->descsz
;
17625 if (descdata
[pnote
->descsz
- 1] != '\0')
17627 error (_(" Malformed note - does not end with \\0\n"));
17631 count
= byte_get (descdata
, addr_size
);
17632 descdata
+= addr_size
;
17634 page_size
= byte_get (descdata
, addr_size
);
17635 descdata
+= addr_size
;
17637 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17638 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17640 error (_(" Malformed note - too short for supplied file count\n"));
17644 printf (_(" Page size: "));
17645 print_vma (page_size
, DEC
);
17648 printf (_(" %*s%*s%*s\n"),
17649 (int) (2 + 2 * addr_size
), _("Start"),
17650 (int) (4 + 2 * addr_size
), _("End"),
17651 (int) (4 + 2 * addr_size
), _("Page Offset"));
17652 filenames
= descdata
+ count
* 3 * addr_size
;
17653 while (count
-- > 0)
17655 bfd_vma start
, end
, file_ofs
;
17657 if (filenames
== descend
)
17659 error (_(" Malformed note - filenames end too early\n"));
17663 start
= byte_get (descdata
, addr_size
);
17664 descdata
+= addr_size
;
17665 end
= byte_get (descdata
, addr_size
);
17666 descdata
+= addr_size
;
17667 file_ofs
= byte_get (descdata
, addr_size
);
17668 descdata
+= addr_size
;
17671 print_vma (start
, FULL_HEX
);
17673 print_vma (end
, FULL_HEX
);
17675 print_vma (file_ofs
, FULL_HEX
);
17676 printf ("\n %s\n", filenames
);
17678 filenames
+= 1 + strlen ((char *) filenames
);
17684 static const char *
17685 get_gnu_elf_note_type (unsigned e_type
)
17687 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17690 case NT_GNU_ABI_TAG
:
17691 return _("NT_GNU_ABI_TAG (ABI version tag)");
17693 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17694 case NT_GNU_BUILD_ID
:
17695 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17696 case NT_GNU_GOLD_VERSION
:
17697 return _("NT_GNU_GOLD_VERSION (gold version)");
17698 case NT_GNU_PROPERTY_TYPE_0
:
17699 return _("NT_GNU_PROPERTY_TYPE_0");
17700 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17701 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17702 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17703 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17706 static char buff
[64];
17708 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17715 decode_x86_compat_isa (unsigned int bitmask
)
17719 unsigned int bit
= bitmask
& (- bitmask
);
17724 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17727 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17730 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17733 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17736 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17739 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17742 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17745 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17748 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17751 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17754 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17757 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17758 printf ("AVX512F");
17760 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17761 printf ("AVX512CD");
17763 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17764 printf ("AVX512ER");
17766 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17767 printf ("AVX512PF");
17769 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17770 printf ("AVX512VL");
17772 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17773 printf ("AVX512DQ");
17775 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17776 printf ("AVX512BW");
17779 printf (_("<unknown: %x>"), bit
);
17788 decode_x86_isa (unsigned int bitmask
)
17792 printf (_("<None>"));
17798 unsigned int bit
= bitmask
& (- bitmask
);
17803 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17806 case GNU_PROPERTY_X86_ISA_1_SSE
:
17809 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17812 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17815 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17818 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17821 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17824 case GNU_PROPERTY_X86_ISA_1_AVX
:
17827 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17830 case GNU_PROPERTY_X86_ISA_1_FMA
:
17833 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17834 printf ("AVX512F");
17836 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17837 printf ("AVX512CD");
17839 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17840 printf ("AVX512ER");
17842 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17843 printf ("AVX512PF");
17845 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17846 printf ("AVX512VL");
17848 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17849 printf ("AVX512DQ");
17851 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17852 printf ("AVX512BW");
17854 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17855 printf ("AVX512_4FMAPS");
17857 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17858 printf ("AVX512_4VNNIW");
17860 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17861 printf ("AVX512_BITALG");
17863 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17864 printf ("AVX512_IFMA");
17866 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17867 printf ("AVX512_VBMI");
17869 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17870 printf ("AVX512_VBMI2");
17872 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17873 printf ("AVX512_VNNI");
17875 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17876 printf ("AVX512_BF16");
17879 printf (_("<unknown: %x>"), bit
);
17888 decode_x86_feature_1 (unsigned int bitmask
)
17892 printf (_("<None>"));
17898 unsigned int bit
= bitmask
& (- bitmask
);
17903 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17906 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17910 printf (_("<unknown: %x>"), bit
);
17919 decode_x86_feature_2 (unsigned int bitmask
)
17923 printf (_("<None>"));
17929 unsigned int bit
= bitmask
& (- bitmask
);
17934 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17937 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17940 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17943 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17946 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17949 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17952 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17955 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17958 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17959 printf ("XSAVEOPT");
17961 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17965 printf (_("<unknown: %x>"), bit
);
17974 decode_aarch64_feature_1_and (unsigned int bitmask
)
17978 unsigned int bit
= bitmask
& (- bitmask
);
17983 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17987 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17992 printf (_("<unknown: %x>"), bit
);
18001 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18003 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18004 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18005 unsigned int size
= is_32bit_elf
? 4 : 8;
18007 printf (_(" Properties: "));
18009 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18011 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18015 while (ptr
< ptr_end
)
18019 unsigned int datasz
;
18021 if ((size_t) (ptr_end
- ptr
) < 8)
18023 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18027 type
= byte_get (ptr
, 4);
18028 datasz
= byte_get (ptr
+ 4, 4);
18032 if (datasz
> (size_t) (ptr_end
- ptr
))
18034 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18039 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18041 if (filedata
->file_header
.e_machine
== EM_X86_64
18042 || filedata
->file_header
.e_machine
== EM_IAMCU
18043 || filedata
->file_header
.e_machine
== EM_386
)
18045 unsigned int bitmask
;
18048 bitmask
= byte_get (ptr
, 4);
18054 case GNU_PROPERTY_X86_ISA_1_USED
:
18056 printf (_("x86 ISA used: <corrupt length: %#x> "),
18060 printf ("x86 ISA used: ");
18061 decode_x86_isa (bitmask
);
18065 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18067 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18071 printf ("x86 ISA needed: ");
18072 decode_x86_isa (bitmask
);
18076 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18078 printf (_("x86 feature: <corrupt length: %#x> "),
18082 printf ("x86 feature: ");
18083 decode_x86_feature_1 (bitmask
);
18087 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18089 printf (_("x86 feature used: <corrupt length: %#x> "),
18093 printf ("x86 feature used: ");
18094 decode_x86_feature_2 (bitmask
);
18098 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18100 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18103 printf ("x86 feature needed: ");
18104 decode_x86_feature_2 (bitmask
);
18108 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18110 printf (_("x86 ISA used: <corrupt length: %#x> "),
18114 printf ("x86 ISA used: ");
18115 decode_x86_compat_isa (bitmask
);
18119 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18121 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18125 printf ("x86 ISA needed: ");
18126 decode_x86_compat_isa (bitmask
);
18134 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18136 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18138 printf ("AArch64 feature: ");
18140 printf (_("<corrupt length: %#x> "), datasz
);
18142 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18151 case GNU_PROPERTY_STACK_SIZE
:
18152 printf (_("stack size: "));
18153 if (datasz
!= size
)
18154 printf (_("<corrupt length: %#x> "), datasz
);
18156 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18159 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18160 printf ("no copy on protected ");
18162 printf (_("<corrupt length: %#x> "), datasz
);
18170 if (type
< GNU_PROPERTY_LOPROC
)
18171 printf (_("<unknown type %#x data: "), type
);
18172 else if (type
< GNU_PROPERTY_LOUSER
)
18173 printf (_("<procesor-specific type %#x data: "), type
);
18175 printf (_("<application-specific type %#x data: "), type
);
18176 for (j
= 0; j
< datasz
; ++j
)
18177 printf ("%02x ", ptr
[j
] & 0xff);
18181 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18182 if (ptr
== ptr_end
)
18195 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18197 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18198 switch (pnote
->type
)
18200 case NT_GNU_BUILD_ID
:
18204 printf (_(" Build ID: "));
18205 for (i
= 0; i
< pnote
->descsz
; ++i
)
18206 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18211 case NT_GNU_ABI_TAG
:
18213 unsigned long os
, major
, minor
, subminor
;
18214 const char *osname
;
18216 /* PR 17531: file: 030-599401-0.004. */
18217 if (pnote
->descsz
< 16)
18219 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18223 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18224 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18225 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18226 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18230 case GNU_ABI_TAG_LINUX
:
18233 case GNU_ABI_TAG_HURD
:
18236 case GNU_ABI_TAG_SOLARIS
:
18237 osname
= "Solaris";
18239 case GNU_ABI_TAG_FREEBSD
:
18240 osname
= "FreeBSD";
18242 case GNU_ABI_TAG_NETBSD
:
18245 case GNU_ABI_TAG_SYLLABLE
:
18246 osname
= "Syllable";
18248 case GNU_ABI_TAG_NACL
:
18252 osname
= "Unknown";
18256 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18257 major
, minor
, subminor
);
18261 case NT_GNU_GOLD_VERSION
:
18265 printf (_(" Version: "));
18266 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18267 printf ("%c", pnote
->descdata
[i
]);
18274 unsigned long num_entries
, mask
;
18276 /* Hardware capabilities information. Word 0 is the number of entries.
18277 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18278 is a series of entries, where each entry is a single byte followed
18279 by a nul terminated string. The byte gives the bit number to test
18280 if enabled in the bitmask. */
18281 printf (_(" Hardware Capabilities: "));
18282 if (pnote
->descsz
< 8)
18284 error (_("<corrupt GNU_HWCAP>\n"));
18287 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18288 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18289 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18290 /* FIXME: Add code to display the entries... */
18294 case NT_GNU_PROPERTY_TYPE_0
:
18295 print_gnu_property_note (filedata
, pnote
);
18299 /* Handle unrecognised types. An error message should have already been
18300 created by get_gnu_elf_note_type(), so all that we need to do is to
18301 display the data. */
18305 printf (_(" Description data: "));
18306 for (i
= 0; i
< pnote
->descsz
; ++i
)
18307 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18316 static const char *
18317 get_v850_elf_note_type (enum v850_notes n_type
)
18319 static char buff
[64];
18323 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18324 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18325 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18326 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18327 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18328 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18330 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18336 print_v850_note (Elf_Internal_Note
* pnote
)
18340 if (pnote
->descsz
!= 4)
18343 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18347 printf (_("not set\n"));
18351 switch (pnote
->type
)
18353 case V850_NOTE_ALIGNMENT
:
18356 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18357 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18361 case V850_NOTE_DATA_SIZE
:
18364 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18365 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18369 case V850_NOTE_FPU_INFO
:
18372 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18373 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18377 case V850_NOTE_MMU_INFO
:
18378 case V850_NOTE_CACHE_INFO
:
18379 case V850_NOTE_SIMD_INFO
:
18380 if (val
== EF_RH850_SIMD
)
18382 printf (_("yes\n"));
18388 /* An 'unknown note type' message will already have been displayed. */
18392 printf (_("unknown value: %x\n"), val
);
18397 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18399 unsigned int version
;
18401 switch (pnote
->type
)
18403 case NT_NETBSD_IDENT
:
18404 if (pnote
->descsz
< 1)
18406 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18407 if ((version
/ 10000) % 100)
18408 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18409 version
, version
/ 100000000, (version
/ 1000000) % 100,
18410 (version
/ 10000) % 100 > 26 ? "Z" : "",
18411 'A' + (version
/ 10000) % 26);
18413 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18414 version
, version
/ 100000000, (version
/ 1000000) % 100,
18415 (version
/ 100) % 100);
18418 case NT_NETBSD_MARCH
:
18419 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18423 #ifdef NT_NETBSD_PAX
18424 case NT_NETBSD_PAX
:
18425 if (pnote
->descsz
< 1)
18427 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18428 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18429 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18430 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18431 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18432 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18433 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18434 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18439 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18440 pnote
->descsz
, pnote
->type
);
18444 static const char *
18445 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18449 case NT_FREEBSD_THRMISC
:
18450 return _("NT_THRMISC (thrmisc structure)");
18451 case NT_FREEBSD_PROCSTAT_PROC
:
18452 return _("NT_PROCSTAT_PROC (proc data)");
18453 case NT_FREEBSD_PROCSTAT_FILES
:
18454 return _("NT_PROCSTAT_FILES (files data)");
18455 case NT_FREEBSD_PROCSTAT_VMMAP
:
18456 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18457 case NT_FREEBSD_PROCSTAT_GROUPS
:
18458 return _("NT_PROCSTAT_GROUPS (groups data)");
18459 case NT_FREEBSD_PROCSTAT_UMASK
:
18460 return _("NT_PROCSTAT_UMASK (umask data)");
18461 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18462 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18463 case NT_FREEBSD_PROCSTAT_OSREL
:
18464 return _("NT_PROCSTAT_OSREL (osreldate data)");
18465 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18466 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18467 case NT_FREEBSD_PROCSTAT_AUXV
:
18468 return _("NT_PROCSTAT_AUXV (auxv data)");
18469 case NT_FREEBSD_PTLWPINFO
:
18470 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18472 return get_note_type (filedata
, e_type
);
18475 static const char *
18476 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18478 static char buff
[64];
18482 case NT_NETBSDCORE_PROCINFO
:
18483 /* NetBSD core "procinfo" structure. */
18484 return _("NetBSD procinfo structure");
18486 #ifdef NT_NETBSDCORE_AUXV
18487 case NT_NETBSDCORE_AUXV
:
18488 return _("NetBSD ELF auxiliary vector data");
18491 #ifdef NT_NETBSDCORE_LWPSTATUS
18492 case NT_NETBSDCORE_LWPSTATUS
:
18493 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18497 /* As of Jan 2020 there are no other machine-independent notes
18498 defined for NetBSD core files. If the note type is less
18499 than the start of the machine-dependent note types, we don't
18502 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18504 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18510 switch (filedata
->file_header
.e_machine
)
18512 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18513 and PT_GETFPREGS == mach+2. */
18518 case EM_SPARC32PLUS
:
18522 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18523 return _("PT_GETREGS (reg structure)");
18524 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18525 return _("PT_GETFPREGS (fpreg structure)");
18531 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18532 There's also old PT___GETREGS40 == mach + 1 for old reg
18533 structure which lacks GBR. */
18537 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18538 return _("PT___GETREGS40 (old reg structure)");
18539 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18540 return _("PT_GETREGS (reg structure)");
18541 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18542 return _("PT_GETFPREGS (fpreg structure)");
18548 /* On all other arch's, PT_GETREGS == mach+1 and
18549 PT_GETFPREGS == mach+3. */
18553 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18554 return _("PT_GETREGS (reg structure)");
18555 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18556 return _("PT_GETFPREGS (fpreg structure)");
18562 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18563 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18567 static const char *
18568 get_stapsdt_note_type (unsigned e_type
)
18570 static char buff
[64];
18575 return _("NT_STAPSDT (SystemTap probe descriptors)");
18581 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18586 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18588 size_t len
, maxlen
;
18589 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18590 char *data
= pnote
->descdata
;
18591 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18592 bfd_vma pc
, base_addr
, semaphore
;
18593 char *provider
, *probe
, *arg_fmt
;
18595 if (pnote
->descsz
< (addr_size
* 3))
18596 goto stapdt_note_too_small
;
18598 pc
= byte_get ((unsigned char *) data
, addr_size
);
18601 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18604 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18607 if (data
>= data_end
)
18608 goto stapdt_note_too_small
;
18609 maxlen
= data_end
- data
;
18610 len
= strnlen (data
, maxlen
);
18617 goto stapdt_note_too_small
;
18619 if (data
>= data_end
)
18620 goto stapdt_note_too_small
;
18621 maxlen
= data_end
- data
;
18622 len
= strnlen (data
, maxlen
);
18629 goto stapdt_note_too_small
;
18631 if (data
>= data_end
)
18632 goto stapdt_note_too_small
;
18633 maxlen
= data_end
- data
;
18634 len
= strnlen (data
, maxlen
);
18641 goto stapdt_note_too_small
;
18643 printf (_(" Provider: %s\n"), provider
);
18644 printf (_(" Name: %s\n"), probe
);
18645 printf (_(" Location: "));
18646 print_vma (pc
, FULL_HEX
);
18647 printf (_(", Base: "));
18648 print_vma (base_addr
, FULL_HEX
);
18649 printf (_(", Semaphore: "));
18650 print_vma (semaphore
, FULL_HEX
);
18652 printf (_(" Arguments: %s\n"), arg_fmt
);
18654 return data
== data_end
;
18656 stapdt_note_too_small
:
18657 printf (_(" <corrupt - note is too small>\n"));
18658 error (_("corrupt stapdt note - the data size is too small\n"));
18662 static const char *
18663 get_ia64_vms_note_type (unsigned e_type
)
18665 static char buff
[64];
18670 return _("NT_VMS_MHD (module header)");
18672 return _("NT_VMS_LNM (language name)");
18674 return _("NT_VMS_SRC (source files)");
18676 return "NT_VMS_TITLE";
18678 return _("NT_VMS_EIDC (consistency check)");
18679 case NT_VMS_FPMODE
:
18680 return _("NT_VMS_FPMODE (FP mode)");
18681 case NT_VMS_LINKTIME
:
18682 return "NT_VMS_LINKTIME";
18683 case NT_VMS_IMGNAM
:
18684 return _("NT_VMS_IMGNAM (image name)");
18686 return _("NT_VMS_IMGID (image id)");
18687 case NT_VMS_LINKID
:
18688 return _("NT_VMS_LINKID (link id)");
18689 case NT_VMS_IMGBID
:
18690 return _("NT_VMS_IMGBID (build id)");
18691 case NT_VMS_GSTNAM
:
18692 return _("NT_VMS_GSTNAM (sym table name)");
18693 case NT_VMS_ORIG_DYN
:
18694 return "NT_VMS_ORIG_DYN";
18695 case NT_VMS_PATCHTIME
:
18696 return "NT_VMS_PATCHTIME";
18698 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18704 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18706 int maxlen
= pnote
->descsz
;
18708 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18709 goto desc_size_fail
;
18711 switch (pnote
->type
)
18715 goto desc_size_fail
;
18717 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18719 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18720 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18721 if (l
+ 34 < maxlen
)
18723 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18724 if (l
+ 35 < maxlen
)
18725 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18727 printf (_(" Module version : <missing>\n"));
18731 printf (_(" Module name : <missing>\n"));
18732 printf (_(" Module version : <missing>\n"));
18737 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18741 case NT_VMS_FPMODE
:
18742 printf (_(" Floating Point mode: "));
18744 goto desc_size_fail
;
18745 /* FIXME: Generate an error if descsz > 8 ? */
18747 printf ("0x%016" BFD_VMA_FMT
"x\n",
18748 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18751 case NT_VMS_LINKTIME
:
18752 printf (_(" Link time: "));
18754 goto desc_size_fail
;
18755 /* FIXME: Generate an error if descsz > 8 ? */
18758 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18762 case NT_VMS_PATCHTIME
:
18763 printf (_(" Patch time: "));
18765 goto desc_size_fail
;
18766 /* FIXME: Generate an error if descsz > 8 ? */
18769 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18773 case NT_VMS_ORIG_DYN
:
18775 goto desc_size_fail
;
18777 printf (_(" Major id: %u, minor id: %u\n"),
18778 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18779 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18780 printf (_(" Last modified : "));
18782 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18783 printf (_("\n Link flags : "));
18784 printf ("0x%016" BFD_VMA_FMT
"x\n",
18785 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18786 printf (_(" Header flags: 0x%08x\n"),
18787 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18788 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18792 case NT_VMS_IMGNAM
:
18793 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18796 case NT_VMS_GSTNAM
:
18797 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18801 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18804 case NT_VMS_LINKID
:
18805 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18815 printf (_(" <corrupt - data size is too small>\n"));
18816 error (_("corrupt IA64 note: data size is too small\n"));
18820 struct build_attr_cache
{
18821 Filedata
*filedata
;
18823 unsigned long strtablen
;
18824 Elf_Internal_Sym
*symtab
;
18825 unsigned long nsyms
;
18828 /* Find the symbol associated with a build attribute that is attached
18829 to address OFFSET. If PNAME is non-NULL then store the name of
18830 the symbol (if found) in the provided pointer, Returns NULL if a
18831 symbol could not be found. */
18833 static Elf_Internal_Sym
*
18834 get_symbol_for_build_attribute (Filedata
* filedata
,
18835 unsigned long offset
,
18836 bfd_boolean is_open_attr
,
18837 const char ** pname
)
18839 Elf_Internal_Sym
*saved_sym
= NULL
;
18840 Elf_Internal_Sym
*sym
;
18842 if (filedata
->section_headers
!= NULL
18843 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18845 Elf_Internal_Shdr
* symsec
;
18847 free (ba_cache
.strtab
);
18848 ba_cache
.strtab
= NULL
;
18849 free (ba_cache
.symtab
);
18850 ba_cache
.symtab
= NULL
;
18852 /* Load the symbol and string sections. */
18853 for (symsec
= filedata
->section_headers
;
18854 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18857 if (symsec
->sh_type
== SHT_SYMTAB
18858 && get_symtab (filedata
, symsec
,
18859 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18860 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18863 ba_cache
.filedata
= filedata
;
18866 if (ba_cache
.symtab
== NULL
)
18869 /* Find a symbol whose value matches offset. */
18870 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18871 if (sym
->st_value
== offset
)
18873 if (sym
->st_name
>= ba_cache
.strtablen
)
18874 /* Huh ? This should not happen. */
18877 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18880 /* The AArch64 and ARM architectures define mapping symbols
18881 (eg $d, $x, $t) which we want to ignore. */
18882 if (ba_cache
.strtab
[sym
->st_name
] == '$'
18883 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
18884 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
18889 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18890 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18891 FUNC symbols entirely. */
18892 switch (ELF_ST_TYPE (sym
->st_info
))
18899 /* If the symbol has a size associated
18900 with it then we can stop searching. */
18901 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
18906 /* Ignore function symbols. */
18913 switch (ELF_ST_BIND (sym
->st_info
))
18916 if (saved_sym
== NULL
18917 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18922 if (saved_sym
== NULL
)
18932 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18940 if (saved_sym
&& pname
)
18941 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
18946 /* Returns true iff addr1 and addr2 are in the same section. */
18949 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18951 Elf_Internal_Shdr
* a1
;
18952 Elf_Internal_Shdr
* a2
;
18954 a1
= find_section_by_address (filedata
, addr1
);
18955 a2
= find_section_by_address (filedata
, addr2
);
18957 return a1
== a2
&& a1
!= NULL
;
18961 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18962 Filedata
* filedata
)
18964 static unsigned long global_offset
= 0;
18965 static unsigned long global_end
= 0;
18966 static unsigned long func_offset
= 0;
18967 static unsigned long func_end
= 0;
18969 Elf_Internal_Sym
* sym
;
18971 unsigned long start
;
18973 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18975 switch (pnote
->descsz
)
18978 /* A zero-length description means that the range of
18979 the previous note of the same type should be used. */
18982 if (global_end
> global_offset
)
18983 printf (_(" Applies to region from %#lx to %#lx\n"),
18984 global_offset
, global_end
);
18986 printf (_(" Applies to region from %#lx\n"), global_offset
);
18990 if (func_end
> func_offset
)
18991 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18993 printf (_(" Applies to region from %#lx\n"), func_offset
);
18998 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19005 /* FIXME: We should check that version 3+ notes are being used here... */
19006 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19007 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19011 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19017 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19018 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19022 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19023 printf (_(" <invalid descsz>"));
19028 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19029 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19030 in order to avoid them being confused with the start address of the
19031 first function in the file... */
19032 if (sym
== NULL
&& is_open_attr
)
19033 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19036 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19037 end
= start
+ sym
->st_size
;
19041 /* FIXME: Need to properly allow for section alignment.
19042 16 is just the alignment used on x86_64. */
19044 && start
> BFD_ALIGN (global_end
, 16)
19045 /* Build notes are not guaranteed to be organised in order of
19046 increasing address, but we should find the all of the notes
19047 for one section in the same place. */
19048 && same_section (filedata
, start
, global_end
))
19049 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19050 global_end
+ 1, start
- 1);
19052 printf (_(" Applies to region from %#lx"), start
);
19053 global_offset
= start
;
19057 printf (_(" to %#lx"), end
);
19063 printf (_(" Applies to region from %#lx"), start
);
19064 func_offset
= start
;
19068 printf (_(" to %#lx"), end
);
19074 printf (_(" (%s)"), name
);
19081 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19083 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19084 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19085 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19087 char name_attribute
;
19088 const char * expected_types
;
19089 const char * name
= pnote
->namedata
;
19093 if (name
== NULL
|| pnote
->namesz
< 2)
19095 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19096 print_symbol (-20, _(" <corrupt name>"));
19105 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19106 if (name
[0] == 'G' && name
[1] == 'A')
19108 if (pnote
->namesz
< 4)
19110 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19111 print_symbol (-20, _(" <corrupt name>"));
19120 switch ((name_type
= * name
))
19122 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19123 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19124 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19125 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19126 printf ("%c", * name
);
19130 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19131 print_symbol (-20, _("<unknown name type>"));
19138 switch ((name_attribute
= * name
))
19140 case GNU_BUILD_ATTRIBUTE_VERSION
:
19141 text
= _("<version>");
19142 expected_types
= string_expected
;
19145 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19146 text
= _("<stack prot>");
19147 expected_types
= "!+*";
19150 case GNU_BUILD_ATTRIBUTE_RELRO
:
19151 text
= _("<relro>");
19152 expected_types
= bool_expected
;
19155 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19156 text
= _("<stack size>");
19157 expected_types
= number_expected
;
19160 case GNU_BUILD_ATTRIBUTE_TOOL
:
19161 text
= _("<tool>");
19162 expected_types
= string_expected
;
19165 case GNU_BUILD_ATTRIBUTE_ABI
:
19167 expected_types
= "$*";
19170 case GNU_BUILD_ATTRIBUTE_PIC
:
19172 expected_types
= number_expected
;
19175 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19176 text
= _("<short enum>");
19177 expected_types
= bool_expected
;
19181 if (ISPRINT (* name
))
19183 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19185 if (len
> left
&& ! do_wide
)
19187 printf ("%.*s:", len
, name
);
19193 static char tmpbuf
[128];
19195 error (_("unrecognised byte in name field: %d\n"), * name
);
19196 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19200 expected_types
= "*$!+";
19205 left
-= printf ("%s", text
);
19207 if (strchr (expected_types
, name_type
) == NULL
)
19208 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19210 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19212 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19213 (unsigned long) pnote
->namesz
,
19214 (long) (name
- pnote
->namedata
));
19218 if (left
< 1 && ! do_wide
)
19223 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19225 unsigned int bytes
;
19226 unsigned long long val
= 0;
19227 unsigned int shift
= 0;
19228 char * decoded
= NULL
;
19230 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19232 /* The -1 is because the name field is always 0 terminated, and we
19233 want to be able to ensure that the shift in the while loop below
19234 will not overflow. */
19237 if (bytes
> sizeof (val
))
19239 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19241 bytes
= sizeof (val
);
19243 /* We do not bother to warn if bytes == 0 as this can
19244 happen with some early versions of the gcc plugin. */
19248 unsigned long byte
= (* name
++) & 0xff;
19250 val
|= byte
<< shift
;
19254 switch (name_attribute
)
19256 case GNU_BUILD_ATTRIBUTE_PIC
:
19259 case 0: decoded
= "static"; break;
19260 case 1: decoded
= "pic"; break;
19261 case 2: decoded
= "PIC"; break;
19262 case 3: decoded
= "pie"; break;
19263 case 4: decoded
= "PIE"; break;
19267 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19270 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19271 case 0: decoded
= "off"; break;
19272 case 1: decoded
= "on"; break;
19273 case 2: decoded
= "all"; break;
19274 case 3: decoded
= "strong"; break;
19275 case 4: decoded
= "explicit"; break;
19283 if (decoded
!= NULL
)
19285 print_symbol (-left
, decoded
);
19296 left
-= printf ("0x%llx", val
);
19298 left
-= printf ("0x%-.*llx", left
, val
);
19302 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19303 left
-= print_symbol (- left
, name
);
19305 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19306 left
-= print_symbol (- left
, "true");
19308 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19309 left
-= print_symbol (- left
, "false");
19313 if (do_wide
&& left
> 0)
19314 printf ("%-*s", left
, " ");
19319 /* Note that by the ELF standard, the name field is already null byte
19320 terminated, and namesz includes the terminating null byte.
19321 I.E. the value of namesz for the name "FSF" is 4.
19323 If the value of namesz is zero, there is no name present. */
19326 process_note (Elf_Internal_Note
* pnote
,
19327 Filedata
* filedata
)
19329 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19332 if (pnote
->namesz
== 0)
19333 /* If there is no note name, then use the default set of
19334 note type strings. */
19335 nt
= get_note_type (filedata
, pnote
->type
);
19337 else if (const_strneq (pnote
->namedata
, "GNU"))
19338 /* GNU-specific object file notes. */
19339 nt
= get_gnu_elf_note_type (pnote
->type
);
19341 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19342 /* FreeBSD-specific core file notes. */
19343 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19345 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19346 /* NetBSD-specific core file notes. */
19347 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19349 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19350 /* NetBSD-specific core file notes. */
19351 return process_netbsd_elf_note (pnote
);
19353 else if (const_strneq (pnote
->namedata
, "PaX"))
19354 /* NetBSD-specific core file notes. */
19355 return process_netbsd_elf_note (pnote
);
19357 else if (strneq (pnote
->namedata
, "SPU/", 4))
19359 /* SPU-specific core file notes. */
19360 nt
= pnote
->namedata
+ 4;
19364 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19365 /* VMS/ia64-specific file notes. */
19366 nt
= get_ia64_vms_note_type (pnote
->type
);
19368 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19369 nt
= get_stapsdt_note_type (pnote
->type
);
19372 /* Don't recognize this note name; just use the default set of
19373 note type strings. */
19374 nt
= get_note_type (filedata
, pnote
->type
);
19378 if (((const_strneq (pnote
->namedata
, "GA")
19379 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19380 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19381 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19382 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19383 print_gnu_build_attribute_name (pnote
);
19385 print_symbol (-20, name
);
19388 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19390 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19392 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19393 return print_ia64_vms_note (pnote
);
19394 else if (const_strneq (pnote
->namedata
, "GNU"))
19395 return print_gnu_note (filedata
, pnote
);
19396 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19397 return print_stapsdt_note (pnote
);
19398 else if (const_strneq (pnote
->namedata
, "CORE"))
19399 return print_core_note (pnote
);
19400 else if (((const_strneq (pnote
->namedata
, "GA")
19401 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19402 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19403 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19404 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19405 return print_gnu_build_attribute_description (pnote
, filedata
);
19411 printf (_(" description data: "));
19412 for (i
= 0; i
< pnote
->descsz
; i
++)
19413 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19425 process_notes_at (Filedata
* filedata
,
19426 Elf_Internal_Shdr
* section
,
19431 Elf_External_Note
* pnotes
;
19432 Elf_External_Note
* external
;
19434 bfd_boolean res
= TRUE
;
19441 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19444 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19452 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19455 if (pnotes
== NULL
)
19461 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19463 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19464 (unsigned long) offset
, (unsigned long) length
);
19466 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19467 specifies that notes should be aligned to 4 bytes in 32-bit
19468 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19469 we also support 4 byte alignment in 64-bit objects. If section
19470 alignment is less than 4, we treate alignment as 4 bytes. */
19473 else if (align
!= 4 && align
!= 8)
19475 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19481 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19483 end
= (char *) pnotes
+ length
;
19484 while ((char *) external
< end
)
19486 Elf_Internal_Note inote
;
19489 char * temp
= NULL
;
19490 size_t data_remaining
= end
- (char *) external
;
19492 if (!is_ia64_vms (filedata
))
19494 /* PR binutils/15191
19495 Make sure that there is enough data to read. */
19496 min_notesz
= offsetof (Elf_External_Note
, name
);
19497 if (data_remaining
< min_notesz
)
19499 warn (ngettext ("Corrupt note: only %ld byte remains, "
19500 "not enough for a full note\n",
19501 "Corrupt note: only %ld bytes remain, "
19502 "not enough for a full note\n",
19504 (long) data_remaining
);
19507 data_remaining
-= min_notesz
;
19509 inote
.type
= BYTE_GET (external
->type
);
19510 inote
.namesz
= BYTE_GET (external
->namesz
);
19511 inote
.namedata
= external
->name
;
19512 inote
.descsz
= BYTE_GET (external
->descsz
);
19513 inote
.descdata
= ((char *) external
19514 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19515 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19516 next
= ((char *) external
19517 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19521 Elf64_External_VMS_Note
*vms_external
;
19523 /* PR binutils/15191
19524 Make sure that there is enough data to read. */
19525 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19526 if (data_remaining
< min_notesz
)
19528 warn (ngettext ("Corrupt note: only %ld byte remains, "
19529 "not enough for a full note\n",
19530 "Corrupt note: only %ld bytes remain, "
19531 "not enough for a full note\n",
19533 (long) data_remaining
);
19536 data_remaining
-= min_notesz
;
19538 vms_external
= (Elf64_External_VMS_Note
*) external
;
19539 inote
.type
= BYTE_GET (vms_external
->type
);
19540 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19541 inote
.namedata
= vms_external
->name
;
19542 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19543 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19544 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19545 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19548 /* PR 17531: file: 3443835e. */
19549 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19550 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19551 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19552 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19553 || ((size_t) (next
- inote
.descdata
)
19554 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19556 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19557 (unsigned long) ((char *) external
- (char *) pnotes
));
19558 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19559 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19563 external
= (Elf_External_Note
*) next
;
19565 /* Verify that name is null terminated. It appears that at least
19566 one version of Linux (RedHat 6.0) generates corefiles that don't
19567 comply with the ELF spec by failing to include the null byte in
19569 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19571 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19573 temp
= (char *) malloc (inote
.namesz
+ 1);
19576 error (_("Out of memory allocating space for inote name\n"));
19581 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19582 inote
.namedata
= temp
;
19584 inote
.namedata
[inote
.namesz
] = 0;
19587 if (! process_note (& inote
, filedata
))
19603 process_corefile_note_segments (Filedata
* filedata
)
19605 Elf_Internal_Phdr
* segment
;
19607 bfd_boolean res
= TRUE
;
19609 if (! get_program_headers (filedata
))
19612 for (i
= 0, segment
= filedata
->program_headers
;
19613 i
< filedata
->file_header
.e_phnum
;
19616 if (segment
->p_type
== PT_NOTE
)
19617 if (! process_notes_at (filedata
, NULL
,
19618 (bfd_vma
) segment
->p_offset
,
19619 (bfd_vma
) segment
->p_filesz
,
19620 (bfd_vma
) segment
->p_align
))
19628 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19630 Elf_External_Note
* pnotes
;
19631 Elf_External_Note
* external
;
19633 bfd_boolean res
= TRUE
;
19638 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19640 if (pnotes
== NULL
)
19644 end
= (char*) pnotes
+ length
;
19646 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19647 (unsigned long) offset
, (unsigned long) length
);
19649 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19651 Elf_External_Note
* next
;
19652 Elf_Internal_Note inote
;
19654 inote
.type
= BYTE_GET (external
->type
);
19655 inote
.namesz
= BYTE_GET (external
->namesz
);
19656 inote
.namedata
= external
->name
;
19657 inote
.descsz
= BYTE_GET (external
->descsz
);
19658 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19659 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19661 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19663 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19664 inote
.descdata
= inote
.namedata
;
19668 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19670 if ( ((char *) next
> end
)
19671 || ((char *) next
< (char *) pnotes
))
19673 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19674 (unsigned long) ((char *) external
- (char *) pnotes
));
19675 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19676 inote
.type
, inote
.namesz
, inote
.descsz
);
19682 /* Prevent out-of-bounds indexing. */
19683 if ( inote
.namedata
+ inote
.namesz
> end
19684 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19686 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19687 (unsigned long) ((char *) external
- (char *) pnotes
));
19688 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19689 inote
.type
, inote
.namesz
, inote
.descsz
);
19693 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19695 if (! print_v850_note (& inote
))
19698 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19699 inote
.namesz
, inote
.descsz
);
19709 process_note_sections (Filedata
* filedata
)
19711 Elf_Internal_Shdr
* section
;
19713 unsigned int n
= 0;
19714 bfd_boolean res
= TRUE
;
19716 for (i
= 0, section
= filedata
->section_headers
;
19717 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19720 if (section
->sh_type
== SHT_NOTE
)
19722 if (! process_notes_at (filedata
, section
,
19723 (bfd_vma
) section
->sh_offset
,
19724 (bfd_vma
) section
->sh_size
,
19725 (bfd_vma
) section
->sh_addralign
))
19730 if (( filedata
->file_header
.e_machine
== EM_V800
19731 || filedata
->file_header
.e_machine
== EM_V850
19732 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19733 && section
->sh_type
== SHT_RENESAS_INFO
)
19735 if (! process_v850_notes (filedata
,
19736 (bfd_vma
) section
->sh_offset
,
19737 (bfd_vma
) section
->sh_size
))
19744 /* Try processing NOTE segments instead. */
19745 return process_corefile_note_segments (filedata
);
19751 process_notes (Filedata
* filedata
)
19753 /* If we have not been asked to display the notes then do nothing. */
19757 if (filedata
->file_header
.e_type
!= ET_CORE
)
19758 return process_note_sections (filedata
);
19760 /* No program headers means no NOTE segment. */
19761 if (filedata
->file_header
.e_phnum
> 0)
19762 return process_corefile_note_segments (filedata
);
19764 printf (_("No note segments present in the core file.\n"));
19768 static unsigned char *
19769 display_public_gnu_attributes (unsigned char * start
,
19770 const unsigned char * const end
)
19772 printf (_(" Unknown GNU attribute: %s\n"), start
);
19774 start
+= strnlen ((char *) start
, end
- start
);
19775 display_raw_attribute (start
, end
);
19777 return (unsigned char *) end
;
19780 static unsigned char *
19781 display_generic_attribute (unsigned char * start
,
19783 const unsigned char * const end
)
19786 return (unsigned char *) end
;
19788 return display_tag_value (tag
, start
, end
);
19792 process_arch_specific (Filedata
* filedata
)
19797 switch (filedata
->file_header
.e_machine
)
19800 case EM_ARC_COMPACT
:
19801 case EM_ARC_COMPACT2
:
19802 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19803 display_arc_attribute
,
19804 display_generic_attribute
);
19806 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19807 display_arm_attribute
,
19808 display_generic_attribute
);
19811 case EM_MIPS_RS3_LE
:
19812 return process_mips_specific (filedata
);
19815 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19816 display_msp430x_attribute
,
19817 display_msp430_gnu_attribute
);
19820 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19821 display_riscv_attribute
,
19822 display_generic_attribute
);
19825 return process_nds32_specific (filedata
);
19829 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19830 display_power_gnu_attribute
);
19834 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19835 display_s390_gnu_attribute
);
19838 case EM_SPARC32PLUS
:
19840 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19841 display_sparc_gnu_attribute
);
19844 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19845 display_tic6x_attribute
,
19846 display_generic_attribute
);
19849 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19850 display_public_gnu_attributes
,
19851 display_generic_attribute
);
19856 get_file_header (Filedata
* filedata
)
19858 /* Read in the identity array. */
19859 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19862 /* Determine how to read the rest of the header. */
19863 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19868 byte_get
= byte_get_little_endian
;
19869 byte_put
= byte_put_little_endian
;
19872 byte_get
= byte_get_big_endian
;
19873 byte_put
= byte_put_big_endian
;
19877 /* For now we only support 32 bit and 64 bit ELF files. */
19878 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19880 /* Read in the rest of the header. */
19883 Elf32_External_Ehdr ehdr32
;
19885 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19888 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19889 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19890 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19891 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19892 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19893 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19894 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19895 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19896 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19897 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19898 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19899 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19900 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19904 Elf64_External_Ehdr ehdr64
;
19906 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19907 we will not be able to cope with the 64bit data found in
19908 64 ELF files. Detect this now and abort before we start
19909 overwriting things. */
19910 if (sizeof (bfd_vma
) < 8)
19912 error (_("This instance of readelf has been built without support for a\n\
19913 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19917 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19920 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19921 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19922 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19923 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19924 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19925 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19926 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19927 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19928 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19929 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19930 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19931 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19932 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19935 if (filedata
->file_header
.e_shoff
)
19937 /* There may be some extensions in the first section header. Don't
19938 bomb if we can't read it. */
19940 get_32bit_section_headers (filedata
, TRUE
);
19942 get_64bit_section_headers (filedata
, TRUE
);
19949 close_file (Filedata
* filedata
)
19953 if (filedata
->handle
)
19954 fclose (filedata
->handle
);
19960 close_debug_file (void * data
)
19962 close_file ((Filedata
*) data
);
19966 open_file (const char * pathname
)
19968 struct stat statbuf
;
19969 Filedata
* filedata
= NULL
;
19971 if (stat (pathname
, & statbuf
) < 0
19972 || ! S_ISREG (statbuf
.st_mode
))
19975 filedata
= calloc (1, sizeof * filedata
);
19976 if (filedata
== NULL
)
19979 filedata
->handle
= fopen (pathname
, "rb");
19980 if (filedata
->handle
== NULL
)
19983 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19984 filedata
->file_name
= pathname
;
19986 if (! get_file_header (filedata
))
19989 if (filedata
->file_header
.e_shoff
)
19993 /* Read the section headers again, this time for real. */
19995 res
= get_32bit_section_headers (filedata
, FALSE
);
19997 res
= get_64bit_section_headers (filedata
, FALSE
);
20008 if (filedata
->handle
)
20009 fclose (filedata
->handle
);
20016 open_debug_file (const char * pathname
)
20018 return open_file (pathname
);
20021 /* Process one ELF object file according to the command line options.
20022 This file may actually be stored in an archive. The file is
20023 positioned at the start of the ELF object. Returns TRUE if no
20024 problems were encountered, FALSE otherwise. */
20027 process_object (Filedata
* filedata
)
20029 bfd_boolean have_separate_files
;
20031 bfd_boolean res
= TRUE
;
20033 if (! get_file_header (filedata
))
20035 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20039 /* Initialise per file variables. */
20040 for (i
= ARRAY_SIZE (version_info
); i
--;)
20041 version_info
[i
] = 0;
20043 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
20044 dynamic_info
[i
] = 0;
20045 dynamic_info_DT_GNU_HASH
= 0;
20046 dynamic_info_DT_MIPS_XHASH
= 0;
20048 /* Process the file. */
20050 printf (_("\nFile: %s\n"), filedata
->file_name
);
20052 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20053 Note we do this even if cmdline_dump_sects is empty because we
20054 must make sure that the dump_sets array is zeroed out before each
20055 object file is processed. */
20056 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
20057 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
20059 if (cmdline
.num_dump_sects
> 0)
20061 if (filedata
->num_dump_sects
== 0)
20062 /* A sneaky way of allocating the dump_sects array. */
20063 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
20065 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
20066 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
20067 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
20070 if (! process_file_header (filedata
))
20073 if (! process_section_headers (filedata
))
20075 /* Without loaded section headers we cannot process lots of things. */
20076 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20078 if (! do_using_dynamic
)
20079 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20082 if (! process_section_groups (filedata
))
20083 /* Without loaded section groups we cannot process unwind. */
20086 if (process_program_headers (filedata
))
20087 process_dynamic_section (filedata
);
20091 if (! process_relocs (filedata
))
20094 if (! process_unwind (filedata
))
20097 if (! process_symbol_table (filedata
))
20100 if (! process_syminfo (filedata
))
20103 if (! process_version_sections (filedata
))
20106 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20107 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20109 have_separate_files
= FALSE
;
20111 if (! process_section_contents (filedata
))
20114 if (have_separate_files
)
20118 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20120 if (! process_section_headers (d
->handle
))
20122 else if (! process_section_contents (d
->handle
))
20126 /* The file handles are closed by the call to free_debug_memory() below. */
20129 if (! process_notes (filedata
))
20132 if (! process_gnu_liblist (filedata
))
20135 if (! process_arch_specific (filedata
))
20138 free (filedata
->program_headers
);
20139 filedata
->program_headers
= NULL
;
20141 free (filedata
->section_headers
);
20142 filedata
->section_headers
= NULL
;
20144 free (filedata
->string_table
);
20145 filedata
->string_table
= NULL
;
20146 filedata
->string_table_length
= 0;
20148 if (filedata
->dump_sects
!= NULL
)
20150 free (filedata
->dump_sects
);
20151 filedata
->dump_sects
= NULL
;
20152 filedata
->num_dump_sects
= 0;
20155 if (dynamic_strings
)
20157 free (dynamic_strings
);
20158 dynamic_strings
= NULL
;
20159 dynamic_strings_length
= 0;
20162 if (dynamic_symbols
)
20164 free (dynamic_symbols
);
20165 dynamic_symbols
= NULL
;
20166 num_dynamic_syms
= 0;
20169 if (dynamic_syminfo
)
20171 free (dynamic_syminfo
);
20172 dynamic_syminfo
= NULL
;
20175 if (dynamic_section
)
20177 free (dynamic_section
);
20178 dynamic_section
= NULL
;
20181 while (symtab_shndx_list
!= NULL
)
20183 elf_section_list
*next
= symtab_shndx_list
->next
;
20184 free (symtab_shndx_list
);
20185 symtab_shndx_list
= next
;
20188 if (section_headers_groups
)
20190 free (section_headers_groups
);
20191 section_headers_groups
= NULL
;
20194 if (section_groups
)
20196 struct group_list
* g
;
20197 struct group_list
* next
;
20199 for (i
= 0; i
< group_count
; i
++)
20201 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
20208 free (section_groups
);
20209 section_groups
= NULL
;
20212 free_debug_memory ();
20217 /* Process an ELF archive.
20218 On entry the file is positioned just after the ARMAG string.
20219 Returns TRUE upon success, FALSE otherwise. */
20222 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20224 struct archive_info arch
;
20225 struct archive_info nested_arch
;
20227 bfd_boolean ret
= TRUE
;
20231 /* The ARCH structure is used to hold information about this archive. */
20232 arch
.file_name
= NULL
;
20234 arch
.index_array
= NULL
;
20235 arch
.sym_table
= NULL
;
20236 arch
.longnames
= NULL
;
20238 /* The NESTED_ARCH structure is used as a single-item cache of information
20239 about a nested archive (when members of a thin archive reside within
20240 another regular archive file). */
20241 nested_arch
.file_name
= NULL
;
20242 nested_arch
.file
= NULL
;
20243 nested_arch
.index_array
= NULL
;
20244 nested_arch
.sym_table
= NULL
;
20245 nested_arch
.longnames
= NULL
;
20247 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20248 filedata
->file_size
, is_thin_archive
,
20249 do_archive_index
) != 0)
20255 if (do_archive_index
)
20257 if (arch
.sym_table
== NULL
)
20258 error (_("%s: unable to dump the index as none was found\n"),
20259 filedata
->file_name
);
20262 unsigned long i
, l
;
20263 unsigned long current_pos
;
20265 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20266 "in the symbol table)\n"),
20267 filedata
->file_name
, (unsigned long) arch
.index_num
,
20270 current_pos
= ftell (filedata
->handle
);
20272 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20275 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20278 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20281 if (member_name
!= NULL
)
20283 char * qualified_name
20284 = make_qualified_name (&arch
, &nested_arch
,
20287 if (qualified_name
!= NULL
)
20289 printf (_("Contents of binary %s at offset "),
20291 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20293 free (qualified_name
);
20295 free (member_name
);
20299 if (l
>= arch
.sym_size
)
20301 error (_("%s: end of the symbol table reached "
20302 "before the end of the index\n"),
20303 filedata
->file_name
);
20307 /* PR 17531: file: 0b6630b2. */
20308 printf ("\t%.*s\n",
20309 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20310 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20313 if (arch
.uses_64bit_indices
)
20318 if (l
< arch
.sym_size
)
20320 error (ngettext ("%s: %ld byte remains in the symbol table, "
20321 "but without corresponding entries in "
20322 "the index table\n",
20323 "%s: %ld bytes remain in the symbol table, "
20324 "but without corresponding entries in "
20325 "the index table\n",
20326 arch
.sym_size
- l
),
20327 filedata
->file_name
, arch
.sym_size
- l
);
20331 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20333 error (_("%s: failed to seek back to start of object files "
20334 "in the archive\n"),
20335 filedata
->file_name
);
20341 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20342 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20343 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20344 && !do_section_groups
&& !do_dyn_syms
)
20346 ret
= TRUE
; /* Archive index only. */
20355 char * qualified_name
;
20357 /* Read the next archive header. */
20358 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20360 error (_("%s: failed to seek to next archive header\n"),
20365 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20366 if (got
!= sizeof arch
.arhdr
)
20370 /* PR 24049 - we cannot use filedata->file_name as this will
20371 have already been freed. */
20372 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20377 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20379 error (_("%s: did not find a valid archive header\n"),
20385 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20387 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20388 if (archive_file_size
& 01)
20389 ++archive_file_size
;
20391 name
= get_archive_member_name (&arch
, &nested_arch
);
20394 error (_("%s: bad archive file name\n"), arch
.file_name
);
20398 namelen
= strlen (name
);
20400 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20401 if (qualified_name
== NULL
)
20403 error (_("%s: bad archive file name\n"), arch
.file_name
);
20409 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20411 /* This is a proxy for an external member of a thin archive. */
20412 Filedata
* member_filedata
;
20413 char * member_file_name
= adjust_relative_path
20414 (filedata
->file_name
, name
, namelen
);
20417 if (member_file_name
== NULL
)
20419 free (qualified_name
);
20424 member_filedata
= open_file (member_file_name
);
20425 if (member_filedata
== NULL
)
20427 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20428 free (member_file_name
);
20429 free (qualified_name
);
20434 archive_file_offset
= arch
.nested_member_origin
;
20435 member_filedata
->file_name
= qualified_name
;
20437 if (! process_object (member_filedata
))
20440 close_file (member_filedata
);
20441 free (member_file_name
);
20442 free (qualified_name
);
20444 else if (is_thin_archive
)
20446 Filedata thin_filedata
;
20448 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20450 /* PR 15140: Allow for corrupt thin archives. */
20451 if (nested_arch
.file
== NULL
)
20453 error (_("%s: contains corrupt thin archive: %s\n"),
20454 qualified_name
, name
);
20455 free (qualified_name
);
20462 /* This is a proxy for a member of a nested archive. */
20463 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20465 /* The nested archive file will have been opened and setup by
20466 get_archive_member_name. */
20467 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20469 error (_("%s: failed to seek to archive member.\n"),
20470 nested_arch
.file_name
);
20471 free (qualified_name
);
20476 thin_filedata
.handle
= nested_arch
.file
;
20477 thin_filedata
.file_name
= qualified_name
;
20479 if (! process_object (& thin_filedata
))
20485 archive_file_offset
= arch
.next_arhdr_offset
;
20486 arch
.next_arhdr_offset
+= archive_file_size
;
20488 filedata
->file_name
= qualified_name
;
20489 if (! process_object (filedata
))
20493 free (qualified_name
);
20497 if (nested_arch
.file
!= NULL
)
20498 fclose (nested_arch
.file
);
20499 release_archive (&nested_arch
);
20500 release_archive (&arch
);
20506 process_file (char * file_name
)
20508 Filedata
* filedata
= NULL
;
20509 struct stat statbuf
;
20510 char armag
[SARMAG
];
20511 bfd_boolean ret
= TRUE
;
20513 if (stat (file_name
, &statbuf
) < 0)
20515 if (errno
== ENOENT
)
20516 error (_("'%s': No such file\n"), file_name
);
20518 error (_("Could not locate '%s'. System error message: %s\n"),
20519 file_name
, strerror (errno
));
20523 if (! S_ISREG (statbuf
.st_mode
))
20525 error (_("'%s' is not an ordinary file\n"), file_name
);
20529 filedata
= calloc (1, sizeof * filedata
);
20530 if (filedata
== NULL
)
20532 error (_("Out of memory allocating file data structure\n"));
20536 filedata
->file_name
= file_name
;
20537 filedata
->handle
= fopen (file_name
, "rb");
20538 if (filedata
->handle
== NULL
)
20540 error (_("Input file '%s' is not readable.\n"), file_name
);
20545 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20547 error (_("%s: Failed to read file's magic number\n"), file_name
);
20548 fclose (filedata
->handle
);
20553 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20555 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20557 if (! process_archive (filedata
, FALSE
))
20560 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20562 if ( ! process_archive (filedata
, TRUE
))
20567 if (do_archive_index
)
20568 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20571 rewind (filedata
->handle
);
20572 archive_file_size
= archive_file_offset
= 0;
20574 if (! process_object (filedata
))
20578 fclose (filedata
->handle
);
20579 free (filedata
->section_headers
);
20580 free (filedata
->program_headers
);
20581 free (filedata
->string_table
);
20582 free (filedata
->dump_sects
);
20585 free (ba_cache
.strtab
);
20586 ba_cache
.strtab
= NULL
;
20587 free (ba_cache
.symtab
);
20588 ba_cache
.symtab
= NULL
;
20589 ba_cache
.filedata
= NULL
;
20594 #ifdef SUPPORT_DISASSEMBLY
20595 /* Needed by the i386 disassembler. For extra credit, someone could
20596 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20600 print_address (unsigned int addr
, FILE * outfile
)
20602 fprintf (outfile
,"0x%8.8x", addr
);
20605 /* Needed by the i386 disassembler. */
20608 db_task_printsym (unsigned int addr
)
20610 print_address (addr
, stderr
);
20615 main (int argc
, char ** argv
)
20619 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20620 setlocale (LC_MESSAGES
, "");
20622 #if defined (HAVE_SETLOCALE)
20623 setlocale (LC_CTYPE
, "");
20625 bindtextdomain (PACKAGE
, LOCALEDIR
);
20626 textdomain (PACKAGE
);
20628 expandargv (&argc
, &argv
);
20630 cmdline
.file_name
= "<cmdline>";
20631 parse_args (& cmdline
, argc
, argv
);
20633 if (optind
< (argc
- 1))
20635 else if (optind
>= argc
)
20637 warn (_("Nothing to do.\n"));
20642 while (optind
< argc
)
20643 if (! process_file (argv
[optind
++]))
20646 if (cmdline
.dump_sects
!= NULL
)
20647 free (cmdline
.dump_sects
);
20649 free (dump_ctf_symtab_name
);
20650 free (dump_ctf_strtab_name
);
20651 free (dump_ctf_parent_name
);
20653 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;