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
;
12005 char * strtab
= NULL
;
12006 unsigned long int strtab_size
= 0;
12007 Elf_Internal_Sym
* symtab
;
12008 Elf_Internal_Sym
* psym
;
12009 unsigned long num_syms
;
12011 if ((section
->sh_type
!= SHT_SYMTAB
12012 && section
->sh_type
!= SHT_DYNSYM
)
12014 && section
->sh_type
== SHT_SYMTAB
))
12017 if (section
->sh_entsize
== 0)
12019 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12020 printable_section_name (filedata
, section
));
12024 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12025 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12026 "\nSymbol table '%s' contains %lu entries:\n",
12028 printable_section_name (filedata
, section
),
12032 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12034 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12036 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12037 if (symtab
== NULL
)
12040 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12042 strtab
= filedata
->string_table
;
12043 strtab_size
= filedata
->string_table_length
;
12045 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12047 Elf_Internal_Shdr
* string_sec
;
12049 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12051 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12052 1, string_sec
->sh_size
,
12053 _("string table"));
12054 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12057 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
12059 const char *version_string
;
12060 enum versioned_symbol_info sym_info
;
12061 unsigned short vna_other
;
12063 printf ("%6d: ", si
);
12064 print_vma (psym
->st_value
, LONG_HEX
);
12066 print_vma (psym
->st_size
, DEC_5
);
12067 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12068 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12069 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12070 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12073 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12075 printf (" %-7s", get_symbol_visibility (vis
));
12076 /* Check to see if any other bits in the st_other field are set.
12077 Note - displaying this information disrupts the layout of the
12078 table being generated, but for the moment this case is very rare. */
12079 if (psym
->st_other
^ vis
)
12080 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12082 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12083 print_symbol (25, psym
->st_name
< strtab_size
12084 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12087 = get_symbol_version_string (filedata
,
12088 section
->sh_type
== SHT_DYNSYM
,
12089 strtab
, strtab_size
, si
,
12090 psym
, &sym_info
, &vna_other
);
12091 if (version_string
)
12093 if (sym_info
== symbol_undefined
)
12094 printf ("@%s (%d)", version_string
, vna_other
);
12096 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12102 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12103 && si
>= section
->sh_info
12104 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12105 && filedata
->file_header
.e_machine
!= EM_MIPS
12106 /* Solaris binaries have been found to violate this requirement as
12107 well. Not sure if this is a bug or an ABI requirement. */
12108 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12109 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12110 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12114 if (strtab
!= filedata
->string_table
)
12120 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12122 if (do_histogram
&& buckets
!= NULL
)
12124 unsigned long * lengths
;
12125 unsigned long * counts
;
12128 unsigned long maxlength
= 0;
12129 unsigned long nzero_counts
= 0;
12130 unsigned long nsyms
= 0;
12133 printf (ngettext ("\nHistogram for bucket list length "
12134 "(total of %lu bucket):\n",
12135 "\nHistogram for bucket list length "
12136 "(total of %lu buckets):\n",
12137 (unsigned long) nbuckets
),
12138 (unsigned long) nbuckets
);
12140 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12141 if (lengths
== NULL
)
12143 error (_("Out of memory allocating space for histogram buckets\n"));
12146 visited
= xcmalloc (nchains
, 1);
12147 memset (visited
, 0, nchains
);
12149 printf (_(" Length Number %% of total Coverage\n"));
12150 for (hn
= 0; hn
< nbuckets
; ++hn
)
12152 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12155 if (maxlength
< ++lengths
[hn
])
12157 if (si
>= nchains
|| visited
[si
])
12159 error (_("histogram chain is corrupt\n"));
12167 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12168 if (counts
== NULL
)
12171 error (_("Out of memory allocating space for histogram counts\n"));
12175 for (hn
= 0; hn
< nbuckets
; ++hn
)
12176 ++counts
[lengths
[hn
]];
12181 printf (" 0 %-10lu (%5.1f%%)\n",
12182 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12183 for (i
= 1; i
<= maxlength
; ++i
)
12185 nzero_counts
+= counts
[i
] * i
;
12186 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12187 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12188 (nzero_counts
* 100.0) / nsyms
);
12201 if (do_histogram
&& gnubuckets
!= NULL
)
12203 unsigned long * lengths
;
12204 unsigned long * counts
;
12206 unsigned long maxlength
= 0;
12207 unsigned long nzero_counts
= 0;
12208 unsigned long nsyms
= 0;
12210 printf (ngettext ("\nHistogram for `%s' bucket list length "
12211 "(total of %lu bucket):\n",
12212 "\nHistogram for `%s' bucket list length "
12213 "(total of %lu buckets):\n",
12214 (unsigned long) ngnubuckets
),
12215 GNU_HASH_SECTION_NAME
,
12216 (unsigned long) ngnubuckets
);
12218 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12219 if (lengths
== NULL
)
12221 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12225 printf (_(" Length Number %% of total Coverage\n"));
12227 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12228 if (gnubuckets
[hn
] != 0)
12230 bfd_vma off
, length
= 1;
12232 for (off
= gnubuckets
[hn
] - gnusymidx
;
12233 /* PR 17531 file: 010-77222-0.004. */
12234 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12237 lengths
[hn
] = length
;
12238 if (length
> maxlength
)
12239 maxlength
= length
;
12243 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12244 if (counts
== NULL
)
12247 error (_("Out of memory allocating space for gnu histogram counts\n"));
12251 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12252 ++counts
[lengths
[hn
]];
12254 if (ngnubuckets
> 0)
12257 printf (" 0 %-10lu (%5.1f%%)\n",
12258 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12259 for (j
= 1; j
<= maxlength
; ++j
)
12261 nzero_counts
+= counts
[j
] * j
;
12262 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12263 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12264 (nzero_counts
* 100.0) / nsyms
);
12286 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12290 if (dynamic_syminfo
== NULL
12292 /* No syminfo, this is ok. */
12295 /* There better should be a dynamic symbol section. */
12296 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12300 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12301 "contains %d entry:\n",
12302 "\nDynamic info segment at offset 0x%lx "
12303 "contains %d entries:\n",
12304 dynamic_syminfo_nent
),
12305 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12307 printf (_(" Num: Name BoundTo Flags\n"));
12308 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12310 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12312 printf ("%4d: ", i
);
12313 if (i
>= num_dynamic_syms
)
12314 printf (_("<corrupt index>"));
12315 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12316 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12318 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12321 switch (dynamic_syminfo
[i
].si_boundto
)
12323 case SYMINFO_BT_SELF
:
12324 fputs ("SELF ", stdout
);
12326 case SYMINFO_BT_PARENT
:
12327 fputs ("PARENT ", stdout
);
12330 if (dynamic_syminfo
[i
].si_boundto
> 0
12331 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12332 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12334 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12338 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12342 if (flags
& SYMINFO_FLG_DIRECT
)
12343 printf (" DIRECT");
12344 if (flags
& SYMINFO_FLG_PASSTHRU
)
12345 printf (" PASSTHRU");
12346 if (flags
& SYMINFO_FLG_COPY
)
12348 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12349 printf (" LAZYLOAD");
12357 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12358 is contained by the region START .. END. The types of ADDR, START
12359 and END should all be the same. Note both ADDR + NELEM and END
12360 point to just beyond the end of the regions that are being tested. */
12361 #define IN_RANGE(START,END,ADDR,NELEM) \
12362 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12364 /* Check to see if the given reloc needs to be handled in a target specific
12365 manner. If so then process the reloc and return TRUE otherwise return
12368 If called with reloc == NULL, then this is a signal that reloc processing
12369 for the current section has finished, and any saved state should be
12373 target_specific_reloc_handling (Filedata
* filedata
,
12374 Elf_Internal_Rela
* reloc
,
12375 unsigned char * start
,
12376 unsigned char * end
,
12377 Elf_Internal_Sym
* symtab
,
12378 unsigned long num_syms
)
12380 unsigned int reloc_type
= 0;
12381 unsigned long sym_index
= 0;
12385 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12386 sym_index
= get_reloc_symindex (reloc
->r_info
);
12389 switch (filedata
->file_header
.e_machine
)
12392 case EM_MSP430_OLD
:
12394 static Elf_Internal_Sym
* saved_sym
= NULL
;
12402 switch (reloc_type
)
12404 case 10: /* R_MSP430_SYM_DIFF */
12405 if (uses_msp430x_relocs (filedata
))
12407 /* Fall through. */
12408 case 21: /* R_MSP430X_SYM_DIFF */
12410 if (sym_index
>= num_syms
)
12411 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12414 saved_sym
= symtab
+ sym_index
;
12417 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12418 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12419 goto handle_sym_diff
;
12421 case 5: /* R_MSP430_16_BYTE */
12422 case 9: /* R_MSP430_8 */
12423 if (uses_msp430x_relocs (filedata
))
12425 goto handle_sym_diff
;
12427 case 2: /* R_MSP430_ABS16 */
12428 case 15: /* R_MSP430X_ABS16 */
12429 if (! uses_msp430x_relocs (filedata
))
12431 goto handle_sym_diff
;
12434 if (saved_sym
!= NULL
)
12436 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12439 if (sym_index
>= num_syms
)
12440 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12444 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12445 - saved_sym
->st_value
);
12447 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12448 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12451 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12452 (long) reloc
->r_offset
);
12461 if (saved_sym
!= NULL
)
12462 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12469 case EM_CYGNUS_MN10300
:
12471 static Elf_Internal_Sym
* saved_sym
= NULL
;
12479 switch (reloc_type
)
12481 case 34: /* R_MN10300_ALIGN */
12483 case 33: /* R_MN10300_SYM_DIFF */
12484 if (sym_index
>= num_syms
)
12485 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12488 saved_sym
= symtab
+ sym_index
;
12491 case 1: /* R_MN10300_32 */
12492 case 2: /* R_MN10300_16 */
12493 if (saved_sym
!= NULL
)
12495 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12498 if (sym_index
>= num_syms
)
12499 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12503 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12504 - saved_sym
->st_value
);
12506 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12507 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12509 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12510 (long) reloc
->r_offset
);
12518 if (saved_sym
!= NULL
)
12519 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12527 static bfd_vma saved_sym1
= 0;
12528 static bfd_vma saved_sym2
= 0;
12529 static bfd_vma value
;
12533 saved_sym1
= saved_sym2
= 0;
12537 switch (reloc_type
)
12539 case 0x80: /* R_RL78_SYM. */
12540 saved_sym1
= saved_sym2
;
12541 if (sym_index
>= num_syms
)
12542 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12546 saved_sym2
= symtab
[sym_index
].st_value
;
12547 saved_sym2
+= reloc
->r_addend
;
12551 case 0x83: /* R_RL78_OPsub. */
12552 value
= saved_sym1
- saved_sym2
;
12553 saved_sym2
= saved_sym1
= 0;
12557 case 0x41: /* R_RL78_ABS32. */
12558 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12559 byte_put (start
+ reloc
->r_offset
, value
, 4);
12561 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12562 (long) reloc
->r_offset
);
12566 case 0x43: /* R_RL78_ABS16. */
12567 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12568 byte_put (start
+ reloc
->r_offset
, value
, 2);
12570 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12571 (long) reloc
->r_offset
);
12585 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12586 DWARF debug sections. This is a target specific test. Note - we do not
12587 go through the whole including-target-headers-multiple-times route, (as
12588 we have already done with <elf/h8.h>) because this would become very
12589 messy and even then this function would have to contain target specific
12590 information (the names of the relocs instead of their numeric values).
12591 FIXME: This is not the correct way to solve this problem. The proper way
12592 is to have target specific reloc sizing and typing functions created by
12593 the reloc-macros.h header, in the same way that it already creates the
12594 reloc naming functions. */
12597 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12599 /* Please keep this table alpha-sorted for ease of visual lookup. */
12600 switch (filedata
->file_header
.e_machine
)
12604 return reloc_type
== 1; /* R_386_32. */
12606 return reloc_type
== 1; /* R_68K_32. */
12608 return reloc_type
== 1; /* R_860_32. */
12610 return reloc_type
== 2; /* R_960_32. */
12612 return (reloc_type
== 258
12613 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12615 return reloc_type
== 11; /* R_BPF_DATA_32 */
12616 case EM_ADAPTEVA_EPIPHANY
:
12617 return reloc_type
== 3;
12619 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12621 return reloc_type
== 1; /* R_ARC_32. */
12622 case EM_ARC_COMPACT
:
12623 case EM_ARC_COMPACT2
:
12624 return reloc_type
== 4; /* R_ARC_32. */
12626 return reloc_type
== 2; /* R_ARM_ABS32 */
12629 return reloc_type
== 1;
12631 return reloc_type
== 0x12; /* R_byte4_data. */
12633 return reloc_type
== 3; /* R_CRIS_32. */
12635 return reloc_type
== 3; /* R_CR16_NUM32. */
12637 return reloc_type
== 15; /* R_CRX_NUM32. */
12639 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12640 case EM_CYGNUS_FRV
:
12641 return reloc_type
== 1;
12642 case EM_CYGNUS_D10V
:
12644 return reloc_type
== 6; /* R_D10V_32. */
12645 case EM_CYGNUS_D30V
:
12647 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12649 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12650 case EM_CYGNUS_FR30
:
12652 return reloc_type
== 3; /* R_FR30_32. */
12654 return reloc_type
== 1; /* R_FT32_32. */
12658 return reloc_type
== 1; /* R_H8_DIR32. */
12660 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12661 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12662 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12663 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12666 return reloc_type
== 2; /* R_IP2K_32. */
12668 return reloc_type
== 2; /* R_IQ2000_32. */
12669 case EM_LATTICEMICO32
:
12670 return reloc_type
== 3; /* R_LM32_32. */
12673 return reloc_type
== 3; /* R_M32C_32. */
12675 return reloc_type
== 34; /* R_M32R_32_RELA. */
12678 return reloc_type
== 6; /* R_M68HC11_32. */
12680 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12681 reloc_type
== 6; /* R_S12Z_CW32. */
12683 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12684 case EM_CYGNUS_MEP
:
12685 return reloc_type
== 4; /* R_MEP_32. */
12687 return reloc_type
== 2; /* R_METAG_ADDR32. */
12688 case EM_MICROBLAZE
:
12689 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12691 return reloc_type
== 2; /* R_MIPS_32. */
12693 return reloc_type
== 4; /* R_MMIX_32. */
12694 case EM_CYGNUS_MN10200
:
12696 return reloc_type
== 1; /* R_MN10200_32. */
12697 case EM_CYGNUS_MN10300
:
12699 return reloc_type
== 1; /* R_MN10300_32. */
12701 return reloc_type
== 1; /* R_MOXIE_32. */
12702 case EM_MSP430_OLD
:
12704 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12706 return reloc_type
== 2; /* R_MT_32. */
12708 return reloc_type
== 20; /* R_NDS32_RELA. */
12709 case EM_ALTERA_NIOS2
:
12710 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12712 return reloc_type
== 1; /* R_NIOS_32. */
12714 return reloc_type
== 1; /* R_OR1K_32. */
12716 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12717 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12718 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12721 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12723 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12725 return reloc_type
== 1; /* R_PPC_ADDR32. */
12727 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12729 return reloc_type
== 1; /* R_RISCV_32. */
12731 return reloc_type
== 1; /* R_RL78_DIR32. */
12733 return reloc_type
== 1; /* R_RX_DIR32. */
12735 return reloc_type
== 1; /* R_I370_ADDR31. */
12738 return reloc_type
== 4; /* R_S390_32. */
12740 return reloc_type
== 8; /* R_SCORE_ABS32. */
12742 return reloc_type
== 1; /* R_SH_DIR32. */
12743 case EM_SPARC32PLUS
:
12746 return reloc_type
== 3 /* R_SPARC_32. */
12747 || reloc_type
== 23; /* R_SPARC_UA32. */
12749 return reloc_type
== 6; /* R_SPU_ADDR32 */
12751 return reloc_type
== 1; /* R_C6000_ABS32. */
12753 return reloc_type
== 2; /* R_TILEGX_32. */
12755 return reloc_type
== 1; /* R_TILEPRO_32. */
12756 case EM_CYGNUS_V850
:
12758 return reloc_type
== 6; /* R_V850_ABS32. */
12760 return reloc_type
== 0x33; /* R_V810_WORD. */
12762 return reloc_type
== 1; /* R_VAX_32. */
12764 return reloc_type
== 3; /* R_VISIUM_32. */
12765 case EM_WEBASSEMBLY
:
12766 return reloc_type
== 1; /* R_WASM32_32. */
12770 return reloc_type
== 10; /* R_X86_64_32. */
12773 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12775 return reloc_type
== 4; /* R_XGATE_32. */
12777 return reloc_type
== 1; /* R_XSTROMY16_32. */
12778 case EM_XTENSA_OLD
:
12780 return reloc_type
== 1; /* R_XTENSA_32. */
12782 return reloc_type
== 6; /* R_Z80_32. */
12785 static unsigned int prev_warn
= 0;
12787 /* Avoid repeating the same warning multiple times. */
12788 if (prev_warn
!= filedata
->file_header
.e_machine
)
12789 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12790 filedata
->file_header
.e_machine
);
12791 prev_warn
= filedata
->file_header
.e_machine
;
12797 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12798 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12801 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12803 switch (filedata
->file_header
.e_machine
)
12804 /* Please keep this table alpha-sorted for ease of visual lookup. */
12808 return reloc_type
== 2; /* R_386_PC32. */
12810 return reloc_type
== 4; /* R_68K_PC32. */
12812 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12813 case EM_ADAPTEVA_EPIPHANY
:
12814 return reloc_type
== 6;
12816 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12817 case EM_ARC_COMPACT
:
12818 case EM_ARC_COMPACT2
:
12819 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12821 return reloc_type
== 3; /* R_ARM_REL32 */
12824 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12825 case EM_MICROBLAZE
:
12826 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12828 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12830 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12832 return reloc_type
== 26; /* R_PPC_REL32. */
12834 return reloc_type
== 26; /* R_PPC64_REL32. */
12836 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12839 return reloc_type
== 5; /* R_390_PC32. */
12841 return reloc_type
== 2; /* R_SH_REL32. */
12842 case EM_SPARC32PLUS
:
12845 return reloc_type
== 6; /* R_SPARC_DISP32. */
12847 return reloc_type
== 13; /* R_SPU_REL32. */
12849 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12851 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12853 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12857 return reloc_type
== 2; /* R_X86_64_PC32. */
12859 return reloc_type
== 4; /* R_VAX_PCREL32. */
12860 case EM_XTENSA_OLD
:
12862 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12864 /* Do not abort or issue an error message here. Not all targets use
12865 pc-relative 32-bit relocs in their DWARF debug information and we
12866 have already tested for target coverage in is_32bit_abs_reloc. A
12867 more helpful warning message will be generated by apply_relocations
12868 anyway, so just return. */
12873 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12874 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12877 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12879 switch (filedata
->file_header
.e_machine
)
12882 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12884 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12886 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12887 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12889 return reloc_type
== 80; /* R_PARISC_DIR64. */
12891 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12893 return reloc_type
== 2; /* R_RISCV_64. */
12894 case EM_SPARC32PLUS
:
12897 return reloc_type
== 32 /* R_SPARC_64. */
12898 || reloc_type
== 54; /* R_SPARC_UA64. */
12902 return reloc_type
== 1; /* R_X86_64_64. */
12905 return reloc_type
== 22; /* R_S390_64. */
12907 return reloc_type
== 1; /* R_TILEGX_64. */
12909 return reloc_type
== 18; /* R_MIPS_64. */
12915 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12916 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12919 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12921 switch (filedata
->file_header
.e_machine
)
12924 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12926 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12928 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12929 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12931 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12933 return reloc_type
== 44; /* R_PPC64_REL64. */
12934 case EM_SPARC32PLUS
:
12937 return reloc_type
== 46; /* R_SPARC_DISP64. */
12941 return reloc_type
== 24; /* R_X86_64_PC64. */
12944 return reloc_type
== 23; /* R_S390_PC64. */
12946 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12952 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12953 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12956 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12958 switch (filedata
->file_header
.e_machine
)
12960 case EM_CYGNUS_MN10200
:
12962 return reloc_type
== 4; /* R_MN10200_24. */
12964 return reloc_type
== 5; /* R_FT32_20. */
12966 return reloc_type
== 5; /* R_Z80_24. */
12972 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12973 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12976 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12978 /* Please keep this table alpha-sorted for ease of visual lookup. */
12979 switch (filedata
->file_header
.e_machine
)
12982 case EM_ARC_COMPACT
:
12983 case EM_ARC_COMPACT2
:
12984 return reloc_type
== 2; /* R_ARC_16. */
12985 case EM_ADAPTEVA_EPIPHANY
:
12986 return reloc_type
== 5;
12989 return reloc_type
== 4; /* R_AVR_16. */
12990 case EM_CYGNUS_D10V
:
12992 return reloc_type
== 3; /* R_D10V_16. */
12994 return reloc_type
== 2; /* R_FT32_16. */
12998 return reloc_type
== R_H8_DIR16
;
13001 return reloc_type
== 1; /* R_IP2K_16. */
13004 return reloc_type
== 1; /* R_M32C_16 */
13005 case EM_CYGNUS_MN10200
:
13007 return reloc_type
== 2; /* R_MN10200_16. */
13008 case EM_CYGNUS_MN10300
:
13010 return reloc_type
== 2; /* R_MN10300_16. */
13012 if (uses_msp430x_relocs (filedata
))
13013 return reloc_type
== 2; /* R_MSP430_ABS16. */
13014 /* Fall through. */
13015 case EM_MSP430_OLD
:
13016 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13018 return reloc_type
== 19; /* R_NDS32_RELA. */
13019 case EM_ALTERA_NIOS2
:
13020 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13022 return reloc_type
== 9; /* R_NIOS_16. */
13024 return reloc_type
== 2; /* R_OR1K_16. */
13026 return reloc_type
== 55; /* R_RISCV_SET16. */
13028 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13030 return reloc_type
== 2; /* R_C6000_ABS16. */
13032 return reloc_type
== 2; /* R_VISIUM_16. */
13035 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13037 return reloc_type
== 3; /* R_XGATE_16. */
13039 return reloc_type
== 4; /* R_Z80_16. */
13045 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13046 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13049 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13051 switch (filedata
->file_header
.e_machine
)
13054 return reloc_type
== 54; /* R_RISCV_SET8. */
13056 return reloc_type
== 1; /* R_Z80_8. */
13062 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13063 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13066 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13068 switch (filedata
->file_header
.e_machine
)
13071 return reloc_type
== 53; /* R_RISCV_SET6. */
13077 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13078 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13081 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13083 /* Please keep this table alpha-sorted for ease of visual lookup. */
13084 switch (filedata
->file_header
.e_machine
)
13087 return reloc_type
== 35; /* R_RISCV_ADD32. */
13093 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13094 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13097 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13099 /* Please keep this table alpha-sorted for ease of visual lookup. */
13100 switch (filedata
->file_header
.e_machine
)
13103 return reloc_type
== 39; /* R_RISCV_SUB32. */
13109 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13110 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13113 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13115 /* Please keep this table alpha-sorted for ease of visual lookup. */
13116 switch (filedata
->file_header
.e_machine
)
13119 return reloc_type
== 36; /* R_RISCV_ADD64. */
13125 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13126 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13129 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13131 /* Please keep this table alpha-sorted for ease of visual lookup. */
13132 switch (filedata
->file_header
.e_machine
)
13135 return reloc_type
== 40; /* R_RISCV_SUB64. */
13141 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13142 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13145 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13147 /* Please keep this table alpha-sorted for ease of visual lookup. */
13148 switch (filedata
->file_header
.e_machine
)
13151 return reloc_type
== 34; /* R_RISCV_ADD16. */
13157 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13158 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13161 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13163 /* Please keep this table alpha-sorted for ease of visual lookup. */
13164 switch (filedata
->file_header
.e_machine
)
13167 return reloc_type
== 38; /* R_RISCV_SUB16. */
13173 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13174 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13177 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13179 /* Please keep this table alpha-sorted for ease of visual lookup. */
13180 switch (filedata
->file_header
.e_machine
)
13183 return reloc_type
== 33; /* R_RISCV_ADD8. */
13189 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13190 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13193 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13195 /* Please keep this table alpha-sorted for ease of visual lookup. */
13196 switch (filedata
->file_header
.e_machine
)
13199 return reloc_type
== 37; /* R_RISCV_SUB8. */
13205 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13206 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13209 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13211 switch (filedata
->file_header
.e_machine
)
13214 return reloc_type
== 52; /* R_RISCV_SUB6. */
13220 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13221 relocation entries (possibly formerly used for SHT_GROUP sections). */
13224 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13226 switch (filedata
->file_header
.e_machine
)
13228 case EM_386
: /* R_386_NONE. */
13229 case EM_68K
: /* R_68K_NONE. */
13230 case EM_ADAPTEVA_EPIPHANY
:
13231 case EM_ALPHA
: /* R_ALPHA_NONE. */
13232 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13233 case EM_ARC
: /* R_ARC_NONE. */
13234 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13235 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13236 case EM_ARM
: /* R_ARM_NONE. */
13237 case EM_C166
: /* R_XC16X_NONE. */
13238 case EM_CRIS
: /* R_CRIS_NONE. */
13239 case EM_FT32
: /* R_FT32_NONE. */
13240 case EM_IA_64
: /* R_IA64_NONE. */
13241 case EM_K1OM
: /* R_X86_64_NONE. */
13242 case EM_L1OM
: /* R_X86_64_NONE. */
13243 case EM_M32R
: /* R_M32R_NONE. */
13244 case EM_MIPS
: /* R_MIPS_NONE. */
13245 case EM_MN10300
: /* R_MN10300_NONE. */
13246 case EM_MOXIE
: /* R_MOXIE_NONE. */
13247 case EM_NIOS32
: /* R_NIOS_NONE. */
13248 case EM_OR1K
: /* R_OR1K_NONE. */
13249 case EM_PARISC
: /* R_PARISC_NONE. */
13250 case EM_PPC64
: /* R_PPC64_NONE. */
13251 case EM_PPC
: /* R_PPC_NONE. */
13252 case EM_RISCV
: /* R_RISCV_NONE. */
13253 case EM_S390
: /* R_390_NONE. */
13255 case EM_SH
: /* R_SH_NONE. */
13256 case EM_SPARC32PLUS
:
13257 case EM_SPARC
: /* R_SPARC_NONE. */
13259 case EM_TILEGX
: /* R_TILEGX_NONE. */
13260 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13261 case EM_TI_C6000
:/* R_C6000_NONE. */
13262 case EM_X86_64
: /* R_X86_64_NONE. */
13264 case EM_Z80
: /* R_Z80_NONE. */
13265 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13266 return reloc_type
== 0;
13269 return reloc_type
== 0 || reloc_type
== 256;
13272 return (reloc_type
== 0 /* R_AVR_NONE. */
13273 || reloc_type
== 30 /* R_AVR_DIFF8. */
13274 || reloc_type
== 31 /* R_AVR_DIFF16. */
13275 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13277 return reloc_type
== 3; /* R_METAG_NONE. */
13279 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13280 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13281 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13282 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13283 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13285 return (reloc_type
== 0 /* R_PRU_NONE. */
13286 || reloc_type
== 65 /* R_PRU_DIFF8. */
13287 || reloc_type
== 66 /* R_PRU_DIFF16. */
13288 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13289 case EM_XTENSA_OLD
:
13291 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13292 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13293 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13294 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13299 /* Returns TRUE if there is a relocation against
13300 section NAME at OFFSET bytes. */
13303 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13305 Elf_Internal_Rela
* relocs
;
13306 Elf_Internal_Rela
* rp
;
13308 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13311 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13313 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13314 if (rp
->r_offset
== offset
)
13320 /* Apply relocations to a section.
13321 Returns TRUE upon success, FALSE otherwise.
13322 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13323 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13324 will be set to the number of relocs loaded.
13326 Note: So far support has been added only for those relocations
13327 which can be found in debug sections. FIXME: Add support for
13328 more relocations ? */
13331 apply_relocations (Filedata
* filedata
,
13332 const Elf_Internal_Shdr
* section
,
13333 unsigned char * start
,
13334 bfd_size_type size
,
13335 void ** relocs_return
,
13336 unsigned long * num_relocs_return
)
13338 Elf_Internal_Shdr
* relsec
;
13339 unsigned char * end
= start
+ size
;
13341 if (relocs_return
!= NULL
)
13343 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13344 * num_relocs_return
= 0;
13347 if (filedata
->file_header
.e_type
!= ET_REL
)
13348 /* No relocs to apply. */
13351 /* Find the reloc section associated with the section. */
13352 for (relsec
= filedata
->section_headers
;
13353 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13356 bfd_boolean is_rela
;
13357 unsigned long num_relocs
;
13358 Elf_Internal_Rela
* relocs
;
13359 Elf_Internal_Rela
* rp
;
13360 Elf_Internal_Shdr
* symsec
;
13361 Elf_Internal_Sym
* symtab
;
13362 unsigned long num_syms
;
13363 Elf_Internal_Sym
* sym
;
13365 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13366 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13367 || filedata
->section_headers
+ relsec
->sh_info
!= section
13368 || relsec
->sh_size
== 0
13369 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13372 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13373 if (symsec
->sh_type
!= SHT_SYMTAB
13374 && symsec
->sh_type
!= SHT_DYNSYM
)
13377 is_rela
= relsec
->sh_type
== SHT_RELA
;
13381 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13382 relsec
->sh_size
, & relocs
, & num_relocs
))
13387 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13388 relsec
->sh_size
, & relocs
, & num_relocs
))
13392 /* SH uses RELA but uses in place value instead of the addend field. */
13393 if (filedata
->file_header
.e_machine
== EM_SH
)
13396 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13398 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13401 unsigned int reloc_type
;
13402 unsigned int reloc_size
;
13403 bfd_boolean reloc_inplace
= FALSE
;
13404 bfd_boolean reloc_subtract
= FALSE
;
13405 unsigned char * rloc
;
13406 unsigned long sym_index
;
13408 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13410 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13412 else if (is_none_reloc (filedata
, reloc_type
))
13414 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13415 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13417 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13418 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13420 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13422 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13424 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13425 || is_6bit_abs_reloc (filedata
, reloc_type
))
13427 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13429 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13432 reloc_inplace
= TRUE
;
13434 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13436 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13439 reloc_inplace
= TRUE
;
13441 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13443 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13446 reloc_inplace
= TRUE
;
13448 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13450 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13453 reloc_inplace
= TRUE
;
13455 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13459 reloc_inplace
= TRUE
;
13463 static unsigned int prev_reloc
= 0;
13465 if (reloc_type
!= prev_reloc
)
13466 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13467 reloc_type
, printable_section_name (filedata
, section
));
13468 prev_reloc
= reloc_type
;
13472 rloc
= start
+ rp
->r_offset
;
13473 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13475 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13476 (unsigned long) rp
->r_offset
,
13477 printable_section_name (filedata
, section
));
13481 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13482 if (sym_index
>= num_syms
)
13484 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13485 sym_index
, printable_section_name (filedata
, section
));
13488 sym
= symtab
+ sym_index
;
13490 /* If the reloc has a symbol associated with it,
13491 make sure that it is of an appropriate type.
13493 Relocations against symbols without type can happen.
13494 Gcc -feliminate-dwarf2-dups may generate symbols
13495 without type for debug info.
13497 Icc generates relocations against function symbols
13498 instead of local labels.
13500 Relocations against object symbols can happen, eg when
13501 referencing a global array. For an example of this see
13502 the _clz.o binary in libgcc.a. */
13504 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13505 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13507 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13508 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13509 printable_section_name (filedata
, relsec
),
13510 (long int)(rp
- relocs
));
13516 addend
+= rp
->r_addend
;
13517 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13518 partial_inplace. */
13520 || (filedata
->file_header
.e_machine
== EM_XTENSA
13521 && reloc_type
== 1)
13522 || ((filedata
->file_header
.e_machine
== EM_PJ
13523 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13524 && reloc_type
== 1)
13525 || ((filedata
->file_header
.e_machine
== EM_D30V
13526 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13527 && reloc_type
== 12)
13530 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13531 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13533 addend
+= byte_get (rloc
, reloc_size
);
13536 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13537 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13539 /* On HPPA, all pc-relative relocations are biased by 8. */
13540 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13542 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13545 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13546 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13548 if (reloc_subtract
)
13549 addend
-= sym
->st_value
;
13551 addend
+= sym
->st_value
;
13552 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13553 byte_put (rloc
, addend
, reloc_size
);
13555 else if (reloc_subtract
)
13556 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13558 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13562 /* Let the target specific reloc processing code know that
13563 we have finished with these relocs. */
13564 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13568 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13569 * num_relocs_return
= num_relocs
;
13580 #ifdef SUPPORT_DISASSEMBLY
13582 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13584 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13586 /* FIXME: XXX -- to be done --- XXX */
13592 /* Reads in the contents of SECTION from FILE, returning a pointer
13593 to a malloc'ed buffer or NULL if something went wrong. */
13596 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13598 bfd_size_type num_bytes
= section
->sh_size
;
13600 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13602 printf (_("Section '%s' has no data to dump.\n"),
13603 printable_section_name (filedata
, section
));
13607 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13608 _("section contents"));
13611 /* Uncompresses a section that was compressed using zlib, in place. */
13614 uncompress_section_contents (unsigned char ** buffer
,
13615 dwarf_size_type uncompressed_size
,
13616 dwarf_size_type
* size
)
13618 dwarf_size_type compressed_size
= *size
;
13619 unsigned char * compressed_buffer
= *buffer
;
13620 unsigned char * uncompressed_buffer
;
13624 /* It is possible the section consists of several compressed
13625 buffers concatenated together, so we uncompress in a loop. */
13626 /* PR 18313: The state field in the z_stream structure is supposed
13627 to be invisible to the user (ie us), but some compilers will
13628 still complain about it being used without initialisation. So
13629 we first zero the entire z_stream structure and then set the fields
13631 memset (& strm
, 0, sizeof strm
);
13632 strm
.avail_in
= compressed_size
;
13633 strm
.next_in
= (Bytef
*) compressed_buffer
;
13634 strm
.avail_out
= uncompressed_size
;
13635 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13637 rc
= inflateInit (& strm
);
13638 while (strm
.avail_in
> 0)
13642 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13643 + (uncompressed_size
- strm
.avail_out
));
13644 rc
= inflate (&strm
, Z_FINISH
);
13645 if (rc
!= Z_STREAM_END
)
13647 rc
= inflateReset (& strm
);
13649 rc
= inflateEnd (& strm
);
13651 || strm
.avail_out
!= 0)
13654 *buffer
= uncompressed_buffer
;
13655 *size
= uncompressed_size
;
13659 free (uncompressed_buffer
);
13660 /* Indicate decompression failure. */
13666 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13668 Elf_Internal_Shdr
* relsec
;
13669 bfd_size_type num_bytes
;
13670 unsigned char * data
;
13671 unsigned char * end
;
13672 unsigned char * real_start
;
13673 unsigned char * start
;
13674 bfd_boolean some_strings_shown
;
13676 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13678 /* PR 21820: Do not fail if the section was empty. */
13679 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13681 num_bytes
= section
->sh_size
;
13683 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13685 if (decompress_dumps
)
13687 dwarf_size_type new_size
= num_bytes
;
13688 dwarf_size_type uncompressed_size
= 0;
13690 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13692 Elf_Internal_Chdr chdr
;
13693 unsigned int compression_header_size
13694 = get_compression_header (& chdr
, (unsigned char *) start
,
13697 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13699 warn (_("section '%s' has unsupported compress type: %d\n"),
13700 printable_section_name (filedata
, section
), chdr
.ch_type
);
13703 uncompressed_size
= chdr
.ch_size
;
13704 start
+= compression_header_size
;
13705 new_size
-= compression_header_size
;
13707 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13709 /* Read the zlib header. In this case, it should be "ZLIB"
13710 followed by the uncompressed section size, 8 bytes in
13711 big-endian order. */
13712 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13713 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13714 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13715 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13716 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13717 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13718 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13719 uncompressed_size
+= start
[11];
13724 if (uncompressed_size
)
13726 if (uncompress_section_contents (& start
,
13727 uncompressed_size
, & new_size
))
13728 num_bytes
= new_size
;
13731 error (_("Unable to decompress section %s\n"),
13732 printable_section_name (filedata
, section
));
13737 start
= real_start
;
13740 /* If the section being dumped has relocations against it the user might
13741 be expecting these relocations to have been applied. Check for this
13742 case and issue a warning message in order to avoid confusion.
13743 FIXME: Maybe we ought to have an option that dumps a section with
13744 relocs applied ? */
13745 for (relsec
= filedata
->section_headers
;
13746 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13749 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13750 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13751 || filedata
->section_headers
+ relsec
->sh_info
!= section
13752 || relsec
->sh_size
== 0
13753 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13756 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13761 end
= start
+ num_bytes
;
13762 some_strings_shown
= FALSE
;
13764 #ifdef HAVE_MBSTATE_T
13766 /* Initialise the multibyte conversion state. */
13767 memset (& state
, 0, sizeof (state
));
13770 bfd_boolean continuing
= FALSE
;
13774 while (!ISPRINT (* data
))
13775 if (++ data
>= end
)
13780 size_t maxlen
= end
- data
;
13785 continuing
= FALSE
;
13790 /* PR 11128: Use two separate invocations in order to work
13791 around bugs in the Solaris 8 implementation of printf. */
13792 printf (" [%6tx] ", data
- start
);
13794 printf (" [%6Ix] ", (size_t) (data
- start
));
13809 /* PR 25543: Treat new-lines as string-ending characters. */
13818 /* Do not print control characters directly as they can affect terminal
13819 settings. Such characters usually appear in the names generated
13820 by the assembler for local labels. */
13823 printf ("^%c", c
+ 0x40);
13825 else if (ISPRINT (c
))
13832 #ifdef HAVE_MBSTATE_T
13835 /* Let printf do the hard work of displaying multibyte characters. */
13836 printf ("%.1s", data
- 1);
13837 #ifdef HAVE_MBSTATE_T
13838 /* Try to find out how many bytes made up the character that was
13839 just printed. Advance the symbol pointer past the bytes that
13841 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13845 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13855 printf (_("<corrupt>\n"));
13858 some_strings_shown
= TRUE
;
13862 if (! some_strings_shown
)
13863 printf (_(" No strings found in this section."));
13876 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13877 Filedata
* filedata
,
13878 bfd_boolean relocate
)
13880 Elf_Internal_Shdr
* relsec
;
13881 bfd_size_type bytes
;
13882 bfd_size_type section_size
;
13884 unsigned char * data
;
13885 unsigned char * real_start
;
13886 unsigned char * start
;
13888 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13890 /* PR 21820: Do not fail if the section was empty. */
13891 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13893 section_size
= section
->sh_size
;
13895 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13897 if (decompress_dumps
)
13899 dwarf_size_type new_size
= section_size
;
13900 dwarf_size_type uncompressed_size
= 0;
13902 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13904 Elf_Internal_Chdr chdr
;
13905 unsigned int compression_header_size
13906 = get_compression_header (& chdr
, start
, section_size
);
13908 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13910 warn (_("section '%s' has unsupported compress type: %d\n"),
13911 printable_section_name (filedata
, section
), chdr
.ch_type
);
13914 uncompressed_size
= chdr
.ch_size
;
13915 start
+= compression_header_size
;
13916 new_size
-= compression_header_size
;
13918 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13920 /* Read the zlib header. In this case, it should be "ZLIB"
13921 followed by the uncompressed section size, 8 bytes in
13922 big-endian order. */
13923 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13924 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13925 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13926 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13927 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13928 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13929 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13930 uncompressed_size
+= start
[11];
13935 if (uncompressed_size
)
13937 if (uncompress_section_contents (& start
, uncompressed_size
,
13940 section_size
= new_size
;
13944 error (_("Unable to decompress section %s\n"),
13945 printable_section_name (filedata
, section
));
13946 /* FIXME: Print the section anyway ? */
13951 start
= real_start
;
13956 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13961 /* If the section being dumped has relocations against it the user might
13962 be expecting these relocations to have been applied. Check for this
13963 case and issue a warning message in order to avoid confusion.
13964 FIXME: Maybe we ought to have an option that dumps a section with
13965 relocs applied ? */
13966 for (relsec
= filedata
->section_headers
;
13967 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13970 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13971 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13972 || filedata
->section_headers
+ relsec
->sh_info
!= section
13973 || relsec
->sh_size
== 0
13974 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13977 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13982 addr
= section
->sh_addr
;
13983 bytes
= section_size
;
13992 lbytes
= (bytes
> 16 ? 16 : bytes
);
13994 printf (" 0x%8.8lx ", (unsigned long) addr
);
13996 for (j
= 0; j
< 16; j
++)
13999 printf ("%2.2x", data
[j
]);
14007 for (j
= 0; j
< lbytes
; j
++)
14010 if (k
>= ' ' && k
< 0x7f)
14033 static ctf_sect_t
*
14034 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14036 buf
->cts_name
= SECTION_NAME (shdr
);
14037 buf
->cts_size
= shdr
->sh_size
;
14038 buf
->cts_entsize
= shdr
->sh_entsize
;
14043 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14044 it is passed, or a pointer to newly-allocated storage, in which case
14045 dump_ctf() will free it when it no longer needs it. */
14047 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14048 char *s
, void *arg
)
14050 const char *blanks
= arg
;
14053 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14059 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14061 Elf_Internal_Shdr
* parent_sec
= NULL
;
14062 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14063 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14064 void * data
= NULL
;
14065 void * symdata
= NULL
;
14066 void * strdata
= NULL
;
14067 void * parentdata
= NULL
;
14068 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14069 ctf_sect_t
* symsectp
= NULL
;
14070 ctf_sect_t
* strsectp
= NULL
;
14071 ctf_file_t
* ctf
= NULL
;
14072 ctf_file_t
* parent
= NULL
;
14074 const char *things
[] = {"Header", "Labels", "Data objects",
14075 "Function objects", "Variables", "Types", "Strings",
14077 const char **thing
;
14079 bfd_boolean ret
= FALSE
;
14082 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14083 data
= get_section_contents (section
, filedata
);
14084 ctfsect
.cts_data
= data
;
14086 if (!dump_ctf_symtab_name
)
14087 dump_ctf_symtab_name
= strdup (".symtab");
14089 if (!dump_ctf_strtab_name
)
14090 dump_ctf_strtab_name
= strdup (".strtab");
14092 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14094 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14096 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14099 if ((symdata
= (void *) get_data (NULL
, filedata
,
14100 symtab_sec
->sh_offset
, 1,
14101 symtab_sec
->sh_size
,
14102 _("symbols"))) == NULL
)
14104 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14105 symsect
.cts_data
= symdata
;
14107 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14109 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14111 error (_("No string table section named %s\n"),
14112 dump_ctf_strtab_name
);
14115 if ((strdata
= (void *) get_data (NULL
, filedata
,
14116 strtab_sec
->sh_offset
, 1,
14117 strtab_sec
->sh_size
,
14118 _("strings"))) == NULL
)
14120 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14121 strsect
.cts_data
= strdata
;
14123 if (dump_ctf_parent_name
)
14125 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14127 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14130 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14131 parent_sec
->sh_offset
, 1,
14132 parent_sec
->sh_size
,
14133 _("CTF parent"))) == NULL
)
14135 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14136 parentsect
.cts_data
= parentdata
;
14139 /* Load the CTF file and dump it. */
14141 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14143 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14149 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14151 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14155 ctf_import (ctf
, parent
);
14160 printf (_("\nDump of CTF section '%s':\n"),
14161 printable_section_name (filedata
, section
));
14163 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14165 ctf_dump_state_t
*s
= NULL
;
14168 printf ("\n %s:\n", *thing
);
14169 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14170 (void *) " ")) != NULL
)
14172 printf ("%s\n", item
);
14176 if (ctf_errno (ctf
))
14178 error (_("Iteration failed: %s, %s\n"), *thing
,
14179 ctf_errmsg (ctf_errno (ctf
)));
14185 ctf_file_close (ctf
);
14186 ctf_file_close (parent
);
14195 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14196 const Elf_Internal_Shdr
* sec
,
14199 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14201 Filedata
* filedata
= (Filedata
*) data
;
14203 if (section
->start
!= NULL
)
14205 /* If it is already loaded, do nothing. */
14206 if (streq (section
->filename
, filedata
->file_name
))
14208 free (section
->start
);
14211 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14212 section
->address
= sec
->sh_addr
;
14213 section
->user_data
= NULL
;
14214 section
->filename
= filedata
->file_name
;
14215 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14217 sec
->sh_size
, buf
);
14218 if (section
->start
== NULL
)
14222 unsigned char *start
= section
->start
;
14223 dwarf_size_type size
= sec
->sh_size
;
14224 dwarf_size_type uncompressed_size
= 0;
14226 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14228 Elf_Internal_Chdr chdr
;
14229 unsigned int compression_header_size
;
14231 if (size
< (is_32bit_elf
14232 ? sizeof (Elf32_External_Chdr
)
14233 : sizeof (Elf64_External_Chdr
)))
14235 warn (_("compressed section %s is too small to contain a compression header\n"),
14240 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14242 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14244 warn (_("section '%s' has unsupported compress type: %d\n"),
14245 section
->name
, chdr
.ch_type
);
14248 uncompressed_size
= chdr
.ch_size
;
14249 start
+= compression_header_size
;
14250 size
-= compression_header_size
;
14252 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14254 /* Read the zlib header. In this case, it should be "ZLIB"
14255 followed by the uncompressed section size, 8 bytes in
14256 big-endian order. */
14257 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14258 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14259 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14260 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14261 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14262 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14263 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14264 uncompressed_size
+= start
[11];
14269 if (uncompressed_size
)
14271 if (uncompress_section_contents (&start
, uncompressed_size
,
14274 /* Free the compressed buffer, update the section buffer
14275 and the section size if uncompress is successful. */
14276 free (section
->start
);
14277 section
->start
= start
;
14281 error (_("Unable to decompress section %s\n"),
14282 printable_section_name (filedata
, sec
));
14287 section
->size
= size
;
14290 if (section
->start
== NULL
)
14293 if (debug_displays
[debug
].relocate
)
14295 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14296 & section
->reloc_info
, & section
->num_relocs
))
14301 section
->reloc_info
= NULL
;
14302 section
->num_relocs
= 0;
14308 #if HAVE_LIBDEBUGINFOD
14309 /* Return a hex string representation of the build-id. */
14311 get_build_id (void * data
)
14313 Filedata
* filedata
= (Filedata
*)data
;
14314 Elf_Internal_Shdr
* shdr
;
14317 /* Iterate through notes to find note.gnu.build-id.
14318 FIXME: Only the first note in any note section is examined. */
14319 for (i
= 0, shdr
= filedata
->section_headers
;
14320 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14323 if (shdr
->sh_type
!= SHT_NOTE
)
14328 size_t data_remaining
;
14330 Elf_External_Note
* enote
;
14331 Elf_Internal_Note inote
;
14333 bfd_vma offset
= shdr
->sh_offset
;
14334 bfd_vma align
= shdr
->sh_addralign
;
14335 bfd_vma length
= shdr
->sh_size
;
14337 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14343 else if (align
!= 4 && align
!= 8)
14349 end
= (char *) enote
+ length
;
14350 data_remaining
= end
- (char *) enote
;
14352 if (!is_ia64_vms (filedata
))
14354 min_notesz
= offsetof (Elf_External_Note
, name
);
14355 if (data_remaining
< min_notesz
)
14358 malformed note encountered in section %s whilst scanning for build-id note\n"),
14359 printable_section_name (filedata
, shdr
));
14363 data_remaining
-= min_notesz
;
14365 inote
.type
= BYTE_GET (enote
->type
);
14366 inote
.namesz
= BYTE_GET (enote
->namesz
);
14367 inote
.namedata
= enote
->name
;
14368 inote
.descsz
= BYTE_GET (enote
->descsz
);
14369 inote
.descdata
= ((char *) enote
14370 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14371 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14372 next
= ((char *) enote
14373 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14377 Elf64_External_VMS_Note
*vms_enote
;
14379 /* PR binutils/15191
14380 Make sure that there is enough data to read. */
14381 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14382 if (data_remaining
< min_notesz
)
14385 malformed note encountered in section %s whilst scanning for build-id note\n"),
14386 printable_section_name (filedata
, shdr
));
14390 data_remaining
-= min_notesz
;
14392 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14393 inote
.type
= BYTE_GET (vms_enote
->type
);
14394 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14395 inote
.namedata
= vms_enote
->name
;
14396 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14397 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14398 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14399 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14402 /* Skip malformed notes. */
14403 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14404 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14405 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14406 || ((size_t) (next
- inote
.descdata
)
14407 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14410 malformed note encountered in section %s whilst scanning for build-id note\n"),
14411 printable_section_name (filedata
, shdr
));
14416 /* Check if this is the build-id note. If so then convert the build-id
14417 bytes to a hex string. */
14418 if (inote
.namesz
> 0
14419 && const_strneq (inote
.namedata
, "GNU")
14420 && inote
.type
== NT_GNU_BUILD_ID
)
14425 build_id
= malloc (inote
.descsz
* 2 + 1);
14426 if (build_id
== NULL
)
14432 for (j
= 0; j
< inote
.descsz
; ++j
)
14433 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14434 build_id
[inote
.descsz
* 2] = '\0';
14437 return (unsigned char *) build_id
;
14444 #endif /* HAVE_LIBDEBUGINFOD */
14446 /* If this is not NULL, load_debug_section will only look for sections
14447 within the list of sections given here. */
14448 static unsigned int * section_subset
= NULL
;
14451 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14453 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14454 Elf_Internal_Shdr
* sec
;
14455 Filedata
* filedata
= (Filedata
*) data
;
14457 /* Without section headers we cannot find any sections. */
14458 if (filedata
->section_headers
== NULL
)
14461 if (filedata
->string_table
== NULL
14462 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14463 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14465 Elf_Internal_Shdr
* strs
;
14467 /* Read in the string table, so that we have section names to scan. */
14468 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14470 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14472 filedata
->string_table
14473 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14474 1, strs
->sh_size
, _("string table"));
14476 filedata
->string_table_length
14477 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14481 /* Locate the debug section. */
14482 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14484 section
->name
= section
->uncompressed_name
;
14487 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14489 section
->name
= section
->compressed_name
;
14494 /* If we're loading from a subset of sections, and we've loaded
14495 a section matching this name before, it's likely that it's a
14497 if (section_subset
!= NULL
)
14498 free_debug_section (debug
);
14500 return load_specific_debug_section (debug
, sec
, data
);
14504 free_debug_section (enum dwarf_section_display_enum debug
)
14506 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14508 if (section
->start
== NULL
)
14511 free ((char *) section
->start
);
14512 section
->start
= NULL
;
14513 section
->address
= 0;
14516 if (section
->reloc_info
!= NULL
)
14518 free (section
->reloc_info
);
14519 section
->reloc_info
= NULL
;
14520 section
->num_relocs
= 0;
14525 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14527 char * name
= SECTION_NAME (section
);
14528 const char * print_name
= printable_section_name (filedata
, section
);
14529 bfd_size_type length
;
14530 bfd_boolean result
= TRUE
;
14533 length
= section
->sh_size
;
14536 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14539 if (section
->sh_type
== SHT_NOBITS
)
14541 /* There is no point in dumping the contents of a debugging section
14542 which has the NOBITS type - the bits in the file will be random.
14543 This can happen when a file containing a .eh_frame section is
14544 stripped with the --only-keep-debug command line option. */
14545 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14550 if (const_strneq (name
, ".gnu.linkonce.wi."))
14551 name
= ".debug_info";
14553 /* See if we know how to display the contents of this section. */
14554 for (i
= 0; i
< max
; i
++)
14556 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14557 struct dwarf_section_display
* display
= debug_displays
+ i
;
14558 struct dwarf_section
* sec
= & display
->section
;
14560 if (streq (sec
->uncompressed_name
, name
)
14561 || (id
== line
&& const_strneq (name
, ".debug_line."))
14562 || streq (sec
->compressed_name
, name
))
14564 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14567 free_debug_section (id
);
14569 if (i
== line
&& const_strneq (name
, ".debug_line."))
14571 else if (streq (sec
->uncompressed_name
, name
))
14572 sec
->name
= sec
->uncompressed_name
;
14574 sec
->name
= sec
->compressed_name
;
14576 if (load_specific_debug_section (id
, section
, filedata
))
14578 /* If this debug section is part of a CU/TU set in a .dwp file,
14579 restrict load_debug_section to the sections in that set. */
14580 section_subset
= find_cu_tu_set (filedata
, shndx
);
14582 result
&= display
->display (sec
, filedata
);
14584 section_subset
= NULL
;
14586 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14587 free_debug_section (id
);
14595 printf (_("Unrecognized debug section: %s\n"), print_name
);
14602 /* Set DUMP_SECTS for all sections where dumps were requested
14603 based on section name. */
14606 initialise_dumps_byname (Filedata
* filedata
)
14608 struct dump_list_entry
* cur
;
14610 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14613 bfd_boolean any
= FALSE
;
14615 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14616 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14618 request_dump_bynumber (filedata
, i
, cur
->type
);
14623 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14629 process_section_contents (Filedata
* filedata
)
14631 Elf_Internal_Shdr
* section
;
14633 bfd_boolean res
= TRUE
;
14638 initialise_dumps_byname (filedata
);
14640 for (i
= 0, section
= filedata
->section_headers
;
14641 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14644 dump_type dump
= filedata
->dump_sects
[i
];
14646 #ifdef SUPPORT_DISASSEMBLY
14647 if (dump
& DISASS_DUMP
)
14649 if (! disassemble_section (section
, filedata
))
14653 if (dump
& HEX_DUMP
)
14655 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14659 if (dump
& RELOC_DUMP
)
14661 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14665 if (dump
& STRING_DUMP
)
14667 if (! dump_section_as_strings (section
, filedata
))
14671 if (dump
& DEBUG_DUMP
)
14673 if (! display_debug_section (i
, section
, filedata
))
14677 if (dump
& CTF_DUMP
)
14679 if (! dump_section_as_ctf (section
, filedata
))
14684 /* Check to see if the user requested a
14685 dump of a section that does not exist. */
14686 while (i
< filedata
->num_dump_sects
)
14688 if (filedata
->dump_sects
[i
])
14690 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14700 process_mips_fpe_exception (int mask
)
14704 bfd_boolean first
= TRUE
;
14706 if (mask
& OEX_FPU_INEX
)
14707 fputs ("INEX", stdout
), first
= FALSE
;
14708 if (mask
& OEX_FPU_UFLO
)
14709 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14710 if (mask
& OEX_FPU_OFLO
)
14711 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14712 if (mask
& OEX_FPU_DIV0
)
14713 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14714 if (mask
& OEX_FPU_INVAL
)
14715 printf ("%sINVAL", first
? "" : "|");
14718 fputs ("0", stdout
);
14721 /* Display's the value of TAG at location P. If TAG is
14722 greater than 0 it is assumed to be an unknown tag, and
14723 a message is printed to this effect. Otherwise it is
14724 assumed that a message has already been printed.
14726 If the bottom bit of TAG is set it assumed to have a
14727 string value, otherwise it is assumed to have an integer
14730 Returns an updated P pointing to the first unread byte
14731 beyond the end of TAG's value.
14733 Reads at or beyond END will not be made. */
14735 static unsigned char *
14736 display_tag_value (signed int tag
,
14738 const unsigned char * const end
)
14743 printf (" Tag_unknown_%d: ", tag
);
14747 warn (_("<corrupt tag>\n"));
14751 /* PR 17531 file: 027-19978-0.004. */
14752 size_t maxlen
= (end
- p
) - 1;
14757 print_symbol ((int) maxlen
, (const char *) p
);
14758 p
+= strnlen ((char *) p
, maxlen
) + 1;
14762 printf (_("<corrupt string tag>"));
14763 p
= (unsigned char *) end
;
14769 READ_ULEB (val
, p
, end
);
14770 printf ("%ld (0x%lx)\n", val
, val
);
14777 /* ARC ABI attributes section. */
14779 static unsigned char *
14780 display_arc_attribute (unsigned char * p
,
14781 const unsigned char * const end
)
14786 READ_ULEB (tag
, p
, end
);
14790 case Tag_ARC_PCS_config
:
14791 READ_ULEB (val
, p
, end
);
14792 printf (" Tag_ARC_PCS_config: ");
14796 printf (_("Absent/Non standard\n"));
14799 printf (_("Bare metal/mwdt\n"));
14802 printf (_("Bare metal/newlib\n"));
14805 printf (_("Linux/uclibc\n"));
14808 printf (_("Linux/glibc\n"));
14811 printf (_("Unknown\n"));
14816 case Tag_ARC_CPU_base
:
14817 READ_ULEB (val
, p
, end
);
14818 printf (" Tag_ARC_CPU_base: ");
14823 printf (_("Absent\n"));
14825 case TAG_CPU_ARC6xx
:
14826 printf ("ARC6xx\n");
14828 case TAG_CPU_ARC7xx
:
14829 printf ("ARC7xx\n");
14831 case TAG_CPU_ARCEM
:
14832 printf ("ARCEM\n");
14834 case TAG_CPU_ARCHS
:
14835 printf ("ARCHS\n");
14840 case Tag_ARC_CPU_variation
:
14841 READ_ULEB (val
, p
, end
);
14842 printf (" Tag_ARC_CPU_variation: ");
14846 if (val
> 0 && val
< 16)
14847 printf ("Core%d\n", val
);
14849 printf ("Unknown\n");
14853 printf (_("Absent\n"));
14858 case Tag_ARC_CPU_name
:
14859 printf (" Tag_ARC_CPU_name: ");
14860 p
= display_tag_value (-1, p
, end
);
14863 case Tag_ARC_ABI_rf16
:
14864 READ_ULEB (val
, p
, end
);
14865 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14868 case Tag_ARC_ABI_osver
:
14869 READ_ULEB (val
, p
, end
);
14870 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14873 case Tag_ARC_ABI_pic
:
14874 case Tag_ARC_ABI_sda
:
14875 READ_ULEB (val
, p
, end
);
14876 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14877 : " Tag_ARC_ABI_pic: ");
14881 printf (_("Absent\n"));
14890 printf (_("Unknown\n"));
14895 case Tag_ARC_ABI_tls
:
14896 READ_ULEB (val
, p
, end
);
14897 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14900 case Tag_ARC_ABI_enumsize
:
14901 READ_ULEB (val
, p
, end
);
14902 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14906 case Tag_ARC_ABI_exceptions
:
14907 READ_ULEB (val
, p
, end
);
14908 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14912 case Tag_ARC_ABI_double_size
:
14913 READ_ULEB (val
, p
, end
);
14914 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14917 case Tag_ARC_ISA_config
:
14918 printf (" Tag_ARC_ISA_config: ");
14919 p
= display_tag_value (-1, p
, end
);
14922 case Tag_ARC_ISA_apex
:
14923 printf (" Tag_ARC_ISA_apex: ");
14924 p
= display_tag_value (-1, p
, end
);
14927 case Tag_ARC_ISA_mpy_option
:
14928 READ_ULEB (val
, p
, end
);
14929 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14932 case Tag_ARC_ATR_version
:
14933 READ_ULEB (val
, p
, end
);
14934 printf (" Tag_ARC_ATR_version: %d\n", val
);
14938 return display_tag_value (tag
& 1, p
, end
);
14944 /* ARM EABI attributes section. */
14949 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14951 const char ** table
;
14952 } arm_attr_public_tag
;
14954 static const char * arm_attr_tag_CPU_arch
[] =
14955 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14956 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14957 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14958 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14959 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14960 {"No", "Thumb-1", "Thumb-2", "Yes"};
14961 static const char * arm_attr_tag_FP_arch
[] =
14962 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14963 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14964 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14965 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14966 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14967 "NEON for ARMv8.1"};
14968 static const char * arm_attr_tag_PCS_config
[] =
14969 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14970 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14971 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14972 {"V6", "SB", "TLS", "Unused"};
14973 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14974 {"Absolute", "PC-relative", "SB-relative", "None"};
14975 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14976 {"Absolute", "PC-relative", "None"};
14977 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14978 {"None", "direct", "GOT-indirect"};
14979 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14980 {"None", "??? 1", "2", "??? 3", "4"};
14981 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14982 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14983 {"Unused", "Needed", "Sign only"};
14984 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14985 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14986 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14987 {"Unused", "Finite", "RTABI", "IEEE 754"};
14988 static const char * arm_attr_tag_ABI_enum_size
[] =
14989 {"Unused", "small", "int", "forced to int"};
14990 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14991 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14992 static const char * arm_attr_tag_ABI_VFP_args
[] =
14993 {"AAPCS", "VFP registers", "custom", "compatible"};
14994 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14995 {"AAPCS", "WMMX registers", "custom"};
14996 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14997 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14998 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14999 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15000 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15001 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15002 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15003 static const char * arm_attr_tag_FP_HP_extension
[] =
15004 {"Not Allowed", "Allowed"};
15005 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15006 {"None", "IEEE 754", "Alternative Format"};
15007 static const char * arm_attr_tag_DSP_extension
[] =
15008 {"Follow architecture", "Allowed"};
15009 static const char * arm_attr_tag_MPextension_use
[] =
15010 {"Not Allowed", "Allowed"};
15011 static const char * arm_attr_tag_DIV_use
[] =
15012 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15013 "Allowed in v7-A with integer division extension"};
15014 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15015 static const char * arm_attr_tag_Virtualization_use
[] =
15016 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15017 "TrustZone and Virtualization Extensions"};
15018 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15019 {"Not Allowed", "Allowed"};
15021 static const char * arm_attr_tag_MVE_arch
[] =
15022 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15024 #define LOOKUP(id, name) \
15025 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15026 static arm_attr_public_tag arm_attr_public_tags
[] =
15028 {4, "CPU_raw_name", 1, NULL
},
15029 {5, "CPU_name", 1, NULL
},
15030 LOOKUP(6, CPU_arch
),
15031 {7, "CPU_arch_profile", 0, NULL
},
15032 LOOKUP(8, ARM_ISA_use
),
15033 LOOKUP(9, THUMB_ISA_use
),
15034 LOOKUP(10, FP_arch
),
15035 LOOKUP(11, WMMX_arch
),
15036 LOOKUP(12, Advanced_SIMD_arch
),
15037 LOOKUP(13, PCS_config
),
15038 LOOKUP(14, ABI_PCS_R9_use
),
15039 LOOKUP(15, ABI_PCS_RW_data
),
15040 LOOKUP(16, ABI_PCS_RO_data
),
15041 LOOKUP(17, ABI_PCS_GOT_use
),
15042 LOOKUP(18, ABI_PCS_wchar_t
),
15043 LOOKUP(19, ABI_FP_rounding
),
15044 LOOKUP(20, ABI_FP_denormal
),
15045 LOOKUP(21, ABI_FP_exceptions
),
15046 LOOKUP(22, ABI_FP_user_exceptions
),
15047 LOOKUP(23, ABI_FP_number_model
),
15048 {24, "ABI_align_needed", 0, NULL
},
15049 {25, "ABI_align_preserved", 0, NULL
},
15050 LOOKUP(26, ABI_enum_size
),
15051 LOOKUP(27, ABI_HardFP_use
),
15052 LOOKUP(28, ABI_VFP_args
),
15053 LOOKUP(29, ABI_WMMX_args
),
15054 LOOKUP(30, ABI_optimization_goals
),
15055 LOOKUP(31, ABI_FP_optimization_goals
),
15056 {32, "compatibility", 0, NULL
},
15057 LOOKUP(34, CPU_unaligned_access
),
15058 LOOKUP(36, FP_HP_extension
),
15059 LOOKUP(38, ABI_FP_16bit_format
),
15060 LOOKUP(42, MPextension_use
),
15061 LOOKUP(44, DIV_use
),
15062 LOOKUP(46, DSP_extension
),
15063 LOOKUP(48, MVE_arch
),
15064 {64, "nodefaults", 0, NULL
},
15065 {65, "also_compatible_with", 0, NULL
},
15066 LOOKUP(66, T2EE_use
),
15067 {67, "conformance", 1, NULL
},
15068 LOOKUP(68, Virtualization_use
),
15069 LOOKUP(70, MPextension_use_legacy
)
15073 static unsigned char *
15074 display_arm_attribute (unsigned char * p
,
15075 const unsigned char * const end
)
15079 arm_attr_public_tag
* attr
;
15083 READ_ULEB (tag
, p
, end
);
15085 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15087 if (arm_attr_public_tags
[i
].tag
== tag
)
15089 attr
= &arm_attr_public_tags
[i
];
15096 printf (" Tag_%s: ", attr
->name
);
15097 switch (attr
->type
)
15102 case 7: /* Tag_CPU_arch_profile. */
15103 READ_ULEB (val
, p
, end
);
15106 case 0: printf (_("None\n")); break;
15107 case 'A': printf (_("Application\n")); break;
15108 case 'R': printf (_("Realtime\n")); break;
15109 case 'M': printf (_("Microcontroller\n")); break;
15110 case 'S': printf (_("Application or Realtime\n")); break;
15111 default: printf ("??? (%d)\n", val
); break;
15115 case 24: /* Tag_align_needed. */
15116 READ_ULEB (val
, p
, end
);
15119 case 0: printf (_("None\n")); break;
15120 case 1: printf (_("8-byte\n")); break;
15121 case 2: printf (_("4-byte\n")); break;
15122 case 3: printf ("??? 3\n"); break;
15125 printf (_("8-byte and up to %d-byte extended\n"),
15128 printf ("??? (%d)\n", val
);
15133 case 25: /* Tag_align_preserved. */
15134 READ_ULEB (val
, p
, end
);
15137 case 0: printf (_("None\n")); break;
15138 case 1: printf (_("8-byte, except leaf SP\n")); break;
15139 case 2: printf (_("8-byte\n")); break;
15140 case 3: printf ("??? 3\n"); break;
15143 printf (_("8-byte and up to %d-byte extended\n"),
15146 printf ("??? (%d)\n", val
);
15151 case 32: /* Tag_compatibility. */
15153 READ_ULEB (val
, p
, end
);
15154 printf (_("flag = %d, vendor = "), val
);
15157 size_t maxlen
= (end
- p
) - 1;
15159 print_symbol ((int) maxlen
, (const char *) p
);
15160 p
+= strnlen ((char *) p
, maxlen
) + 1;
15164 printf (_("<corrupt>"));
15165 p
= (unsigned char *) end
;
15171 case 64: /* Tag_nodefaults. */
15172 /* PR 17531: file: 001-505008-0.01. */
15175 printf (_("True\n"));
15178 case 65: /* Tag_also_compatible_with. */
15179 READ_ULEB (val
, p
, end
);
15180 if (val
== 6 /* Tag_CPU_arch. */)
15182 READ_ULEB (val
, p
, end
);
15183 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15184 printf ("??? (%d)\n", val
);
15186 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15190 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15195 printf (_("<unknown: %d>\n"), tag
);
15201 return display_tag_value (-1, p
, end
);
15203 return display_tag_value (0, p
, end
);
15206 assert (attr
->type
& 0x80);
15207 READ_ULEB (val
, p
, end
);
15208 type
= attr
->type
& 0x7f;
15210 printf ("??? (%d)\n", val
);
15212 printf ("%s\n", attr
->table
[val
]);
15217 return display_tag_value (tag
, p
, end
);
15220 static unsigned char *
15221 display_gnu_attribute (unsigned char * p
,
15222 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15223 const unsigned char * const end
)
15228 READ_ULEB (tag
, p
, end
);
15230 /* Tag_compatibility is the only generic GNU attribute defined at
15234 READ_ULEB (val
, p
, end
);
15236 printf (_("flag = %d, vendor = "), val
);
15239 printf (_("<corrupt>\n"));
15240 warn (_("corrupt vendor attribute\n"));
15246 size_t maxlen
= (end
- p
) - 1;
15248 print_symbol ((int) maxlen
, (const char *) p
);
15249 p
+= strnlen ((char *) p
, maxlen
) + 1;
15253 printf (_("<corrupt>"));
15254 p
= (unsigned char *) end
;
15261 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15262 return display_proc_gnu_attribute (p
, tag
, end
);
15264 return display_tag_value (tag
, p
, end
);
15267 static unsigned char *
15268 display_power_gnu_attribute (unsigned char * p
,
15270 const unsigned char * const end
)
15274 if (tag
== Tag_GNU_Power_ABI_FP
)
15276 printf (" Tag_GNU_Power_ABI_FP: ");
15279 printf (_("<corrupt>\n"));
15282 READ_ULEB (val
, p
, end
);
15285 printf ("(%#x), ", val
);
15290 printf (_("unspecified hard/soft float, "));
15293 printf (_("hard float, "));
15296 printf (_("soft float, "));
15299 printf (_("single-precision hard float, "));
15306 printf (_("unspecified long double\n"));
15309 printf (_("128-bit IBM long double\n"));
15312 printf (_("64-bit long double\n"));
15315 printf (_("128-bit IEEE long double\n"));
15321 if (tag
== Tag_GNU_Power_ABI_Vector
)
15323 printf (" Tag_GNU_Power_ABI_Vector: ");
15326 printf (_("<corrupt>\n"));
15329 READ_ULEB (val
, p
, end
);
15332 printf ("(%#x), ", val
);
15337 printf (_("unspecified\n"));
15340 printf (_("generic\n"));
15343 printf ("AltiVec\n");
15352 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15354 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15357 printf (_("<corrupt>\n"));
15360 READ_ULEB (val
, p
, end
);
15363 printf ("(%#x), ", val
);
15368 printf (_("unspecified\n"));
15371 printf ("r3/r4\n");
15374 printf (_("memory\n"));
15383 return display_tag_value (tag
& 1, p
, end
);
15386 static unsigned char *
15387 display_s390_gnu_attribute (unsigned char * p
,
15389 const unsigned char * const end
)
15393 if (tag
== Tag_GNU_S390_ABI_Vector
)
15395 printf (" Tag_GNU_S390_ABI_Vector: ");
15396 READ_ULEB (val
, p
, end
);
15401 printf (_("any\n"));
15404 printf (_("software\n"));
15407 printf (_("hardware\n"));
15410 printf ("??? (%d)\n", val
);
15416 return display_tag_value (tag
& 1, p
, end
);
15420 display_sparc_hwcaps (unsigned int mask
)
15424 bfd_boolean first
= TRUE
;
15426 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15427 fputs ("mul32", stdout
), first
= FALSE
;
15428 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15429 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15430 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15431 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15432 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15433 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15434 if (mask
& ELF_SPARC_HWCAP_POPC
)
15435 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15436 if (mask
& ELF_SPARC_HWCAP_VIS
)
15437 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15438 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15439 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15440 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15441 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15442 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15443 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15444 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15445 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15446 if (mask
& ELF_SPARC_HWCAP_HPC
)
15447 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15448 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15449 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15450 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15451 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15452 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15453 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15454 if (mask
& ELF_SPARC_HWCAP_IMA
)
15455 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15456 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15457 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15460 fputc ('0', stdout
);
15461 fputc ('\n', stdout
);
15465 display_sparc_hwcaps2 (unsigned int mask
)
15469 bfd_boolean first
= TRUE
;
15471 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15472 fputs ("fjathplus", stdout
), first
= FALSE
;
15473 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15474 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15475 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15476 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15477 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15478 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15479 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15480 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15481 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15482 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15483 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15484 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15485 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15486 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15487 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15488 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15489 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15490 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15491 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15492 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15495 fputc ('0', stdout
);
15496 fputc ('\n', stdout
);
15499 static unsigned char *
15500 display_sparc_gnu_attribute (unsigned char * p
,
15502 const unsigned char * const end
)
15506 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15508 READ_ULEB (val
, p
, end
);
15509 printf (" Tag_GNU_Sparc_HWCAPS: ");
15510 display_sparc_hwcaps (val
);
15513 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15515 READ_ULEB (val
, p
, end
);
15516 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15517 display_sparc_hwcaps2 (val
);
15521 return display_tag_value (tag
, p
, end
);
15525 print_mips_fp_abi_value (unsigned int val
)
15529 case Val_GNU_MIPS_ABI_FP_ANY
:
15530 printf (_("Hard or soft float\n"));
15532 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15533 printf (_("Hard float (double precision)\n"));
15535 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15536 printf (_("Hard float (single precision)\n"));
15538 case Val_GNU_MIPS_ABI_FP_SOFT
:
15539 printf (_("Soft float\n"));
15541 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15542 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15544 case Val_GNU_MIPS_ABI_FP_XX
:
15545 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15547 case Val_GNU_MIPS_ABI_FP_64
:
15548 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15550 case Val_GNU_MIPS_ABI_FP_64A
:
15551 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15553 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15554 printf (_("NaN 2008 compatibility\n"));
15557 printf ("??? (%d)\n", val
);
15562 static unsigned char *
15563 display_mips_gnu_attribute (unsigned char * p
,
15565 const unsigned char * const end
)
15567 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15571 printf (" Tag_GNU_MIPS_ABI_FP: ");
15572 READ_ULEB (val
, p
, end
);
15573 print_mips_fp_abi_value (val
);
15577 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15581 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15582 READ_ULEB (val
, p
, end
);
15586 case Val_GNU_MIPS_ABI_MSA_ANY
:
15587 printf (_("Any MSA or not\n"));
15589 case Val_GNU_MIPS_ABI_MSA_128
:
15590 printf (_("128-bit MSA\n"));
15593 printf ("??? (%d)\n", val
);
15599 return display_tag_value (tag
& 1, p
, end
);
15602 static unsigned char *
15603 display_tic6x_attribute (unsigned char * p
,
15604 const unsigned char * const end
)
15609 READ_ULEB (tag
, p
, end
);
15614 printf (" Tag_ISA: ");
15615 READ_ULEB (val
, p
, end
);
15619 case C6XABI_Tag_ISA_none
:
15620 printf (_("None\n"));
15622 case C6XABI_Tag_ISA_C62X
:
15625 case C6XABI_Tag_ISA_C67X
:
15628 case C6XABI_Tag_ISA_C67XP
:
15629 printf ("C67x+\n");
15631 case C6XABI_Tag_ISA_C64X
:
15634 case C6XABI_Tag_ISA_C64XP
:
15635 printf ("C64x+\n");
15637 case C6XABI_Tag_ISA_C674X
:
15638 printf ("C674x\n");
15641 printf ("??? (%d)\n", val
);
15646 case Tag_ABI_wchar_t
:
15647 printf (" Tag_ABI_wchar_t: ");
15648 READ_ULEB (val
, p
, end
);
15652 printf (_("Not used\n"));
15655 printf (_("2 bytes\n"));
15658 printf (_("4 bytes\n"));
15661 printf ("??? (%d)\n", val
);
15666 case Tag_ABI_stack_align_needed
:
15667 printf (" Tag_ABI_stack_align_needed: ");
15668 READ_ULEB (val
, p
, end
);
15672 printf (_("8-byte\n"));
15675 printf (_("16-byte\n"));
15678 printf ("??? (%d)\n", val
);
15683 case Tag_ABI_stack_align_preserved
:
15684 READ_ULEB (val
, p
, end
);
15685 printf (" Tag_ABI_stack_align_preserved: ");
15689 printf (_("8-byte\n"));
15692 printf (_("16-byte\n"));
15695 printf ("??? (%d)\n", val
);
15701 READ_ULEB (val
, p
, end
);
15702 printf (" Tag_ABI_DSBT: ");
15706 printf (_("DSBT addressing not used\n"));
15709 printf (_("DSBT addressing used\n"));
15712 printf ("??? (%d)\n", val
);
15718 READ_ULEB (val
, p
, end
);
15719 printf (" Tag_ABI_PID: ");
15723 printf (_("Data addressing position-dependent\n"));
15726 printf (_("Data addressing position-independent, GOT near DP\n"));
15729 printf (_("Data addressing position-independent, GOT far from DP\n"));
15732 printf ("??? (%d)\n", val
);
15738 READ_ULEB (val
, p
, end
);
15739 printf (" Tag_ABI_PIC: ");
15743 printf (_("Code addressing position-dependent\n"));
15746 printf (_("Code addressing position-independent\n"));
15749 printf ("??? (%d)\n", val
);
15754 case Tag_ABI_array_object_alignment
:
15755 READ_ULEB (val
, p
, end
);
15756 printf (" Tag_ABI_array_object_alignment: ");
15760 printf (_("8-byte\n"));
15763 printf (_("4-byte\n"));
15766 printf (_("16-byte\n"));
15769 printf ("??? (%d)\n", val
);
15774 case Tag_ABI_array_object_align_expected
:
15775 READ_ULEB (val
, p
, end
);
15776 printf (" Tag_ABI_array_object_align_expected: ");
15780 printf (_("8-byte\n"));
15783 printf (_("4-byte\n"));
15786 printf (_("16-byte\n"));
15789 printf ("??? (%d)\n", val
);
15794 case Tag_ABI_compatibility
:
15796 READ_ULEB (val
, p
, end
);
15797 printf (" Tag_ABI_compatibility: ");
15798 printf (_("flag = %d, vendor = "), val
);
15801 size_t maxlen
= (end
- p
) - 1;
15803 print_symbol ((int) maxlen
, (const char *) p
);
15804 p
+= strnlen ((char *) p
, maxlen
) + 1;
15808 printf (_("<corrupt>"));
15809 p
= (unsigned char *) end
;
15815 case Tag_ABI_conformance
:
15817 printf (" Tag_ABI_conformance: \"");
15820 size_t maxlen
= (end
- p
) - 1;
15822 print_symbol ((int) maxlen
, (const char *) p
);
15823 p
+= strnlen ((char *) p
, maxlen
) + 1;
15827 printf (_("<corrupt>"));
15828 p
= (unsigned char *) end
;
15835 return display_tag_value (tag
, p
, end
);
15839 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15841 unsigned long addr
= 0;
15842 size_t bytes
= end
- p
;
15849 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15851 printf (" 0x%8.8lx ", addr
);
15853 for (j
= 0; j
< 16; j
++)
15856 printf ("%2.2x", p
[j
]);
15864 for (j
= 0; j
< lbytes
; j
++)
15867 if (k
>= ' ' && k
< 0x7f)
15883 static unsigned char *
15884 display_msp430x_attribute (unsigned char * p
,
15885 const unsigned char * const end
)
15890 READ_ULEB (tag
, p
, end
);
15894 case OFBA_MSPABI_Tag_ISA
:
15895 printf (" Tag_ISA: ");
15896 READ_ULEB (val
, p
, end
);
15899 case 0: printf (_("None\n")); break;
15900 case 1: printf (_("MSP430\n")); break;
15901 case 2: printf (_("MSP430X\n")); break;
15902 default: printf ("??? (%d)\n", val
); break;
15906 case OFBA_MSPABI_Tag_Code_Model
:
15907 printf (" Tag_Code_Model: ");
15908 READ_ULEB (val
, p
, end
);
15911 case 0: printf (_("None\n")); break;
15912 case 1: printf (_("Small\n")); break;
15913 case 2: printf (_("Large\n")); break;
15914 default: printf ("??? (%d)\n", val
); break;
15918 case OFBA_MSPABI_Tag_Data_Model
:
15919 printf (" Tag_Data_Model: ");
15920 READ_ULEB (val
, p
, end
);
15923 case 0: printf (_("None\n")); break;
15924 case 1: printf (_("Small\n")); break;
15925 case 2: printf (_("Large\n")); break;
15926 case 3: printf (_("Restricted Large\n")); break;
15927 default: printf ("??? (%d)\n", val
); break;
15932 printf (_(" <unknown tag %d>: "), tag
);
15939 size_t maxlen
= (end
- p
) - 1;
15941 print_symbol ((int) maxlen
, (const char *) p
);
15942 p
+= strnlen ((char *) p
, maxlen
) + 1;
15946 printf (_("<corrupt>"));
15947 p
= (unsigned char *) end
;
15953 READ_ULEB (val
, p
, end
);
15954 printf ("%d (0x%x)\n", val
, val
);
15963 static unsigned char *
15964 display_msp430_gnu_attribute (unsigned char * p
,
15966 const unsigned char * const end
)
15968 if (tag
== Tag_GNU_MSP430_Data_Region
)
15972 printf (" Tag_GNU_MSP430_Data_Region: ");
15973 READ_ULEB (val
, p
, end
);
15977 case Val_GNU_MSP430_Data_Region_Any
:
15978 printf (_("Any Region\n"));
15980 case Val_GNU_MSP430_Data_Region_Lower
:
15981 printf (_("Lower Region Only\n"));
15984 printf ("??? (%u)\n", val
);
15988 return display_tag_value (tag
& 1, p
, end
);
15991 struct riscv_attr_tag_t
{
15996 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15998 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16001 T(priv_spec_minor
),
16002 T(priv_spec_revision
),
16003 T(unaligned_access
),
16008 static unsigned char *
16009 display_riscv_attribute (unsigned char *p
,
16010 const unsigned char * const end
)
16014 struct riscv_attr_tag_t
*attr
= NULL
;
16017 READ_ULEB (tag
, p
, end
);
16019 /* Find the name of attribute. */
16020 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16022 if (riscv_attr_tag
[i
].tag
== tag
)
16024 attr
= &riscv_attr_tag
[i
];
16030 printf (" %s: ", attr
->name
);
16032 return display_tag_value (tag
, p
, end
);
16036 case Tag_RISCV_priv_spec
:
16037 case Tag_RISCV_priv_spec_minor
:
16038 case Tag_RISCV_priv_spec_revision
:
16039 READ_ULEB (val
, p
, end
);
16040 printf (_("%u\n"), val
);
16042 case Tag_RISCV_unaligned_access
:
16043 READ_ULEB (val
, p
, end
);
16047 printf (_("No unaligned access\n"));
16050 printf (_("Unaligned access\n"));
16054 case Tag_RISCV_stack_align
:
16055 READ_ULEB (val
, p
, end
);
16056 printf (_("%u-bytes\n"), val
);
16058 case Tag_RISCV_arch
:
16059 p
= display_tag_value (-1, p
, end
);
16062 return display_tag_value (tag
, p
, end
);
16069 process_attributes (Filedata
* filedata
,
16070 const char * public_name
,
16071 unsigned int proc_type
,
16072 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16073 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16075 Elf_Internal_Shdr
* sect
;
16077 bfd_boolean res
= TRUE
;
16079 /* Find the section header so that we get the size. */
16080 for (i
= 0, sect
= filedata
->section_headers
;
16081 i
< filedata
->file_header
.e_shnum
;
16084 unsigned char * contents
;
16087 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16090 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16091 sect
->sh_size
, _("attributes"));
16092 if (contents
== NULL
)
16099 /* The first character is the version of the attributes.
16100 Currently only version 1, (aka 'A') is recognised here. */
16103 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16108 bfd_vma section_len
;
16110 section_len
= sect
->sh_size
- 1;
16113 while (section_len
> 0)
16116 unsigned int namelen
;
16117 bfd_boolean public_section
;
16118 bfd_boolean gnu_section
;
16120 if (section_len
<= 4)
16122 error (_("Tag section ends prematurely\n"));
16126 attr_len
= byte_get (p
, 4);
16129 if (attr_len
> section_len
)
16131 error (_("Bad attribute length (%u > %u)\n"),
16132 (unsigned) attr_len
, (unsigned) section_len
);
16133 attr_len
= section_len
;
16136 /* PR 17531: file: 001-101425-0.004 */
16137 else if (attr_len
< 5)
16139 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16144 section_len
-= attr_len
;
16147 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16148 if (namelen
== 0 || namelen
>= attr_len
)
16150 error (_("Corrupt attribute section name\n"));
16155 printf (_("Attribute Section: "));
16156 print_symbol (INT_MAX
, (const char *) p
);
16159 if (public_name
&& streq ((char *) p
, public_name
))
16160 public_section
= TRUE
;
16162 public_section
= FALSE
;
16164 if (streq ((char *) p
, "gnu"))
16165 gnu_section
= TRUE
;
16167 gnu_section
= FALSE
;
16170 attr_len
-= namelen
;
16172 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16177 unsigned char * end
;
16179 /* PR binutils/17531: Safe handling of corrupt files. */
16182 error (_("Unused bytes at end of section\n"));
16189 size
= byte_get (p
, 4);
16190 if (size
> attr_len
)
16192 error (_("Bad subsection length (%u > %u)\n"),
16193 (unsigned) size
, (unsigned) attr_len
);
16197 /* PR binutils/17531: Safe handling of corrupt files. */
16200 error (_("Bad subsection length (%u < 6)\n"),
16208 end
= p
+ size
- 1;
16209 assert (end
<= contents
+ sect
->sh_size
);
16215 printf (_("File Attributes\n"));
16218 printf (_("Section Attributes:"));
16221 printf (_("Symbol Attributes:"));
16222 /* Fall through. */
16226 READ_ULEB (val
, p
, end
);
16229 printf (" %d", val
);
16234 printf (_("Unknown tag: %d\n"), tag
);
16235 public_section
= FALSE
;
16239 if (public_section
&& display_pub_attribute
!= NULL
)
16242 p
= display_pub_attribute (p
, end
);
16245 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16248 p
= display_gnu_attribute (p
,
16249 display_proc_gnu_attribute
,
16255 printf (_(" Unknown attribute:\n"));
16256 display_raw_attribute (p
, end
);
16271 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16272 Print the Address, Access and Initial fields of an entry at VMA ADDR
16273 and return the VMA of the next entry, or -1 if there was a problem.
16274 Does not read from DATA_END or beyond. */
16277 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16278 unsigned char * data_end
)
16281 print_vma (addr
, LONG_HEX
);
16283 if (addr
< pltgot
+ 0xfff0)
16284 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16286 printf ("%10s", "");
16289 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16293 unsigned char * from
= data
+ addr
- pltgot
;
16295 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16297 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16298 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16299 return (bfd_vma
) -1;
16303 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16304 print_vma (entry
, LONG_HEX
);
16307 return addr
+ (is_32bit_elf
? 4 : 8);
16310 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16311 PLTGOT. Print the Address and Initial fields of an entry at VMA
16312 ADDR and return the VMA of the next entry. */
16315 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16318 print_vma (addr
, LONG_HEX
);
16321 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16326 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16327 print_vma (entry
, LONG_HEX
);
16329 return addr
+ (is_32bit_elf
? 4 : 8);
16333 print_mips_ases (unsigned int mask
)
16335 if (mask
& AFL_ASE_DSP
)
16336 fputs ("\n\tDSP ASE", stdout
);
16337 if (mask
& AFL_ASE_DSPR2
)
16338 fputs ("\n\tDSP R2 ASE", stdout
);
16339 if (mask
& AFL_ASE_DSPR3
)
16340 fputs ("\n\tDSP R3 ASE", stdout
);
16341 if (mask
& AFL_ASE_EVA
)
16342 fputs ("\n\tEnhanced VA Scheme", stdout
);
16343 if (mask
& AFL_ASE_MCU
)
16344 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16345 if (mask
& AFL_ASE_MDMX
)
16346 fputs ("\n\tMDMX ASE", stdout
);
16347 if (mask
& AFL_ASE_MIPS3D
)
16348 fputs ("\n\tMIPS-3D ASE", stdout
);
16349 if (mask
& AFL_ASE_MT
)
16350 fputs ("\n\tMT ASE", stdout
);
16351 if (mask
& AFL_ASE_SMARTMIPS
)
16352 fputs ("\n\tSmartMIPS ASE", stdout
);
16353 if (mask
& AFL_ASE_VIRT
)
16354 fputs ("\n\tVZ ASE", stdout
);
16355 if (mask
& AFL_ASE_MSA
)
16356 fputs ("\n\tMSA ASE", stdout
);
16357 if (mask
& AFL_ASE_MIPS16
)
16358 fputs ("\n\tMIPS16 ASE", stdout
);
16359 if (mask
& AFL_ASE_MICROMIPS
)
16360 fputs ("\n\tMICROMIPS ASE", stdout
);
16361 if (mask
& AFL_ASE_XPA
)
16362 fputs ("\n\tXPA ASE", stdout
);
16363 if (mask
& AFL_ASE_MIPS16E2
)
16364 fputs ("\n\tMIPS16e2 ASE", stdout
);
16365 if (mask
& AFL_ASE_CRC
)
16366 fputs ("\n\tCRC ASE", stdout
);
16367 if (mask
& AFL_ASE_GINV
)
16368 fputs ("\n\tGINV ASE", stdout
);
16369 if (mask
& AFL_ASE_LOONGSON_MMI
)
16370 fputs ("\n\tLoongson MMI ASE", stdout
);
16371 if (mask
& AFL_ASE_LOONGSON_CAM
)
16372 fputs ("\n\tLoongson CAM ASE", stdout
);
16373 if (mask
& AFL_ASE_LOONGSON_EXT
)
16374 fputs ("\n\tLoongson EXT ASE", stdout
);
16375 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16376 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16378 fprintf (stdout
, "\n\t%s", _("None"));
16379 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16380 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16384 print_mips_isa_ext (unsigned int isa_ext
)
16389 fputs (_("None"), stdout
);
16392 fputs ("RMI XLR", stdout
);
16394 case AFL_EXT_OCTEON3
:
16395 fputs ("Cavium Networks Octeon3", stdout
);
16397 case AFL_EXT_OCTEON2
:
16398 fputs ("Cavium Networks Octeon2", stdout
);
16400 case AFL_EXT_OCTEONP
:
16401 fputs ("Cavium Networks OcteonP", stdout
);
16403 case AFL_EXT_OCTEON
:
16404 fputs ("Cavium Networks Octeon", stdout
);
16407 fputs ("Toshiba R5900", stdout
);
16410 fputs ("MIPS R4650", stdout
);
16413 fputs ("LSI R4010", stdout
);
16416 fputs ("NEC VR4100", stdout
);
16419 fputs ("Toshiba R3900", stdout
);
16421 case AFL_EXT_10000
:
16422 fputs ("MIPS R10000", stdout
);
16425 fputs ("Broadcom SB-1", stdout
);
16428 fputs ("NEC VR4111/VR4181", stdout
);
16431 fputs ("NEC VR4120", stdout
);
16434 fputs ("NEC VR5400", stdout
);
16437 fputs ("NEC VR5500", stdout
);
16439 case AFL_EXT_LOONGSON_2E
:
16440 fputs ("ST Microelectronics Loongson 2E", stdout
);
16442 case AFL_EXT_LOONGSON_2F
:
16443 fputs ("ST Microelectronics Loongson 2F", stdout
);
16445 case AFL_EXT_INTERAPTIV_MR2
:
16446 fputs ("Imagination interAptiv MR2", stdout
);
16449 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16454 get_mips_reg_size (int reg_size
)
16456 return (reg_size
== AFL_REG_NONE
) ? 0
16457 : (reg_size
== AFL_REG_32
) ? 32
16458 : (reg_size
== AFL_REG_64
) ? 64
16459 : (reg_size
== AFL_REG_128
) ? 128
16464 process_mips_specific (Filedata
* filedata
)
16466 Elf_Internal_Dyn
* entry
;
16467 Elf_Internal_Shdr
*sect
= NULL
;
16468 size_t liblist_offset
= 0;
16469 size_t liblistno
= 0;
16470 size_t conflictsno
= 0;
16471 size_t options_offset
= 0;
16472 size_t conflicts_offset
= 0;
16473 size_t pltrelsz
= 0;
16475 bfd_vma pltgot
= 0;
16476 bfd_vma mips_pltgot
= 0;
16477 bfd_vma jmprel
= 0;
16478 bfd_vma local_gotno
= 0;
16479 bfd_vma gotsym
= 0;
16480 bfd_vma symtabno
= 0;
16481 bfd_boolean res
= TRUE
;
16483 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16484 display_mips_gnu_attribute
))
16487 sect
= find_section (filedata
, ".MIPS.abiflags");
16491 Elf_External_ABIFlags_v0
*abiflags_ext
;
16492 Elf_Internal_ABIFlags_v0 abiflags_in
;
16494 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16496 error (_("Corrupt MIPS ABI Flags section.\n"));
16501 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16502 sect
->sh_size
, _("MIPS ABI Flags section"));
16505 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16506 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16507 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16508 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16509 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16510 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16511 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16512 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16513 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16514 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16515 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16517 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16518 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16519 if (abiflags_in
.isa_rev
> 1)
16520 printf ("r%d", abiflags_in
.isa_rev
);
16521 printf ("\nGPR size: %d",
16522 get_mips_reg_size (abiflags_in
.gpr_size
));
16523 printf ("\nCPR1 size: %d",
16524 get_mips_reg_size (abiflags_in
.cpr1_size
));
16525 printf ("\nCPR2 size: %d",
16526 get_mips_reg_size (abiflags_in
.cpr2_size
));
16527 fputs ("\nFP ABI: ", stdout
);
16528 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16529 fputs ("ISA Extension: ", stdout
);
16530 print_mips_isa_ext (abiflags_in
.isa_ext
);
16531 fputs ("\nASEs:", stdout
);
16532 print_mips_ases (abiflags_in
.ases
);
16533 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16534 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16535 fputc ('\n', stdout
);
16536 free (abiflags_ext
);
16541 /* We have a lot of special sections. Thanks SGI! */
16542 if (dynamic_section
== NULL
)
16544 /* No dynamic information available. See if there is static GOT. */
16545 sect
= find_section (filedata
, ".got");
16548 unsigned char *data_end
;
16549 unsigned char *data
;
16553 pltgot
= sect
->sh_addr
;
16556 addr_size
= (is_32bit_elf
? 4 : 8);
16557 end
= pltgot
+ sect
->sh_size
;
16559 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16561 _("Global Offset Table data"));
16562 /* PR 12855: Null data is handled gracefully throughout. */
16563 data_end
= data
+ (end
- pltgot
);
16565 printf (_("\nStatic GOT:\n"));
16566 printf (_(" Canonical gp value: "));
16567 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16570 /* In a dynamic binary GOT[0] is reserved for the dynamic
16571 loader to store the lazy resolver pointer, however in
16572 a static binary it may well have been omitted and GOT
16573 reduced to a table of addresses.
16574 PR 21344: Check for the entry being fully available
16575 before fetching it. */
16577 && data
+ ent
- pltgot
+ addr_size
<= data_end
16578 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16580 printf (_(" Reserved entries:\n"));
16581 printf (_(" %*s %10s %*s\n"),
16582 addr_size
* 2, _("Address"), _("Access"),
16583 addr_size
* 2, _("Value"));
16584 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16586 if (ent
== (bfd_vma
) -1)
16587 goto sgot_print_fail
;
16589 /* Check for the MSB of GOT[1] being set, identifying a
16590 GNU object. This entry will be used by some runtime
16591 loaders, to store the module pointer. Otherwise this
16592 is an ordinary local entry.
16593 PR 21344: Check for the entry being fully available
16594 before fetching it. */
16596 && data
+ ent
- pltgot
+ addr_size
<= data_end
16597 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16598 >> (addr_size
* 8 - 1)) != 0)
16600 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16602 if (ent
== (bfd_vma
) -1)
16603 goto sgot_print_fail
;
16608 if (data
!= NULL
&& ent
< end
)
16610 printf (_(" Local entries:\n"));
16611 printf (" %*s %10s %*s\n",
16612 addr_size
* 2, _("Address"), _("Access"),
16613 addr_size
* 2, _("Value"));
16616 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16618 if (ent
== (bfd_vma
) -1)
16619 goto sgot_print_fail
;
16631 for (entry
= dynamic_section
;
16632 /* PR 17531 file: 012-50589-0.004. */
16633 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16635 switch (entry
->d_tag
)
16637 case DT_MIPS_LIBLIST
:
16639 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16640 liblistno
* sizeof (Elf32_External_Lib
));
16642 case DT_MIPS_LIBLISTNO
:
16643 liblistno
= entry
->d_un
.d_val
;
16645 case DT_MIPS_OPTIONS
:
16646 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16648 case DT_MIPS_CONFLICT
:
16650 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16651 conflictsno
* sizeof (Elf32_External_Conflict
));
16653 case DT_MIPS_CONFLICTNO
:
16654 conflictsno
= entry
->d_un
.d_val
;
16657 pltgot
= entry
->d_un
.d_ptr
;
16659 case DT_MIPS_LOCAL_GOTNO
:
16660 local_gotno
= entry
->d_un
.d_val
;
16662 case DT_MIPS_GOTSYM
:
16663 gotsym
= entry
->d_un
.d_val
;
16665 case DT_MIPS_SYMTABNO
:
16666 symtabno
= entry
->d_un
.d_val
;
16668 case DT_MIPS_PLTGOT
:
16669 mips_pltgot
= entry
->d_un
.d_ptr
;
16672 pltrel
= entry
->d_un
.d_val
;
16675 pltrelsz
= entry
->d_un
.d_val
;
16678 jmprel
= entry
->d_un
.d_ptr
;
16684 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16686 Elf32_External_Lib
* elib
;
16689 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16690 sizeof (Elf32_External_Lib
),
16692 _("liblist section data"));
16695 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16696 "\nSection '.liblist' contains %lu entries:\n",
16697 (unsigned long) liblistno
),
16698 (unsigned long) liblistno
);
16699 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16702 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16709 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16710 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16711 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16712 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16713 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16715 tmp
= gmtime (&atime
);
16716 snprintf (timebuf
, sizeof (timebuf
),
16717 "%04u-%02u-%02uT%02u:%02u:%02u",
16718 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16719 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16721 printf ("%3lu: ", (unsigned long) cnt
);
16722 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16723 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16725 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16726 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16727 liblist
.l_version
);
16729 if (liblist
.l_flags
== 0)
16733 static const struct
16740 { " EXACT_MATCH", LL_EXACT_MATCH
},
16741 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16742 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16743 { " EXPORTS", LL_EXPORTS
},
16744 { " DELAY_LOAD", LL_DELAY_LOAD
},
16745 { " DELTA", LL_DELTA
}
16747 int flags
= liblist
.l_flags
;
16750 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16751 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16753 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16754 flags
^= l_flags_vals
[fcnt
].bit
;
16757 printf (" %#x", (unsigned int) flags
);
16769 if (options_offset
!= 0)
16771 Elf_External_Options
* eopt
;
16774 sect
= filedata
->section_headers
;
16776 /* Find the section header so that we get the size. */
16777 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16778 /* PR 17533 file: 012-277276-0.004. */
16781 error (_("No MIPS_OPTIONS header found\n"));
16785 if (sect
->sh_size
< sizeof (* eopt
))
16787 error (_("The MIPS options section is too small.\n"));
16791 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16792 sect
->sh_size
, _("options"));
16795 Elf_Internal_Options
* iopt
;
16796 Elf_Internal_Options
* option
;
16797 Elf_Internal_Options
* iopt_end
;
16799 iopt
= (Elf_Internal_Options
*)
16800 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16803 error (_("Out of memory allocating space for MIPS options\n"));
16809 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16811 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16813 Elf_External_Options
* eoption
;
16815 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16817 option
->kind
= BYTE_GET (eoption
->kind
);
16818 option
->size
= BYTE_GET (eoption
->size
);
16819 option
->section
= BYTE_GET (eoption
->section
);
16820 option
->info
= BYTE_GET (eoption
->info
);
16822 /* PR 17531: file: ffa0fa3b. */
16823 if (option
->size
< sizeof (* eopt
)
16824 || offset
+ option
->size
> sect
->sh_size
)
16826 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16829 offset
+= option
->size
;
16835 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16836 "\nSection '%s' contains %d entries:\n",
16838 printable_section_name (filedata
, sect
), cnt
);
16847 switch (option
->kind
)
16850 /* This shouldn't happen. */
16851 printf (" NULL %d %lx", option
->section
, option
->info
);
16855 printf (" REGINFO ");
16856 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16858 Elf32_External_RegInfo
* ereg
;
16859 Elf32_RegInfo reginfo
;
16862 if (option
+ 2 > iopt_end
)
16864 printf (_("<corrupt>\n"));
16865 error (_("Truncated MIPS REGINFO option\n"));
16870 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16872 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16873 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16874 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16875 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16876 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16877 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16879 printf ("GPR %08lx GP 0x%lx\n",
16880 reginfo
.ri_gprmask
,
16881 (unsigned long) reginfo
.ri_gp_value
);
16882 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16883 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16884 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16889 Elf64_External_RegInfo
* ereg
;
16890 Elf64_Internal_RegInfo reginfo
;
16892 if (option
+ 2 > iopt_end
)
16894 printf (_("<corrupt>\n"));
16895 error (_("Truncated MIPS REGINFO option\n"));
16900 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16901 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16902 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16903 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16904 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16905 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16906 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16908 printf ("GPR %08lx GP 0x",
16909 reginfo
.ri_gprmask
);
16910 printf_vma (reginfo
.ri_gp_value
);
16913 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16914 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16915 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16920 case ODK_EXCEPTIONS
:
16921 fputs (" EXCEPTIONS fpe_min(", stdout
);
16922 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16923 fputs (") fpe_max(", stdout
);
16924 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16925 fputs (")", stdout
);
16927 if (option
->info
& OEX_PAGE0
)
16928 fputs (" PAGE0", stdout
);
16929 if (option
->info
& OEX_SMM
)
16930 fputs (" SMM", stdout
);
16931 if (option
->info
& OEX_FPDBUG
)
16932 fputs (" FPDBUG", stdout
);
16933 if (option
->info
& OEX_DISMISS
)
16934 fputs (" DISMISS", stdout
);
16938 fputs (" PAD ", stdout
);
16939 if (option
->info
& OPAD_PREFIX
)
16940 fputs (" PREFIX", stdout
);
16941 if (option
->info
& OPAD_POSTFIX
)
16942 fputs (" POSTFIX", stdout
);
16943 if (option
->info
& OPAD_SYMBOL
)
16944 fputs (" SYMBOL", stdout
);
16948 fputs (" HWPATCH ", stdout
);
16949 if (option
->info
& OHW_R4KEOP
)
16950 fputs (" R4KEOP", stdout
);
16951 if (option
->info
& OHW_R8KPFETCH
)
16952 fputs (" R8KPFETCH", stdout
);
16953 if (option
->info
& OHW_R5KEOP
)
16954 fputs (" R5KEOP", stdout
);
16955 if (option
->info
& OHW_R5KCVTL
)
16956 fputs (" R5KCVTL", stdout
);
16960 fputs (" FILL ", stdout
);
16961 /* XXX Print content of info word? */
16965 fputs (" TAGS ", stdout
);
16966 /* XXX Print content of info word? */
16970 fputs (" HWAND ", stdout
);
16971 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16972 fputs (" R4KEOP_CHECKED", stdout
);
16973 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16974 fputs (" R4KEOP_CLEAN", stdout
);
16978 fputs (" HWOR ", stdout
);
16979 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16980 fputs (" R4KEOP_CHECKED", stdout
);
16981 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16982 fputs (" R4KEOP_CLEAN", stdout
);
16986 printf (" GP_GROUP %#06lx self-contained %#06lx",
16987 option
->info
& OGP_GROUP
,
16988 (option
->info
& OGP_SELF
) >> 16);
16992 printf (" IDENT %#06lx self-contained %#06lx",
16993 option
->info
& OGP_GROUP
,
16994 (option
->info
& OGP_SELF
) >> 16);
16998 /* This shouldn't happen. */
16999 printf (" %3d ??? %d %lx",
17000 option
->kind
, option
->section
, option
->info
);
17004 len
= sizeof (* eopt
);
17005 while (len
< option
->size
)
17007 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17009 if (ISPRINT (datum
))
17010 printf ("%c", datum
);
17012 printf ("\\%03o", datum
);
17015 fputs ("\n", stdout
);
17017 offset
+= option
->size
;
17027 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17029 Elf32_Conflict
* iconf
;
17032 if (dynamic_symbols
== NULL
)
17034 error (_("conflict list found without a dynamic symbol table\n"));
17038 /* PR 21345 - print a slightly more helpful error message
17039 if we are sure that the cmalloc will fail. */
17040 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
17042 error (_("Overlarge number of conflicts detected: %lx\n"),
17043 (long) conflictsno
);
17047 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17050 error (_("Out of memory allocating space for dynamic conflicts\n"));
17056 Elf32_External_Conflict
* econf32
;
17058 econf32
= (Elf32_External_Conflict
*)
17059 get_data (NULL
, filedata
, conflicts_offset
,
17060 sizeof (*econf32
), conflictsno
, _("conflict"));
17064 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17065 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17071 Elf64_External_Conflict
* econf64
;
17073 econf64
= (Elf64_External_Conflict
*)
17074 get_data (NULL
, filedata
, conflicts_offset
,
17075 sizeof (*econf64
), conflictsno
, _("conflict"));
17079 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17080 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17085 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17086 "\nSection '.conflict' contains %lu entries:\n",
17087 (unsigned long) conflictsno
),
17088 (unsigned long) conflictsno
);
17089 puts (_(" Num: Index Value Name"));
17091 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17093 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17095 if (iconf
[cnt
] >= num_dynamic_syms
)
17096 printf (_("<corrupt symbol index>"));
17099 Elf_Internal_Sym
* psym
;
17101 psym
= & dynamic_symbols
[iconf
[cnt
]];
17102 print_vma (psym
->st_value
, FULL_HEX
);
17104 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17105 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
17107 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17115 if (pltgot
!= 0 && local_gotno
!= 0)
17117 bfd_vma ent
, local_end
, global_end
;
17119 unsigned char * data
;
17120 unsigned char * data_end
;
17124 addr_size
= (is_32bit_elf
? 4 : 8);
17125 local_end
= pltgot
+ local_gotno
* addr_size
;
17127 /* PR binutils/17533 file: 012-111227-0.004 */
17128 if (symtabno
< gotsym
)
17130 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17131 (unsigned long) gotsym
, (unsigned long) symtabno
);
17135 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17136 /* PR 17531: file: 54c91a34. */
17137 if (global_end
< local_end
)
17139 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17143 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17144 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17145 global_end
- pltgot
, 1,
17146 _("Global Offset Table data"));
17147 /* PR 12855: Null data is handled gracefully throughout. */
17148 data_end
= data
+ (global_end
- pltgot
);
17150 printf (_("\nPrimary GOT:\n"));
17151 printf (_(" Canonical gp value: "));
17152 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17155 printf (_(" Reserved entries:\n"));
17156 printf (_(" %*s %10s %*s Purpose\n"),
17157 addr_size
* 2, _("Address"), _("Access"),
17158 addr_size
* 2, _("Initial"));
17159 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17160 printf (_(" Lazy resolver\n"));
17161 if (ent
== (bfd_vma
) -1)
17162 goto got_print_fail
;
17164 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17165 This entry will be used by some runtime loaders, to store the
17166 module pointer. Otherwise this is an ordinary local entry.
17167 PR 21344: Check for the entry being fully available before
17170 && data
+ ent
- pltgot
+ addr_size
<= data_end
17171 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17172 >> (addr_size
* 8 - 1)) != 0)
17174 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17175 printf (_(" Module pointer (GNU extension)\n"));
17176 if (ent
== (bfd_vma
) -1)
17177 goto got_print_fail
;
17181 if (data
!= NULL
&& ent
< local_end
)
17183 printf (_(" Local entries:\n"));
17184 printf (" %*s %10s %*s\n",
17185 addr_size
* 2, _("Address"), _("Access"),
17186 addr_size
* 2, _("Initial"));
17187 while (ent
< local_end
)
17189 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17191 if (ent
== (bfd_vma
) -1)
17192 goto got_print_fail
;
17197 if (data
!= NULL
&& gotsym
< symtabno
)
17201 printf (_(" Global entries:\n"));
17202 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17203 addr_size
* 2, _("Address"),
17205 addr_size
* 2, _("Initial"),
17206 addr_size
* 2, _("Sym.Val."),
17208 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17209 _("Ndx"), _("Name"));
17211 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17213 for (i
= gotsym
; i
< symtabno
; i
++)
17215 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17218 if (dynamic_symbols
== NULL
)
17219 printf (_("<no dynamic symbols>"));
17220 else if (i
< num_dynamic_syms
)
17222 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17224 print_vma (psym
->st_value
, LONG_HEX
);
17225 printf (" %-7s %3s ",
17226 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17227 get_symbol_index_type (filedata
, psym
->st_shndx
));
17229 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17230 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17232 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17235 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17236 (unsigned long) i
);
17239 if (ent
== (bfd_vma
) -1)
17250 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17253 size_t offset
, rel_offset
;
17254 unsigned long count
, i
;
17255 unsigned char * data
;
17256 int addr_size
, sym_width
;
17257 Elf_Internal_Rela
* rels
;
17259 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17260 if (pltrel
== DT_RELA
)
17262 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17267 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17272 addr_size
= (is_32bit_elf
? 4 : 8);
17273 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17275 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17276 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17277 1, _("Procedure Linkage Table data"));
17281 printf ("\nPLT GOT:\n\n");
17282 printf (_(" Reserved entries:\n"));
17283 printf (_(" %*s %*s Purpose\n"),
17284 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17285 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17286 printf (_(" PLT lazy resolver\n"));
17287 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17288 printf (_(" Module pointer\n"));
17291 printf (_(" Entries:\n"));
17292 printf (" %*s %*s %*s %-7s %3s %s\n",
17293 addr_size
* 2, _("Address"),
17294 addr_size
* 2, _("Initial"),
17295 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17296 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17297 for (i
= 0; i
< count
; i
++)
17299 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17301 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17304 if (idx
>= num_dynamic_syms
)
17305 printf (_("<corrupt symbol index: %lu>"), idx
);
17308 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17310 print_vma (psym
->st_value
, LONG_HEX
);
17311 printf (" %-7s %3s ",
17312 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17313 get_symbol_index_type (filedata
, psym
->st_shndx
));
17314 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17315 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17317 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17332 process_nds32_specific (Filedata
* filedata
)
17334 Elf_Internal_Shdr
*sect
= NULL
;
17336 sect
= find_section (filedata
, ".nds32_e_flags");
17339 unsigned int *flag
;
17341 printf ("\nNDS32 elf flags section:\n");
17342 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17343 sect
->sh_size
, _("NDS32 elf flags section"));
17348 switch ((*flag
) & 0x3)
17351 printf ("(VEC_SIZE):\tNo entry.\n");
17354 printf ("(VEC_SIZE):\t4 bytes\n");
17357 printf ("(VEC_SIZE):\t16 bytes\n");
17360 printf ("(VEC_SIZE):\treserved\n");
17369 process_gnu_liblist (Filedata
* filedata
)
17371 Elf_Internal_Shdr
* section
;
17372 Elf_Internal_Shdr
* string_sec
;
17373 Elf32_External_Lib
* elib
;
17375 size_t strtab_size
;
17377 unsigned long num_liblist
;
17379 bfd_boolean res
= TRUE
;
17384 for (i
= 0, section
= filedata
->section_headers
;
17385 i
< filedata
->file_header
.e_shnum
;
17388 switch (section
->sh_type
)
17390 case SHT_GNU_LIBLIST
:
17391 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17394 elib
= (Elf32_External_Lib
*)
17395 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17396 _("liblist section data"));
17404 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17405 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17406 string_sec
->sh_size
,
17407 _("liblist string table"));
17409 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17416 strtab_size
= string_sec
->sh_size
;
17418 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17419 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17420 "\nLibrary list section '%s' contains %lu entries:\n",
17422 printable_section_name (filedata
, section
),
17425 puts (_(" Library Time Stamp Checksum Version Flags"));
17427 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17435 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17436 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17437 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17438 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17439 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17441 tmp
= gmtime (&atime
);
17442 snprintf (timebuf
, sizeof (timebuf
),
17443 "%04u-%02u-%02uT%02u:%02u:%02u",
17444 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17445 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17447 printf ("%3lu: ", (unsigned long) cnt
);
17449 printf ("%-20s", liblist
.l_name
< strtab_size
17450 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17452 printf ("%-20.20s", liblist
.l_name
< strtab_size
17453 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17454 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17455 liblist
.l_version
, liblist
.l_flags
);
17466 static const char *
17467 get_note_type (Filedata
* filedata
, unsigned e_type
)
17469 static char buff
[64];
17471 if (filedata
->file_header
.e_type
== ET_CORE
)
17475 return _("NT_AUXV (auxiliary vector)");
17477 return _("NT_PRSTATUS (prstatus structure)");
17479 return _("NT_FPREGSET (floating point registers)");
17481 return _("NT_PRPSINFO (prpsinfo structure)");
17482 case NT_TASKSTRUCT
:
17483 return _("NT_TASKSTRUCT (task structure)");
17485 return _("NT_PRXFPREG (user_xfpregs structure)");
17487 return _("NT_PPC_VMX (ppc Altivec registers)");
17489 return _("NT_PPC_VSX (ppc VSX registers)");
17491 return _("NT_PPC_TAR (ppc TAR register)");
17493 return _("NT_PPC_PPR (ppc PPR register)");
17495 return _("NT_PPC_DSCR (ppc DSCR register)");
17497 return _("NT_PPC_EBB (ppc EBB registers)");
17499 return _("NT_PPC_PMU (ppc PMU registers)");
17500 case NT_PPC_TM_CGPR
:
17501 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17502 case NT_PPC_TM_CFPR
:
17503 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17504 case NT_PPC_TM_CVMX
:
17505 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17506 case NT_PPC_TM_CVSX
:
17507 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17508 case NT_PPC_TM_SPR
:
17509 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17510 case NT_PPC_TM_CTAR
:
17511 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17512 case NT_PPC_TM_CPPR
:
17513 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17514 case NT_PPC_TM_CDSCR
:
17515 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17517 return _("NT_386_TLS (x86 TLS information)");
17518 case NT_386_IOPERM
:
17519 return _("NT_386_IOPERM (x86 I/O permissions)");
17520 case NT_X86_XSTATE
:
17521 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17522 case NT_S390_HIGH_GPRS
:
17523 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17524 case NT_S390_TIMER
:
17525 return _("NT_S390_TIMER (s390 timer register)");
17526 case NT_S390_TODCMP
:
17527 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17528 case NT_S390_TODPREG
:
17529 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17531 return _("NT_S390_CTRS (s390 control registers)");
17532 case NT_S390_PREFIX
:
17533 return _("NT_S390_PREFIX (s390 prefix register)");
17534 case NT_S390_LAST_BREAK
:
17535 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17536 case NT_S390_SYSTEM_CALL
:
17537 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17539 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17540 case NT_S390_VXRS_LOW
:
17541 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17542 case NT_S390_VXRS_HIGH
:
17543 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17544 case NT_S390_GS_CB
:
17545 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17546 case NT_S390_GS_BC
:
17547 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17549 return _("NT_ARM_VFP (arm VFP registers)");
17551 return _("NT_ARM_TLS (AArch TLS registers)");
17552 case NT_ARM_HW_BREAK
:
17553 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17554 case NT_ARM_HW_WATCH
:
17555 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17557 return _("NT_PSTATUS (pstatus structure)");
17559 return _("NT_FPREGS (floating point registers)");
17561 return _("NT_PSINFO (psinfo structure)");
17563 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17565 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17566 case NT_WIN32PSTATUS
:
17567 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17569 return _("NT_SIGINFO (siginfo_t data)");
17571 return _("NT_FILE (mapped files)");
17579 return _("NT_VERSION (version)");
17581 return _("NT_ARCH (architecture)");
17582 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17584 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17590 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17595 print_core_note (Elf_Internal_Note
*pnote
)
17597 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17598 bfd_vma count
, page_size
;
17599 unsigned char *descdata
, *filenames
, *descend
;
17601 if (pnote
->type
!= NT_FILE
)
17611 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17612 /* Still "successful". */
17617 if (pnote
->descsz
< 2 * addr_size
)
17619 error (_(" Malformed note - too short for header\n"));
17623 descdata
= (unsigned char *) pnote
->descdata
;
17624 descend
= descdata
+ pnote
->descsz
;
17626 if (descdata
[pnote
->descsz
- 1] != '\0')
17628 error (_(" Malformed note - does not end with \\0\n"));
17632 count
= byte_get (descdata
, addr_size
);
17633 descdata
+= addr_size
;
17635 page_size
= byte_get (descdata
, addr_size
);
17636 descdata
+= addr_size
;
17638 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17639 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17641 error (_(" Malformed note - too short for supplied file count\n"));
17645 printf (_(" Page size: "));
17646 print_vma (page_size
, DEC
);
17649 printf (_(" %*s%*s%*s\n"),
17650 (int) (2 + 2 * addr_size
), _("Start"),
17651 (int) (4 + 2 * addr_size
), _("End"),
17652 (int) (4 + 2 * addr_size
), _("Page Offset"));
17653 filenames
= descdata
+ count
* 3 * addr_size
;
17654 while (count
-- > 0)
17656 bfd_vma start
, end
, file_ofs
;
17658 if (filenames
== descend
)
17660 error (_(" Malformed note - filenames end too early\n"));
17664 start
= byte_get (descdata
, addr_size
);
17665 descdata
+= addr_size
;
17666 end
= byte_get (descdata
, addr_size
);
17667 descdata
+= addr_size
;
17668 file_ofs
= byte_get (descdata
, addr_size
);
17669 descdata
+= addr_size
;
17672 print_vma (start
, FULL_HEX
);
17674 print_vma (end
, FULL_HEX
);
17676 print_vma (file_ofs
, FULL_HEX
);
17677 printf ("\n %s\n", filenames
);
17679 filenames
+= 1 + strlen ((char *) filenames
);
17685 static const char *
17686 get_gnu_elf_note_type (unsigned e_type
)
17688 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17691 case NT_GNU_ABI_TAG
:
17692 return _("NT_GNU_ABI_TAG (ABI version tag)");
17694 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17695 case NT_GNU_BUILD_ID
:
17696 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17697 case NT_GNU_GOLD_VERSION
:
17698 return _("NT_GNU_GOLD_VERSION (gold version)");
17699 case NT_GNU_PROPERTY_TYPE_0
:
17700 return _("NT_GNU_PROPERTY_TYPE_0");
17701 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17702 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17703 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17704 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17707 static char buff
[64];
17709 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17716 decode_x86_compat_isa (unsigned int bitmask
)
17720 unsigned int bit
= bitmask
& (- bitmask
);
17725 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17728 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17731 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17734 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17737 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17740 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17743 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17746 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17749 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17752 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17755 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17758 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17759 printf ("AVX512F");
17761 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17762 printf ("AVX512CD");
17764 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17765 printf ("AVX512ER");
17767 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17768 printf ("AVX512PF");
17770 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17771 printf ("AVX512VL");
17773 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17774 printf ("AVX512DQ");
17776 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17777 printf ("AVX512BW");
17780 printf (_("<unknown: %x>"), bit
);
17789 decode_x86_isa (unsigned int bitmask
)
17793 printf (_("<None>"));
17799 unsigned int bit
= bitmask
& (- bitmask
);
17804 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17807 case GNU_PROPERTY_X86_ISA_1_SSE
:
17810 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17813 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17816 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17819 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17822 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17825 case GNU_PROPERTY_X86_ISA_1_AVX
:
17828 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17831 case GNU_PROPERTY_X86_ISA_1_FMA
:
17834 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17835 printf ("AVX512F");
17837 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17838 printf ("AVX512CD");
17840 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17841 printf ("AVX512ER");
17843 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17844 printf ("AVX512PF");
17846 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17847 printf ("AVX512VL");
17849 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17850 printf ("AVX512DQ");
17852 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17853 printf ("AVX512BW");
17855 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17856 printf ("AVX512_4FMAPS");
17858 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17859 printf ("AVX512_4VNNIW");
17861 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17862 printf ("AVX512_BITALG");
17864 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17865 printf ("AVX512_IFMA");
17867 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17868 printf ("AVX512_VBMI");
17870 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17871 printf ("AVX512_VBMI2");
17873 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17874 printf ("AVX512_VNNI");
17876 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17877 printf ("AVX512_BF16");
17880 printf (_("<unknown: %x>"), bit
);
17889 decode_x86_feature_1 (unsigned int bitmask
)
17893 printf (_("<None>"));
17899 unsigned int bit
= bitmask
& (- bitmask
);
17904 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17907 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17911 printf (_("<unknown: %x>"), bit
);
17920 decode_x86_feature_2 (unsigned int bitmask
)
17924 printf (_("<None>"));
17930 unsigned int bit
= bitmask
& (- bitmask
);
17935 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17938 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17941 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17944 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17947 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17950 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17953 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17956 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17959 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17960 printf ("XSAVEOPT");
17962 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17966 printf (_("<unknown: %x>"), bit
);
17975 decode_aarch64_feature_1_and (unsigned int bitmask
)
17979 unsigned int bit
= bitmask
& (- bitmask
);
17984 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17988 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17993 printf (_("<unknown: %x>"), bit
);
18002 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18004 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18005 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18006 unsigned int size
= is_32bit_elf
? 4 : 8;
18008 printf (_(" Properties: "));
18010 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18012 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18016 while (ptr
< ptr_end
)
18020 unsigned int datasz
;
18022 if ((size_t) (ptr_end
- ptr
) < 8)
18024 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18028 type
= byte_get (ptr
, 4);
18029 datasz
= byte_get (ptr
+ 4, 4);
18033 if (datasz
> (size_t) (ptr_end
- ptr
))
18035 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18040 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18042 if (filedata
->file_header
.e_machine
== EM_X86_64
18043 || filedata
->file_header
.e_machine
== EM_IAMCU
18044 || filedata
->file_header
.e_machine
== EM_386
)
18046 unsigned int bitmask
;
18049 bitmask
= byte_get (ptr
, 4);
18055 case GNU_PROPERTY_X86_ISA_1_USED
:
18057 printf (_("x86 ISA used: <corrupt length: %#x> "),
18061 printf ("x86 ISA used: ");
18062 decode_x86_isa (bitmask
);
18066 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18068 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18072 printf ("x86 ISA needed: ");
18073 decode_x86_isa (bitmask
);
18077 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18079 printf (_("x86 feature: <corrupt length: %#x> "),
18083 printf ("x86 feature: ");
18084 decode_x86_feature_1 (bitmask
);
18088 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18090 printf (_("x86 feature used: <corrupt length: %#x> "),
18094 printf ("x86 feature used: ");
18095 decode_x86_feature_2 (bitmask
);
18099 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18101 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18104 printf ("x86 feature needed: ");
18105 decode_x86_feature_2 (bitmask
);
18109 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18111 printf (_("x86 ISA used: <corrupt length: %#x> "),
18115 printf ("x86 ISA used: ");
18116 decode_x86_compat_isa (bitmask
);
18120 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18122 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18126 printf ("x86 ISA needed: ");
18127 decode_x86_compat_isa (bitmask
);
18135 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18137 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18139 printf ("AArch64 feature: ");
18141 printf (_("<corrupt length: %#x> "), datasz
);
18143 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18152 case GNU_PROPERTY_STACK_SIZE
:
18153 printf (_("stack size: "));
18154 if (datasz
!= size
)
18155 printf (_("<corrupt length: %#x> "), datasz
);
18157 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18160 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18161 printf ("no copy on protected ");
18163 printf (_("<corrupt length: %#x> "), datasz
);
18171 if (type
< GNU_PROPERTY_LOPROC
)
18172 printf (_("<unknown type %#x data: "), type
);
18173 else if (type
< GNU_PROPERTY_LOUSER
)
18174 printf (_("<procesor-specific type %#x data: "), type
);
18176 printf (_("<application-specific type %#x data: "), type
);
18177 for (j
= 0; j
< datasz
; ++j
)
18178 printf ("%02x ", ptr
[j
] & 0xff);
18182 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18183 if (ptr
== ptr_end
)
18196 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18198 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18199 switch (pnote
->type
)
18201 case NT_GNU_BUILD_ID
:
18205 printf (_(" Build ID: "));
18206 for (i
= 0; i
< pnote
->descsz
; ++i
)
18207 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18212 case NT_GNU_ABI_TAG
:
18214 unsigned long os
, major
, minor
, subminor
;
18215 const char *osname
;
18217 /* PR 17531: file: 030-599401-0.004. */
18218 if (pnote
->descsz
< 16)
18220 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18224 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18225 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18226 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18227 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18231 case GNU_ABI_TAG_LINUX
:
18234 case GNU_ABI_TAG_HURD
:
18237 case GNU_ABI_TAG_SOLARIS
:
18238 osname
= "Solaris";
18240 case GNU_ABI_TAG_FREEBSD
:
18241 osname
= "FreeBSD";
18243 case GNU_ABI_TAG_NETBSD
:
18246 case GNU_ABI_TAG_SYLLABLE
:
18247 osname
= "Syllable";
18249 case GNU_ABI_TAG_NACL
:
18253 osname
= "Unknown";
18257 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18258 major
, minor
, subminor
);
18262 case NT_GNU_GOLD_VERSION
:
18266 printf (_(" Version: "));
18267 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18268 printf ("%c", pnote
->descdata
[i
]);
18275 unsigned long num_entries
, mask
;
18277 /* Hardware capabilities information. Word 0 is the number of entries.
18278 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18279 is a series of entries, where each entry is a single byte followed
18280 by a nul terminated string. The byte gives the bit number to test
18281 if enabled in the bitmask. */
18282 printf (_(" Hardware Capabilities: "));
18283 if (pnote
->descsz
< 8)
18285 error (_("<corrupt GNU_HWCAP>\n"));
18288 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18289 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18290 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18291 /* FIXME: Add code to display the entries... */
18295 case NT_GNU_PROPERTY_TYPE_0
:
18296 print_gnu_property_note (filedata
, pnote
);
18300 /* Handle unrecognised types. An error message should have already been
18301 created by get_gnu_elf_note_type(), so all that we need to do is to
18302 display the data. */
18306 printf (_(" Description data: "));
18307 for (i
= 0; i
< pnote
->descsz
; ++i
)
18308 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18317 static const char *
18318 get_v850_elf_note_type (enum v850_notes n_type
)
18320 static char buff
[64];
18324 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18325 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18326 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18327 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18328 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18329 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18331 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18337 print_v850_note (Elf_Internal_Note
* pnote
)
18341 if (pnote
->descsz
!= 4)
18344 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18348 printf (_("not set\n"));
18352 switch (pnote
->type
)
18354 case V850_NOTE_ALIGNMENT
:
18357 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18358 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18362 case V850_NOTE_DATA_SIZE
:
18365 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18366 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18370 case V850_NOTE_FPU_INFO
:
18373 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18374 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18378 case V850_NOTE_MMU_INFO
:
18379 case V850_NOTE_CACHE_INFO
:
18380 case V850_NOTE_SIMD_INFO
:
18381 if (val
== EF_RH850_SIMD
)
18383 printf (_("yes\n"));
18389 /* An 'unknown note type' message will already have been displayed. */
18393 printf (_("unknown value: %x\n"), val
);
18398 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18400 unsigned int version
;
18402 switch (pnote
->type
)
18404 case NT_NETBSD_IDENT
:
18405 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18406 if ((version
/ 10000) % 100)
18407 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18408 version
, version
/ 100000000, (version
/ 1000000) % 100,
18409 (version
/ 10000) % 100 > 26 ? "Z" : "",
18410 'A' + (version
/ 10000) % 26);
18412 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18413 version
, version
/ 100000000, (version
/ 1000000) % 100,
18414 (version
/ 100) % 100);
18417 case NT_NETBSD_MARCH
:
18418 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18422 #ifdef NT_NETBSD_PAX
18423 case NT_NETBSD_PAX
:
18424 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18425 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18426 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18427 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18428 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18429 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18430 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18431 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18436 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
18442 static const char *
18443 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18447 case NT_FREEBSD_THRMISC
:
18448 return _("NT_THRMISC (thrmisc structure)");
18449 case NT_FREEBSD_PROCSTAT_PROC
:
18450 return _("NT_PROCSTAT_PROC (proc data)");
18451 case NT_FREEBSD_PROCSTAT_FILES
:
18452 return _("NT_PROCSTAT_FILES (files data)");
18453 case NT_FREEBSD_PROCSTAT_VMMAP
:
18454 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18455 case NT_FREEBSD_PROCSTAT_GROUPS
:
18456 return _("NT_PROCSTAT_GROUPS (groups data)");
18457 case NT_FREEBSD_PROCSTAT_UMASK
:
18458 return _("NT_PROCSTAT_UMASK (umask data)");
18459 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18460 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18461 case NT_FREEBSD_PROCSTAT_OSREL
:
18462 return _("NT_PROCSTAT_OSREL (osreldate data)");
18463 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18464 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18465 case NT_FREEBSD_PROCSTAT_AUXV
:
18466 return _("NT_PROCSTAT_AUXV (auxv data)");
18467 case NT_FREEBSD_PTLWPINFO
:
18468 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18470 return get_note_type (filedata
, e_type
);
18473 static const char *
18474 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18476 static char buff
[64];
18480 case NT_NETBSDCORE_PROCINFO
:
18481 /* NetBSD core "procinfo" structure. */
18482 return _("NetBSD procinfo structure");
18484 #ifdef NT_NETBSDCORE_AUXV
18485 case NT_NETBSDCORE_AUXV
:
18486 return _("NetBSD ELF auxiliary vector data");
18489 #ifdef NT_NETBSDCORE_LWPSTATUS
18490 case NT_NETBSDCORE_LWPSTATUS
:
18491 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18495 /* As of Jan 2020 there are no other machine-independent notes
18496 defined for NetBSD core files. If the note type is less
18497 than the start of the machine-dependent note types, we don't
18500 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18502 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18508 switch (filedata
->file_header
.e_machine
)
18510 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18511 and PT_GETFPREGS == mach+2. */
18516 case EM_SPARC32PLUS
:
18520 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18521 return _("PT_GETREGS (reg structure)");
18522 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18523 return _("PT_GETFPREGS (fpreg structure)");
18529 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18530 There's also old PT___GETREGS40 == mach + 1 for old reg
18531 structure which lacks GBR. */
18535 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18536 return _("PT___GETREGS40 (old reg structure)");
18537 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18538 return _("PT_GETREGS (reg structure)");
18539 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18540 return _("PT_GETFPREGS (fpreg structure)");
18546 /* On all other arch's, PT_GETREGS == mach+1 and
18547 PT_GETFPREGS == mach+3. */
18551 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18552 return _("PT_GETREGS (reg structure)");
18553 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18554 return _("PT_GETFPREGS (fpreg structure)");
18560 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18561 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18565 static const char *
18566 get_stapsdt_note_type (unsigned e_type
)
18568 static char buff
[64];
18573 return _("NT_STAPSDT (SystemTap probe descriptors)");
18579 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18584 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18586 size_t len
, maxlen
;
18587 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18588 char *data
= pnote
->descdata
;
18589 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18590 bfd_vma pc
, base_addr
, semaphore
;
18591 char *provider
, *probe
, *arg_fmt
;
18593 if (pnote
->descsz
< (addr_size
* 3))
18594 goto stapdt_note_too_small
;
18596 pc
= byte_get ((unsigned char *) data
, addr_size
);
18599 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18602 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18605 if (data
>= data_end
)
18606 goto stapdt_note_too_small
;
18607 maxlen
= data_end
- data
;
18608 len
= strnlen (data
, maxlen
);
18615 goto stapdt_note_too_small
;
18617 if (data
>= data_end
)
18618 goto stapdt_note_too_small
;
18619 maxlen
= data_end
- data
;
18620 len
= strnlen (data
, maxlen
);
18627 goto stapdt_note_too_small
;
18629 if (data
>= data_end
)
18630 goto stapdt_note_too_small
;
18631 maxlen
= data_end
- data
;
18632 len
= strnlen (data
, maxlen
);
18639 goto stapdt_note_too_small
;
18641 printf (_(" Provider: %s\n"), provider
);
18642 printf (_(" Name: %s\n"), probe
);
18643 printf (_(" Location: "));
18644 print_vma (pc
, FULL_HEX
);
18645 printf (_(", Base: "));
18646 print_vma (base_addr
, FULL_HEX
);
18647 printf (_(", Semaphore: "));
18648 print_vma (semaphore
, FULL_HEX
);
18650 printf (_(" Arguments: %s\n"), arg_fmt
);
18652 return data
== data_end
;
18654 stapdt_note_too_small
:
18655 printf (_(" <corrupt - note is too small>\n"));
18656 error (_("corrupt stapdt note - the data size is too small\n"));
18660 static const char *
18661 get_ia64_vms_note_type (unsigned e_type
)
18663 static char buff
[64];
18668 return _("NT_VMS_MHD (module header)");
18670 return _("NT_VMS_LNM (language name)");
18672 return _("NT_VMS_SRC (source files)");
18674 return "NT_VMS_TITLE";
18676 return _("NT_VMS_EIDC (consistency check)");
18677 case NT_VMS_FPMODE
:
18678 return _("NT_VMS_FPMODE (FP mode)");
18679 case NT_VMS_LINKTIME
:
18680 return "NT_VMS_LINKTIME";
18681 case NT_VMS_IMGNAM
:
18682 return _("NT_VMS_IMGNAM (image name)");
18684 return _("NT_VMS_IMGID (image id)");
18685 case NT_VMS_LINKID
:
18686 return _("NT_VMS_LINKID (link id)");
18687 case NT_VMS_IMGBID
:
18688 return _("NT_VMS_IMGBID (build id)");
18689 case NT_VMS_GSTNAM
:
18690 return _("NT_VMS_GSTNAM (sym table name)");
18691 case NT_VMS_ORIG_DYN
:
18692 return "NT_VMS_ORIG_DYN";
18693 case NT_VMS_PATCHTIME
:
18694 return "NT_VMS_PATCHTIME";
18696 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18702 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18704 int maxlen
= pnote
->descsz
;
18706 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18707 goto desc_size_fail
;
18709 switch (pnote
->type
)
18713 goto desc_size_fail
;
18715 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18717 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18718 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18719 if (l
+ 34 < maxlen
)
18721 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18722 if (l
+ 35 < maxlen
)
18723 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18725 printf (_(" Module version : <missing>\n"));
18729 printf (_(" Module name : <missing>\n"));
18730 printf (_(" Module version : <missing>\n"));
18735 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18739 case NT_VMS_FPMODE
:
18740 printf (_(" Floating Point mode: "));
18742 goto desc_size_fail
;
18743 /* FIXME: Generate an error if descsz > 8 ? */
18745 printf ("0x%016" BFD_VMA_FMT
"x\n",
18746 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18749 case NT_VMS_LINKTIME
:
18750 printf (_(" Link time: "));
18752 goto desc_size_fail
;
18753 /* FIXME: Generate an error if descsz > 8 ? */
18756 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18760 case NT_VMS_PATCHTIME
:
18761 printf (_(" Patch time: "));
18763 goto desc_size_fail
;
18764 /* FIXME: Generate an error if descsz > 8 ? */
18767 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18771 case NT_VMS_ORIG_DYN
:
18773 goto desc_size_fail
;
18775 printf (_(" Major id: %u, minor id: %u\n"),
18776 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18777 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18778 printf (_(" Last modified : "));
18780 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18781 printf (_("\n Link flags : "));
18782 printf ("0x%016" BFD_VMA_FMT
"x\n",
18783 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18784 printf (_(" Header flags: 0x%08x\n"),
18785 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18786 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18790 case NT_VMS_IMGNAM
:
18791 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18794 case NT_VMS_GSTNAM
:
18795 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18799 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18802 case NT_VMS_LINKID
:
18803 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18813 printf (_(" <corrupt - data size is too small>\n"));
18814 error (_("corrupt IA64 note: data size is too small\n"));
18818 struct build_attr_cache
{
18819 Filedata
*filedata
;
18821 unsigned long strtablen
;
18822 Elf_Internal_Sym
*symtab
;
18823 unsigned long nsyms
;
18826 /* Find the symbol associated with a build attribute that is attached
18827 to address OFFSET. If PNAME is non-NULL then store the name of
18828 the symbol (if found) in the provided pointer, Returns NULL if a
18829 symbol could not be found. */
18831 static Elf_Internal_Sym
*
18832 get_symbol_for_build_attribute (Filedata
* filedata
,
18833 unsigned long offset
,
18834 bfd_boolean is_open_attr
,
18835 const char ** pname
)
18837 Elf_Internal_Sym
*saved_sym
= NULL
;
18838 Elf_Internal_Sym
*sym
;
18840 if (filedata
->section_headers
!= NULL
18841 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18843 Elf_Internal_Shdr
* symsec
;
18845 free (ba_cache
.strtab
);
18846 ba_cache
.strtab
= NULL
;
18847 free (ba_cache
.symtab
);
18848 ba_cache
.symtab
= NULL
;
18850 /* Load the symbol and string sections. */
18851 for (symsec
= filedata
->section_headers
;
18852 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18855 if (symsec
->sh_type
== SHT_SYMTAB
18856 && get_symtab (filedata
, symsec
,
18857 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18858 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18861 ba_cache
.filedata
= filedata
;
18864 if (ba_cache
.symtab
== NULL
)
18867 /* Find a symbol whose value matches offset. */
18868 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18869 if (sym
->st_value
== offset
)
18871 if (sym
->st_name
>= ba_cache
.strtablen
)
18872 /* Huh ? This should not happen. */
18875 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18878 /* The AArch64 and ARM architectures define mapping symbols
18879 (eg $d, $x, $t) which we want to ignore. */
18880 if (ba_cache
.strtab
[sym
->st_name
] == '$'
18881 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
18882 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
18887 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18888 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18889 FUNC symbols entirely. */
18890 switch (ELF_ST_TYPE (sym
->st_info
))
18897 /* If the symbol has a size associated
18898 with it then we can stop searching. */
18899 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
18904 /* Ignore function symbols. */
18911 switch (ELF_ST_BIND (sym
->st_info
))
18914 if (saved_sym
== NULL
18915 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18920 if (saved_sym
== NULL
)
18930 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18938 if (saved_sym
&& pname
)
18939 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
18944 /* Returns true iff addr1 and addr2 are in the same section. */
18947 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18949 Elf_Internal_Shdr
* a1
;
18950 Elf_Internal_Shdr
* a2
;
18952 a1
= find_section_by_address (filedata
, addr1
);
18953 a2
= find_section_by_address (filedata
, addr2
);
18955 return a1
== a2
&& a1
!= NULL
;
18959 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18960 Filedata
* filedata
)
18962 static unsigned long global_offset
= 0;
18963 static unsigned long global_end
= 0;
18964 static unsigned long func_offset
= 0;
18965 static unsigned long func_end
= 0;
18967 Elf_Internal_Sym
* sym
;
18969 unsigned long start
;
18971 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18973 switch (pnote
->descsz
)
18976 /* A zero-length description means that the range of
18977 the previous note of the same type should be used. */
18980 if (global_end
> global_offset
)
18981 printf (_(" Applies to region from %#lx to %#lx\n"),
18982 global_offset
, global_end
);
18984 printf (_(" Applies to region from %#lx\n"), global_offset
);
18988 if (func_end
> func_offset
)
18989 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18991 printf (_(" Applies to region from %#lx\n"), func_offset
);
18996 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19003 /* FIXME: We should check that version 3+ notes are being used here... */
19004 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19005 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19009 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19015 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19016 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19020 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19021 printf (_(" <invalid descsz>"));
19026 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19027 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19028 in order to avoid them being confused with the start address of the
19029 first function in the file... */
19030 if (sym
== NULL
&& is_open_attr
)
19031 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19034 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19035 end
= start
+ sym
->st_size
;
19039 /* FIXME: Need to properly allow for section alignment.
19040 16 is just the alignment used on x86_64. */
19042 && start
> BFD_ALIGN (global_end
, 16)
19043 /* Build notes are not guaranteed to be organised in order of
19044 increasing address, but we should find the all of the notes
19045 for one section in the same place. */
19046 && same_section (filedata
, start
, global_end
))
19047 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19048 global_end
+ 1, start
- 1);
19050 printf (_(" Applies to region from %#lx"), start
);
19051 global_offset
= start
;
19055 printf (_(" to %#lx"), end
);
19061 printf (_(" Applies to region from %#lx"), start
);
19062 func_offset
= start
;
19066 printf (_(" to %#lx"), end
);
19072 printf (_(" (%s)"), name
);
19079 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19081 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19082 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19083 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19085 char name_attribute
;
19086 const char * expected_types
;
19087 const char * name
= pnote
->namedata
;
19091 if (name
== NULL
|| pnote
->namesz
< 2)
19093 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19094 print_symbol (-20, _(" <corrupt name>"));
19103 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19104 if (name
[0] == 'G' && name
[1] == 'A')
19106 if (pnote
->namesz
< 4)
19108 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19109 print_symbol (-20, _(" <corrupt name>"));
19118 switch ((name_type
= * name
))
19120 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19121 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19122 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19123 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19124 printf ("%c", * name
);
19128 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19129 print_symbol (-20, _("<unknown name type>"));
19136 switch ((name_attribute
= * name
))
19138 case GNU_BUILD_ATTRIBUTE_VERSION
:
19139 text
= _("<version>");
19140 expected_types
= string_expected
;
19143 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19144 text
= _("<stack prot>");
19145 expected_types
= "!+*";
19148 case GNU_BUILD_ATTRIBUTE_RELRO
:
19149 text
= _("<relro>");
19150 expected_types
= bool_expected
;
19153 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19154 text
= _("<stack size>");
19155 expected_types
= number_expected
;
19158 case GNU_BUILD_ATTRIBUTE_TOOL
:
19159 text
= _("<tool>");
19160 expected_types
= string_expected
;
19163 case GNU_BUILD_ATTRIBUTE_ABI
:
19165 expected_types
= "$*";
19168 case GNU_BUILD_ATTRIBUTE_PIC
:
19170 expected_types
= number_expected
;
19173 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19174 text
= _("<short enum>");
19175 expected_types
= bool_expected
;
19179 if (ISPRINT (* name
))
19181 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19183 if (len
> left
&& ! do_wide
)
19185 printf ("%.*s:", len
, name
);
19191 static char tmpbuf
[128];
19193 error (_("unrecognised byte in name field: %d\n"), * name
);
19194 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19198 expected_types
= "*$!+";
19203 left
-= printf ("%s", text
);
19205 if (strchr (expected_types
, name_type
) == NULL
)
19206 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19208 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19210 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19211 (unsigned long) pnote
->namesz
,
19212 (long) (name
- pnote
->namedata
));
19216 if (left
< 1 && ! do_wide
)
19221 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19223 unsigned int bytes
;
19224 unsigned long long val
= 0;
19225 unsigned int shift
= 0;
19226 char * decoded
= NULL
;
19228 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19230 /* The -1 is because the name field is always 0 terminated, and we
19231 want to be able to ensure that the shift in the while loop below
19232 will not overflow. */
19235 if (bytes
> sizeof (val
))
19237 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19239 bytes
= sizeof (val
);
19241 /* We do not bother to warn if bytes == 0 as this can
19242 happen with some early versions of the gcc plugin. */
19246 unsigned long byte
= (* name
++) & 0xff;
19248 val
|= byte
<< shift
;
19252 switch (name_attribute
)
19254 case GNU_BUILD_ATTRIBUTE_PIC
:
19257 case 0: decoded
= "static"; break;
19258 case 1: decoded
= "pic"; break;
19259 case 2: decoded
= "PIC"; break;
19260 case 3: decoded
= "pie"; break;
19261 case 4: decoded
= "PIE"; break;
19265 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19268 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19269 case 0: decoded
= "off"; break;
19270 case 1: decoded
= "on"; break;
19271 case 2: decoded
= "all"; break;
19272 case 3: decoded
= "strong"; break;
19273 case 4: decoded
= "explicit"; break;
19281 if (decoded
!= NULL
)
19283 print_symbol (-left
, decoded
);
19294 left
-= printf ("0x%llx", val
);
19296 left
-= printf ("0x%-.*llx", left
, val
);
19300 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19301 left
-= print_symbol (- left
, name
);
19303 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19304 left
-= print_symbol (- left
, "true");
19306 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19307 left
-= print_symbol (- left
, "false");
19311 if (do_wide
&& left
> 0)
19312 printf ("%-*s", left
, " ");
19317 /* Note that by the ELF standard, the name field is already null byte
19318 terminated, and namesz includes the terminating null byte.
19319 I.E. the value of namesz for the name "FSF" is 4.
19321 If the value of namesz is zero, there is no name present. */
19324 process_note (Elf_Internal_Note
* pnote
,
19325 Filedata
* filedata
)
19327 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19330 if (pnote
->namesz
== 0)
19331 /* If there is no note name, then use the default set of
19332 note type strings. */
19333 nt
= get_note_type (filedata
, pnote
->type
);
19335 else if (const_strneq (pnote
->namedata
, "GNU"))
19336 /* GNU-specific object file notes. */
19337 nt
= get_gnu_elf_note_type (pnote
->type
);
19339 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19340 /* FreeBSD-specific core file notes. */
19341 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19343 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19344 /* NetBSD-specific core file notes. */
19345 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19347 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19348 /* NetBSD-specific core file notes. */
19349 return process_netbsd_elf_note (pnote
);
19351 else if (const_strneq (pnote
->namedata
, "PaX"))
19352 /* NetBSD-specific core file notes. */
19353 return process_netbsd_elf_note (pnote
);
19355 else if (strneq (pnote
->namedata
, "SPU/", 4))
19357 /* SPU-specific core file notes. */
19358 nt
= pnote
->namedata
+ 4;
19362 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19363 /* VMS/ia64-specific file notes. */
19364 nt
= get_ia64_vms_note_type (pnote
->type
);
19366 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19367 nt
= get_stapsdt_note_type (pnote
->type
);
19370 /* Don't recognize this note name; just use the default set of
19371 note type strings. */
19372 nt
= get_note_type (filedata
, pnote
->type
);
19376 if (((const_strneq (pnote
->namedata
, "GA")
19377 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19378 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19379 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19380 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19381 print_gnu_build_attribute_name (pnote
);
19383 print_symbol (-20, name
);
19386 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19388 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19390 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19391 return print_ia64_vms_note (pnote
);
19392 else if (const_strneq (pnote
->namedata
, "GNU"))
19393 return print_gnu_note (filedata
, pnote
);
19394 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19395 return print_stapsdt_note (pnote
);
19396 else if (const_strneq (pnote
->namedata
, "CORE"))
19397 return print_core_note (pnote
);
19398 else if (((const_strneq (pnote
->namedata
, "GA")
19399 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19400 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19401 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19402 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19403 return print_gnu_build_attribute_description (pnote
, filedata
);
19409 printf (_(" description data: "));
19410 for (i
= 0; i
< pnote
->descsz
; i
++)
19411 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19423 process_notes_at (Filedata
* filedata
,
19424 Elf_Internal_Shdr
* section
,
19429 Elf_External_Note
* pnotes
;
19430 Elf_External_Note
* external
;
19432 bfd_boolean res
= TRUE
;
19439 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19442 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19450 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19453 if (pnotes
== NULL
)
19459 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19461 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19462 (unsigned long) offset
, (unsigned long) length
);
19464 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19465 specifies that notes should be aligned to 4 bytes in 32-bit
19466 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19467 we also support 4 byte alignment in 64-bit objects. If section
19468 alignment is less than 4, we treate alignment as 4 bytes. */
19471 else if (align
!= 4 && align
!= 8)
19473 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19479 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19481 end
= (char *) pnotes
+ length
;
19482 while ((char *) external
< end
)
19484 Elf_Internal_Note inote
;
19487 char * temp
= NULL
;
19488 size_t data_remaining
= end
- (char *) external
;
19490 if (!is_ia64_vms (filedata
))
19492 /* PR binutils/15191
19493 Make sure that there is enough data to read. */
19494 min_notesz
= offsetof (Elf_External_Note
, name
);
19495 if (data_remaining
< min_notesz
)
19497 warn (ngettext ("Corrupt note: only %ld byte remains, "
19498 "not enough for a full note\n",
19499 "Corrupt note: only %ld bytes remain, "
19500 "not enough for a full note\n",
19502 (long) data_remaining
);
19505 data_remaining
-= min_notesz
;
19507 inote
.type
= BYTE_GET (external
->type
);
19508 inote
.namesz
= BYTE_GET (external
->namesz
);
19509 inote
.namedata
= external
->name
;
19510 inote
.descsz
= BYTE_GET (external
->descsz
);
19511 inote
.descdata
= ((char *) external
19512 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19513 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19514 next
= ((char *) external
19515 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19519 Elf64_External_VMS_Note
*vms_external
;
19521 /* PR binutils/15191
19522 Make sure that there is enough data to read. */
19523 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19524 if (data_remaining
< min_notesz
)
19526 warn (ngettext ("Corrupt note: only %ld byte remains, "
19527 "not enough for a full note\n",
19528 "Corrupt note: only %ld bytes remain, "
19529 "not enough for a full note\n",
19531 (long) data_remaining
);
19534 data_remaining
-= min_notesz
;
19536 vms_external
= (Elf64_External_VMS_Note
*) external
;
19537 inote
.type
= BYTE_GET (vms_external
->type
);
19538 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19539 inote
.namedata
= vms_external
->name
;
19540 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19541 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19542 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19543 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19546 /* PR 17531: file: 3443835e. */
19547 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19548 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19549 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19550 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19551 || ((size_t) (next
- inote
.descdata
)
19552 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19554 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19555 (unsigned long) ((char *) external
- (char *) pnotes
));
19556 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19557 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19561 external
= (Elf_External_Note
*) next
;
19563 /* Verify that name is null terminated. It appears that at least
19564 one version of Linux (RedHat 6.0) generates corefiles that don't
19565 comply with the ELF spec by failing to include the null byte in
19567 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19569 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19571 temp
= (char *) malloc (inote
.namesz
+ 1);
19574 error (_("Out of memory allocating space for inote name\n"));
19579 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19580 inote
.namedata
= temp
;
19582 inote
.namedata
[inote
.namesz
] = 0;
19585 if (! process_note (& inote
, filedata
))
19601 process_corefile_note_segments (Filedata
* filedata
)
19603 Elf_Internal_Phdr
* segment
;
19605 bfd_boolean res
= TRUE
;
19607 if (! get_program_headers (filedata
))
19610 for (i
= 0, segment
= filedata
->program_headers
;
19611 i
< filedata
->file_header
.e_phnum
;
19614 if (segment
->p_type
== PT_NOTE
)
19615 if (! process_notes_at (filedata
, NULL
,
19616 (bfd_vma
) segment
->p_offset
,
19617 (bfd_vma
) segment
->p_filesz
,
19618 (bfd_vma
) segment
->p_align
))
19626 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19628 Elf_External_Note
* pnotes
;
19629 Elf_External_Note
* external
;
19631 bfd_boolean res
= TRUE
;
19636 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19638 if (pnotes
== NULL
)
19642 end
= (char*) pnotes
+ length
;
19644 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19645 (unsigned long) offset
, (unsigned long) length
);
19647 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19649 Elf_External_Note
* next
;
19650 Elf_Internal_Note inote
;
19652 inote
.type
= BYTE_GET (external
->type
);
19653 inote
.namesz
= BYTE_GET (external
->namesz
);
19654 inote
.namedata
= external
->name
;
19655 inote
.descsz
= BYTE_GET (external
->descsz
);
19656 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19657 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19659 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19661 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19662 inote
.descdata
= inote
.namedata
;
19666 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19668 if ( ((char *) next
> end
)
19669 || ((char *) next
< (char *) pnotes
))
19671 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19672 (unsigned long) ((char *) external
- (char *) pnotes
));
19673 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19674 inote
.type
, inote
.namesz
, inote
.descsz
);
19680 /* Prevent out-of-bounds indexing. */
19681 if ( inote
.namedata
+ inote
.namesz
> end
19682 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19684 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19685 (unsigned long) ((char *) external
- (char *) pnotes
));
19686 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19687 inote
.type
, inote
.namesz
, inote
.descsz
);
19691 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19693 if (! print_v850_note (& inote
))
19696 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19697 inote
.namesz
, inote
.descsz
);
19707 process_note_sections (Filedata
* filedata
)
19709 Elf_Internal_Shdr
* section
;
19711 unsigned int n
= 0;
19712 bfd_boolean res
= TRUE
;
19714 for (i
= 0, section
= filedata
->section_headers
;
19715 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19718 if (section
->sh_type
== SHT_NOTE
)
19720 if (! process_notes_at (filedata
, section
,
19721 (bfd_vma
) section
->sh_offset
,
19722 (bfd_vma
) section
->sh_size
,
19723 (bfd_vma
) section
->sh_addralign
))
19728 if (( filedata
->file_header
.e_machine
== EM_V800
19729 || filedata
->file_header
.e_machine
== EM_V850
19730 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19731 && section
->sh_type
== SHT_RENESAS_INFO
)
19733 if (! process_v850_notes (filedata
,
19734 (bfd_vma
) section
->sh_offset
,
19735 (bfd_vma
) section
->sh_size
))
19742 /* Try processing NOTE segments instead. */
19743 return process_corefile_note_segments (filedata
);
19749 process_notes (Filedata
* filedata
)
19751 /* If we have not been asked to display the notes then do nothing. */
19755 if (filedata
->file_header
.e_type
!= ET_CORE
)
19756 return process_note_sections (filedata
);
19758 /* No program headers means no NOTE segment. */
19759 if (filedata
->file_header
.e_phnum
> 0)
19760 return process_corefile_note_segments (filedata
);
19762 printf (_("No note segments present in the core file.\n"));
19766 static unsigned char *
19767 display_public_gnu_attributes (unsigned char * start
,
19768 const unsigned char * const end
)
19770 printf (_(" Unknown GNU attribute: %s\n"), start
);
19772 start
+= strnlen ((char *) start
, end
- start
);
19773 display_raw_attribute (start
, end
);
19775 return (unsigned char *) end
;
19778 static unsigned char *
19779 display_generic_attribute (unsigned char * start
,
19781 const unsigned char * const end
)
19784 return (unsigned char *) end
;
19786 return display_tag_value (tag
, start
, end
);
19790 process_arch_specific (Filedata
* filedata
)
19795 switch (filedata
->file_header
.e_machine
)
19798 case EM_ARC_COMPACT
:
19799 case EM_ARC_COMPACT2
:
19800 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19801 display_arc_attribute
,
19802 display_generic_attribute
);
19804 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19805 display_arm_attribute
,
19806 display_generic_attribute
);
19809 case EM_MIPS_RS3_LE
:
19810 return process_mips_specific (filedata
);
19813 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19814 display_msp430x_attribute
,
19815 display_msp430_gnu_attribute
);
19818 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19819 display_riscv_attribute
,
19820 display_generic_attribute
);
19823 return process_nds32_specific (filedata
);
19827 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19828 display_power_gnu_attribute
);
19832 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19833 display_s390_gnu_attribute
);
19836 case EM_SPARC32PLUS
:
19838 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19839 display_sparc_gnu_attribute
);
19842 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19843 display_tic6x_attribute
,
19844 display_generic_attribute
);
19847 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19848 display_public_gnu_attributes
,
19849 display_generic_attribute
);
19854 get_file_header (Filedata
* filedata
)
19856 /* Read in the identity array. */
19857 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19860 /* Determine how to read the rest of the header. */
19861 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19866 byte_get
= byte_get_little_endian
;
19867 byte_put
= byte_put_little_endian
;
19870 byte_get
= byte_get_big_endian
;
19871 byte_put
= byte_put_big_endian
;
19875 /* For now we only support 32 bit and 64 bit ELF files. */
19876 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19878 /* Read in the rest of the header. */
19881 Elf32_External_Ehdr ehdr32
;
19883 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19886 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19887 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19888 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19889 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19890 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19891 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19892 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19893 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19894 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19895 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19896 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19897 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19898 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19902 Elf64_External_Ehdr ehdr64
;
19904 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19905 we will not be able to cope with the 64bit data found in
19906 64 ELF files. Detect this now and abort before we start
19907 overwriting things. */
19908 if (sizeof (bfd_vma
) < 8)
19910 error (_("This instance of readelf has been built without support for a\n\
19911 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19915 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19918 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19919 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19920 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19921 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19922 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19923 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19924 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19925 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19926 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19927 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19928 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19929 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19930 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19933 if (filedata
->file_header
.e_shoff
)
19935 /* There may be some extensions in the first section header. Don't
19936 bomb if we can't read it. */
19938 get_32bit_section_headers (filedata
, TRUE
);
19940 get_64bit_section_headers (filedata
, TRUE
);
19947 close_file (Filedata
* filedata
)
19951 if (filedata
->handle
)
19952 fclose (filedata
->handle
);
19958 close_debug_file (void * data
)
19960 close_file ((Filedata
*) data
);
19964 open_file (const char * pathname
)
19966 struct stat statbuf
;
19967 Filedata
* filedata
= NULL
;
19969 if (stat (pathname
, & statbuf
) < 0
19970 || ! S_ISREG (statbuf
.st_mode
))
19973 filedata
= calloc (1, sizeof * filedata
);
19974 if (filedata
== NULL
)
19977 filedata
->handle
= fopen (pathname
, "rb");
19978 if (filedata
->handle
== NULL
)
19981 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19982 filedata
->file_name
= pathname
;
19984 if (! get_file_header (filedata
))
19987 if (filedata
->file_header
.e_shoff
)
19991 /* Read the section headers again, this time for real. */
19993 res
= get_32bit_section_headers (filedata
, FALSE
);
19995 res
= get_64bit_section_headers (filedata
, FALSE
);
20006 if (filedata
->handle
)
20007 fclose (filedata
->handle
);
20014 open_debug_file (const char * pathname
)
20016 return open_file (pathname
);
20019 /* Process one ELF object file according to the command line options.
20020 This file may actually be stored in an archive. The file is
20021 positioned at the start of the ELF object. Returns TRUE if no
20022 problems were encountered, FALSE otherwise. */
20025 process_object (Filedata
* filedata
)
20027 bfd_boolean have_separate_files
;
20029 bfd_boolean res
= TRUE
;
20031 if (! get_file_header (filedata
))
20033 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20037 /* Initialise per file variables. */
20038 for (i
= ARRAY_SIZE (version_info
); i
--;)
20039 version_info
[i
] = 0;
20041 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
20042 dynamic_info
[i
] = 0;
20043 dynamic_info_DT_GNU_HASH
= 0;
20044 dynamic_info_DT_MIPS_XHASH
= 0;
20046 /* Process the file. */
20048 printf (_("\nFile: %s\n"), filedata
->file_name
);
20050 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20051 Note we do this even if cmdline_dump_sects is empty because we
20052 must make sure that the dump_sets array is zeroed out before each
20053 object file is processed. */
20054 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
20055 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
20057 if (cmdline
.num_dump_sects
> 0)
20059 if (filedata
->num_dump_sects
== 0)
20060 /* A sneaky way of allocating the dump_sects array. */
20061 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
20063 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
20064 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
20065 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
20068 if (! process_file_header (filedata
))
20071 if (! process_section_headers (filedata
))
20073 /* Without loaded section headers we cannot process lots of things. */
20074 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20076 if (! do_using_dynamic
)
20077 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20080 if (! process_section_groups (filedata
))
20081 /* Without loaded section groups we cannot process unwind. */
20084 if (process_program_headers (filedata
))
20085 process_dynamic_section (filedata
);
20089 if (! process_relocs (filedata
))
20092 if (! process_unwind (filedata
))
20095 if (! process_symbol_table (filedata
))
20098 if (! process_syminfo (filedata
))
20101 if (! process_version_sections (filedata
))
20104 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20105 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20107 have_separate_files
= FALSE
;
20109 if (! process_section_contents (filedata
))
20112 if (have_separate_files
)
20116 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20118 if (! process_section_headers (d
->handle
))
20120 else if (! process_section_contents (d
->handle
))
20124 /* The file handles are closed by the call to free_debug_memory() below. */
20127 if (! process_notes (filedata
))
20130 if (! process_gnu_liblist (filedata
))
20133 if (! process_arch_specific (filedata
))
20136 free (filedata
->program_headers
);
20137 filedata
->program_headers
= NULL
;
20139 free (filedata
->section_headers
);
20140 filedata
->section_headers
= NULL
;
20142 free (filedata
->string_table
);
20143 filedata
->string_table
= NULL
;
20144 filedata
->string_table_length
= 0;
20146 if (filedata
->dump_sects
!= NULL
)
20148 free (filedata
->dump_sects
);
20149 filedata
->dump_sects
= NULL
;
20150 filedata
->num_dump_sects
= 0;
20153 if (dynamic_strings
)
20155 free (dynamic_strings
);
20156 dynamic_strings
= NULL
;
20157 dynamic_strings_length
= 0;
20160 if (dynamic_symbols
)
20162 free (dynamic_symbols
);
20163 dynamic_symbols
= NULL
;
20164 num_dynamic_syms
= 0;
20167 if (dynamic_syminfo
)
20169 free (dynamic_syminfo
);
20170 dynamic_syminfo
= NULL
;
20173 if (dynamic_section
)
20175 free (dynamic_section
);
20176 dynamic_section
= NULL
;
20179 while (symtab_shndx_list
!= NULL
)
20181 elf_section_list
*next
= symtab_shndx_list
->next
;
20182 free (symtab_shndx_list
);
20183 symtab_shndx_list
= next
;
20186 if (section_headers_groups
)
20188 free (section_headers_groups
);
20189 section_headers_groups
= NULL
;
20192 if (section_groups
)
20194 struct group_list
* g
;
20195 struct group_list
* next
;
20197 for (i
= 0; i
< group_count
; i
++)
20199 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
20206 free (section_groups
);
20207 section_groups
= NULL
;
20210 free_debug_memory ();
20215 /* Process an ELF archive.
20216 On entry the file is positioned just after the ARMAG string.
20217 Returns TRUE upon success, FALSE otherwise. */
20220 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20222 struct archive_info arch
;
20223 struct archive_info nested_arch
;
20225 bfd_boolean ret
= TRUE
;
20229 /* The ARCH structure is used to hold information about this archive. */
20230 arch
.file_name
= NULL
;
20232 arch
.index_array
= NULL
;
20233 arch
.sym_table
= NULL
;
20234 arch
.longnames
= NULL
;
20236 /* The NESTED_ARCH structure is used as a single-item cache of information
20237 about a nested archive (when members of a thin archive reside within
20238 another regular archive file). */
20239 nested_arch
.file_name
= NULL
;
20240 nested_arch
.file
= NULL
;
20241 nested_arch
.index_array
= NULL
;
20242 nested_arch
.sym_table
= NULL
;
20243 nested_arch
.longnames
= NULL
;
20245 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20246 filedata
->file_size
, is_thin_archive
,
20247 do_archive_index
) != 0)
20253 if (do_archive_index
)
20255 if (arch
.sym_table
== NULL
)
20256 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
20259 unsigned long i
, l
;
20260 unsigned long current_pos
;
20262 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20263 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
20265 current_pos
= ftell (filedata
->handle
);
20267 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20269 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
20271 char * member_name
;
20273 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
20275 if (member_name
!= NULL
)
20277 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
20279 if (qualified_name
!= NULL
)
20281 printf (_("Contents of binary %s at offset "), qualified_name
);
20282 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20284 free (qualified_name
);
20286 free (member_name
);
20290 if (l
>= arch
.sym_size
)
20292 error (_("%s: end of the symbol table reached before the end of the index\n"),
20293 filedata
->file_name
);
20297 /* PR 17531: file: 0b6630b2. */
20298 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20299 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20302 if (arch
.uses_64bit_indices
)
20307 if (l
< arch
.sym_size
)
20309 error (ngettext ("%s: %ld byte remains in the symbol table, "
20310 "but without corresponding entries in "
20311 "the index table\n",
20312 "%s: %ld bytes remain in the symbol table, "
20313 "but without corresponding entries in "
20314 "the index table\n",
20315 arch
.sym_size
- l
),
20316 filedata
->file_name
, arch
.sym_size
- l
);
20320 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20322 error (_("%s: failed to seek back to start of object files in the archive\n"),
20323 filedata
->file_name
);
20329 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20330 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20331 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20332 && !do_section_groups
&& !do_dyn_syms
)
20334 ret
= TRUE
; /* Archive index only. */
20343 char * qualified_name
;
20345 /* Read the next archive header. */
20346 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20348 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
20351 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20352 if (got
!= sizeof arch
.arhdr
)
20356 /* PR 24049 - we cannot use filedata->file_name as this will
20357 have already been freed. */
20358 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20363 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20365 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
20370 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20372 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20373 if (archive_file_size
& 01)
20374 ++archive_file_size
;
20376 name
= get_archive_member_name (&arch
, &nested_arch
);
20379 error (_("%s: bad archive file name\n"), arch
.file_name
);
20383 namelen
= strlen (name
);
20385 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20386 if (qualified_name
== NULL
)
20388 error (_("%s: bad archive file name\n"), arch
.file_name
);
20394 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20396 /* This is a proxy for an external member of a thin archive. */
20397 Filedata
* member_filedata
;
20398 char * member_file_name
= adjust_relative_path
20399 (filedata
->file_name
, name
, namelen
);
20402 if (member_file_name
== NULL
)
20404 free (qualified_name
);
20409 member_filedata
= open_file (member_file_name
);
20410 if (member_filedata
== NULL
)
20412 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20413 free (member_file_name
);
20414 free (qualified_name
);
20419 archive_file_offset
= arch
.nested_member_origin
;
20420 member_filedata
->file_name
= qualified_name
;
20422 if (! process_object (member_filedata
))
20425 close_file (member_filedata
);
20426 free (member_file_name
);
20427 free (qualified_name
);
20429 else if (is_thin_archive
)
20431 Filedata thin_filedata
;
20433 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20435 /* PR 15140: Allow for corrupt thin archives. */
20436 if (nested_arch
.file
== NULL
)
20438 error (_("%s: contains corrupt thin archive: %s\n"),
20439 qualified_name
, name
);
20440 free (qualified_name
);
20447 /* This is a proxy for a member of a nested archive. */
20448 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20450 /* The nested archive file will have been opened and setup by
20451 get_archive_member_name. */
20452 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20454 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
20455 free (qualified_name
);
20460 thin_filedata
.handle
= nested_arch
.file
;
20461 thin_filedata
.file_name
= qualified_name
;
20463 if (! process_object (& thin_filedata
))
20469 archive_file_offset
= arch
.next_arhdr_offset
;
20470 arch
.next_arhdr_offset
+= archive_file_size
;
20472 filedata
->file_name
= qualified_name
;
20473 if (! process_object (filedata
))
20477 free (qualified_name
);
20481 if (nested_arch
.file
!= NULL
)
20482 fclose (nested_arch
.file
);
20483 release_archive (&nested_arch
);
20484 release_archive (&arch
);
20490 process_file (char * file_name
)
20492 Filedata
* filedata
= NULL
;
20493 struct stat statbuf
;
20494 char armag
[SARMAG
];
20495 bfd_boolean ret
= TRUE
;
20497 if (stat (file_name
, &statbuf
) < 0)
20499 if (errno
== ENOENT
)
20500 error (_("'%s': No such file\n"), file_name
);
20502 error (_("Could not locate '%s'. System error message: %s\n"),
20503 file_name
, strerror (errno
));
20507 if (! S_ISREG (statbuf
.st_mode
))
20509 error (_("'%s' is not an ordinary file\n"), file_name
);
20513 filedata
= calloc (1, sizeof * filedata
);
20514 if (filedata
== NULL
)
20516 error (_("Out of memory allocating file data structure\n"));
20520 filedata
->file_name
= file_name
;
20521 filedata
->handle
= fopen (file_name
, "rb");
20522 if (filedata
->handle
== NULL
)
20524 error (_("Input file '%s' is not readable.\n"), file_name
);
20529 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20531 error (_("%s: Failed to read file's magic number\n"), file_name
);
20532 fclose (filedata
->handle
);
20537 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20539 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20541 if (! process_archive (filedata
, FALSE
))
20544 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20546 if ( ! process_archive (filedata
, TRUE
))
20551 if (do_archive_index
)
20552 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20555 rewind (filedata
->handle
);
20556 archive_file_size
= archive_file_offset
= 0;
20558 if (! process_object (filedata
))
20562 fclose (filedata
->handle
);
20563 free (filedata
->section_headers
);
20564 free (filedata
->program_headers
);
20565 free (filedata
->string_table
);
20566 free (filedata
->dump_sects
);
20569 free (ba_cache
.strtab
);
20570 ba_cache
.strtab
= NULL
;
20571 free (ba_cache
.symtab
);
20572 ba_cache
.symtab
= NULL
;
20573 ba_cache
.filedata
= NULL
;
20578 #ifdef SUPPORT_DISASSEMBLY
20579 /* Needed by the i386 disassembler. For extra credit, someone could
20580 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20584 print_address (unsigned int addr
, FILE * outfile
)
20586 fprintf (outfile
,"0x%8.8x", addr
);
20589 /* Needed by the i386 disassembler. */
20592 db_task_printsym (unsigned int addr
)
20594 print_address (addr
, stderr
);
20599 main (int argc
, char ** argv
)
20603 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20604 setlocale (LC_MESSAGES
, "");
20606 #if defined (HAVE_SETLOCALE)
20607 setlocale (LC_CTYPE
, "");
20609 bindtextdomain (PACKAGE
, LOCALEDIR
);
20610 textdomain (PACKAGE
);
20612 expandargv (&argc
, &argv
);
20614 cmdline
.file_name
= "<cmdline>";
20615 parse_args (& cmdline
, argc
, argv
);
20617 if (optind
< (argc
- 1))
20619 else if (optind
>= argc
)
20621 warn (_("Nothing to do.\n"));
20626 while (optind
< argc
)
20627 if (! process_file (argv
[optind
++]))
20630 if (cmdline
.dump_sects
!= NULL
)
20631 free (cmdline
.dump_sects
);
20633 free (dump_ctf_symtab_name
);
20634 free (dump_ctf_strtab_name
);
20635 free (dump_ctf_parent_name
);
20637 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;