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 filedata
->section_headers
= NULL
;
6122 if (filedata
->file_header
.e_shnum
== 0)
6124 /* PR binutils/12467. */
6125 if (filedata
->file_header
.e_shoff
!= 0)
6127 warn (_("possibly corrupt ELF file header - it has a non-zero"
6128 " section header offset, but no section headers\n"));
6131 else if (do_sections
)
6132 printf (_("\nThere are no sections in this file.\n"));
6137 if (do_sections
&& !do_header
)
6138 printf (ngettext ("There is %d section header, "
6139 "starting at offset 0x%lx:\n",
6140 "There are %d section headers, "
6141 "starting at offset 0x%lx:\n",
6142 filedata
->file_header
.e_shnum
),
6143 filedata
->file_header
.e_shnum
,
6144 (unsigned long) filedata
->file_header
.e_shoff
);
6148 if (! get_32bit_section_headers (filedata
, FALSE
))
6153 if (! get_64bit_section_headers (filedata
, FALSE
))
6157 /* Read in the string table, so that we have names to display. */
6158 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6159 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6161 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6163 if (section
->sh_size
!= 0)
6165 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6166 1, section
->sh_size
,
6169 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6173 /* Scan the sections for the dynamic symbol table
6174 and dynamic string table and debug sections. */
6175 dynamic_symbols
= NULL
;
6176 dynamic_strings
= NULL
;
6177 dynamic_syminfo
= NULL
;
6178 symtab_shndx_list
= NULL
;
6180 eh_addr_size
= is_32bit_elf
? 4 : 8;
6181 switch (filedata
->file_header
.e_machine
)
6184 case EM_MIPS_RS3_LE
:
6185 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6186 FDE addresses. However, the ABI also has a semi-official ILP32
6187 variant for which the normal FDE address size rules apply.
6189 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6190 section, where XX is the size of longs in bits. Unfortunately,
6191 earlier compilers provided no way of distinguishing ILP32 objects
6192 from LP64 objects, so if there's any doubt, we should assume that
6193 the official LP64 form is being used. */
6194 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6195 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6201 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6203 case E_H8_MACH_H8300
:
6204 case E_H8_MACH_H8300HN
:
6205 case E_H8_MACH_H8300SN
:
6206 case E_H8_MACH_H8300SXN
:
6209 case E_H8_MACH_H8300H
:
6210 case E_H8_MACH_H8300S
:
6211 case E_H8_MACH_H8300SX
:
6219 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6221 case EF_M32C_CPU_M16C
:
6228 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6231 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6232 if (section->sh_entsize != expected_entsize) \
6235 sprintf_vma (buf, section->sh_entsize); \
6236 /* Note: coded this way so that there is a single string for \
6238 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6239 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6240 (unsigned) expected_entsize); \
6241 section->sh_entsize = expected_entsize; \
6246 #define CHECK_ENTSIZE(section, i, type) \
6247 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6248 sizeof (Elf64_External_##type))
6250 for (i
= 0, section
= filedata
->section_headers
;
6251 i
< filedata
->file_header
.e_shnum
;
6254 char * name
= SECTION_NAME (section
);
6256 if (section
->sh_type
== SHT_DYNSYM
)
6258 if (dynamic_symbols
!= NULL
)
6260 error (_("File contains multiple dynamic symbol tables\n"));
6264 CHECK_ENTSIZE (section
, i
, Sym
);
6265 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6267 else if (section
->sh_type
== SHT_STRTAB
6268 && streq (name
, ".dynstr"))
6270 if (dynamic_strings
!= NULL
)
6272 error (_("File contains multiple dynamic string tables\n"));
6276 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6277 1, section
->sh_size
,
6278 _("dynamic strings"));
6279 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6281 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6283 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6285 entry
->hdr
= section
;
6286 entry
->next
= symtab_shndx_list
;
6287 symtab_shndx_list
= entry
;
6289 else if (section
->sh_type
== SHT_SYMTAB
)
6290 CHECK_ENTSIZE (section
, i
, Sym
);
6291 else if (section
->sh_type
== SHT_GROUP
)
6292 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6293 else if (section
->sh_type
== SHT_REL
)
6294 CHECK_ENTSIZE (section
, i
, Rel
);
6295 else if (section
->sh_type
== SHT_RELA
)
6296 CHECK_ENTSIZE (section
, i
, Rela
);
6297 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6298 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6299 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6300 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6301 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6302 && (const_strneq (name
, ".debug_")
6303 || const_strneq (name
, ".zdebug_")))
6306 name
+= sizeof (".zdebug_") - 1;
6308 name
+= sizeof (".debug_") - 1;
6311 || (do_debug_info
&& const_strneq (name
, "info"))
6312 || (do_debug_info
&& const_strneq (name
, "types"))
6313 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6314 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6315 || (do_debug_lines
&& const_strneq (name
, "line."))
6316 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6317 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6318 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6319 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6320 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6321 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6322 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6323 || (do_debug_frames
&& const_strneq (name
, "frame"))
6324 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6325 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6326 || (do_debug_str
&& const_strneq (name
, "str"))
6327 || (do_debug_loc
&& const_strneq (name
, "loc"))
6328 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6329 || (do_debug_addr
&& const_strneq (name
, "addr"))
6330 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6331 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6333 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6335 /* Linkonce section to be combined with .debug_info at link time. */
6336 else if ((do_debugging
|| do_debug_info
)
6337 && const_strneq (name
, ".gnu.linkonce.wi."))
6338 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6339 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6340 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6341 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6342 || streq (name
, ".debug_names")))
6343 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6344 /* Trace sections for Itanium VMS. */
6345 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6346 || do_trace_aranges
)
6347 && const_strneq (name
, ".trace_"))
6349 name
+= sizeof (".trace_") - 1;
6352 || (do_trace_info
&& streq (name
, "info"))
6353 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6354 || (do_trace_aranges
&& streq (name
, "aranges"))
6356 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6358 else if ((do_debugging
|| do_debug_links
)
6359 && (const_strneq (name
, ".gnu_debuglink")
6360 || const_strneq (name
, ".gnu_debugaltlink")))
6361 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6367 if (filedata
->file_header
.e_shnum
> 1)
6368 printf (_("\nSection Headers:\n"));
6370 printf (_("\nSection Header:\n"));
6374 if (do_section_details
)
6376 printf (_(" [Nr] Name\n"));
6377 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6381 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6385 if (do_section_details
)
6387 printf (_(" [Nr] Name\n"));
6388 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6392 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6396 if (do_section_details
)
6398 printf (_(" [Nr] Name\n"));
6399 printf (_(" Type Address Offset Link\n"));
6400 printf (_(" Size EntSize Info Align\n"));
6404 printf (_(" [Nr] Name Type Address Offset\n"));
6405 printf (_(" Size EntSize Flags Link Info Align\n"));
6409 if (do_section_details
)
6410 printf (_(" Flags\n"));
6412 for (i
= 0, section
= filedata
->section_headers
;
6413 i
< filedata
->file_header
.e_shnum
;
6416 /* Run some sanity checks on the section header. */
6418 /* Check the sh_link field. */
6419 switch (section
->sh_type
)
6423 if (section
->sh_link
== 0
6424 && (filedata
->file_header
.e_type
== ET_EXEC
6425 || filedata
->file_header
.e_type
== ET_DYN
))
6426 /* A dynamic relocation section where all entries use a
6427 zero symbol index need not specify a symtab section. */
6430 case SHT_SYMTAB_SHNDX
:
6434 case SHT_GNU_versym
:
6435 if (section
->sh_link
== 0
6436 || section
->sh_link
>= filedata
->file_header
.e_shnum
6437 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6438 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6439 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6440 i
, section
->sh_link
);
6446 case SHT_GNU_verneed
:
6447 case SHT_GNU_verdef
:
6448 case SHT_GNU_LIBLIST
:
6449 if (section
->sh_link
== 0
6450 || section
->sh_link
>= filedata
->file_header
.e_shnum
6451 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6452 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6453 i
, section
->sh_link
);
6456 case SHT_INIT_ARRAY
:
6457 case SHT_FINI_ARRAY
:
6458 case SHT_PREINIT_ARRAY
:
6459 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6460 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6461 i
, section
->sh_link
);
6465 /* FIXME: Add support for target specific section types. */
6466 #if 0 /* Currently we do not check other section types as there are too
6467 many special cases. Stab sections for example have a type
6468 of SHT_PROGBITS but an sh_link field that links to the .stabstr
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
);
6477 /* Check the sh_info field. */
6478 switch (section
->sh_type
)
6482 if (section
->sh_info
== 0
6483 && (filedata
->file_header
.e_type
== ET_EXEC
6484 || filedata
->file_header
.e_type
== ET_DYN
))
6485 /* Dynamic relocations apply to segments, so they do not
6486 need to specify the section they relocate. */
6488 if (section
->sh_info
== 0
6489 || section
->sh_info
>= filedata
->file_header
.e_shnum
6490 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6491 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6492 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6493 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6494 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6495 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6496 /* FIXME: Are other section types valid ? */
6497 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6498 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6499 i
, section
->sh_info
);
6504 case SHT_SYMTAB_SHNDX
:
6505 case SHT_INIT_ARRAY
:
6506 case SHT_FINI_ARRAY
:
6507 case SHT_PREINIT_ARRAY
:
6508 if (section
->sh_info
!= 0)
6509 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6510 i
, section
->sh_info
);
6516 /* A symbol index - we assume that it is valid. */
6520 /* FIXME: Add support for target specific section types. */
6521 if (section
->sh_type
== SHT_NOBITS
)
6522 /* NOBITS section headers with non-zero sh_info fields can be
6523 created when a binary is stripped of everything but its debug
6524 information. The stripped sections have their headers
6525 preserved but their types set to SHT_NOBITS. So do not check
6526 this type of section. */
6528 else if (section
->sh_flags
& SHF_INFO_LINK
)
6530 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6531 warn (_("[%2u]: Expected link to another section in info field"), i
);
6533 else if (section
->sh_type
< SHT_LOOS
6534 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6535 && section
->sh_info
!= 0)
6536 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6537 i
, section
->sh_info
);
6541 /* Check the sh_size field. */
6542 if (section
->sh_size
> filedata
->file_size
6543 && section
->sh_type
!= SHT_NOBITS
6544 && section
->sh_type
!= SHT_NULL
6545 && section
->sh_type
< SHT_LOOS
)
6546 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6548 printf (" [%2u] ", i
);
6549 if (do_section_details
)
6550 printf ("%s\n ", printable_section_name (filedata
, section
));
6552 print_symbol (-17, SECTION_NAME (section
));
6554 printf (do_wide
? " %-15s " : " %-15.15s ",
6555 get_section_type_name (filedata
, section
->sh_type
));
6559 const char * link_too_big
= NULL
;
6561 print_vma (section
->sh_addr
, LONG_HEX
);
6563 printf ( " %6.6lx %6.6lx %2.2lx",
6564 (unsigned long) section
->sh_offset
,
6565 (unsigned long) section
->sh_size
,
6566 (unsigned long) section
->sh_entsize
);
6568 if (do_section_details
)
6569 fputs (" ", stdout
);
6571 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6573 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6576 /* The sh_link value is out of range. Normally this indicates
6577 an error but it can have special values in Solaris binaries. */
6578 switch (filedata
->file_header
.e_machine
)
6585 case EM_OLD_SPARCV9
:
6586 case EM_SPARC32PLUS
:
6589 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6590 link_too_big
= "BEFORE";
6591 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6592 link_too_big
= "AFTER";
6599 if (do_section_details
)
6601 if (link_too_big
!= NULL
&& * link_too_big
)
6602 printf ("<%s> ", link_too_big
);
6604 printf ("%2u ", section
->sh_link
);
6605 printf ("%3u %2lu\n", section
->sh_info
,
6606 (unsigned long) section
->sh_addralign
);
6609 printf ("%2u %3u %2lu\n",
6612 (unsigned long) section
->sh_addralign
);
6614 if (link_too_big
&& ! * link_too_big
)
6615 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6616 i
, section
->sh_link
);
6620 print_vma (section
->sh_addr
, LONG_HEX
);
6622 if ((long) section
->sh_offset
== section
->sh_offset
)
6623 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6627 print_vma (section
->sh_offset
, LONG_HEX
);
6630 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6631 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6635 print_vma (section
->sh_size
, LONG_HEX
);
6638 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6639 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6643 print_vma (section
->sh_entsize
, LONG_HEX
);
6646 if (do_section_details
)
6647 fputs (" ", stdout
);
6649 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6651 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6653 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6654 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6657 print_vma (section
->sh_addralign
, DEC
);
6661 else if (do_section_details
)
6664 print_vma (section
->sh_addr
, LONG_HEX
);
6665 if ((long) section
->sh_offset
== section
->sh_offset
)
6666 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6670 print_vma (section
->sh_offset
, LONG_HEX
);
6672 printf (" %u\n ", section
->sh_link
);
6673 print_vma (section
->sh_size
, LONG_HEX
);
6675 print_vma (section
->sh_entsize
, LONG_HEX
);
6677 printf (" %-16u %lu\n",
6679 (unsigned long) section
->sh_addralign
);
6684 print_vma (section
->sh_addr
, LONG_HEX
);
6685 if ((long) section
->sh_offset
== section
->sh_offset
)
6686 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6690 print_vma (section
->sh_offset
, LONG_HEX
);
6693 print_vma (section
->sh_size
, LONG_HEX
);
6695 print_vma (section
->sh_entsize
, LONG_HEX
);
6697 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6699 printf (" %2u %3u %lu\n",
6702 (unsigned long) section
->sh_addralign
);
6705 if (do_section_details
)
6707 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6708 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6710 /* Minimum section size is 12 bytes for 32-bit compression
6711 header + 12 bytes for compressed data header. */
6712 unsigned char buf
[24];
6714 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6715 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6716 sizeof (buf
), _("compression header")))
6718 Elf_Internal_Chdr chdr
;
6720 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6722 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6725 printf (_(" [<unknown>: 0x%x], "),
6727 print_vma (chdr
.ch_size
, LONG_HEX
);
6728 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6734 if (!do_section_details
)
6736 /* The ordering of the letters shown here matches the ordering of the
6737 corresponding SHF_xxx values, and hence the order in which these
6738 letters will be displayed to the user. */
6739 printf (_("Key to Flags:\n\
6740 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6741 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6742 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6743 if (filedata
->file_header
.e_machine
== EM_X86_64
6744 || filedata
->file_header
.e_machine
== EM_L1OM
6745 || filedata
->file_header
.e_machine
== EM_K1OM
)
6746 printf (_("l (large), "));
6747 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6748 printf (_("y (purecode), "));
6749 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6750 printf (_("v (VLE), "));
6751 printf ("p (processor specific)\n");
6758 get_group_flags (unsigned int flags
)
6760 static char buff
[128];
6764 else if (flags
== GRP_COMDAT
)
6767 snprintf (buff
, 14, _("[0x%x: "), flags
);
6769 flags
&= ~ GRP_COMDAT
;
6770 if (flags
& GRP_MASKOS
)
6772 strcat (buff
, "<OS specific>");
6773 flags
&= ~ GRP_MASKOS
;
6776 if (flags
& GRP_MASKPROC
)
6778 strcat (buff
, "<PROC specific>");
6779 flags
&= ~ GRP_MASKPROC
;
6783 strcat (buff
, "<unknown>");
6790 process_section_groups (Filedata
* filedata
)
6792 Elf_Internal_Shdr
* section
;
6794 struct group
* group
;
6795 Elf_Internal_Shdr
* symtab_sec
;
6796 Elf_Internal_Shdr
* strtab_sec
;
6797 Elf_Internal_Sym
* symtab
;
6798 unsigned long num_syms
;
6802 /* Don't process section groups unless needed. */
6803 if (!do_unwind
&& !do_section_groups
)
6806 if (filedata
->file_header
.e_shnum
== 0)
6808 if (do_section_groups
)
6809 printf (_("\nThere are no sections to group in this file.\n"));
6814 if (filedata
->section_headers
== NULL
)
6816 error (_("Section headers are not available!\n"));
6817 /* PR 13622: This can happen with a corrupt ELF header. */
6821 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6822 sizeof (struct group
*));
6824 if (section_headers_groups
== NULL
)
6826 error (_("Out of memory reading %u section group headers\n"),
6827 filedata
->file_header
.e_shnum
);
6831 /* Scan the sections for the group section. */
6833 for (i
= 0, section
= filedata
->section_headers
;
6834 i
< filedata
->file_header
.e_shnum
;
6836 if (section
->sh_type
== SHT_GROUP
)
6839 if (group_count
== 0)
6841 if (do_section_groups
)
6842 printf (_("\nThere are no section groups in this file.\n"));
6847 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6849 if (section_groups
== NULL
)
6851 error (_("Out of memory reading %lu groups\n"),
6852 (unsigned long) group_count
);
6862 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6863 i
< filedata
->file_header
.e_shnum
;
6866 if (section
->sh_type
== SHT_GROUP
)
6868 const char * name
= printable_section_name (filedata
, section
);
6869 const char * group_name
;
6870 unsigned char * start
;
6871 unsigned char * indices
;
6872 unsigned int entry
, j
, size
;
6873 Elf_Internal_Shdr
* sec
;
6874 Elf_Internal_Sym
* sym
;
6876 /* Get the symbol table. */
6877 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6878 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6881 error (_("Bad sh_link in group section `%s'\n"), name
);
6885 if (symtab_sec
!= sec
)
6890 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6895 error (_("Corrupt header in group section `%s'\n"), name
);
6899 if (section
->sh_info
>= num_syms
)
6901 error (_("Bad sh_info in group section `%s'\n"), name
);
6905 sym
= symtab
+ section
->sh_info
;
6907 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6909 if (sym
->st_shndx
== 0
6910 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6912 error (_("Bad sh_info in group section `%s'\n"), name
);
6916 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6925 /* Get the string table. */
6926 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6935 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6941 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6942 1, strtab_sec
->sh_size
,
6944 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6946 group_name
= sym
->st_name
< strtab_size
6947 ? strtab
+ sym
->st_name
: _("<corrupt>");
6950 /* PR 17531: file: loop. */
6951 if (section
->sh_entsize
> section
->sh_size
)
6953 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6954 printable_section_name (filedata
, section
),
6955 (unsigned long) section
->sh_entsize
,
6956 (unsigned long) section
->sh_size
);
6960 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6961 1, section
->sh_size
,
6967 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6968 entry
= byte_get (indices
, 4);
6971 if (do_section_groups
)
6973 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6974 get_group_flags (entry
), i
, name
, group_name
, size
);
6976 printf (_(" [Index] Name\n"));
6979 group
->group_index
= i
;
6981 for (j
= 0; j
< size
; j
++)
6983 struct group_list
* g
;
6985 entry
= byte_get (indices
, 4);
6988 if (entry
>= filedata
->file_header
.e_shnum
)
6990 static unsigned num_group_errors
= 0;
6992 if (num_group_errors
++ < 10)
6994 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6995 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6996 if (num_group_errors
== 10)
6997 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7002 if (section_headers_groups
[entry
] != NULL
)
7006 static unsigned num_errs
= 0;
7008 if (num_errs
++ < 10)
7010 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7012 section_headers_groups
[entry
]->group_index
);
7014 warn (_("Further error messages about already contained group sections suppressed\n"));
7020 /* Intel C/C++ compiler may put section 0 in a
7021 section group. We just warn it the first time
7022 and ignore it afterwards. */
7023 static bfd_boolean warned
= FALSE
;
7026 error (_("section 0 in group section [%5u]\n"),
7027 section_headers_groups
[entry
]->group_index
);
7033 section_headers_groups
[entry
] = group
;
7035 if (do_section_groups
)
7037 sec
= filedata
->section_headers
+ entry
;
7038 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7041 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7042 g
->section_index
= entry
;
7043 g
->next
= group
->root
;
7061 /* Data used to display dynamic fixups. */
7063 struct ia64_vms_dynfixup
7065 bfd_vma needed_ident
; /* Library ident number. */
7066 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7067 bfd_vma fixup_needed
; /* Index of the library. */
7068 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7069 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7072 /* Data used to display dynamic relocations. */
7074 struct ia64_vms_dynimgrela
7076 bfd_vma img_rela_cnt
; /* Number of relocations. */
7077 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7080 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7084 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7085 struct ia64_vms_dynfixup
* fixup
,
7086 const char * strtab
,
7087 unsigned int strtab_sz
)
7089 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7091 const char * lib_name
;
7093 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7094 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
7095 _("dynamic section image fixups"));
7099 if (fixup
->needed
< strtab_sz
)
7100 lib_name
= strtab
+ fixup
->needed
;
7103 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7104 (unsigned long) fixup
->needed
);
7108 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7109 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7111 (_("Seg Offset Type SymVec DataType\n"));
7113 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7118 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7119 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7120 type
= BYTE_GET (imfs
[i
].type
);
7121 rtype
= elf_ia64_reloc_type (type
);
7123 printf (" 0x%08x ", type
);
7125 printf (" %-32s ", rtype
);
7126 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7127 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7134 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7137 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7139 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7142 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7143 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7144 _("dynamic section image relocations"));
7148 printf (_("\nImage relocs\n"));
7150 (_("Seg Offset Type Addend Seg Sym Off\n"));
7152 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7157 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7158 printf ("%08" BFD_VMA_FMT
"x ",
7159 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7160 type
= BYTE_GET (imrs
[i
].type
);
7161 rtype
= elf_ia64_reloc_type (type
);
7163 printf ("0x%08x ", type
);
7165 printf ("%-31s ", rtype
);
7166 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7167 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7168 printf ("%08" BFD_VMA_FMT
"x\n",
7169 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7176 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7179 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7181 struct ia64_vms_dynfixup fixup
;
7182 struct ia64_vms_dynimgrela imgrela
;
7183 Elf_Internal_Dyn
*entry
;
7184 bfd_vma strtab_off
= 0;
7185 bfd_vma strtab_sz
= 0;
7186 char *strtab
= NULL
;
7187 bfd_boolean res
= TRUE
;
7189 memset (&fixup
, 0, sizeof (fixup
));
7190 memset (&imgrela
, 0, sizeof (imgrela
));
7192 /* Note: the order of the entries is specified by the OpenVMS specs. */
7193 for (entry
= dynamic_section
;
7194 entry
< dynamic_section
+ dynamic_nent
;
7197 switch (entry
->d_tag
)
7199 case DT_IA_64_VMS_STRTAB_OFFSET
:
7200 strtab_off
= entry
->d_un
.d_val
;
7203 strtab_sz
= entry
->d_un
.d_val
;
7205 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7206 1, strtab_sz
, _("dynamic string section"));
7211 case DT_IA_64_VMS_NEEDED_IDENT
:
7212 fixup
.needed_ident
= entry
->d_un
.d_val
;
7215 fixup
.needed
= entry
->d_un
.d_val
;
7217 case DT_IA_64_VMS_FIXUP_NEEDED
:
7218 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7220 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7221 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7223 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7224 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7225 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7228 case DT_IA_64_VMS_IMG_RELA_CNT
:
7229 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7231 case DT_IA_64_VMS_IMG_RELA_OFF
:
7232 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7233 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7255 dynamic_relocations
[] =
7257 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7258 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7259 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7262 /* Process the reloc section. */
7265 process_relocs (Filedata
* filedata
)
7267 unsigned long rel_size
;
7268 unsigned long rel_offset
;
7273 if (do_using_dynamic
)
7277 bfd_boolean has_dynamic_reloc
;
7280 has_dynamic_reloc
= FALSE
;
7282 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7284 is_rela
= dynamic_relocations
[i
].rela
;
7285 name
= dynamic_relocations
[i
].name
;
7286 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7287 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7290 has_dynamic_reloc
= TRUE
;
7292 if (is_rela
== UNKNOWN
)
7294 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7295 switch (dynamic_info
[DT_PLTREL
])
7309 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7310 name
, rel_offset
, rel_size
);
7312 dump_relocations (filedata
,
7313 offset_from_vma (filedata
, rel_offset
, rel_size
),
7315 dynamic_symbols
, num_dynamic_syms
,
7316 dynamic_strings
, dynamic_strings_length
,
7317 is_rela
, TRUE
/* is_dynamic */);
7321 if (is_ia64_vms (filedata
))
7322 if (process_ia64_vms_dynamic_relocs (filedata
))
7323 has_dynamic_reloc
= TRUE
;
7325 if (! has_dynamic_reloc
)
7326 printf (_("\nThere are no dynamic relocations in this file.\n"));
7330 Elf_Internal_Shdr
* section
;
7332 bfd_boolean found
= FALSE
;
7334 for (i
= 0, section
= filedata
->section_headers
;
7335 i
< filedata
->file_header
.e_shnum
;
7338 if ( section
->sh_type
!= SHT_RELA
7339 && section
->sh_type
!= SHT_REL
)
7342 rel_offset
= section
->sh_offset
;
7343 rel_size
= section
->sh_size
;
7347 Elf_Internal_Shdr
* strsec
;
7349 unsigned long num_rela
;
7351 printf (_("\nRelocation section "));
7353 if (filedata
->string_table
== NULL
)
7354 printf ("%d", section
->sh_name
);
7356 printf ("'%s'", printable_section_name (filedata
, section
));
7358 num_rela
= rel_size
/ section
->sh_entsize
;
7359 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7360 " at offset 0x%lx contains %lu entries:\n",
7362 rel_offset
, num_rela
);
7364 is_rela
= section
->sh_type
== SHT_RELA
;
7366 if (section
->sh_link
!= 0
7367 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7369 Elf_Internal_Shdr
* symsec
;
7370 Elf_Internal_Sym
* symtab
;
7371 unsigned long nsyms
;
7372 unsigned long strtablen
= 0;
7373 char * strtab
= NULL
;
7375 symsec
= filedata
->section_headers
+ section
->sh_link
;
7376 if (symsec
->sh_type
!= SHT_SYMTAB
7377 && symsec
->sh_type
!= SHT_DYNSYM
)
7380 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7385 if (symsec
->sh_link
!= 0
7386 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7388 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7390 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7393 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7396 dump_relocations (filedata
, rel_offset
, rel_size
,
7397 symtab
, nsyms
, strtab
, strtablen
,
7399 symsec
->sh_type
== SHT_DYNSYM
);
7405 dump_relocations (filedata
, rel_offset
, rel_size
,
7406 NULL
, 0, NULL
, 0, is_rela
,
7407 FALSE
/* is_dynamic */);
7415 /* Users sometimes forget the -D option, so try to be helpful. */
7416 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7418 if (dynamic_info
[dynamic_relocations
[i
].size
])
7420 printf (_("\nThere are no static relocations in this file."));
7421 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7426 if (i
== ARRAY_SIZE (dynamic_relocations
))
7427 printf (_("\nThere are no relocations in this file.\n"));
7434 /* An absolute address consists of a section and an offset. If the
7435 section is NULL, the offset itself is the address, otherwise, the
7436 address equals to LOAD_ADDRESS(section) + offset. */
7440 unsigned short section
;
7444 /* Find the nearest symbol at or below ADDR. Returns the symbol
7445 name, if found, and the offset from the symbol to ADDR. */
7448 find_symbol_for_address (Filedata
* filedata
,
7449 Elf_Internal_Sym
* symtab
,
7450 unsigned long nsyms
,
7451 const char * strtab
,
7452 unsigned long strtab_size
,
7453 struct absaddr addr
,
7454 const char ** symname
,
7457 bfd_vma dist
= 0x100000;
7458 Elf_Internal_Sym
* sym
;
7459 Elf_Internal_Sym
* beg
;
7460 Elf_Internal_Sym
* end
;
7461 Elf_Internal_Sym
* best
= NULL
;
7463 REMOVE_ARCH_BITS (addr
.offset
);
7465 end
= symtab
+ nsyms
;
7471 sym
= beg
+ (end
- beg
) / 2;
7473 value
= sym
->st_value
;
7474 REMOVE_ARCH_BITS (value
);
7476 if (sym
->st_name
!= 0
7477 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7478 && addr
.offset
>= value
7479 && addr
.offset
- value
< dist
)
7482 dist
= addr
.offset
- value
;
7487 if (addr
.offset
< value
)
7495 *symname
= (best
->st_name
>= strtab_size
7496 ? _("<corrupt>") : strtab
+ best
->st_name
);
7502 *offset
= addr
.offset
;
7505 static /* signed */ int
7506 symcmp (const void *p
, const void *q
)
7508 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7509 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7511 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7514 /* Process the unwind section. */
7516 #include "unwind-ia64.h"
7518 struct ia64_unw_table_entry
7520 struct absaddr start
;
7522 struct absaddr info
;
7525 struct ia64_unw_aux_info
7527 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7528 unsigned long table_len
; /* Length of unwind table. */
7529 unsigned char * info
; /* Unwind info. */
7530 unsigned long info_size
; /* Size of unwind info. */
7531 bfd_vma info_addr
; /* Starting address of unwind info. */
7532 bfd_vma seg_base
; /* Starting address of segment. */
7533 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7534 unsigned long nsyms
; /* Number of symbols. */
7535 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7536 unsigned long nfuns
; /* Number of entries in funtab. */
7537 char * strtab
; /* The string table. */
7538 unsigned long strtab_size
; /* Size of string table. */
7542 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7544 struct ia64_unw_table_entry
* tp
;
7545 unsigned long j
, nfuns
;
7547 bfd_boolean res
= TRUE
;
7549 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7550 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7551 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7552 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7554 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7556 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7560 const unsigned char * dp
;
7561 const unsigned char * head
;
7562 const unsigned char * end
;
7563 const char * procname
;
7565 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7566 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7568 fputs ("\n<", stdout
);
7572 fputs (procname
, stdout
);
7575 printf ("+%lx", (unsigned long) offset
);
7578 fputs (">: [", stdout
);
7579 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7580 fputc ('-', stdout
);
7581 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7582 printf ("], info at +0x%lx\n",
7583 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7585 /* PR 17531: file: 86232b32. */
7586 if (aux
->info
== NULL
)
7589 offset
= tp
->info
.offset
;
7590 if (tp
->info
.section
)
7592 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7594 warn (_("Invalid section %u in table entry %ld\n"),
7595 tp
->info
.section
, (long) (tp
- aux
->table
));
7599 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7601 offset
-= aux
->info_addr
;
7602 /* PR 17531: file: 0997b4d1. */
7603 if (offset
>= aux
->info_size
7604 || aux
->info_size
- offset
< 8)
7606 warn (_("Invalid offset %lx in table entry %ld\n"),
7607 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7612 head
= aux
->info
+ offset
;
7613 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7615 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7616 (unsigned) UNW_VER (stamp
),
7617 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7618 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7619 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7620 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7622 if (UNW_VER (stamp
) != 1)
7624 printf (_("\tUnknown version.\n"));
7629 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7630 /* PR 17531: file: 16ceda89. */
7631 if (end
> aux
->info
+ aux
->info_size
)
7632 end
= aux
->info
+ aux
->info_size
;
7633 for (dp
= head
+ 8; dp
< end
;)
7634 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7643 slurp_ia64_unwind_table (Filedata
* filedata
,
7644 struct ia64_unw_aux_info
* aux
,
7645 Elf_Internal_Shdr
* sec
)
7647 unsigned long size
, nrelas
, i
;
7648 Elf_Internal_Phdr
* seg
;
7649 struct ia64_unw_table_entry
* tep
;
7650 Elf_Internal_Shdr
* relsec
;
7651 Elf_Internal_Rela
* rela
;
7652 Elf_Internal_Rela
* rp
;
7653 unsigned char * table
;
7655 Elf_Internal_Sym
* sym
;
7656 const char * relname
;
7660 /* First, find the starting address of the segment that includes
7663 if (filedata
->file_header
.e_phnum
)
7665 if (! get_program_headers (filedata
))
7668 for (seg
= filedata
->program_headers
;
7669 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7672 if (seg
->p_type
!= PT_LOAD
)
7675 if (sec
->sh_addr
>= seg
->p_vaddr
7676 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7678 aux
->seg_base
= seg
->p_vaddr
;
7684 /* Second, build the unwind table from the contents of the unwind section: */
7685 size
= sec
->sh_size
;
7686 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7691 aux
->table_len
= size
/ (3 * eh_addr_size
);
7692 aux
->table
= (struct ia64_unw_table_entry
*)
7693 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7696 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7698 tep
->start
.section
= SHN_UNDEF
;
7699 tep
->end
.section
= SHN_UNDEF
;
7700 tep
->info
.section
= SHN_UNDEF
;
7701 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7702 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7703 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7704 tep
->start
.offset
+= aux
->seg_base
;
7705 tep
->end
.offset
+= aux
->seg_base
;
7706 tep
->info
.offset
+= aux
->seg_base
;
7710 /* Third, apply any relocations to the unwind table: */
7711 for (relsec
= filedata
->section_headers
;
7712 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7715 if (relsec
->sh_type
!= SHT_RELA
7716 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7717 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7720 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7729 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7731 unsigned int sym_ndx
;
7732 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7733 relname
= elf_ia64_reloc_type (r_type
);
7735 /* PR 17531: file: 9fa67536. */
7736 if (relname
== NULL
)
7738 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7742 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7744 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7748 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7750 /* PR 17531: file: 5bc8d9bf. */
7751 if (i
>= aux
->table_len
)
7753 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7757 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7758 if (sym_ndx
>= aux
->nsyms
)
7760 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7764 sym
= aux
->symtab
+ sym_ndx
;
7766 switch (rp
->r_offset
/ eh_addr_size
% 3)
7769 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7770 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7773 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7774 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7777 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7778 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7792 ia64_process_unwind (Filedata
* filedata
)
7794 Elf_Internal_Shdr
* sec
;
7795 Elf_Internal_Shdr
* unwsec
= NULL
;
7796 Elf_Internal_Shdr
* strsec
;
7797 unsigned long i
, unwcount
= 0, unwstart
= 0;
7798 struct ia64_unw_aux_info aux
;
7799 bfd_boolean res
= TRUE
;
7801 memset (& aux
, 0, sizeof (aux
));
7803 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7805 if (sec
->sh_type
== SHT_SYMTAB
7806 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7808 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7810 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7811 if (aux
.strtab
!= NULL
)
7813 error (_("Multiple auxillary string tables encountered\n"));
7817 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7820 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7822 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7827 printf (_("\nThere are no unwind sections in this file.\n"));
7829 while (unwcount
-- > 0)
7834 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7835 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7836 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7841 /* We have already counted the number of SHT_IA64_UNWIND
7842 sections so the loop above should never fail. */
7843 assert (unwsec
!= NULL
);
7846 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7848 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7850 /* We need to find which section group it is in. */
7851 struct group_list
* g
;
7853 if (section_headers_groups
== NULL
7854 || section_headers_groups
[i
] == NULL
)
7855 i
= filedata
->file_header
.e_shnum
;
7858 g
= section_headers_groups
[i
]->root
;
7860 for (; g
!= NULL
; g
= g
->next
)
7862 sec
= filedata
->section_headers
+ g
->section_index
;
7864 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7869 i
= filedata
->file_header
.e_shnum
;
7872 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7874 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7875 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7876 suffix
= SECTION_NAME (unwsec
) + len
;
7877 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7879 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7880 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7885 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7886 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7887 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7888 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7890 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7891 suffix
= SECTION_NAME (unwsec
) + len
;
7892 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7894 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7895 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7899 if (i
== filedata
->file_header
.e_shnum
)
7901 printf (_("\nCould not find unwind info section for "));
7903 if (filedata
->string_table
== NULL
)
7904 printf ("%d", unwsec
->sh_name
);
7906 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7910 aux
.info_addr
= sec
->sh_addr
;
7911 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7914 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7916 printf (_("\nUnwind section "));
7918 if (filedata
->string_table
== NULL
)
7919 printf ("%d", unwsec
->sh_name
);
7921 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7923 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7924 (unsigned long) unwsec
->sh_offset
,
7925 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7927 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7928 && aux
.table_len
> 0)
7929 dump_ia64_unwind (filedata
, & aux
);
7932 free ((char *) aux
.table
);
7934 free ((char *) aux
.info
);
7943 free ((char *) aux
.strtab
);
7948 struct hppa_unw_table_entry
7950 struct absaddr start
;
7952 unsigned int Cannot_unwind
:1; /* 0 */
7953 unsigned int Millicode
:1; /* 1 */
7954 unsigned int Millicode_save_sr0
:1; /* 2 */
7955 unsigned int Region_description
:2; /* 3..4 */
7956 unsigned int reserved1
:1; /* 5 */
7957 unsigned int Entry_SR
:1; /* 6 */
7958 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7959 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7960 unsigned int Args_stored
:1; /* 16 */
7961 unsigned int Variable_Frame
:1; /* 17 */
7962 unsigned int Separate_Package_Body
:1; /* 18 */
7963 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7964 unsigned int Stack_Overflow_Check
:1; /* 20 */
7965 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7966 unsigned int Ada_Region
:1; /* 22 */
7967 unsigned int cxx_info
:1; /* 23 */
7968 unsigned int cxx_try_catch
:1; /* 24 */
7969 unsigned int sched_entry_seq
:1; /* 25 */
7970 unsigned int reserved2
:1; /* 26 */
7971 unsigned int Save_SP
:1; /* 27 */
7972 unsigned int Save_RP
:1; /* 28 */
7973 unsigned int Save_MRP_in_frame
:1; /* 29 */
7974 unsigned int extn_ptr_defined
:1; /* 30 */
7975 unsigned int Cleanup_defined
:1; /* 31 */
7977 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7978 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7979 unsigned int Large_frame
:1; /* 2 */
7980 unsigned int Pseudo_SP_Set
:1; /* 3 */
7981 unsigned int reserved4
:1; /* 4 */
7982 unsigned int Total_frame_size
:27; /* 5..31 */
7985 struct hppa_unw_aux_info
7987 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7988 unsigned long table_len
; /* Length of unwind table. */
7989 bfd_vma seg_base
; /* Starting address of segment. */
7990 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7991 unsigned long nsyms
; /* Number of symbols. */
7992 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7993 unsigned long nfuns
; /* Number of entries in funtab. */
7994 char * strtab
; /* The string table. */
7995 unsigned long strtab_size
; /* Size of string table. */
7999 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8001 struct hppa_unw_table_entry
* tp
;
8002 unsigned long j
, nfuns
;
8003 bfd_boolean res
= TRUE
;
8005 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8006 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8007 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8008 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8010 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8012 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8015 const char * procname
;
8017 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8018 aux
->strtab_size
, tp
->start
, &procname
,
8021 fputs ("\n<", stdout
);
8025 fputs (procname
, stdout
);
8028 printf ("+%lx", (unsigned long) offset
);
8031 fputs (">: [", stdout
);
8032 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8033 fputc ('-', stdout
);
8034 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8037 #define PF(_m) if (tp->_m) printf (#_m " ");
8038 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8041 PF(Millicode_save_sr0
);
8042 /* PV(Region_description); */
8048 PF(Separate_Package_Body
);
8049 PF(Frame_Extension_Millicode
);
8050 PF(Stack_Overflow_Check
);
8051 PF(Two_Instruction_SP_Increment
);
8055 PF(sched_entry_seq
);
8058 PF(Save_MRP_in_frame
);
8059 PF(extn_ptr_defined
);
8060 PF(Cleanup_defined
);
8061 PF(MPE_XL_interrupt_marker
);
8062 PF(HP_UX_interrupt_marker
);
8065 PV(Total_frame_size
);
8078 slurp_hppa_unwind_table (Filedata
* filedata
,
8079 struct hppa_unw_aux_info
* aux
,
8080 Elf_Internal_Shdr
* sec
)
8082 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8083 Elf_Internal_Phdr
* seg
;
8084 struct hppa_unw_table_entry
* tep
;
8085 Elf_Internal_Shdr
* relsec
;
8086 Elf_Internal_Rela
* rela
;
8087 Elf_Internal_Rela
* rp
;
8088 unsigned char * table
;
8090 Elf_Internal_Sym
* sym
;
8091 const char * relname
;
8093 /* First, find the starting address of the segment that includes
8095 if (filedata
->file_header
.e_phnum
)
8097 if (! get_program_headers (filedata
))
8100 for (seg
= filedata
->program_headers
;
8101 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8104 if (seg
->p_type
!= PT_LOAD
)
8107 if (sec
->sh_addr
>= seg
->p_vaddr
8108 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8110 aux
->seg_base
= seg
->p_vaddr
;
8116 /* Second, build the unwind table from the contents of the unwind
8118 size
= sec
->sh_size
;
8119 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8125 nentries
= size
/ unw_ent_size
;
8126 size
= unw_ent_size
* nentries
;
8128 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8129 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8131 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8133 unsigned int tmp1
, tmp2
;
8135 tep
->start
.section
= SHN_UNDEF
;
8136 tep
->end
.section
= SHN_UNDEF
;
8138 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8139 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8140 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8141 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8143 tep
->start
.offset
+= aux
->seg_base
;
8144 tep
->end
.offset
+= aux
->seg_base
;
8146 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8147 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8148 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8149 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8150 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8151 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8152 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8153 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8154 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8155 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8156 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8157 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8158 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8159 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8160 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8161 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8162 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8163 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8164 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8165 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8166 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8167 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8168 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8169 tep
->Cleanup_defined
= tmp1
& 0x1;
8171 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8172 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8173 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8174 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8175 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8176 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8180 /* Third, apply any relocations to the unwind table. */
8181 for (relsec
= filedata
->section_headers
;
8182 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8185 if (relsec
->sh_type
!= SHT_RELA
8186 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8187 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8190 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8194 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8196 unsigned int sym_ndx
;
8197 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8198 relname
= elf_hppa_reloc_type (r_type
);
8200 if (relname
== NULL
)
8202 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8206 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8207 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8209 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8213 i
= rp
->r_offset
/ unw_ent_size
;
8214 if (i
>= aux
->table_len
)
8216 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8220 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8221 if (sym_ndx
>= aux
->nsyms
)
8223 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8227 sym
= aux
->symtab
+ sym_ndx
;
8229 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8232 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8233 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8236 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8237 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8247 aux
->table_len
= nentries
;
8253 hppa_process_unwind (Filedata
* filedata
)
8255 struct hppa_unw_aux_info aux
;
8256 Elf_Internal_Shdr
* unwsec
= NULL
;
8257 Elf_Internal_Shdr
* strsec
;
8258 Elf_Internal_Shdr
* sec
;
8260 bfd_boolean res
= TRUE
;
8262 if (filedata
->string_table
== NULL
)
8265 memset (& aux
, 0, sizeof (aux
));
8267 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8269 if (sec
->sh_type
== SHT_SYMTAB
8270 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8272 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8274 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8275 if (aux
.strtab
!= NULL
)
8277 error (_("Multiple auxillary string tables encountered\n"));
8281 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8284 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8286 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8291 printf (_("\nThere are no unwind sections in this file.\n"));
8293 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8295 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8297 unsigned long num_unwind
= sec
->sh_size
/ 16;
8299 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8300 "contains %lu entry:\n",
8301 "\nUnwind section '%s' at offset 0x%lx "
8302 "contains %lu entries:\n",
8304 printable_section_name (filedata
, sec
),
8305 (unsigned long) sec
->sh_offset
,
8308 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8311 if (res
&& aux
.table_len
> 0)
8313 if (! dump_hppa_unwind (filedata
, &aux
))
8318 free ((char *) aux
.table
);
8326 free ((char *) aux
.strtab
);
8333 unsigned char * data
; /* The unwind data. */
8334 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8335 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8336 unsigned long nrelas
; /* The number of relocations. */
8337 unsigned int rel_type
; /* REL or RELA ? */
8338 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8341 struct arm_unw_aux_info
8343 Filedata
* filedata
; /* The file containing the unwind sections. */
8344 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8345 unsigned long nsyms
; /* Number of symbols. */
8346 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8347 unsigned long nfuns
; /* Number of these symbols. */
8348 char * strtab
; /* The file's string table. */
8349 unsigned long strtab_size
; /* Size of string table. */
8353 arm_print_vma_and_name (Filedata
* filedata
,
8354 struct arm_unw_aux_info
* aux
,
8356 struct absaddr addr
)
8358 const char *procname
;
8361 if (addr
.section
== SHN_UNDEF
)
8364 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8365 aux
->strtab_size
, addr
, &procname
,
8368 print_vma (fn
, PREFIX_HEX
);
8372 fputs (" <", stdout
);
8373 fputs (procname
, stdout
);
8376 printf ("+0x%lx", (unsigned long) sym_offset
);
8377 fputc ('>', stdout
);
8384 arm_free_section (struct arm_section
*arm_sec
)
8386 if (arm_sec
->data
!= NULL
)
8387 free (arm_sec
->data
);
8389 if (arm_sec
->rela
!= NULL
)
8390 free (arm_sec
->rela
);
8393 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8394 cached section and install SEC instead.
8395 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8396 and return its valued in * WORDP, relocating if necessary.
8397 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8398 relocation's offset in ADDR.
8399 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8400 into the string table of the symbol associated with the reloc. If no
8401 reloc was applied store -1 there.
8402 5) Return TRUE upon success, FALSE otherwise. */
8405 get_unwind_section_word (Filedata
* filedata
,
8406 struct arm_unw_aux_info
* aux
,
8407 struct arm_section
* arm_sec
,
8408 Elf_Internal_Shdr
* sec
,
8409 bfd_vma word_offset
,
8410 unsigned int * wordp
,
8411 struct absaddr
* addr
,
8414 Elf_Internal_Rela
*rp
;
8415 Elf_Internal_Sym
*sym
;
8416 const char * relname
;
8418 bfd_boolean wrapped
;
8420 if (sec
== NULL
|| arm_sec
== NULL
)
8423 addr
->section
= SHN_UNDEF
;
8426 if (sym_name
!= NULL
)
8427 *sym_name
= (bfd_vma
) -1;
8429 /* If necessary, update the section cache. */
8430 if (sec
!= arm_sec
->sec
)
8432 Elf_Internal_Shdr
*relsec
;
8434 arm_free_section (arm_sec
);
8437 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8438 sec
->sh_size
, _("unwind data"));
8439 arm_sec
->rela
= NULL
;
8440 arm_sec
->nrelas
= 0;
8442 for (relsec
= filedata
->section_headers
;
8443 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8446 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8447 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8448 /* PR 15745: Check the section type as well. */
8449 || (relsec
->sh_type
!= SHT_REL
8450 && relsec
->sh_type
!= SHT_RELA
))
8453 arm_sec
->rel_type
= relsec
->sh_type
;
8454 if (relsec
->sh_type
== SHT_REL
)
8456 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8458 & arm_sec
->rela
, & arm_sec
->nrelas
))
8461 else /* relsec->sh_type == SHT_RELA */
8463 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8465 & arm_sec
->rela
, & arm_sec
->nrelas
))
8471 arm_sec
->next_rela
= arm_sec
->rela
;
8474 /* If there is no unwind data we can do nothing. */
8475 if (arm_sec
->data
== NULL
)
8478 /* If the offset is invalid then fail. */
8479 if (/* PR 21343 *//* PR 18879 */
8481 || word_offset
> (sec
->sh_size
- 4)
8482 || ((bfd_signed_vma
) word_offset
) < 0)
8485 /* Get the word at the required offset. */
8486 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8488 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8489 if (arm_sec
->rela
== NULL
)
8495 /* Look through the relocs to find the one that applies to the provided offset. */
8497 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8499 bfd_vma prelval
, offset
;
8501 if (rp
->r_offset
> word_offset
&& !wrapped
)
8506 if (rp
->r_offset
> word_offset
)
8509 if (rp
->r_offset
& 3)
8511 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8512 (unsigned long) rp
->r_offset
);
8516 if (rp
->r_offset
< word_offset
)
8519 /* PR 17531: file: 027-161405-0.004 */
8520 if (aux
->symtab
== NULL
)
8523 if (arm_sec
->rel_type
== SHT_REL
)
8525 offset
= word
& 0x7fffffff;
8526 if (offset
& 0x40000000)
8527 offset
|= ~ (bfd_vma
) 0x7fffffff;
8529 else if (arm_sec
->rel_type
== SHT_RELA
)
8530 offset
= rp
->r_addend
;
8533 error (_("Unknown section relocation type %d encountered\n"),
8538 /* PR 17531 file: 027-1241568-0.004. */
8539 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8541 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8542 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8546 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8547 offset
+= sym
->st_value
;
8548 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8550 /* Check that we are processing the expected reloc type. */
8551 if (filedata
->file_header
.e_machine
== EM_ARM
)
8553 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8554 if (relname
== NULL
)
8556 warn (_("Skipping unknown ARM relocation type: %d\n"),
8557 (int) ELF32_R_TYPE (rp
->r_info
));
8561 if (streq (relname
, "R_ARM_NONE"))
8564 if (! streq (relname
, "R_ARM_PREL31"))
8566 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8570 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8572 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8573 if (relname
== NULL
)
8575 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8576 (int) ELF32_R_TYPE (rp
->r_info
));
8580 if (streq (relname
, "R_C6000_NONE"))
8583 if (! streq (relname
, "R_C6000_PREL31"))
8585 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8593 /* This function currently only supports ARM and TI unwinders. */
8594 warn (_("Only TI and ARM unwinders are currently supported\n"));
8598 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8599 addr
->section
= sym
->st_shndx
;
8600 addr
->offset
= offset
;
8603 * sym_name
= sym
->st_name
;
8608 arm_sec
->next_rela
= rp
;
8613 static const char *tic6x_unwind_regnames
[16] =
8615 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8616 "A14", "A13", "A12", "A11", "A10",
8617 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8621 decode_tic6x_unwind_regmask (unsigned int mask
)
8625 for (i
= 12; mask
; mask
>>= 1, i
--)
8629 fputs (tic6x_unwind_regnames
[i
], stdout
);
8631 fputs (", ", stdout
);
8637 if (remaining == 0 && more_words) \
8640 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8641 data_offset, & word, & addr, NULL)) \
8647 #define GET_OP(OP) \
8652 (OP) = word >> 24; \
8657 printf (_("[Truncated opcode]\n")); \
8660 printf ("0x%02x ", OP)
8663 decode_arm_unwind_bytecode (Filedata
* filedata
,
8664 struct arm_unw_aux_info
* aux
,
8666 unsigned int remaining
,
8667 unsigned int more_words
,
8668 bfd_vma data_offset
,
8669 Elf_Internal_Shdr
* data_sec
,
8670 struct arm_section
* data_arm_sec
)
8672 struct absaddr addr
;
8673 bfd_boolean res
= TRUE
;
8675 /* Decode the unwinding instructions. */
8678 unsigned int op
, op2
;
8687 printf (" 0x%02x ", op
);
8689 if ((op
& 0xc0) == 0x00)
8691 int offset
= ((op
& 0x3f) << 2) + 4;
8693 printf (" vsp = vsp + %d", offset
);
8695 else if ((op
& 0xc0) == 0x40)
8697 int offset
= ((op
& 0x3f) << 2) + 4;
8699 printf (" vsp = vsp - %d", offset
);
8701 else if ((op
& 0xf0) == 0x80)
8704 if (op
== 0x80 && op2
== 0)
8705 printf (_("Refuse to unwind"));
8708 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8709 bfd_boolean first
= TRUE
;
8713 for (i
= 0; i
< 12; i
++)
8714 if (mask
& (1 << i
))
8720 printf ("r%d", 4 + i
);
8725 else if ((op
& 0xf0) == 0x90)
8727 if (op
== 0x9d || op
== 0x9f)
8728 printf (_(" [Reserved]"));
8730 printf (" vsp = r%d", op
& 0x0f);
8732 else if ((op
& 0xf0) == 0xa0)
8734 int end
= 4 + (op
& 0x07);
8735 bfd_boolean first
= TRUE
;
8739 for (i
= 4; i
<= end
; i
++)
8755 else if (op
== 0xb0)
8756 printf (_(" finish"));
8757 else if (op
== 0xb1)
8760 if (op2
== 0 || (op2
& 0xf0) != 0)
8761 printf (_("[Spare]"));
8764 unsigned int mask
= op2
& 0x0f;
8765 bfd_boolean first
= TRUE
;
8769 for (i
= 0; i
< 12; i
++)
8770 if (mask
& (1 << i
))
8781 else if (op
== 0xb2)
8783 unsigned char buf
[9];
8784 unsigned int i
, len
;
8785 unsigned long offset
;
8787 for (i
= 0; i
< sizeof (buf
); i
++)
8790 if ((buf
[i
] & 0x80) == 0)
8793 if (i
== sizeof (buf
))
8795 error (_("corrupt change to vsp\n"));
8800 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8801 assert (len
== i
+ 1);
8802 offset
= offset
* 4 + 0x204;
8803 printf ("vsp = vsp + %ld", offset
);
8806 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8808 unsigned int first
, last
;
8815 printf ("pop {D%d", first
);
8817 printf ("-D%d", first
+ last
);
8820 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8822 unsigned int count
= op
& 0x07;
8826 printf ("-D%d", 8 + count
);
8829 else if (op
>= 0xc0 && op
<= 0xc5)
8831 unsigned int count
= op
& 0x07;
8833 printf (" pop {wR10");
8835 printf ("-wR%d", 10 + count
);
8838 else if (op
== 0xc6)
8840 unsigned int first
, last
;
8845 printf ("pop {wR%d", first
);
8847 printf ("-wR%d", first
+ last
);
8850 else if (op
== 0xc7)
8853 if (op2
== 0 || (op2
& 0xf0) != 0)
8854 printf (_("[Spare]"));
8857 unsigned int mask
= op2
& 0x0f;
8858 bfd_boolean first
= TRUE
;
8862 for (i
= 0; i
< 4; i
++)
8863 if (mask
& (1 << i
))
8869 printf ("wCGR%d", i
);
8876 printf (_(" [unsupported opcode]"));
8887 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8888 struct arm_unw_aux_info
* aux
,
8890 unsigned int remaining
,
8891 unsigned int more_words
,
8892 bfd_vma data_offset
,
8893 Elf_Internal_Shdr
* data_sec
,
8894 struct arm_section
* data_arm_sec
)
8896 struct absaddr addr
;
8898 /* Decode the unwinding instructions. */
8901 unsigned int op
, op2
;
8910 printf (" 0x%02x ", op
);
8912 if ((op
& 0xc0) == 0x00)
8914 int offset
= ((op
& 0x3f) << 3) + 8;
8915 printf (" sp = sp + %d", offset
);
8917 else if ((op
& 0xc0) == 0x80)
8920 if (op
== 0x80 && op2
== 0)
8921 printf (_("Refuse to unwind"));
8924 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8926 printf ("pop compact {");
8930 decode_tic6x_unwind_regmask (mask
);
8934 else if ((op
& 0xf0) == 0xc0)
8942 unsigned int offset
;
8946 /* Scan entire instruction first so that GET_OP output is not
8947 interleaved with disassembly. */
8949 for (i
= 0; nregs
< (op
& 0xf); i
++)
8955 regpos
[nregs
].offset
= i
* 2;
8956 regpos
[nregs
].reg
= reg
;
8963 regpos
[nregs
].offset
= i
* 2 + 1;
8964 regpos
[nregs
].reg
= reg
;
8969 printf (_("pop frame {"));
8972 printf (_("*corrupt* - no registers specified"));
8977 for (i
= i
* 2; i
> 0; i
--)
8979 if (regpos
[reg
].offset
== i
- 1)
8981 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8988 fputs (name
, stdout
);
8996 else if (op
== 0xd0)
8997 printf (" MOV FP, SP");
8998 else if (op
== 0xd1)
8999 printf (" __c6xabi_pop_rts");
9000 else if (op
== 0xd2)
9002 unsigned char buf
[9];
9003 unsigned int i
, len
;
9004 unsigned long offset
;
9006 for (i
= 0; i
< sizeof (buf
); i
++)
9009 if ((buf
[i
] & 0x80) == 0)
9012 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9013 if (i
== sizeof (buf
))
9015 warn (_("Corrupt stack pointer adjustment detected\n"));
9019 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9020 assert (len
== i
+ 1);
9021 offset
= offset
* 8 + 0x408;
9022 printf (_("sp = sp + %ld"), offset
);
9024 else if ((op
& 0xf0) == 0xe0)
9026 if ((op
& 0x0f) == 7)
9029 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9033 printf (_(" [unsupported opcode]"));
9042 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9046 offset
= word
& 0x7fffffff;
9047 if (offset
& 0x40000000)
9048 offset
|= ~ (bfd_vma
) 0x7fffffff;
9050 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9053 return offset
+ where
;
9057 decode_arm_unwind (Filedata
* filedata
,
9058 struct arm_unw_aux_info
* aux
,
9060 unsigned int remaining
,
9061 bfd_vma data_offset
,
9062 Elf_Internal_Shdr
* data_sec
,
9063 struct arm_section
* data_arm_sec
)
9066 unsigned int more_words
= 0;
9067 struct absaddr addr
;
9068 bfd_vma sym_name
= (bfd_vma
) -1;
9069 bfd_boolean res
= TRUE
;
9073 /* Fetch the first word.
9074 Note - when decoding an object file the address extracted
9075 here will always be 0. So we also pass in the sym_name
9076 parameter so that we can find the symbol associated with
9077 the personality routine. */
9078 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9079 & word
, & addr
, & sym_name
))
9086 addr
.section
= SHN_UNDEF
;
9090 if ((word
& 0x80000000) == 0)
9092 /* Expand prel31 for personality routine. */
9094 const char *procname
;
9096 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9097 printf (_(" Personality routine: "));
9099 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9100 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9102 procname
= aux
->strtab
+ sym_name
;
9103 print_vma (fn
, PREFIX_HEX
);
9106 fputs (" <", stdout
);
9107 fputs (procname
, stdout
);
9108 fputc ('>', stdout
);
9112 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9113 fputc ('\n', stdout
);
9115 /* The GCC personality routines use the standard compact
9116 encoding, starting with one byte giving the number of
9118 if (procname
!= NULL
9119 && (const_strneq (procname
, "__gcc_personality_v0")
9120 || const_strneq (procname
, "__gxx_personality_v0")
9121 || const_strneq (procname
, "__gcj_personality_v0")
9122 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9129 printf (_(" [Truncated data]\n"));
9132 more_words
= word
>> 24;
9142 /* ARM EHABI Section 6.3:
9144 An exception-handling table entry for the compact model looks like:
9148 1 0 index Data for personalityRoutine[index] */
9150 if (filedata
->file_header
.e_machine
== EM_ARM
9151 && (word
& 0x70000000))
9153 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9157 per_index
= (word
>> 24) & 0x7f;
9158 printf (_(" Compact model index: %d\n"), per_index
);
9165 else if (per_index
< 3)
9167 more_words
= (word
>> 16) & 0xff;
9173 switch (filedata
->file_header
.e_machine
)
9178 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9179 data_offset
, data_sec
, data_arm_sec
))
9184 warn (_("Unknown ARM compact model index encountered\n"));
9185 printf (_(" [reserved]\n"));
9193 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9194 data_offset
, data_sec
, data_arm_sec
))
9197 else if (per_index
< 5)
9199 if (((word
>> 17) & 0x7f) == 0x7f)
9200 printf (_(" Restore stack from frame pointer\n"));
9202 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9203 printf (_(" Registers restored: "));
9205 printf (" (compact) ");
9206 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9208 printf (_(" Return register: %s\n"),
9209 tic6x_unwind_regnames
[word
& 0xf]);
9212 printf (_(" [reserved (%d)]\n"), per_index
);
9216 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9217 filedata
->file_header
.e_machine
);
9221 /* Decode the descriptors. Not implemented. */
9227 dump_arm_unwind (Filedata
* filedata
,
9228 struct arm_unw_aux_info
* aux
,
9229 Elf_Internal_Shdr
* exidx_sec
)
9231 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9232 unsigned int i
, exidx_len
;
9233 unsigned long j
, nfuns
;
9234 bfd_boolean res
= TRUE
;
9236 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9237 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9238 exidx_len
= exidx_sec
->sh_size
/ 8;
9240 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9241 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9242 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9243 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9245 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9247 for (i
= 0; i
< exidx_len
; i
++)
9249 unsigned int exidx_fn
, exidx_entry
;
9250 struct absaddr fn_addr
, entry_addr
;
9253 fputc ('\n', stdout
);
9255 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9256 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9257 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9258 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9261 arm_free_section (& exidx_arm_sec
);
9262 arm_free_section (& extab_arm_sec
);
9266 /* ARM EHABI, Section 5:
9267 An index table entry consists of 2 words.
9268 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9269 if (exidx_fn
& 0x80000000)
9271 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9275 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9277 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9278 fputs (": ", stdout
);
9280 if (exidx_entry
== 1)
9282 print_vma (exidx_entry
, PREFIX_HEX
);
9283 fputs (" [cantunwind]\n", stdout
);
9285 else if (exidx_entry
& 0x80000000)
9287 print_vma (exidx_entry
, PREFIX_HEX
);
9288 fputc ('\n', stdout
);
9289 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9293 bfd_vma table
, table_offset
= 0;
9294 Elf_Internal_Shdr
*table_sec
;
9296 fputs ("@", stdout
);
9297 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9298 print_vma (table
, PREFIX_HEX
);
9301 /* Locate the matching .ARM.extab. */
9302 if (entry_addr
.section
!= SHN_UNDEF
9303 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9305 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9306 table_offset
= entry_addr
.offset
;
9308 if (table_offset
> table_sec
->sh_size
9309 || ((bfd_signed_vma
) table_offset
) < 0)
9311 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9312 (unsigned long) table_offset
,
9313 printable_section_name (filedata
, table_sec
));
9320 table_sec
= find_section_by_address (filedata
, table
);
9321 if (table_sec
!= NULL
)
9322 table_offset
= table
- table_sec
->sh_addr
;
9325 if (table_sec
== NULL
)
9327 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9328 (unsigned long) table
);
9333 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9342 arm_free_section (&exidx_arm_sec
);
9343 arm_free_section (&extab_arm_sec
);
9348 /* Used for both ARM and C6X unwinding tables. */
9351 arm_process_unwind (Filedata
* filedata
)
9353 struct arm_unw_aux_info aux
;
9354 Elf_Internal_Shdr
*unwsec
= NULL
;
9355 Elf_Internal_Shdr
*strsec
;
9356 Elf_Internal_Shdr
*sec
;
9358 unsigned int sec_type
;
9359 bfd_boolean res
= TRUE
;
9361 switch (filedata
->file_header
.e_machine
)
9364 sec_type
= SHT_ARM_EXIDX
;
9368 sec_type
= SHT_C6000_UNWIND
;
9372 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9373 filedata
->file_header
.e_machine
);
9377 if (filedata
->string_table
== NULL
)
9380 memset (& aux
, 0, sizeof (aux
));
9381 aux
.filedata
= filedata
;
9383 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9385 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9387 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9389 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9391 /* PR binutils/17531 file: 011-12666-0.004. */
9392 if (aux
.strtab
!= NULL
)
9394 error (_("Multiple string tables found in file.\n"));
9398 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9399 1, strsec
->sh_size
, _("string table"));
9400 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9402 else if (sec
->sh_type
== sec_type
)
9407 printf (_("\nThere are no unwind sections in this file.\n"));
9409 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9411 if (sec
->sh_type
== sec_type
)
9413 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9414 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9415 "contains %lu entry:\n",
9416 "\nUnwind section '%s' at offset 0x%lx "
9417 "contains %lu entries:\n",
9419 printable_section_name (filedata
, sec
),
9420 (unsigned long) sec
->sh_offset
,
9423 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9431 free ((char *) aux
.strtab
);
9437 process_unwind (Filedata
* filedata
)
9439 struct unwind_handler
9441 unsigned int machtype
;
9442 bfd_boolean (* handler
)(Filedata
*);
9445 { EM_ARM
, arm_process_unwind
},
9446 { EM_IA_64
, ia64_process_unwind
},
9447 { EM_PARISC
, hppa_process_unwind
},
9448 { EM_TI_C6000
, arm_process_unwind
},
9456 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9457 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9458 return handlers
[i
].handler (filedata
);
9460 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9461 get_machine_name (filedata
->file_header
.e_machine
));
9466 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9468 switch (entry
->d_tag
)
9470 case DT_AARCH64_BTI_PLT
:
9471 case DT_AARCH64_PAC_PLT
:
9474 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9481 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9483 switch (entry
->d_tag
)
9486 if (entry
->d_un
.d_val
== 0)
9490 static const char * opts
[] =
9492 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9493 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9494 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9495 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9499 bfd_boolean first
= TRUE
;
9501 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9502 if (entry
->d_un
.d_val
& (1 << cnt
))
9504 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9510 case DT_MIPS_IVERSION
:
9511 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9512 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9516 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9517 /* Note: coded this way so that there is a single string for translation. */
9518 printf (_("<corrupt: %s>"), buf
);
9522 case DT_MIPS_TIME_STAMP
:
9526 time_t atime
= entry
->d_un
.d_val
;
9528 tmp
= gmtime (&atime
);
9529 /* PR 17531: file: 6accc532. */
9531 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9533 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9534 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9535 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9536 printf (_("Time Stamp: %s"), timebuf
);
9540 case DT_MIPS_RLD_VERSION
:
9541 case DT_MIPS_LOCAL_GOTNO
:
9542 case DT_MIPS_CONFLICTNO
:
9543 case DT_MIPS_LIBLISTNO
:
9544 case DT_MIPS_SYMTABNO
:
9545 case DT_MIPS_UNREFEXTNO
:
9546 case DT_MIPS_HIPAGENO
:
9547 case DT_MIPS_DELTA_CLASS_NO
:
9548 case DT_MIPS_DELTA_INSTANCE_NO
:
9549 case DT_MIPS_DELTA_RELOC_NO
:
9550 case DT_MIPS_DELTA_SYM_NO
:
9551 case DT_MIPS_DELTA_CLASSSYM_NO
:
9552 case DT_MIPS_COMPACT_SIZE
:
9553 print_vma (entry
->d_un
.d_val
, DEC
);
9557 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9558 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9559 /* Falls through. */
9562 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9568 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9570 switch (entry
->d_tag
)
9572 case DT_HP_DLD_FLAGS
:
9581 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9582 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9583 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9584 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9585 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9586 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9587 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9588 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9589 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9590 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9591 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9592 { DT_HP_GST
, "HP_GST" },
9593 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9594 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9595 { DT_HP_NODELETE
, "HP_NODELETE" },
9596 { DT_HP_GROUP
, "HP_GROUP" },
9597 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9599 bfd_boolean first
= TRUE
;
9601 bfd_vma val
= entry
->d_un
.d_val
;
9603 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9604 if (val
& flags
[cnt
].bit
)
9608 fputs (flags
[cnt
].str
, stdout
);
9610 val
^= flags
[cnt
].bit
;
9613 if (val
!= 0 || first
)
9617 print_vma (val
, HEX
);
9623 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9631 /* VMS vs Unix time offset and factor. */
9633 #define VMS_EPOCH_OFFSET 35067168000000000LL
9634 #define VMS_GRANULARITY_FACTOR 10000000
9636 /* Display a VMS time in a human readable format. */
9639 print_vms_time (bfd_int64_t vmstime
)
9644 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9645 tm
= gmtime (&unxtime
);
9646 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9647 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9648 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9653 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9655 switch (entry
->d_tag
)
9657 case DT_IA_64_PLT_RESERVE
:
9658 /* First 3 slots reserved. */
9659 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9661 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9664 case DT_IA_64_VMS_LINKTIME
:
9666 print_vms_time (entry
->d_un
.d_val
);
9670 case DT_IA_64_VMS_LNKFLAGS
:
9671 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9672 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9673 printf (" CALL_DEBUG");
9674 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9675 printf (" NOP0BUFS");
9676 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9677 printf (" P0IMAGE");
9678 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9679 printf (" MKTHREADS");
9680 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9681 printf (" UPCALLS");
9682 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9684 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9685 printf (" INITIALIZE");
9686 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9688 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9689 printf (" EXE_INIT");
9690 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9691 printf (" TBK_IN_IMG");
9692 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9693 printf (" DBG_IN_IMG");
9694 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9695 printf (" TBK_IN_DSF");
9696 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9697 printf (" DBG_IN_DSF");
9698 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9699 printf (" SIGNATURES");
9700 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9701 printf (" REL_SEG_OFF");
9705 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9712 get_32bit_dynamic_section (Filedata
* filedata
)
9714 Elf32_External_Dyn
* edyn
;
9715 Elf32_External_Dyn
* ext
;
9716 Elf_Internal_Dyn
* entry
;
9718 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9719 dynamic_size
, _("dynamic section"));
9723 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9724 might not have the luxury of section headers. Look for the DT_NULL
9725 terminator to determine the number of entries. */
9726 for (ext
= edyn
, dynamic_nent
= 0;
9727 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9731 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9735 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9737 if (dynamic_section
== NULL
)
9739 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9740 (unsigned long) dynamic_nent
);
9745 for (ext
= edyn
, entry
= dynamic_section
;
9746 entry
< dynamic_section
+ dynamic_nent
;
9749 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9750 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9759 get_64bit_dynamic_section (Filedata
* filedata
)
9761 Elf64_External_Dyn
* edyn
;
9762 Elf64_External_Dyn
* ext
;
9763 Elf_Internal_Dyn
* entry
;
9765 /* Read in the data. */
9766 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9767 dynamic_size
, _("dynamic section"));
9771 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9772 might not have the luxury of section headers. Look for the DT_NULL
9773 terminator to determine the number of entries. */
9774 for (ext
= edyn
, dynamic_nent
= 0;
9775 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9776 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9780 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9784 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9786 if (dynamic_section
== NULL
)
9788 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9789 (unsigned long) dynamic_nent
);
9794 /* Convert from external to internal formats. */
9795 for (ext
= edyn
, entry
= dynamic_section
;
9796 entry
< dynamic_section
+ dynamic_nent
;
9799 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9800 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9809 print_dynamic_flags (bfd_vma flags
)
9811 bfd_boolean first
= TRUE
;
9817 flag
= flags
& - flags
;
9827 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9828 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9829 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9830 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9831 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9832 default: fputs (_("unknown"), stdout
); break;
9838 /* Parse and display the contents of the dynamic section. */
9841 process_dynamic_section (Filedata
* filedata
)
9843 Elf_Internal_Dyn
* entry
;
9845 if (dynamic_size
== 0)
9848 printf (_("\nThere is no dynamic section in this file.\n"));
9855 if (! get_32bit_dynamic_section (filedata
))
9860 if (! get_64bit_dynamic_section (filedata
))
9864 /* Find the appropriate symbol table. */
9865 if (dynamic_symbols
== NULL
)
9867 for (entry
= dynamic_section
;
9868 entry
< dynamic_section
+ dynamic_nent
;
9871 Elf_Internal_Shdr section
;
9873 if (entry
->d_tag
!= DT_SYMTAB
)
9876 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9878 /* Since we do not know how big the symbol table is,
9879 we default to reading in the entire file (!) and
9880 processing that. This is overkill, I know, but it
9882 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9883 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9885 /* See PR 21379 for a reproducer. */
9886 error (_("Invalid DT_SYMTAB entry: %lx\n"),
9887 (long) section
.sh_offset
);
9891 if (archive_file_offset
!= 0)
9892 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9894 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9897 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9899 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9900 section
.sh_name
= filedata
->string_table_length
;
9902 if (dynamic_symbols
!= NULL
)
9904 error (_("Multiple dynamic symbol table sections found\n"));
9905 free (dynamic_symbols
);
9907 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9908 if (num_dynamic_syms
< 1)
9910 error (_("Unable to determine the number of symbols to load\n"));
9916 /* Similarly find a string table. */
9917 if (dynamic_strings
== NULL
)
9919 for (entry
= dynamic_section
;
9920 entry
< dynamic_section
+ dynamic_nent
;
9923 unsigned long offset
;
9926 if (entry
->d_tag
!= DT_STRTAB
)
9929 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9931 /* Since we do not know how big the string table is,
9932 we default to reading in the entire file (!) and
9933 processing that. This is overkill, I know, but it
9936 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9938 if (archive_file_offset
!= 0)
9939 str_tab_len
= archive_file_size
- offset
;
9941 str_tab_len
= filedata
->file_size
- offset
;
9943 if (str_tab_len
< 1)
9946 (_("Unable to determine the length of the dynamic string table\n"));
9950 if (dynamic_strings
!= NULL
)
9952 error (_("Multiple dynamic string tables found\n"));
9953 free (dynamic_strings
);
9956 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9958 _("dynamic string table"));
9959 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9963 /* And find the syminfo section if available. */
9964 if (dynamic_syminfo
== NULL
)
9966 unsigned long syminsz
= 0;
9968 for (entry
= dynamic_section
;
9969 entry
< dynamic_section
+ dynamic_nent
;
9972 if (entry
->d_tag
== DT_SYMINENT
)
9974 /* Note: these braces are necessary to avoid a syntax
9975 error from the SunOS4 C compiler. */
9976 /* PR binutils/17531: A corrupt file can trigger this test.
9977 So do not use an assert, instead generate an error message. */
9978 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9979 error (_("Bad value (%d) for SYMINENT entry\n"),
9980 (int) entry
->d_un
.d_val
);
9982 else if (entry
->d_tag
== DT_SYMINSZ
)
9983 syminsz
= entry
->d_un
.d_val
;
9984 else if (entry
->d_tag
== DT_SYMINFO
)
9985 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9989 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9991 Elf_External_Syminfo
* extsyminfo
;
9992 Elf_External_Syminfo
* extsym
;
9993 Elf_Internal_Syminfo
* syminfo
;
9995 /* There is a syminfo section. Read the data. */
9996 extsyminfo
= (Elf_External_Syminfo
*)
9997 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9998 _("symbol information"));
10002 if (dynamic_syminfo
!= NULL
)
10004 error (_("Multiple dynamic symbol information sections found\n"));
10005 free (dynamic_syminfo
);
10007 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10008 if (dynamic_syminfo
== NULL
)
10010 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10011 (unsigned long) syminsz
);
10015 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10016 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10017 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10018 ++syminfo
, ++extsym
)
10020 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10021 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10028 if (do_dynamic
&& dynamic_addr
)
10029 printf (ngettext ("\nDynamic section at offset 0x%lx "
10030 "contains %lu entry:\n",
10031 "\nDynamic section at offset 0x%lx "
10032 "contains %lu entries:\n",
10034 dynamic_addr
, (unsigned long) dynamic_nent
);
10036 printf (_(" Tag Type Name/Value\n"));
10038 for (entry
= dynamic_section
;
10039 entry
< dynamic_section
+ dynamic_nent
;
10044 const char * dtype
;
10047 print_vma (entry
->d_tag
, FULL_HEX
);
10048 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10049 printf (" (%s)%*s", dtype
,
10050 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10053 switch (entry
->d_tag
)
10057 print_dynamic_flags (entry
->d_un
.d_val
);
10067 switch (entry
->d_tag
)
10070 printf (_("Auxiliary library"));
10074 printf (_("Filter library"));
10078 printf (_("Configuration file"));
10082 printf (_("Dependency audit library"));
10086 printf (_("Audit library"));
10090 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10091 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10095 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10104 printf (_("Flags:"));
10106 if (entry
->d_un
.d_val
== 0)
10107 printf (_(" None\n"));
10110 unsigned long int val
= entry
->d_un
.d_val
;
10112 if (val
& DTF_1_PARINIT
)
10114 printf (" PARINIT");
10115 val
^= DTF_1_PARINIT
;
10117 if (val
& DTF_1_CONFEXP
)
10119 printf (" CONFEXP");
10120 val
^= DTF_1_CONFEXP
;
10123 printf (" %lx", val
);
10132 printf (_("Flags:"));
10134 if (entry
->d_un
.d_val
== 0)
10135 printf (_(" None\n"));
10138 unsigned long int val
= entry
->d_un
.d_val
;
10140 if (val
& DF_P1_LAZYLOAD
)
10142 printf (" LAZYLOAD");
10143 val
^= DF_P1_LAZYLOAD
;
10145 if (val
& DF_P1_GROUPPERM
)
10147 printf (" GROUPPERM");
10148 val
^= DF_P1_GROUPPERM
;
10151 printf (" %lx", val
);
10160 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_1_NOW
)
10172 if (val
& DF_1_GLOBAL
)
10174 printf (" GLOBAL");
10175 val
^= DF_1_GLOBAL
;
10177 if (val
& DF_1_GROUP
)
10182 if (val
& DF_1_NODELETE
)
10184 printf (" NODELETE");
10185 val
^= DF_1_NODELETE
;
10187 if (val
& DF_1_LOADFLTR
)
10189 printf (" LOADFLTR");
10190 val
^= DF_1_LOADFLTR
;
10192 if (val
& DF_1_INITFIRST
)
10194 printf (" INITFIRST");
10195 val
^= DF_1_INITFIRST
;
10197 if (val
& DF_1_NOOPEN
)
10199 printf (" NOOPEN");
10200 val
^= DF_1_NOOPEN
;
10202 if (val
& DF_1_ORIGIN
)
10204 printf (" ORIGIN");
10205 val
^= DF_1_ORIGIN
;
10207 if (val
& DF_1_DIRECT
)
10209 printf (" DIRECT");
10210 val
^= DF_1_DIRECT
;
10212 if (val
& DF_1_TRANS
)
10217 if (val
& DF_1_INTERPOSE
)
10219 printf (" INTERPOSE");
10220 val
^= DF_1_INTERPOSE
;
10222 if (val
& DF_1_NODEFLIB
)
10224 printf (" NODEFLIB");
10225 val
^= DF_1_NODEFLIB
;
10227 if (val
& DF_1_NODUMP
)
10229 printf (" NODUMP");
10230 val
^= DF_1_NODUMP
;
10232 if (val
& DF_1_CONFALT
)
10234 printf (" CONFALT");
10235 val
^= DF_1_CONFALT
;
10237 if (val
& DF_1_ENDFILTEE
)
10239 printf (" ENDFILTEE");
10240 val
^= DF_1_ENDFILTEE
;
10242 if (val
& DF_1_DISPRELDNE
)
10244 printf (" DISPRELDNE");
10245 val
^= DF_1_DISPRELDNE
;
10247 if (val
& DF_1_DISPRELPND
)
10249 printf (" DISPRELPND");
10250 val
^= DF_1_DISPRELPND
;
10252 if (val
& DF_1_NODIRECT
)
10254 printf (" NODIRECT");
10255 val
^= DF_1_NODIRECT
;
10257 if (val
& DF_1_IGNMULDEF
)
10259 printf (" IGNMULDEF");
10260 val
^= DF_1_IGNMULDEF
;
10262 if (val
& DF_1_NOKSYMS
)
10264 printf (" NOKSYMS");
10265 val
^= DF_1_NOKSYMS
;
10267 if (val
& DF_1_NOHDR
)
10272 if (val
& DF_1_EDITED
)
10274 printf (" EDITED");
10275 val
^= DF_1_EDITED
;
10277 if (val
& DF_1_NORELOC
)
10279 printf (" NORELOC");
10280 val
^= DF_1_NORELOC
;
10282 if (val
& DF_1_SYMINTPOSE
)
10284 printf (" SYMINTPOSE");
10285 val
^= DF_1_SYMINTPOSE
;
10287 if (val
& DF_1_GLOBAUDIT
)
10289 printf (" GLOBAUDIT");
10290 val
^= DF_1_GLOBAUDIT
;
10292 if (val
& DF_1_SINGLETON
)
10294 printf (" SINGLETON");
10295 val
^= DF_1_SINGLETON
;
10297 if (val
& DF_1_STUB
)
10302 if (val
& DF_1_PIE
)
10307 if (val
& DF_1_KMOD
)
10312 if (val
& DF_1_WEAKFILTER
)
10314 printf (" WEAKFILTER");
10315 val
^= DF_1_WEAKFILTER
;
10317 if (val
& DF_1_NOCOMMON
)
10319 printf (" NOCOMMON");
10320 val
^= DF_1_NOCOMMON
;
10323 printf (" %lx", val
);
10330 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10332 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10352 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10358 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10359 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10365 switch (entry
->d_tag
)
10368 printf (_("Shared library: [%s]"), name
);
10370 if (streq (name
, program_interpreter
))
10371 printf (_(" program interpreter"));
10375 printf (_("Library soname: [%s]"), name
);
10379 printf (_("Library rpath: [%s]"), name
);
10383 printf (_("Library runpath: [%s]"), name
);
10387 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10392 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10405 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10406 /* Fall through. */
10410 case DT_INIT_ARRAYSZ
:
10411 case DT_FINI_ARRAYSZ
:
10412 case DT_GNU_CONFLICTSZ
:
10413 case DT_GNU_LIBLISTSZ
:
10416 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10417 printf (_(" (bytes)\n"));
10422 case DT_VERNEEDNUM
:
10427 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10436 case DT_INIT_ARRAY
:
10437 case DT_FINI_ARRAY
:
10440 if (entry
->d_tag
== DT_USED
10441 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10443 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10447 printf (_("Not needed object: [%s]\n"), name
);
10452 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10458 /* The value of this entry is ignored. */
10463 case DT_GNU_PRELINKED
:
10467 time_t atime
= entry
->d_un
.d_val
;
10469 tmp
= gmtime (&atime
);
10470 /* PR 17533 file: 041-1244816-0.004. */
10472 printf (_("<corrupt time val: %lx"),
10473 (unsigned long) atime
);
10475 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10476 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10477 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10483 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10486 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10492 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10493 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10498 switch (filedata
->file_header
.e_machine
)
10501 dynamic_section_aarch64_val (entry
);
10504 case EM_MIPS_RS3_LE
:
10505 dynamic_section_mips_val (entry
);
10508 dynamic_section_parisc_val (entry
);
10511 dynamic_section_ia64_val (entry
);
10514 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10526 get_ver_flags (unsigned int flags
)
10528 static char buff
[128];
10535 if (flags
& VER_FLG_BASE
)
10536 strcat (buff
, "BASE");
10538 if (flags
& VER_FLG_WEAK
)
10540 if (flags
& VER_FLG_BASE
)
10541 strcat (buff
, " | ");
10543 strcat (buff
, "WEAK");
10546 if (flags
& VER_FLG_INFO
)
10548 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10549 strcat (buff
, " | ");
10551 strcat (buff
, "INFO");
10554 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10556 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10557 strcat (buff
, " | ");
10559 strcat (buff
, _("<unknown>"));
10565 /* Display the contents of the version sections. */
10568 process_version_sections (Filedata
* filedata
)
10570 Elf_Internal_Shdr
* section
;
10572 bfd_boolean found
= FALSE
;
10577 for (i
= 0, section
= filedata
->section_headers
;
10578 i
< filedata
->file_header
.e_shnum
;
10581 switch (section
->sh_type
)
10583 case SHT_GNU_verdef
:
10585 Elf_External_Verdef
* edefs
;
10592 printf (ngettext ("\nVersion definition section '%s' "
10593 "contains %u entry:\n",
10594 "\nVersion definition section '%s' "
10595 "contains %u entries:\n",
10597 printable_section_name (filedata
, section
),
10600 printf (_(" Addr: 0x"));
10601 printf_vma (section
->sh_addr
);
10602 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10603 (unsigned long) section
->sh_offset
, section
->sh_link
,
10604 printable_section_name_from_index (filedata
, section
->sh_link
));
10606 edefs
= (Elf_External_Verdef
*)
10607 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10608 _("version definition section"));
10611 endbuf
= (char *) edefs
+ section
->sh_size
;
10613 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10616 Elf_External_Verdef
* edef
;
10617 Elf_Internal_Verdef ent
;
10618 Elf_External_Verdaux
* eaux
;
10619 Elf_Internal_Verdaux aux
;
10620 unsigned long isum
;
10623 vstart
= ((char *) edefs
) + idx
;
10624 if (vstart
+ sizeof (*edef
) > endbuf
)
10627 edef
= (Elf_External_Verdef
*) vstart
;
10629 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10630 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10631 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10632 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10633 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10634 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10635 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10637 printf (_(" %#06lx: Rev: %d Flags: %s"),
10638 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10640 printf (_(" Index: %d Cnt: %d "),
10641 ent
.vd_ndx
, ent
.vd_cnt
);
10643 /* Check for overflow. */
10644 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10647 vstart
+= ent
.vd_aux
;
10649 if (vstart
+ sizeof (*eaux
) > endbuf
)
10651 eaux
= (Elf_External_Verdaux
*) vstart
;
10653 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10654 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10656 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10657 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10659 printf (_("Name index: %ld\n"), aux
.vda_name
);
10661 isum
= idx
+ ent
.vd_aux
;
10663 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10665 if (aux
.vda_next
< sizeof (*eaux
)
10666 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10668 warn (_("Invalid vda_next field of %lx\n"),
10673 /* Check for overflow. */
10674 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10677 isum
+= aux
.vda_next
;
10678 vstart
+= aux
.vda_next
;
10680 if (vstart
+ sizeof (*eaux
) > endbuf
)
10682 eaux
= (Elf_External_Verdaux
*) vstart
;
10684 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10685 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10687 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10688 printf (_(" %#06lx: Parent %d: %s\n"),
10689 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10691 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10692 isum
, j
, aux
.vda_name
);
10695 if (j
< ent
.vd_cnt
)
10696 printf (_(" Version def aux past end of section\n"));
10699 file: id:000001,src:000172+005151,op:splice,rep:2. */
10700 if (ent
.vd_next
< sizeof (*edef
)
10701 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10703 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10704 cnt
= section
->sh_info
;
10707 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10710 idx
+= ent
.vd_next
;
10713 if (cnt
< section
->sh_info
)
10714 printf (_(" Version definition past end of section\n"));
10720 case SHT_GNU_verneed
:
10722 Elf_External_Verneed
* eneed
;
10729 printf (ngettext ("\nVersion needs section '%s' "
10730 "contains %u entry:\n",
10731 "\nVersion needs section '%s' "
10732 "contains %u entries:\n",
10734 printable_section_name (filedata
, section
), section
->sh_info
);
10736 printf (_(" Addr: 0x"));
10737 printf_vma (section
->sh_addr
);
10738 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10739 (unsigned long) section
->sh_offset
, section
->sh_link
,
10740 printable_section_name_from_index (filedata
, section
->sh_link
));
10742 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10743 section
->sh_offset
, 1,
10745 _("Version Needs section"));
10748 endbuf
= (char *) eneed
+ section
->sh_size
;
10750 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10752 Elf_External_Verneed
* entry
;
10753 Elf_Internal_Verneed ent
;
10754 unsigned long isum
;
10758 vstart
= ((char *) eneed
) + idx
;
10759 if (vstart
+ sizeof (*entry
) > endbuf
)
10762 entry
= (Elf_External_Verneed
*) vstart
;
10764 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10765 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10766 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10767 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10768 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10770 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10772 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10773 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10775 printf (_(" File: %lx"), ent
.vn_file
);
10777 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10779 /* Check for overflow. */
10780 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10782 vstart
+= ent
.vn_aux
;
10784 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10786 Elf_External_Vernaux
* eaux
;
10787 Elf_Internal_Vernaux aux
;
10789 if (vstart
+ sizeof (*eaux
) > endbuf
)
10791 eaux
= (Elf_External_Vernaux
*) vstart
;
10793 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10794 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10795 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10796 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10797 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10799 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10800 printf (_(" %#06lx: Name: %s"),
10801 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10803 printf (_(" %#06lx: Name index: %lx"),
10804 isum
, aux
.vna_name
);
10806 printf (_(" Flags: %s Version: %d\n"),
10807 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10809 if (aux
.vna_next
< sizeof (*eaux
)
10810 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10812 warn (_("Invalid vna_next field of %lx\n"),
10817 /* Check for overflow. */
10818 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10820 isum
+= aux
.vna_next
;
10821 vstart
+= aux
.vna_next
;
10824 if (j
< ent
.vn_cnt
)
10825 warn (_("Missing Version Needs auxillary information\n"));
10827 if (ent
.vn_next
< sizeof (*entry
)
10828 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10830 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10831 cnt
= section
->sh_info
;
10834 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10836 idx
+= ent
.vn_next
;
10839 if (cnt
< section
->sh_info
)
10840 warn (_("Missing Version Needs information\n"));
10846 case SHT_GNU_versym
:
10848 Elf_Internal_Shdr
* link_section
;
10851 unsigned char * edata
;
10852 unsigned short * data
;
10854 Elf_Internal_Sym
* symbols
;
10855 Elf_Internal_Shdr
* string_sec
;
10856 unsigned long num_syms
;
10859 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10862 link_section
= filedata
->section_headers
+ section
->sh_link
;
10863 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10865 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10870 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10871 if (symbols
== NULL
)
10874 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10876 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10877 string_sec
->sh_size
,
10878 _("version string table"));
10885 printf (ngettext ("\nVersion symbols section '%s' "
10886 "contains %lu entry:\n",
10887 "\nVersion symbols section '%s' "
10888 "contains %lu entries:\n",
10890 printable_section_name (filedata
, section
), (unsigned long) total
);
10892 printf (_(" Addr: 0x"));
10893 printf_vma (section
->sh_addr
);
10894 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10895 (unsigned long) section
->sh_offset
, section
->sh_link
,
10896 printable_section_name (filedata
, link_section
));
10898 off
= offset_from_vma (filedata
,
10899 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10900 total
* sizeof (short));
10901 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10903 _("version symbol data"));
10911 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10913 for (cnt
= total
; cnt
--;)
10914 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10919 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10923 char *invalid
= _("*invalid*");
10925 printf (" %03x:", cnt
);
10927 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10928 switch (data
[cnt
+ j
])
10931 fputs (_(" 0 (*local*) "), stdout
);
10935 fputs (_(" 1 (*global*) "), stdout
);
10939 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10940 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10942 /* If this index value is greater than the size of the symbols
10943 array, break to avoid an out-of-bounds read. */
10944 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10946 warn (_("invalid index into symbol array\n"));
10951 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10953 Elf_Internal_Verneed ivn
;
10954 unsigned long offset
;
10956 offset
= offset_from_vma
10957 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10958 sizeof (Elf_External_Verneed
));
10962 Elf_Internal_Vernaux ivna
;
10963 Elf_External_Verneed evn
;
10964 Elf_External_Vernaux evna
;
10965 unsigned long a_off
;
10967 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10968 _("version need")) == NULL
)
10971 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10972 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10974 a_off
= offset
+ ivn
.vn_aux
;
10978 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10979 1, _("version need aux (2)")) == NULL
)
10982 ivna
.vna_other
= 0;
10986 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10987 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10990 a_off
+= ivna
.vna_next
;
10992 while (ivna
.vna_other
!= data
[cnt
+ j
]
10993 && ivna
.vna_next
!= 0);
10995 if (ivna
.vna_other
== data
[cnt
+ j
])
10997 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10999 if (ivna
.vna_name
>= string_sec
->sh_size
)
11002 name
= strtab
+ ivna
.vna_name
;
11006 offset
+= ivn
.vn_next
;
11008 while (ivn
.vn_next
);
11011 if (data
[cnt
+ j
] != 0x8001
11012 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11014 Elf_Internal_Verdef ivd
;
11015 Elf_External_Verdef evd
;
11016 unsigned long offset
;
11018 offset
= offset_from_vma
11019 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11024 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11025 _("version def")) == NULL
)
11028 /* PR 17531: file: 046-1082287-0.004. */
11029 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11034 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11035 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11038 offset
+= ivd
.vd_next
;
11040 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11041 && ivd
.vd_next
!= 0);
11043 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11045 Elf_External_Verdaux evda
;
11046 Elf_Internal_Verdaux ivda
;
11048 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11050 if (get_data (&evda
, filedata
,
11051 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11053 _("version def aux")) == NULL
)
11056 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11058 if (ivda
.vda_name
>= string_sec
->sh_size
)
11060 else if (name
!= NULL
&& name
!= invalid
)
11061 name
= _("*both*");
11063 name
= strtab
+ ivda
.vda_name
;
11067 nn
+= printf ("(%s%-*s",
11069 12 - (int) strlen (name
),
11073 printf ("%*c", 18 - nn
, ' ');
11091 printf (_("\nNo version information found in this file.\n"));
11096 static const char *
11097 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11099 static char buff
[32];
11103 case STB_LOCAL
: return "LOCAL";
11104 case STB_GLOBAL
: return "GLOBAL";
11105 case STB_WEAK
: return "WEAK";
11107 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11108 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11110 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11112 if (binding
== STB_GNU_UNIQUE
11113 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11115 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11118 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11123 static const char *
11124 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11126 static char buff
[32];
11130 case STT_NOTYPE
: return "NOTYPE";
11131 case STT_OBJECT
: return "OBJECT";
11132 case STT_FUNC
: return "FUNC";
11133 case STT_SECTION
: return "SECTION";
11134 case STT_FILE
: return "FILE";
11135 case STT_COMMON
: return "COMMON";
11136 case STT_TLS
: return "TLS";
11137 case STT_RELC
: return "RELC";
11138 case STT_SRELC
: return "SRELC";
11140 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11142 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11143 return "THUMB_FUNC";
11145 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11148 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11149 return "PARISC_MILLI";
11151 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11153 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11155 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11157 if (type
== STT_HP_OPAQUE
)
11158 return "HP_OPAQUE";
11159 if (type
== STT_HP_STUB
)
11163 if (type
== STT_GNU_IFUNC
11164 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11165 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11168 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11171 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11176 static const char *
11177 get_symbol_visibility (unsigned int visibility
)
11179 switch (visibility
)
11181 case STV_DEFAULT
: return "DEFAULT";
11182 case STV_INTERNAL
: return "INTERNAL";
11183 case STV_HIDDEN
: return "HIDDEN";
11184 case STV_PROTECTED
: return "PROTECTED";
11186 error (_("Unrecognized visibility value: %u\n"), visibility
);
11187 return _("<unknown>");
11191 static const char *
11192 get_alpha_symbol_other (unsigned int other
)
11196 case STO_ALPHA_NOPV
: return "NOPV";
11197 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11199 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11200 return _("<unknown>");
11204 static const char *
11205 get_solaris_symbol_visibility (unsigned int visibility
)
11207 switch (visibility
)
11209 case 4: return "EXPORTED";
11210 case 5: return "SINGLETON";
11211 case 6: return "ELIMINATE";
11212 default: return get_symbol_visibility (visibility
);
11216 static const char *
11217 get_aarch64_symbol_other (unsigned int other
)
11219 static char buf
[32];
11221 if (other
& STO_AARCH64_VARIANT_PCS
)
11223 other
&= ~STO_AARCH64_VARIANT_PCS
;
11225 return "VARIANT_PCS";
11226 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11232 static const char *
11233 get_mips_symbol_other (unsigned int other
)
11237 case STO_OPTIONAL
: return "OPTIONAL";
11238 case STO_MIPS_PLT
: return "MIPS PLT";
11239 case STO_MIPS_PIC
: return "MIPS PIC";
11240 case STO_MICROMIPS
: return "MICROMIPS";
11241 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11242 case STO_MIPS16
: return "MIPS16";
11243 default: return NULL
;
11247 static const char *
11248 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11250 if (is_ia64_vms (filedata
))
11252 static char res
[32];
11256 /* Function types is for images and .STB files only. */
11257 switch (filedata
->file_header
.e_type
)
11261 switch (VMS_ST_FUNC_TYPE (other
))
11263 case VMS_SFT_CODE_ADDR
:
11264 strcat (res
, " CA");
11266 case VMS_SFT_SYMV_IDX
:
11267 strcat (res
, " VEC");
11270 strcat (res
, " FD");
11272 case VMS_SFT_RESERVE
:
11273 strcat (res
, " RSV");
11276 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11277 VMS_ST_FUNC_TYPE (other
));
11278 strcat (res
, " <unknown>");
11285 switch (VMS_ST_LINKAGE (other
))
11287 case VMS_STL_IGNORE
:
11288 strcat (res
, " IGN");
11290 case VMS_STL_RESERVE
:
11291 strcat (res
, " RSV");
11294 strcat (res
, " STD");
11297 strcat (res
, " LNK");
11300 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11301 VMS_ST_LINKAGE (other
));
11302 strcat (res
, " <unknown>");
11314 static const char *
11315 get_ppc64_symbol_other (unsigned int other
)
11317 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11320 other
>>= STO_PPC64_LOCAL_BIT
;
11323 static char buf
[32];
11325 other
= ppc64_decode_local_entry (other
);
11326 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11332 static const char *
11333 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11335 const char * result
= NULL
;
11336 static char buff
[32];
11341 switch (filedata
->file_header
.e_machine
)
11344 result
= get_alpha_symbol_other (other
);
11347 result
= get_aarch64_symbol_other (other
);
11350 result
= get_mips_symbol_other (other
);
11353 result
= get_ia64_symbol_other (filedata
, other
);
11356 result
= get_ppc64_symbol_other (other
);
11366 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11370 static const char *
11371 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11373 static char buff
[32];
11377 case SHN_UNDEF
: return "UND";
11378 case SHN_ABS
: return "ABS";
11379 case SHN_COMMON
: return "COM";
11381 if (type
== SHN_IA_64_ANSI_COMMON
11382 && filedata
->file_header
.e_machine
== EM_IA_64
11383 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11385 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11386 || filedata
->file_header
.e_machine
== EM_L1OM
11387 || filedata
->file_header
.e_machine
== EM_K1OM
)
11388 && type
== SHN_X86_64_LCOMMON
)
11389 return "LARGE_COM";
11390 else if ((type
== SHN_MIPS_SCOMMON
11391 && filedata
->file_header
.e_machine
== EM_MIPS
)
11392 || (type
== SHN_TIC6X_SCOMMON
11393 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11395 else if (type
== SHN_MIPS_SUNDEFINED
11396 && filedata
->file_header
.e_machine
== EM_MIPS
)
11398 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11399 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11400 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11401 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11402 else if (type
>= SHN_LORESERVE
)
11403 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11404 else if (type
>= filedata
->file_header
.e_shnum
)
11405 sprintf (buff
, _("bad section index[%3d]"), type
);
11407 sprintf (buff
, "%3d", type
);
11415 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11417 unsigned char * e_data
;
11420 /* If the size_t type is smaller than the bfd_size_type, eg because
11421 you are building a 32-bit tool on a 64-bit host, then make sure
11422 that when (number) is cast to (size_t) no information is lost. */
11423 if (sizeof (size_t) < sizeof (bfd_size_type
)
11424 && (bfd_size_type
) ((size_t) number
) != number
)
11426 error (_("Size truncation prevents reading %s elements of size %u\n"),
11427 bfd_vmatoa ("u", number
), ent_size
);
11431 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11432 attempting to allocate memory when the read is bound to fail. */
11433 if (ent_size
* number
> filedata
->file_size
)
11435 error (_("Invalid number of dynamic entries: %s\n"),
11436 bfd_vmatoa ("u", number
));
11440 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11441 if (e_data
== NULL
)
11443 error (_("Out of memory reading %s dynamic entries\n"),
11444 bfd_vmatoa ("u", number
));
11448 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11450 error (_("Unable to read in %s bytes of dynamic data\n"),
11451 bfd_vmatoa ("u", number
* ent_size
));
11456 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11457 if (i_data
== NULL
)
11459 error (_("Out of memory allocating space for %s dynamic entries\n"),
11460 bfd_vmatoa ("u", number
));
11466 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11474 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11476 Elf_Internal_Sym
* psym
;
11479 n
= print_vma (si
, DEC_5
);
11481 fputs (&" "[n
], stdout
);
11482 printf (" %3lu: ", hn
);
11484 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11486 printf (_("<No info available for dynamic symbol number %lu>\n"),
11487 (unsigned long) si
);
11491 psym
= dynamic_symbols
+ si
;
11492 print_vma (psym
->st_value
, LONG_HEX
);
11494 print_vma (psym
->st_size
, DEC_5
);
11496 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11497 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11499 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11500 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11503 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11505 printf (" %-7s", get_symbol_visibility (vis
));
11506 /* Check to see if any other bits in the st_other field are set.
11507 Note - displaying this information disrupts the layout of the
11508 table being generated, but for the moment this case is very
11510 if (psym
->st_other
^ vis
)
11511 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11514 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11515 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11516 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11518 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11522 static const char *
11523 get_symbol_version_string (Filedata
* filedata
,
11524 bfd_boolean is_dynsym
,
11525 const char * strtab
,
11526 unsigned long int strtab_size
,
11528 Elf_Internal_Sym
* psym
,
11529 enum versioned_symbol_info
* sym_info
,
11530 unsigned short * vna_other
)
11532 unsigned char data
[2];
11533 unsigned short vers_data
;
11534 unsigned long offset
;
11535 unsigned short max_vd_ndx
;
11538 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11541 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11542 sizeof data
+ si
* sizeof (vers_data
));
11544 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11545 sizeof (data
), 1, _("version data")) == NULL
)
11548 vers_data
= byte_get (data
, 2);
11550 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11553 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11556 /* Usually we'd only see verdef for defined symbols, and verneed for
11557 undefined symbols. However, symbols defined by the linker in
11558 .dynbss for variables copied from a shared library in order to
11559 avoid text relocations are defined yet have verneed. We could
11560 use a heuristic to detect the special case, for example, check
11561 for verneed first on symbols defined in SHT_NOBITS sections, but
11562 it is simpler and more reliable to just look for both verdef and
11563 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11565 if (psym
->st_shndx
!= SHN_UNDEF
11566 && vers_data
!= 0x8001
11567 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11569 Elf_Internal_Verdef ivd
;
11570 Elf_Internal_Verdaux ivda
;
11571 Elf_External_Verdaux evda
;
11574 off
= offset_from_vma (filedata
,
11575 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11576 sizeof (Elf_External_Verdef
));
11580 Elf_External_Verdef evd
;
11582 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11583 _("version def")) == NULL
)
11592 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11593 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11594 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11595 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11598 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11599 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11601 off
+= ivd
.vd_next
;
11603 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11605 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11607 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11610 off
-= ivd
.vd_next
;
11613 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11614 _("version def aux")) != NULL
)
11616 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11618 if (psym
->st_name
!= ivda
.vda_name
)
11619 return (ivda
.vda_name
< strtab_size
11620 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11625 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11627 Elf_External_Verneed evn
;
11628 Elf_Internal_Verneed ivn
;
11629 Elf_Internal_Vernaux ivna
;
11631 offset
= offset_from_vma (filedata
,
11632 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11636 unsigned long vna_off
;
11638 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11639 _("version need")) == NULL
)
11642 ivna
.vna_other
= 0;
11647 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11648 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11650 vna_off
= offset
+ ivn
.vn_aux
;
11654 Elf_External_Vernaux evna
;
11656 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11657 _("version need aux (3)")) == NULL
)
11660 ivna
.vna_other
= 0;
11665 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11666 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11667 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11670 vna_off
+= ivna
.vna_next
;
11672 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11674 if (ivna
.vna_other
== vers_data
)
11677 offset
+= ivn
.vn_next
;
11679 while (ivn
.vn_next
!= 0);
11681 if (ivna
.vna_other
== vers_data
)
11683 *sym_info
= symbol_undefined
;
11684 *vna_other
= ivna
.vna_other
;
11685 return (ivna
.vna_name
< strtab_size
11686 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11688 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11689 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11690 return _("<corrupt>");
11695 /* Dump the symbol table. */
11697 process_symbol_table (Filedata
* filedata
)
11699 Elf_Internal_Shdr
* section
;
11700 bfd_size_type nbuckets
= 0;
11701 bfd_size_type nchains
= 0;
11702 bfd_vma
* buckets
= NULL
;
11703 bfd_vma
* chains
= NULL
;
11704 bfd_vma ngnubuckets
= 0;
11705 bfd_vma
* gnubuckets
= NULL
;
11706 bfd_vma
* gnuchains
= NULL
;
11707 bfd_vma
* mipsxlat
= NULL
;
11708 bfd_vma gnusymidx
= 0;
11709 bfd_size_type ngnuchains
= 0;
11711 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11714 if (dynamic_info
[DT_HASH
]
11716 || (do_using_dynamic
11718 && dynamic_strings
!= NULL
)))
11720 unsigned char nb
[8];
11721 unsigned char nc
[8];
11722 unsigned int hash_ent_size
= 4;
11724 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11725 || filedata
->file_header
.e_machine
== EM_S390
11726 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11727 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11730 if (fseek (filedata
->handle
,
11731 (archive_file_offset
11732 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11733 sizeof nb
+ sizeof nc
)),
11736 error (_("Unable to seek to start of dynamic information\n"));
11740 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11742 error (_("Failed to read in number of buckets\n"));
11746 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11748 error (_("Failed to read in number of chains\n"));
11752 nbuckets
= byte_get (nb
, hash_ent_size
);
11753 nchains
= byte_get (nc
, hash_ent_size
);
11755 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11756 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11759 if (buckets
== NULL
|| chains
== NULL
)
11761 if (do_using_dynamic
)
11772 if (dynamic_info_DT_GNU_HASH
11774 || (do_using_dynamic
11776 && dynamic_strings
!= NULL
)))
11778 unsigned char nb
[16];
11779 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11780 bfd_vma buckets_vma
;
11782 if (fseek (filedata
->handle
,
11783 (archive_file_offset
11784 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11788 error (_("Unable to seek to start of dynamic information\n"));
11792 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11794 error (_("Failed to read in number of buckets\n"));
11798 ngnubuckets
= byte_get (nb
, 4);
11799 gnusymidx
= byte_get (nb
+ 4, 4);
11800 bitmaskwords
= byte_get (nb
+ 8, 4);
11801 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11803 buckets_vma
+= bitmaskwords
* 4;
11805 buckets_vma
+= bitmaskwords
* 8;
11807 if (fseek (filedata
->handle
,
11808 (archive_file_offset
11809 + offset_from_vma (filedata
, buckets_vma
, 4)),
11812 error (_("Unable to seek to start of dynamic information\n"));
11816 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11818 if (gnubuckets
== NULL
)
11821 for (i
= 0; i
< ngnubuckets
; i
++)
11822 if (gnubuckets
[i
] != 0)
11824 if (gnubuckets
[i
] < gnusymidx
)
11827 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11828 maxchain
= gnubuckets
[i
];
11831 if (maxchain
== 0xffffffff)
11834 maxchain
-= gnusymidx
;
11836 if (fseek (filedata
->handle
,
11837 (archive_file_offset
11838 + offset_from_vma (filedata
, buckets_vma
11839 + 4 * (ngnubuckets
+ maxchain
), 4)),
11842 error (_("Unable to seek to start of dynamic information\n"));
11848 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11850 error (_("Failed to determine last chain length\n"));
11854 if (maxchain
+ 1 == 0)
11859 while ((byte_get (nb
, 4) & 1) == 0);
11861 if (fseek (filedata
->handle
,
11862 (archive_file_offset
11863 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11866 error (_("Unable to seek to start of dynamic information\n"));
11870 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11871 ngnuchains
= maxchain
;
11873 if (gnuchains
== NULL
)
11876 if (dynamic_info_DT_MIPS_XHASH
)
11878 if (fseek (filedata
->handle
,
11879 (archive_file_offset
11880 + offset_from_vma (filedata
, (buckets_vma
11885 error (_("Unable to seek to start of dynamic information\n"));
11889 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11893 if (dynamic_info_DT_MIPS_XHASH
&& mipsxlat
== NULL
)
11898 if (gnuchains
== NULL
)
11903 if (do_using_dynamic
)
11908 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11910 && do_using_dynamic
11911 && dynamic_strings
!= NULL
11912 && dynamic_symbols
!= NULL
)
11916 if (dynamic_info
[DT_HASH
])
11921 printf (_("\nSymbol table for image:\n"));
11923 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11925 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11927 visited
= xcmalloc (nchains
, 1);
11928 memset (visited
, 0, nchains
);
11929 for (hn
= 0; hn
< nbuckets
; hn
++)
11931 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11933 print_dynamic_symbol (filedata
, si
, hn
);
11934 if (si
>= nchains
|| visited
[si
])
11936 error (_("histogram chain is corrupt\n"));
11945 if (dynamic_info_DT_GNU_HASH
)
11947 printf (_("\nSymbol table of `%s' for image:\n"),
11948 GNU_HASH_SECTION_NAME
);
11950 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11952 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11954 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11955 if (gnubuckets
[hn
] != 0)
11957 bfd_vma si
= gnubuckets
[hn
];
11958 bfd_vma off
= si
- gnusymidx
;
11962 if (dynamic_info_DT_MIPS_XHASH
)
11963 print_dynamic_symbol (filedata
, mipsxlat
[off
], hn
);
11965 print_dynamic_symbol (filedata
, si
, hn
);
11968 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11972 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11973 && filedata
->section_headers
!= NULL
)
11977 for (i
= 0, section
= filedata
->section_headers
;
11978 i
< filedata
->file_header
.e_shnum
;
11982 char * strtab
= NULL
;
11983 unsigned long int strtab_size
= 0;
11984 Elf_Internal_Sym
* symtab
;
11985 Elf_Internal_Sym
* psym
;
11986 unsigned long num_syms
;
11988 if ((section
->sh_type
!= SHT_SYMTAB
11989 && section
->sh_type
!= SHT_DYNSYM
)
11991 && section
->sh_type
== SHT_SYMTAB
))
11994 if (section
->sh_entsize
== 0)
11996 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11997 printable_section_name (filedata
, section
));
12001 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12002 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12003 "\nSymbol table '%s' contains %lu entries:\n",
12005 printable_section_name (filedata
, section
),
12009 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12011 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12013 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12014 if (symtab
== NULL
)
12017 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12019 strtab
= filedata
->string_table
;
12020 strtab_size
= filedata
->string_table_length
;
12022 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12024 Elf_Internal_Shdr
* string_sec
;
12026 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12028 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12029 1, string_sec
->sh_size
,
12030 _("string table"));
12031 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12034 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
12036 const char *version_string
;
12037 enum versioned_symbol_info sym_info
;
12038 unsigned short vna_other
;
12040 printf ("%6d: ", si
);
12041 print_vma (psym
->st_value
, LONG_HEX
);
12043 print_vma (psym
->st_size
, DEC_5
);
12044 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12045 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12046 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12047 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12050 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12052 printf (" %-7s", get_symbol_visibility (vis
));
12053 /* Check to see if any other bits in the st_other field are set.
12054 Note - displaying this information disrupts the layout of the
12055 table being generated, but for the moment this case is very rare. */
12056 if (psym
->st_other
^ vis
)
12057 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12059 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12060 print_symbol (25, psym
->st_name
< strtab_size
12061 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12064 = get_symbol_version_string (filedata
,
12065 section
->sh_type
== SHT_DYNSYM
,
12066 strtab
, strtab_size
, si
,
12067 psym
, &sym_info
, &vna_other
);
12068 if (version_string
)
12070 if (sym_info
== symbol_undefined
)
12071 printf ("@%s (%d)", version_string
, vna_other
);
12073 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12079 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12080 && si
>= section
->sh_info
12081 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12082 && filedata
->file_header
.e_machine
!= EM_MIPS
12083 /* Solaris binaries have been found to violate this requirement as
12084 well. Not sure if this is a bug or an ABI requirement. */
12085 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12086 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12087 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12091 if (strtab
!= filedata
->string_table
)
12097 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12099 if (do_histogram
&& buckets
!= NULL
)
12101 unsigned long * lengths
;
12102 unsigned long * counts
;
12105 unsigned long maxlength
= 0;
12106 unsigned long nzero_counts
= 0;
12107 unsigned long nsyms
= 0;
12110 printf (ngettext ("\nHistogram for bucket list length "
12111 "(total of %lu bucket):\n",
12112 "\nHistogram for bucket list length "
12113 "(total of %lu buckets):\n",
12114 (unsigned long) nbuckets
),
12115 (unsigned long) nbuckets
);
12117 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12118 if (lengths
== NULL
)
12120 error (_("Out of memory allocating space for histogram buckets\n"));
12123 visited
= xcmalloc (nchains
, 1);
12124 memset (visited
, 0, nchains
);
12126 printf (_(" Length Number %% of total Coverage\n"));
12127 for (hn
= 0; hn
< nbuckets
; ++hn
)
12129 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12132 if (maxlength
< ++lengths
[hn
])
12134 if (si
>= nchains
|| visited
[si
])
12136 error (_("histogram chain is corrupt\n"));
12144 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12145 if (counts
== NULL
)
12148 error (_("Out of memory allocating space for histogram counts\n"));
12152 for (hn
= 0; hn
< nbuckets
; ++hn
)
12153 ++counts
[lengths
[hn
]];
12158 printf (" 0 %-10lu (%5.1f%%)\n",
12159 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12160 for (i
= 1; i
<= maxlength
; ++i
)
12162 nzero_counts
+= counts
[i
] * i
;
12163 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12164 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12165 (nzero_counts
* 100.0) / nsyms
);
12173 if (buckets
!= NULL
)
12179 if (do_histogram
&& gnubuckets
!= NULL
)
12181 unsigned long * lengths
;
12182 unsigned long * counts
;
12184 unsigned long maxlength
= 0;
12185 unsigned long nzero_counts
= 0;
12186 unsigned long nsyms
= 0;
12188 printf (ngettext ("\nHistogram for `%s' bucket list length "
12189 "(total of %lu bucket):\n",
12190 "\nHistogram for `%s' bucket list length "
12191 "(total of %lu buckets):\n",
12192 (unsigned long) ngnubuckets
),
12193 GNU_HASH_SECTION_NAME
,
12194 (unsigned long) ngnubuckets
);
12196 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12197 if (lengths
== NULL
)
12199 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12203 printf (_(" Length Number %% of total Coverage\n"));
12205 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12206 if (gnubuckets
[hn
] != 0)
12208 bfd_vma off
, length
= 1;
12210 for (off
= gnubuckets
[hn
] - gnusymidx
;
12211 /* PR 17531 file: 010-77222-0.004. */
12212 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12215 lengths
[hn
] = length
;
12216 if (length
> maxlength
)
12217 maxlength
= length
;
12221 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12222 if (counts
== NULL
)
12225 error (_("Out of memory allocating space for gnu histogram counts\n"));
12229 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12230 ++counts
[lengths
[hn
]];
12232 if (ngnubuckets
> 0)
12235 printf (" 0 %-10lu (%5.1f%%)\n",
12236 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12237 for (j
= 1; j
<= maxlength
; ++j
)
12239 nzero_counts
+= counts
[j
] * j
;
12240 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12241 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12242 (nzero_counts
* 100.0) / nsyms
);
12257 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12261 if (dynamic_syminfo
== NULL
12263 /* No syminfo, this is ok. */
12266 /* There better should be a dynamic symbol section. */
12267 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12271 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12272 "contains %d entry:\n",
12273 "\nDynamic info segment at offset 0x%lx "
12274 "contains %d entries:\n",
12275 dynamic_syminfo_nent
),
12276 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12278 printf (_(" Num: Name BoundTo Flags\n"));
12279 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12281 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12283 printf ("%4d: ", i
);
12284 if (i
>= num_dynamic_syms
)
12285 printf (_("<corrupt index>"));
12286 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12287 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12289 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12292 switch (dynamic_syminfo
[i
].si_boundto
)
12294 case SYMINFO_BT_SELF
:
12295 fputs ("SELF ", stdout
);
12297 case SYMINFO_BT_PARENT
:
12298 fputs ("PARENT ", stdout
);
12301 if (dynamic_syminfo
[i
].si_boundto
> 0
12302 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12303 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12305 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12309 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12313 if (flags
& SYMINFO_FLG_DIRECT
)
12314 printf (" DIRECT");
12315 if (flags
& SYMINFO_FLG_PASSTHRU
)
12316 printf (" PASSTHRU");
12317 if (flags
& SYMINFO_FLG_COPY
)
12319 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12320 printf (" LAZYLOAD");
12328 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12329 is contained by the region START .. END. The types of ADDR, START
12330 and END should all be the same. Note both ADDR + NELEM and END
12331 point to just beyond the end of the regions that are being tested. */
12332 #define IN_RANGE(START,END,ADDR,NELEM) \
12333 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12335 /* Check to see if the given reloc needs to be handled in a target specific
12336 manner. If so then process the reloc and return TRUE otherwise return
12339 If called with reloc == NULL, then this is a signal that reloc processing
12340 for the current section has finished, and any saved state should be
12344 target_specific_reloc_handling (Filedata
* filedata
,
12345 Elf_Internal_Rela
* reloc
,
12346 unsigned char * start
,
12347 unsigned char * end
,
12348 Elf_Internal_Sym
* symtab
,
12349 unsigned long num_syms
)
12351 unsigned int reloc_type
= 0;
12352 unsigned long sym_index
= 0;
12356 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12357 sym_index
= get_reloc_symindex (reloc
->r_info
);
12360 switch (filedata
->file_header
.e_machine
)
12363 case EM_MSP430_OLD
:
12365 static Elf_Internal_Sym
* saved_sym
= NULL
;
12373 switch (reloc_type
)
12375 case 10: /* R_MSP430_SYM_DIFF */
12376 if (uses_msp430x_relocs (filedata
))
12378 /* Fall through. */
12379 case 21: /* R_MSP430X_SYM_DIFF */
12381 if (sym_index
>= num_syms
)
12382 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12385 saved_sym
= symtab
+ sym_index
;
12388 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12389 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12390 goto handle_sym_diff
;
12392 case 5: /* R_MSP430_16_BYTE */
12393 case 9: /* R_MSP430_8 */
12394 if (uses_msp430x_relocs (filedata
))
12396 goto handle_sym_diff
;
12398 case 2: /* R_MSP430_ABS16 */
12399 case 15: /* R_MSP430X_ABS16 */
12400 if (! uses_msp430x_relocs (filedata
))
12402 goto handle_sym_diff
;
12405 if (saved_sym
!= NULL
)
12407 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12410 if (sym_index
>= num_syms
)
12411 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12415 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12416 - saved_sym
->st_value
);
12418 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12419 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12422 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12423 (long) reloc
->r_offset
);
12432 if (saved_sym
!= NULL
)
12433 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12440 case EM_CYGNUS_MN10300
:
12442 static Elf_Internal_Sym
* saved_sym
= NULL
;
12450 switch (reloc_type
)
12452 case 34: /* R_MN10300_ALIGN */
12454 case 33: /* R_MN10300_SYM_DIFF */
12455 if (sym_index
>= num_syms
)
12456 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12459 saved_sym
= symtab
+ sym_index
;
12462 case 1: /* R_MN10300_32 */
12463 case 2: /* R_MN10300_16 */
12464 if (saved_sym
!= NULL
)
12466 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12469 if (sym_index
>= num_syms
)
12470 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12474 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12475 - saved_sym
->st_value
);
12477 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12478 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12480 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12481 (long) reloc
->r_offset
);
12489 if (saved_sym
!= NULL
)
12490 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12498 static bfd_vma saved_sym1
= 0;
12499 static bfd_vma saved_sym2
= 0;
12500 static bfd_vma value
;
12504 saved_sym1
= saved_sym2
= 0;
12508 switch (reloc_type
)
12510 case 0x80: /* R_RL78_SYM. */
12511 saved_sym1
= saved_sym2
;
12512 if (sym_index
>= num_syms
)
12513 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12517 saved_sym2
= symtab
[sym_index
].st_value
;
12518 saved_sym2
+= reloc
->r_addend
;
12522 case 0x83: /* R_RL78_OPsub. */
12523 value
= saved_sym1
- saved_sym2
;
12524 saved_sym2
= saved_sym1
= 0;
12528 case 0x41: /* R_RL78_ABS32. */
12529 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12530 byte_put (start
+ reloc
->r_offset
, value
, 4);
12532 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12533 (long) reloc
->r_offset
);
12537 case 0x43: /* R_RL78_ABS16. */
12538 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12539 byte_put (start
+ reloc
->r_offset
, value
, 2);
12541 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12542 (long) reloc
->r_offset
);
12556 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12557 DWARF debug sections. This is a target specific test. Note - we do not
12558 go through the whole including-target-headers-multiple-times route, (as
12559 we have already done with <elf/h8.h>) because this would become very
12560 messy and even then this function would have to contain target specific
12561 information (the names of the relocs instead of their numeric values).
12562 FIXME: This is not the correct way to solve this problem. The proper way
12563 is to have target specific reloc sizing and typing functions created by
12564 the reloc-macros.h header, in the same way that it already creates the
12565 reloc naming functions. */
12568 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12570 /* Please keep this table alpha-sorted for ease of visual lookup. */
12571 switch (filedata
->file_header
.e_machine
)
12575 return reloc_type
== 1; /* R_386_32. */
12577 return reloc_type
== 1; /* R_68K_32. */
12579 return reloc_type
== 1; /* R_860_32. */
12581 return reloc_type
== 2; /* R_960_32. */
12583 return (reloc_type
== 258
12584 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12586 return reloc_type
== 11; /* R_BPF_DATA_32 */
12587 case EM_ADAPTEVA_EPIPHANY
:
12588 return reloc_type
== 3;
12590 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12592 return reloc_type
== 1; /* R_ARC_32. */
12593 case EM_ARC_COMPACT
:
12594 case EM_ARC_COMPACT2
:
12595 return reloc_type
== 4; /* R_ARC_32. */
12597 return reloc_type
== 2; /* R_ARM_ABS32 */
12600 return reloc_type
== 1;
12602 return reloc_type
== 0x12; /* R_byte4_data. */
12604 return reloc_type
== 3; /* R_CRIS_32. */
12606 return reloc_type
== 3; /* R_CR16_NUM32. */
12608 return reloc_type
== 15; /* R_CRX_NUM32. */
12610 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12611 case EM_CYGNUS_FRV
:
12612 return reloc_type
== 1;
12613 case EM_CYGNUS_D10V
:
12615 return reloc_type
== 6; /* R_D10V_32. */
12616 case EM_CYGNUS_D30V
:
12618 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12620 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12621 case EM_CYGNUS_FR30
:
12623 return reloc_type
== 3; /* R_FR30_32. */
12625 return reloc_type
== 1; /* R_FT32_32. */
12629 return reloc_type
== 1; /* R_H8_DIR32. */
12631 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12632 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12633 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12634 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12637 return reloc_type
== 2; /* R_IP2K_32. */
12639 return reloc_type
== 2; /* R_IQ2000_32. */
12640 case EM_LATTICEMICO32
:
12641 return reloc_type
== 3; /* R_LM32_32. */
12644 return reloc_type
== 3; /* R_M32C_32. */
12646 return reloc_type
== 34; /* R_M32R_32_RELA. */
12649 return reloc_type
== 6; /* R_M68HC11_32. */
12651 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12652 reloc_type
== 6; /* R_S12Z_CW32. */
12654 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12655 case EM_CYGNUS_MEP
:
12656 return reloc_type
== 4; /* R_MEP_32. */
12658 return reloc_type
== 2; /* R_METAG_ADDR32. */
12659 case EM_MICROBLAZE
:
12660 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12662 return reloc_type
== 2; /* R_MIPS_32. */
12664 return reloc_type
== 4; /* R_MMIX_32. */
12665 case EM_CYGNUS_MN10200
:
12667 return reloc_type
== 1; /* R_MN10200_32. */
12668 case EM_CYGNUS_MN10300
:
12670 return reloc_type
== 1; /* R_MN10300_32. */
12672 return reloc_type
== 1; /* R_MOXIE_32. */
12673 case EM_MSP430_OLD
:
12675 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12677 return reloc_type
== 2; /* R_MT_32. */
12679 return reloc_type
== 20; /* R_NDS32_RELA. */
12680 case EM_ALTERA_NIOS2
:
12681 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12683 return reloc_type
== 1; /* R_NIOS_32. */
12685 return reloc_type
== 1; /* R_OR1K_32. */
12687 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12688 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12689 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12692 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12694 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12696 return reloc_type
== 1; /* R_PPC_ADDR32. */
12698 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12700 return reloc_type
== 1; /* R_RISCV_32. */
12702 return reloc_type
== 1; /* R_RL78_DIR32. */
12704 return reloc_type
== 1; /* R_RX_DIR32. */
12706 return reloc_type
== 1; /* R_I370_ADDR31. */
12709 return reloc_type
== 4; /* R_S390_32. */
12711 return reloc_type
== 8; /* R_SCORE_ABS32. */
12713 return reloc_type
== 1; /* R_SH_DIR32. */
12714 case EM_SPARC32PLUS
:
12717 return reloc_type
== 3 /* R_SPARC_32. */
12718 || reloc_type
== 23; /* R_SPARC_UA32. */
12720 return reloc_type
== 6; /* R_SPU_ADDR32 */
12722 return reloc_type
== 1; /* R_C6000_ABS32. */
12724 return reloc_type
== 2; /* R_TILEGX_32. */
12726 return reloc_type
== 1; /* R_TILEPRO_32. */
12727 case EM_CYGNUS_V850
:
12729 return reloc_type
== 6; /* R_V850_ABS32. */
12731 return reloc_type
== 0x33; /* R_V810_WORD. */
12733 return reloc_type
== 1; /* R_VAX_32. */
12735 return reloc_type
== 3; /* R_VISIUM_32. */
12736 case EM_WEBASSEMBLY
:
12737 return reloc_type
== 1; /* R_WASM32_32. */
12741 return reloc_type
== 10; /* R_X86_64_32. */
12744 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12746 return reloc_type
== 4; /* R_XGATE_32. */
12748 return reloc_type
== 1; /* R_XSTROMY16_32. */
12749 case EM_XTENSA_OLD
:
12751 return reloc_type
== 1; /* R_XTENSA_32. */
12753 return reloc_type
== 6; /* R_Z80_32. */
12756 static unsigned int prev_warn
= 0;
12758 /* Avoid repeating the same warning multiple times. */
12759 if (prev_warn
!= filedata
->file_header
.e_machine
)
12760 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12761 filedata
->file_header
.e_machine
);
12762 prev_warn
= filedata
->file_header
.e_machine
;
12768 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12769 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12772 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12774 switch (filedata
->file_header
.e_machine
)
12775 /* Please keep this table alpha-sorted for ease of visual lookup. */
12779 return reloc_type
== 2; /* R_386_PC32. */
12781 return reloc_type
== 4; /* R_68K_PC32. */
12783 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12784 case EM_ADAPTEVA_EPIPHANY
:
12785 return reloc_type
== 6;
12787 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12788 case EM_ARC_COMPACT
:
12789 case EM_ARC_COMPACT2
:
12790 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12792 return reloc_type
== 3; /* R_ARM_REL32 */
12795 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12796 case EM_MICROBLAZE
:
12797 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12799 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12801 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12803 return reloc_type
== 26; /* R_PPC_REL32. */
12805 return reloc_type
== 26; /* R_PPC64_REL32. */
12807 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12810 return reloc_type
== 5; /* R_390_PC32. */
12812 return reloc_type
== 2; /* R_SH_REL32. */
12813 case EM_SPARC32PLUS
:
12816 return reloc_type
== 6; /* R_SPARC_DISP32. */
12818 return reloc_type
== 13; /* R_SPU_REL32. */
12820 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12822 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12824 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12828 return reloc_type
== 2; /* R_X86_64_PC32. */
12830 return reloc_type
== 4; /* R_VAX_PCREL32. */
12831 case EM_XTENSA_OLD
:
12833 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12835 /* Do not abort or issue an error message here. Not all targets use
12836 pc-relative 32-bit relocs in their DWARF debug information and we
12837 have already tested for target coverage in is_32bit_abs_reloc. A
12838 more helpful warning message will be generated by apply_relocations
12839 anyway, so just return. */
12844 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12845 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12848 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12850 switch (filedata
->file_header
.e_machine
)
12853 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12855 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12857 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12858 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12860 return reloc_type
== 80; /* R_PARISC_DIR64. */
12862 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12864 return reloc_type
== 2; /* R_RISCV_64. */
12865 case EM_SPARC32PLUS
:
12868 return reloc_type
== 32 /* R_SPARC_64. */
12869 || reloc_type
== 54; /* R_SPARC_UA64. */
12873 return reloc_type
== 1; /* R_X86_64_64. */
12876 return reloc_type
== 22; /* R_S390_64. */
12878 return reloc_type
== 1; /* R_TILEGX_64. */
12880 return reloc_type
== 18; /* R_MIPS_64. */
12886 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12887 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12890 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12892 switch (filedata
->file_header
.e_machine
)
12895 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12897 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12899 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12900 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12902 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12904 return reloc_type
== 44; /* R_PPC64_REL64. */
12905 case EM_SPARC32PLUS
:
12908 return reloc_type
== 46; /* R_SPARC_DISP64. */
12912 return reloc_type
== 24; /* R_X86_64_PC64. */
12915 return reloc_type
== 23; /* R_S390_PC64. */
12917 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12923 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12924 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12927 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12929 switch (filedata
->file_header
.e_machine
)
12931 case EM_CYGNUS_MN10200
:
12933 return reloc_type
== 4; /* R_MN10200_24. */
12935 return reloc_type
== 5; /* R_FT32_20. */
12937 return reloc_type
== 5; /* R_Z80_24. */
12943 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12944 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12947 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12949 /* Please keep this table alpha-sorted for ease of visual lookup. */
12950 switch (filedata
->file_header
.e_machine
)
12953 case EM_ARC_COMPACT
:
12954 case EM_ARC_COMPACT2
:
12955 return reloc_type
== 2; /* R_ARC_16. */
12956 case EM_ADAPTEVA_EPIPHANY
:
12957 return reloc_type
== 5;
12960 return reloc_type
== 4; /* R_AVR_16. */
12961 case EM_CYGNUS_D10V
:
12963 return reloc_type
== 3; /* R_D10V_16. */
12965 return reloc_type
== 2; /* R_FT32_16. */
12969 return reloc_type
== R_H8_DIR16
;
12972 return reloc_type
== 1; /* R_IP2K_16. */
12975 return reloc_type
== 1; /* R_M32C_16 */
12976 case EM_CYGNUS_MN10200
:
12978 return reloc_type
== 2; /* R_MN10200_16. */
12979 case EM_CYGNUS_MN10300
:
12981 return reloc_type
== 2; /* R_MN10300_16. */
12983 if (uses_msp430x_relocs (filedata
))
12984 return reloc_type
== 2; /* R_MSP430_ABS16. */
12985 /* Fall through. */
12986 case EM_MSP430_OLD
:
12987 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12989 return reloc_type
== 19; /* R_NDS32_RELA. */
12990 case EM_ALTERA_NIOS2
:
12991 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12993 return reloc_type
== 9; /* R_NIOS_16. */
12995 return reloc_type
== 2; /* R_OR1K_16. */
12997 return reloc_type
== 55; /* R_RISCV_SET16. */
12999 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13001 return reloc_type
== 2; /* R_C6000_ABS16. */
13003 return reloc_type
== 2; /* R_VISIUM_16. */
13006 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13008 return reloc_type
== 3; /* R_XGATE_16. */
13010 return reloc_type
== 4; /* R_Z80_16. */
13016 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13017 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13020 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13022 switch (filedata
->file_header
.e_machine
)
13025 return reloc_type
== 54; /* R_RISCV_SET8. */
13027 return reloc_type
== 1; /* R_Z80_8. */
13033 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13034 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13037 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13039 switch (filedata
->file_header
.e_machine
)
13042 return reloc_type
== 53; /* R_RISCV_SET6. */
13048 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13049 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13052 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13054 /* Please keep this table alpha-sorted for ease of visual lookup. */
13055 switch (filedata
->file_header
.e_machine
)
13058 return reloc_type
== 35; /* R_RISCV_ADD32. */
13064 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13065 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13068 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13070 /* Please keep this table alpha-sorted for ease of visual lookup. */
13071 switch (filedata
->file_header
.e_machine
)
13074 return reloc_type
== 39; /* R_RISCV_SUB32. */
13080 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13081 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13084 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13086 /* Please keep this table alpha-sorted for ease of visual lookup. */
13087 switch (filedata
->file_header
.e_machine
)
13090 return reloc_type
== 36; /* R_RISCV_ADD64. */
13096 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13097 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13100 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13102 /* Please keep this table alpha-sorted for ease of visual lookup. */
13103 switch (filedata
->file_header
.e_machine
)
13106 return reloc_type
== 40; /* R_RISCV_SUB64. */
13112 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13113 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13116 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13118 /* Please keep this table alpha-sorted for ease of visual lookup. */
13119 switch (filedata
->file_header
.e_machine
)
13122 return reloc_type
== 34; /* R_RISCV_ADD16. */
13128 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13129 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13132 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13134 /* Please keep this table alpha-sorted for ease of visual lookup. */
13135 switch (filedata
->file_header
.e_machine
)
13138 return reloc_type
== 38; /* R_RISCV_SUB16. */
13144 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13145 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13148 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13150 /* Please keep this table alpha-sorted for ease of visual lookup. */
13151 switch (filedata
->file_header
.e_machine
)
13154 return reloc_type
== 33; /* R_RISCV_ADD8. */
13160 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13161 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13164 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13166 /* Please keep this table alpha-sorted for ease of visual lookup. */
13167 switch (filedata
->file_header
.e_machine
)
13170 return reloc_type
== 37; /* R_RISCV_SUB8. */
13176 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13177 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13180 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13182 switch (filedata
->file_header
.e_machine
)
13185 return reloc_type
== 52; /* R_RISCV_SUB6. */
13191 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13192 relocation entries (possibly formerly used for SHT_GROUP sections). */
13195 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13197 switch (filedata
->file_header
.e_machine
)
13199 case EM_386
: /* R_386_NONE. */
13200 case EM_68K
: /* R_68K_NONE. */
13201 case EM_ADAPTEVA_EPIPHANY
:
13202 case EM_ALPHA
: /* R_ALPHA_NONE. */
13203 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13204 case EM_ARC
: /* R_ARC_NONE. */
13205 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13206 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13207 case EM_ARM
: /* R_ARM_NONE. */
13208 case EM_C166
: /* R_XC16X_NONE. */
13209 case EM_CRIS
: /* R_CRIS_NONE. */
13210 case EM_FT32
: /* R_FT32_NONE. */
13211 case EM_IA_64
: /* R_IA64_NONE. */
13212 case EM_K1OM
: /* R_X86_64_NONE. */
13213 case EM_L1OM
: /* R_X86_64_NONE. */
13214 case EM_M32R
: /* R_M32R_NONE. */
13215 case EM_MIPS
: /* R_MIPS_NONE. */
13216 case EM_MN10300
: /* R_MN10300_NONE. */
13217 case EM_MOXIE
: /* R_MOXIE_NONE. */
13218 case EM_NIOS32
: /* R_NIOS_NONE. */
13219 case EM_OR1K
: /* R_OR1K_NONE. */
13220 case EM_PARISC
: /* R_PARISC_NONE. */
13221 case EM_PPC64
: /* R_PPC64_NONE. */
13222 case EM_PPC
: /* R_PPC_NONE. */
13223 case EM_RISCV
: /* R_RISCV_NONE. */
13224 case EM_S390
: /* R_390_NONE. */
13226 case EM_SH
: /* R_SH_NONE. */
13227 case EM_SPARC32PLUS
:
13228 case EM_SPARC
: /* R_SPARC_NONE. */
13230 case EM_TILEGX
: /* R_TILEGX_NONE. */
13231 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13232 case EM_TI_C6000
:/* R_C6000_NONE. */
13233 case EM_X86_64
: /* R_X86_64_NONE. */
13235 case EM_Z80
: /* R_Z80_NONE. */
13236 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13237 return reloc_type
== 0;
13240 return reloc_type
== 0 || reloc_type
== 256;
13243 return (reloc_type
== 0 /* R_AVR_NONE. */
13244 || reloc_type
== 30 /* R_AVR_DIFF8. */
13245 || reloc_type
== 31 /* R_AVR_DIFF16. */
13246 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13248 return reloc_type
== 3; /* R_METAG_NONE. */
13250 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13251 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13252 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13253 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13254 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13256 return (reloc_type
== 0 /* R_PRU_NONE. */
13257 || reloc_type
== 65 /* R_PRU_DIFF8. */
13258 || reloc_type
== 66 /* R_PRU_DIFF16. */
13259 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13260 case EM_XTENSA_OLD
:
13262 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13263 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13264 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13265 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13270 /* Returns TRUE if there is a relocation against
13271 section NAME at OFFSET bytes. */
13274 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13276 Elf_Internal_Rela
* relocs
;
13277 Elf_Internal_Rela
* rp
;
13279 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13282 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13284 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13285 if (rp
->r_offset
== offset
)
13291 /* Apply relocations to a section.
13292 Returns TRUE upon success, FALSE otherwise.
13293 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13294 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13295 will be set to the number of relocs loaded.
13297 Note: So far support has been added only for those relocations
13298 which can be found in debug sections. FIXME: Add support for
13299 more relocations ? */
13302 apply_relocations (Filedata
* filedata
,
13303 const Elf_Internal_Shdr
* section
,
13304 unsigned char * start
,
13305 bfd_size_type size
,
13306 void ** relocs_return
,
13307 unsigned long * num_relocs_return
)
13309 Elf_Internal_Shdr
* relsec
;
13310 unsigned char * end
= start
+ size
;
13312 if (relocs_return
!= NULL
)
13314 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13315 * num_relocs_return
= 0;
13318 if (filedata
->file_header
.e_type
!= ET_REL
)
13319 /* No relocs to apply. */
13322 /* Find the reloc section associated with the section. */
13323 for (relsec
= filedata
->section_headers
;
13324 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13327 bfd_boolean is_rela
;
13328 unsigned long num_relocs
;
13329 Elf_Internal_Rela
* relocs
;
13330 Elf_Internal_Rela
* rp
;
13331 Elf_Internal_Shdr
* symsec
;
13332 Elf_Internal_Sym
* symtab
;
13333 unsigned long num_syms
;
13334 Elf_Internal_Sym
* sym
;
13336 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13337 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13338 || filedata
->section_headers
+ relsec
->sh_info
!= section
13339 || relsec
->sh_size
== 0
13340 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13343 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13344 if (symsec
->sh_type
!= SHT_SYMTAB
13345 && symsec
->sh_type
!= SHT_DYNSYM
)
13348 is_rela
= relsec
->sh_type
== SHT_RELA
;
13352 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13353 relsec
->sh_size
, & relocs
, & num_relocs
))
13358 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13359 relsec
->sh_size
, & relocs
, & num_relocs
))
13363 /* SH uses RELA but uses in place value instead of the addend field. */
13364 if (filedata
->file_header
.e_machine
== EM_SH
)
13367 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13369 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13372 unsigned int reloc_type
;
13373 unsigned int reloc_size
;
13374 bfd_boolean reloc_inplace
= FALSE
;
13375 bfd_boolean reloc_subtract
= FALSE
;
13376 unsigned char * rloc
;
13377 unsigned long sym_index
;
13379 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13381 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13383 else if (is_none_reloc (filedata
, reloc_type
))
13385 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13386 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13388 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13389 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13391 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13393 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13395 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13396 || is_6bit_abs_reloc (filedata
, reloc_type
))
13398 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13400 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13403 reloc_inplace
= TRUE
;
13405 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13407 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13410 reloc_inplace
= TRUE
;
13412 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13414 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13417 reloc_inplace
= TRUE
;
13419 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13421 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13424 reloc_inplace
= TRUE
;
13426 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13430 reloc_inplace
= TRUE
;
13434 static unsigned int prev_reloc
= 0;
13436 if (reloc_type
!= prev_reloc
)
13437 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13438 reloc_type
, printable_section_name (filedata
, section
));
13439 prev_reloc
= reloc_type
;
13443 rloc
= start
+ rp
->r_offset
;
13444 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13446 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13447 (unsigned long) rp
->r_offset
,
13448 printable_section_name (filedata
, section
));
13452 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13453 if (sym_index
>= num_syms
)
13455 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13456 sym_index
, printable_section_name (filedata
, section
));
13459 sym
= symtab
+ sym_index
;
13461 /* If the reloc has a symbol associated with it,
13462 make sure that it is of an appropriate type.
13464 Relocations against symbols without type can happen.
13465 Gcc -feliminate-dwarf2-dups may generate symbols
13466 without type for debug info.
13468 Icc generates relocations against function symbols
13469 instead of local labels.
13471 Relocations against object symbols can happen, eg when
13472 referencing a global array. For an example of this see
13473 the _clz.o binary in libgcc.a. */
13475 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13476 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13478 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13479 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13480 printable_section_name (filedata
, relsec
),
13481 (long int)(rp
- relocs
));
13487 addend
+= rp
->r_addend
;
13488 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13489 partial_inplace. */
13491 || (filedata
->file_header
.e_machine
== EM_XTENSA
13492 && reloc_type
== 1)
13493 || ((filedata
->file_header
.e_machine
== EM_PJ
13494 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13495 && reloc_type
== 1)
13496 || ((filedata
->file_header
.e_machine
== EM_D30V
13497 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13498 && reloc_type
== 12)
13501 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13502 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13504 addend
+= byte_get (rloc
, reloc_size
);
13507 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13508 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13510 /* On HPPA, all pc-relative relocations are biased by 8. */
13511 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13513 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13516 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13517 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13519 if (reloc_subtract
)
13520 addend
-= sym
->st_value
;
13522 addend
+= sym
->st_value
;
13523 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13524 byte_put (rloc
, addend
, reloc_size
);
13526 else if (reloc_subtract
)
13527 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13529 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13533 /* Let the target specific reloc processing code know that
13534 we have finished with these relocs. */
13535 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13539 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13540 * num_relocs_return
= num_relocs
;
13551 #ifdef SUPPORT_DISASSEMBLY
13553 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13555 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13557 /* FIXME: XXX -- to be done --- XXX */
13563 /* Reads in the contents of SECTION from FILE, returning a pointer
13564 to a malloc'ed buffer or NULL if something went wrong. */
13567 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13569 bfd_size_type num_bytes
= section
->sh_size
;
13571 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13573 printf (_("Section '%s' has no data to dump.\n"),
13574 printable_section_name (filedata
, section
));
13578 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13579 _("section contents"));
13582 /* Uncompresses a section that was compressed using zlib, in place. */
13585 uncompress_section_contents (unsigned char ** buffer
,
13586 dwarf_size_type uncompressed_size
,
13587 dwarf_size_type
* size
)
13589 dwarf_size_type compressed_size
= *size
;
13590 unsigned char * compressed_buffer
= *buffer
;
13591 unsigned char * uncompressed_buffer
;
13595 /* It is possible the section consists of several compressed
13596 buffers concatenated together, so we uncompress in a loop. */
13597 /* PR 18313: The state field in the z_stream structure is supposed
13598 to be invisible to the user (ie us), but some compilers will
13599 still complain about it being used without initialisation. So
13600 we first zero the entire z_stream structure and then set the fields
13602 memset (& strm
, 0, sizeof strm
);
13603 strm
.avail_in
= compressed_size
;
13604 strm
.next_in
= (Bytef
*) compressed_buffer
;
13605 strm
.avail_out
= uncompressed_size
;
13606 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13608 rc
= inflateInit (& strm
);
13609 while (strm
.avail_in
> 0)
13613 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13614 + (uncompressed_size
- strm
.avail_out
));
13615 rc
= inflate (&strm
, Z_FINISH
);
13616 if (rc
!= Z_STREAM_END
)
13618 rc
= inflateReset (& strm
);
13620 rc
= inflateEnd (& strm
);
13622 || strm
.avail_out
!= 0)
13625 *buffer
= uncompressed_buffer
;
13626 *size
= uncompressed_size
;
13630 free (uncompressed_buffer
);
13631 /* Indicate decompression failure. */
13637 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13639 Elf_Internal_Shdr
* relsec
;
13640 bfd_size_type num_bytes
;
13641 unsigned char * data
;
13642 unsigned char * end
;
13643 unsigned char * real_start
;
13644 unsigned char * start
;
13645 bfd_boolean some_strings_shown
;
13647 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13649 /* PR 21820: Do not fail if the section was empty. */
13650 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13652 num_bytes
= section
->sh_size
;
13654 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13656 if (decompress_dumps
)
13658 dwarf_size_type new_size
= num_bytes
;
13659 dwarf_size_type uncompressed_size
= 0;
13661 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13663 Elf_Internal_Chdr chdr
;
13664 unsigned int compression_header_size
13665 = get_compression_header (& chdr
, (unsigned char *) start
,
13668 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13670 warn (_("section '%s' has unsupported compress type: %d\n"),
13671 printable_section_name (filedata
, section
), chdr
.ch_type
);
13674 uncompressed_size
= chdr
.ch_size
;
13675 start
+= compression_header_size
;
13676 new_size
-= compression_header_size
;
13678 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13680 /* Read the zlib header. In this case, it should be "ZLIB"
13681 followed by the uncompressed section size, 8 bytes in
13682 big-endian order. */
13683 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13684 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13685 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13686 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13687 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13688 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13689 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13690 uncompressed_size
+= start
[11];
13695 if (uncompressed_size
)
13697 if (uncompress_section_contents (& start
,
13698 uncompressed_size
, & new_size
))
13699 num_bytes
= new_size
;
13702 error (_("Unable to decompress section %s\n"),
13703 printable_section_name (filedata
, section
));
13708 start
= real_start
;
13711 /* If the section being dumped has relocations against it the user might
13712 be expecting these relocations to have been applied. Check for this
13713 case and issue a warning message in order to avoid confusion.
13714 FIXME: Maybe we ought to have an option that dumps a section with
13715 relocs applied ? */
13716 for (relsec
= filedata
->section_headers
;
13717 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13720 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13721 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13722 || filedata
->section_headers
+ relsec
->sh_info
!= section
13723 || relsec
->sh_size
== 0
13724 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13727 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13732 end
= start
+ num_bytes
;
13733 some_strings_shown
= FALSE
;
13735 #ifdef HAVE_MBSTATE_T
13737 /* Initialise the multibyte conversion state. */
13738 memset (& state
, 0, sizeof (state
));
13741 bfd_boolean continuing
= FALSE
;
13745 while (!ISPRINT (* data
))
13746 if (++ data
>= end
)
13751 size_t maxlen
= end
- data
;
13756 continuing
= FALSE
;
13761 /* PR 11128: Use two separate invocations in order to work
13762 around bugs in the Solaris 8 implementation of printf. */
13763 printf (" [%6tx] ", data
- start
);
13765 printf (" [%6Ix] ", (size_t) (data
- start
));
13780 /* PR 25543: Treat new-lines as string-ending characters. */
13789 /* Do not print control characters directly as they can affect terminal
13790 settings. Such characters usually appear in the names generated
13791 by the assembler for local labels. */
13794 printf ("^%c", c
+ 0x40);
13796 else if (ISPRINT (c
))
13803 #ifdef HAVE_MBSTATE_T
13806 /* Let printf do the hard work of displaying multibyte characters. */
13807 printf ("%.1s", data
- 1);
13808 #ifdef HAVE_MBSTATE_T
13809 /* Try to find out how many bytes made up the character that was
13810 just printed. Advance the symbol pointer past the bytes that
13812 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13816 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13826 printf (_("<corrupt>\n"));
13829 some_strings_shown
= TRUE
;
13833 if (! some_strings_shown
)
13834 printf (_(" No strings found in this section."));
13843 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13844 Filedata
* filedata
,
13845 bfd_boolean relocate
)
13847 Elf_Internal_Shdr
* relsec
;
13848 bfd_size_type bytes
;
13849 bfd_size_type section_size
;
13851 unsigned char * data
;
13852 unsigned char * real_start
;
13853 unsigned char * start
;
13855 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13857 /* PR 21820: Do not fail if the section was empty. */
13858 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13860 section_size
= section
->sh_size
;
13862 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13864 if (decompress_dumps
)
13866 dwarf_size_type new_size
= section_size
;
13867 dwarf_size_type uncompressed_size
= 0;
13869 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13871 Elf_Internal_Chdr chdr
;
13872 unsigned int compression_header_size
13873 = get_compression_header (& chdr
, start
, section_size
);
13875 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13877 warn (_("section '%s' has unsupported compress type: %d\n"),
13878 printable_section_name (filedata
, section
), chdr
.ch_type
);
13881 uncompressed_size
= chdr
.ch_size
;
13882 start
+= compression_header_size
;
13883 new_size
-= compression_header_size
;
13885 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13887 /* Read the zlib header. In this case, it should be "ZLIB"
13888 followed by the uncompressed section size, 8 bytes in
13889 big-endian order. */
13890 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13891 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13892 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13893 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13894 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13895 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13896 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13897 uncompressed_size
+= start
[11];
13902 if (uncompressed_size
)
13904 if (uncompress_section_contents (& start
, uncompressed_size
,
13907 section_size
= new_size
;
13911 error (_("Unable to decompress section %s\n"),
13912 printable_section_name (filedata
, section
));
13913 /* FIXME: Print the section anyway ? */
13918 start
= real_start
;
13923 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13928 /* If the section being dumped has relocations against it the user might
13929 be expecting these relocations to have been applied. Check for this
13930 case and issue a warning message in order to avoid confusion.
13931 FIXME: Maybe we ought to have an option that dumps a section with
13932 relocs applied ? */
13933 for (relsec
= filedata
->section_headers
;
13934 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13937 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13938 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13939 || filedata
->section_headers
+ relsec
->sh_info
!= section
13940 || relsec
->sh_size
== 0
13941 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13944 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13949 addr
= section
->sh_addr
;
13950 bytes
= section_size
;
13959 lbytes
= (bytes
> 16 ? 16 : bytes
);
13961 printf (" 0x%8.8lx ", (unsigned long) addr
);
13963 for (j
= 0; j
< 16; j
++)
13966 printf ("%2.2x", data
[j
]);
13974 for (j
= 0; j
< lbytes
; j
++)
13977 if (k
>= ' ' && k
< 0x7f)
13996 static ctf_sect_t
*
13997 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
13999 buf
->cts_name
= SECTION_NAME (shdr
);
14000 buf
->cts_size
= shdr
->sh_size
;
14001 buf
->cts_entsize
= shdr
->sh_entsize
;
14006 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14007 it is passed, or a pointer to newly-allocated storage, in which case
14008 dump_ctf() will free it when it no longer needs it. */
14010 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14011 char *s
, void *arg
)
14013 const char *blanks
= arg
;
14016 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14022 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14024 Elf_Internal_Shdr
* parent_sec
= NULL
;
14025 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14026 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14027 void * data
= NULL
;
14028 void * symdata
= NULL
;
14029 void * strdata
= NULL
;
14030 void * parentdata
= NULL
;
14031 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14032 ctf_sect_t
* symsectp
= NULL
;
14033 ctf_sect_t
* strsectp
= NULL
;
14034 ctf_file_t
* ctf
= NULL
;
14035 ctf_file_t
* parent
= NULL
;
14037 const char *things
[] = {"Header", "Labels", "Data objects",
14038 "Function objects", "Variables", "Types", "Strings",
14040 const char **thing
;
14042 bfd_boolean ret
= FALSE
;
14045 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14046 data
= get_section_contents (section
, filedata
);
14047 ctfsect
.cts_data
= data
;
14049 if (!dump_ctf_symtab_name
)
14050 dump_ctf_symtab_name
= strdup (".symtab");
14052 if (!dump_ctf_strtab_name
)
14053 dump_ctf_strtab_name
= strdup (".strtab");
14055 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14057 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14059 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14062 if ((symdata
= (void *) get_data (NULL
, filedata
,
14063 symtab_sec
->sh_offset
, 1,
14064 symtab_sec
->sh_size
,
14065 _("symbols"))) == NULL
)
14067 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14068 symsect
.cts_data
= symdata
;
14070 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14072 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14074 error (_("No string table section named %s\n"),
14075 dump_ctf_strtab_name
);
14078 if ((strdata
= (void *) get_data (NULL
, filedata
,
14079 strtab_sec
->sh_offset
, 1,
14080 strtab_sec
->sh_size
,
14081 _("strings"))) == NULL
)
14083 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14084 strsect
.cts_data
= strdata
;
14086 if (dump_ctf_parent_name
)
14088 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14090 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14093 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14094 parent_sec
->sh_offset
, 1,
14095 parent_sec
->sh_size
,
14096 _("CTF parent"))) == NULL
)
14098 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14099 parentsect
.cts_data
= parentdata
;
14102 /* Load the CTF file and dump it. */
14104 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14106 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14112 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14114 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14118 ctf_import (ctf
, parent
);
14123 printf (_("\nDump of CTF section '%s':\n"),
14124 printable_section_name (filedata
, section
));
14126 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14128 ctf_dump_state_t
*s
= NULL
;
14131 printf ("\n %s:\n", *thing
);
14132 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14133 (void *) " ")) != NULL
)
14135 printf ("%s\n", item
);
14139 if (ctf_errno (ctf
))
14141 error (_("Iteration failed: %s, %s\n"), *thing
,
14142 ctf_errmsg (ctf_errno (ctf
)));
14148 ctf_file_close (ctf
);
14149 ctf_file_close (parent
);
14158 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14159 const Elf_Internal_Shdr
* sec
,
14162 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14164 Filedata
* filedata
= (Filedata
*) data
;
14166 if (section
->start
!= NULL
)
14168 /* If it is already loaded, do nothing. */
14169 if (streq (section
->filename
, filedata
->file_name
))
14171 free (section
->start
);
14174 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14175 section
->address
= sec
->sh_addr
;
14176 section
->user_data
= NULL
;
14177 section
->filename
= filedata
->file_name
;
14178 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14180 sec
->sh_size
, buf
);
14181 if (section
->start
== NULL
)
14185 unsigned char *start
= section
->start
;
14186 dwarf_size_type size
= sec
->sh_size
;
14187 dwarf_size_type uncompressed_size
= 0;
14189 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14191 Elf_Internal_Chdr chdr
;
14192 unsigned int compression_header_size
;
14194 if (size
< (is_32bit_elf
14195 ? sizeof (Elf32_External_Chdr
)
14196 : sizeof (Elf64_External_Chdr
)))
14198 warn (_("compressed section %s is too small to contain a compression header\n"),
14203 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14205 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14207 warn (_("section '%s' has unsupported compress type: %d\n"),
14208 section
->name
, chdr
.ch_type
);
14211 uncompressed_size
= chdr
.ch_size
;
14212 start
+= compression_header_size
;
14213 size
-= compression_header_size
;
14215 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14217 /* Read the zlib header. In this case, it should be "ZLIB"
14218 followed by the uncompressed section size, 8 bytes in
14219 big-endian order. */
14220 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14221 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14222 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14223 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14224 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14225 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14226 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14227 uncompressed_size
+= start
[11];
14232 if (uncompressed_size
)
14234 if (uncompress_section_contents (&start
, uncompressed_size
,
14237 /* Free the compressed buffer, update the section buffer
14238 and the section size if uncompress is successful. */
14239 free (section
->start
);
14240 section
->start
= start
;
14244 error (_("Unable to decompress section %s\n"),
14245 printable_section_name (filedata
, sec
));
14250 section
->size
= size
;
14253 if (section
->start
== NULL
)
14256 if (debug_displays
[debug
].relocate
)
14258 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14259 & section
->reloc_info
, & section
->num_relocs
))
14264 section
->reloc_info
= NULL
;
14265 section
->num_relocs
= 0;
14271 #if HAVE_LIBDEBUGINFOD
14272 /* Return a hex string representation of the build-id. */
14274 get_build_id (void * data
)
14276 Filedata
* filedata
= (Filedata
*)data
;
14277 Elf_Internal_Shdr
* shdr
;
14280 /* Iterate through notes to find note.gnu.build-id.
14281 FIXME: Only the first note in any note section is examined. */
14282 for (i
= 0, shdr
= filedata
->section_headers
;
14283 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14286 if (shdr
->sh_type
!= SHT_NOTE
)
14291 size_t data_remaining
;
14293 Elf_External_Note
* enote
;
14294 Elf_Internal_Note inote
;
14296 bfd_vma offset
= shdr
->sh_offset
;
14297 bfd_vma align
= shdr
->sh_addralign
;
14298 bfd_vma length
= shdr
->sh_size
;
14300 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14306 else if (align
!= 4 && align
!= 8)
14309 end
= (char *) enote
+ length
;
14310 data_remaining
= end
- (char *) enote
;
14312 if (!is_ia64_vms (filedata
))
14314 min_notesz
= offsetof (Elf_External_Note
, name
);
14315 if (data_remaining
< min_notesz
)
14318 malformed note encountered in section %s whilst scanning for build-id note\n"),
14319 printable_section_name (filedata
, shdr
));
14322 data_remaining
-= min_notesz
;
14324 inote
.type
= BYTE_GET (enote
->type
);
14325 inote
.namesz
= BYTE_GET (enote
->namesz
);
14326 inote
.namedata
= enote
->name
;
14327 inote
.descsz
= BYTE_GET (enote
->descsz
);
14328 inote
.descdata
= ((char *) enote
14329 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14330 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14331 next
= ((char *) enote
14332 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14336 Elf64_External_VMS_Note
*vms_enote
;
14338 /* PR binutils/15191
14339 Make sure that there is enough data to read. */
14340 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14341 if (data_remaining
< min_notesz
)
14344 malformed note encountered in section %s whilst scanning for build-id note\n"),
14345 printable_section_name (filedata
, shdr
));
14348 data_remaining
-= min_notesz
;
14350 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14351 inote
.type
= BYTE_GET (vms_enote
->type
);
14352 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14353 inote
.namedata
= vms_enote
->name
;
14354 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14355 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14356 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14357 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14360 /* Skip malformed notes. */
14361 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14362 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14363 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14364 || ((size_t) (next
- inote
.descdata
)
14365 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14368 malformed note encountered in section %s whilst scanning for build-id note\n"),
14369 printable_section_name (filedata
, shdr
));
14373 /* Check if this is the build-id note. If so then convert the build-id
14374 bytes to a hex string. */
14375 if (inote
.namesz
> 0
14376 && const_strneq (inote
.namedata
, "GNU")
14377 && inote
.type
== NT_GNU_BUILD_ID
)
14382 build_id
= malloc (inote
.descsz
* 2 + 1);
14383 if (build_id
== NULL
)
14386 for (j
= 0; j
< inote
.descsz
; ++j
)
14387 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14388 build_id
[inote
.descsz
* 2] = '\0';
14390 return (unsigned char *) build_id
;
14396 #endif /* HAVE_LIBDEBUGINFOD */
14398 /* If this is not NULL, load_debug_section will only look for sections
14399 within the list of sections given here. */
14400 static unsigned int * section_subset
= NULL
;
14403 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14405 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14406 Elf_Internal_Shdr
* sec
;
14407 Filedata
* filedata
= (Filedata
*) data
;
14409 /* Without section headers we cannot find any sections. */
14410 if (filedata
->section_headers
== NULL
)
14413 if (filedata
->string_table
== NULL
14414 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14415 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14417 Elf_Internal_Shdr
* strs
;
14419 /* Read in the string table, so that we have section names to scan. */
14420 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14422 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14424 filedata
->string_table
14425 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14426 1, strs
->sh_size
, _("string table"));
14428 filedata
->string_table_length
14429 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14433 /* Locate the debug section. */
14434 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14436 section
->name
= section
->uncompressed_name
;
14439 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14441 section
->name
= section
->compressed_name
;
14446 /* If we're loading from a subset of sections, and we've loaded
14447 a section matching this name before, it's likely that it's a
14449 if (section_subset
!= NULL
)
14450 free_debug_section (debug
);
14452 return load_specific_debug_section (debug
, sec
, data
);
14456 free_debug_section (enum dwarf_section_display_enum debug
)
14458 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14460 if (section
->start
== NULL
)
14463 free ((char *) section
->start
);
14464 section
->start
= NULL
;
14465 section
->address
= 0;
14468 if (section
->reloc_info
!= NULL
)
14470 free (section
->reloc_info
);
14471 section
->reloc_info
= NULL
;
14472 section
->num_relocs
= 0;
14477 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14479 char * name
= SECTION_NAME (section
);
14480 const char * print_name
= printable_section_name (filedata
, section
);
14481 bfd_size_type length
;
14482 bfd_boolean result
= TRUE
;
14485 length
= section
->sh_size
;
14488 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14491 if (section
->sh_type
== SHT_NOBITS
)
14493 /* There is no point in dumping the contents of a debugging section
14494 which has the NOBITS type - the bits in the file will be random.
14495 This can happen when a file containing a .eh_frame section is
14496 stripped with the --only-keep-debug command line option. */
14497 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14502 if (const_strneq (name
, ".gnu.linkonce.wi."))
14503 name
= ".debug_info";
14505 /* See if we know how to display the contents of this section. */
14506 for (i
= 0; i
< max
; i
++)
14508 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14509 struct dwarf_section_display
* display
= debug_displays
+ i
;
14510 struct dwarf_section
* sec
= & display
->section
;
14512 if (streq (sec
->uncompressed_name
, name
)
14513 || (id
== line
&& const_strneq (name
, ".debug_line."))
14514 || streq (sec
->compressed_name
, name
))
14516 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14519 free_debug_section (id
);
14521 if (i
== line
&& const_strneq (name
, ".debug_line."))
14523 else if (streq (sec
->uncompressed_name
, name
))
14524 sec
->name
= sec
->uncompressed_name
;
14526 sec
->name
= sec
->compressed_name
;
14528 if (load_specific_debug_section (id
, section
, filedata
))
14530 /* If this debug section is part of a CU/TU set in a .dwp file,
14531 restrict load_debug_section to the sections in that set. */
14532 section_subset
= find_cu_tu_set (filedata
, shndx
);
14534 result
&= display
->display (sec
, filedata
);
14536 section_subset
= NULL
;
14538 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14539 free_debug_section (id
);
14547 printf (_("Unrecognized debug section: %s\n"), print_name
);
14554 /* Set DUMP_SECTS for all sections where dumps were requested
14555 based on section name. */
14558 initialise_dumps_byname (Filedata
* filedata
)
14560 struct dump_list_entry
* cur
;
14562 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14565 bfd_boolean any
= FALSE
;
14567 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14568 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14570 request_dump_bynumber (filedata
, i
, cur
->type
);
14575 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14581 process_section_contents (Filedata
* filedata
)
14583 Elf_Internal_Shdr
* section
;
14585 bfd_boolean res
= TRUE
;
14590 initialise_dumps_byname (filedata
);
14592 for (i
= 0, section
= filedata
->section_headers
;
14593 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14596 dump_type dump
= filedata
->dump_sects
[i
];
14598 #ifdef SUPPORT_DISASSEMBLY
14599 if (dump
& DISASS_DUMP
)
14601 if (! disassemble_section (section
, filedata
))
14605 if (dump
& HEX_DUMP
)
14607 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14611 if (dump
& RELOC_DUMP
)
14613 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14617 if (dump
& STRING_DUMP
)
14619 if (! dump_section_as_strings (section
, filedata
))
14623 if (dump
& DEBUG_DUMP
)
14625 if (! display_debug_section (i
, section
, filedata
))
14629 if (dump
& CTF_DUMP
)
14631 if (! dump_section_as_ctf (section
, filedata
))
14636 /* Check to see if the user requested a
14637 dump of a section that does not exist. */
14638 while (i
< filedata
->num_dump_sects
)
14640 if (filedata
->dump_sects
[i
])
14642 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14652 process_mips_fpe_exception (int mask
)
14656 bfd_boolean first
= TRUE
;
14658 if (mask
& OEX_FPU_INEX
)
14659 fputs ("INEX", stdout
), first
= FALSE
;
14660 if (mask
& OEX_FPU_UFLO
)
14661 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14662 if (mask
& OEX_FPU_OFLO
)
14663 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14664 if (mask
& OEX_FPU_DIV0
)
14665 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14666 if (mask
& OEX_FPU_INVAL
)
14667 printf ("%sINVAL", first
? "" : "|");
14670 fputs ("0", stdout
);
14673 /* Display's the value of TAG at location P. If TAG is
14674 greater than 0 it is assumed to be an unknown tag, and
14675 a message is printed to this effect. Otherwise it is
14676 assumed that a message has already been printed.
14678 If the bottom bit of TAG is set it assumed to have a
14679 string value, otherwise it is assumed to have an integer
14682 Returns an updated P pointing to the first unread byte
14683 beyond the end of TAG's value.
14685 Reads at or beyond END will not be made. */
14687 static unsigned char *
14688 display_tag_value (signed int tag
,
14690 const unsigned char * const end
)
14695 printf (" Tag_unknown_%d: ", tag
);
14699 warn (_("<corrupt tag>\n"));
14703 /* PR 17531 file: 027-19978-0.004. */
14704 size_t maxlen
= (end
- p
) - 1;
14709 print_symbol ((int) maxlen
, (const char *) p
);
14710 p
+= strnlen ((char *) p
, maxlen
) + 1;
14714 printf (_("<corrupt string tag>"));
14715 p
= (unsigned char *) end
;
14721 READ_ULEB (val
, p
, end
);
14722 printf ("%ld (0x%lx)\n", val
, val
);
14729 /* ARC ABI attributes section. */
14731 static unsigned char *
14732 display_arc_attribute (unsigned char * p
,
14733 const unsigned char * const end
)
14738 READ_ULEB (tag
, p
, end
);
14742 case Tag_ARC_PCS_config
:
14743 READ_ULEB (val
, p
, end
);
14744 printf (" Tag_ARC_PCS_config: ");
14748 printf (_("Absent/Non standard\n"));
14751 printf (_("Bare metal/mwdt\n"));
14754 printf (_("Bare metal/newlib\n"));
14757 printf (_("Linux/uclibc\n"));
14760 printf (_("Linux/glibc\n"));
14763 printf (_("Unknown\n"));
14768 case Tag_ARC_CPU_base
:
14769 READ_ULEB (val
, p
, end
);
14770 printf (" Tag_ARC_CPU_base: ");
14775 printf (_("Absent\n"));
14777 case TAG_CPU_ARC6xx
:
14778 printf ("ARC6xx\n");
14780 case TAG_CPU_ARC7xx
:
14781 printf ("ARC7xx\n");
14783 case TAG_CPU_ARCEM
:
14784 printf ("ARCEM\n");
14786 case TAG_CPU_ARCHS
:
14787 printf ("ARCHS\n");
14792 case Tag_ARC_CPU_variation
:
14793 READ_ULEB (val
, p
, end
);
14794 printf (" Tag_ARC_CPU_variation: ");
14798 if (val
> 0 && val
< 16)
14799 printf ("Core%d\n", val
);
14801 printf ("Unknown\n");
14805 printf (_("Absent\n"));
14810 case Tag_ARC_CPU_name
:
14811 printf (" Tag_ARC_CPU_name: ");
14812 p
= display_tag_value (-1, p
, end
);
14815 case Tag_ARC_ABI_rf16
:
14816 READ_ULEB (val
, p
, end
);
14817 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14820 case Tag_ARC_ABI_osver
:
14821 READ_ULEB (val
, p
, end
);
14822 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14825 case Tag_ARC_ABI_pic
:
14826 case Tag_ARC_ABI_sda
:
14827 READ_ULEB (val
, p
, end
);
14828 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14829 : " Tag_ARC_ABI_pic: ");
14833 printf (_("Absent\n"));
14842 printf (_("Unknown\n"));
14847 case Tag_ARC_ABI_tls
:
14848 READ_ULEB (val
, p
, end
);
14849 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14852 case Tag_ARC_ABI_enumsize
:
14853 READ_ULEB (val
, p
, end
);
14854 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14858 case Tag_ARC_ABI_exceptions
:
14859 READ_ULEB (val
, p
, end
);
14860 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14864 case Tag_ARC_ABI_double_size
:
14865 READ_ULEB (val
, p
, end
);
14866 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14869 case Tag_ARC_ISA_config
:
14870 printf (" Tag_ARC_ISA_config: ");
14871 p
= display_tag_value (-1, p
, end
);
14874 case Tag_ARC_ISA_apex
:
14875 printf (" Tag_ARC_ISA_apex: ");
14876 p
= display_tag_value (-1, p
, end
);
14879 case Tag_ARC_ISA_mpy_option
:
14880 READ_ULEB (val
, p
, end
);
14881 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14884 case Tag_ARC_ATR_version
:
14885 READ_ULEB (val
, p
, end
);
14886 printf (" Tag_ARC_ATR_version: %d\n", val
);
14890 return display_tag_value (tag
& 1, p
, end
);
14896 /* ARM EABI attributes section. */
14901 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14903 const char ** table
;
14904 } arm_attr_public_tag
;
14906 static const char * arm_attr_tag_CPU_arch
[] =
14907 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14908 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14909 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14910 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14911 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14912 {"No", "Thumb-1", "Thumb-2", "Yes"};
14913 static const char * arm_attr_tag_FP_arch
[] =
14914 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14915 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14916 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14917 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14918 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14919 "NEON for ARMv8.1"};
14920 static const char * arm_attr_tag_PCS_config
[] =
14921 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14922 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14923 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14924 {"V6", "SB", "TLS", "Unused"};
14925 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14926 {"Absolute", "PC-relative", "SB-relative", "None"};
14927 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14928 {"Absolute", "PC-relative", "None"};
14929 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14930 {"None", "direct", "GOT-indirect"};
14931 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14932 {"None", "??? 1", "2", "??? 3", "4"};
14933 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14934 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14935 {"Unused", "Needed", "Sign only"};
14936 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14937 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14938 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14939 {"Unused", "Finite", "RTABI", "IEEE 754"};
14940 static const char * arm_attr_tag_ABI_enum_size
[] =
14941 {"Unused", "small", "int", "forced to int"};
14942 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14943 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14944 static const char * arm_attr_tag_ABI_VFP_args
[] =
14945 {"AAPCS", "VFP registers", "custom", "compatible"};
14946 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14947 {"AAPCS", "WMMX registers", "custom"};
14948 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14949 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14950 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14951 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14952 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14953 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14954 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14955 static const char * arm_attr_tag_FP_HP_extension
[] =
14956 {"Not Allowed", "Allowed"};
14957 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14958 {"None", "IEEE 754", "Alternative Format"};
14959 static const char * arm_attr_tag_DSP_extension
[] =
14960 {"Follow architecture", "Allowed"};
14961 static const char * arm_attr_tag_MPextension_use
[] =
14962 {"Not Allowed", "Allowed"};
14963 static const char * arm_attr_tag_DIV_use
[] =
14964 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14965 "Allowed in v7-A with integer division extension"};
14966 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14967 static const char * arm_attr_tag_Virtualization_use
[] =
14968 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14969 "TrustZone and Virtualization Extensions"};
14970 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14971 {"Not Allowed", "Allowed"};
14973 static const char * arm_attr_tag_MVE_arch
[] =
14974 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14976 #define LOOKUP(id, name) \
14977 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14978 static arm_attr_public_tag arm_attr_public_tags
[] =
14980 {4, "CPU_raw_name", 1, NULL
},
14981 {5, "CPU_name", 1, NULL
},
14982 LOOKUP(6, CPU_arch
),
14983 {7, "CPU_arch_profile", 0, NULL
},
14984 LOOKUP(8, ARM_ISA_use
),
14985 LOOKUP(9, THUMB_ISA_use
),
14986 LOOKUP(10, FP_arch
),
14987 LOOKUP(11, WMMX_arch
),
14988 LOOKUP(12, Advanced_SIMD_arch
),
14989 LOOKUP(13, PCS_config
),
14990 LOOKUP(14, ABI_PCS_R9_use
),
14991 LOOKUP(15, ABI_PCS_RW_data
),
14992 LOOKUP(16, ABI_PCS_RO_data
),
14993 LOOKUP(17, ABI_PCS_GOT_use
),
14994 LOOKUP(18, ABI_PCS_wchar_t
),
14995 LOOKUP(19, ABI_FP_rounding
),
14996 LOOKUP(20, ABI_FP_denormal
),
14997 LOOKUP(21, ABI_FP_exceptions
),
14998 LOOKUP(22, ABI_FP_user_exceptions
),
14999 LOOKUP(23, ABI_FP_number_model
),
15000 {24, "ABI_align_needed", 0, NULL
},
15001 {25, "ABI_align_preserved", 0, NULL
},
15002 LOOKUP(26, ABI_enum_size
),
15003 LOOKUP(27, ABI_HardFP_use
),
15004 LOOKUP(28, ABI_VFP_args
),
15005 LOOKUP(29, ABI_WMMX_args
),
15006 LOOKUP(30, ABI_optimization_goals
),
15007 LOOKUP(31, ABI_FP_optimization_goals
),
15008 {32, "compatibility", 0, NULL
},
15009 LOOKUP(34, CPU_unaligned_access
),
15010 LOOKUP(36, FP_HP_extension
),
15011 LOOKUP(38, ABI_FP_16bit_format
),
15012 LOOKUP(42, MPextension_use
),
15013 LOOKUP(44, DIV_use
),
15014 LOOKUP(46, DSP_extension
),
15015 LOOKUP(48, MVE_arch
),
15016 {64, "nodefaults", 0, NULL
},
15017 {65, "also_compatible_with", 0, NULL
},
15018 LOOKUP(66, T2EE_use
),
15019 {67, "conformance", 1, NULL
},
15020 LOOKUP(68, Virtualization_use
),
15021 LOOKUP(70, MPextension_use_legacy
)
15025 static unsigned char *
15026 display_arm_attribute (unsigned char * p
,
15027 const unsigned char * const end
)
15031 arm_attr_public_tag
* attr
;
15035 READ_ULEB (tag
, p
, end
);
15037 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15039 if (arm_attr_public_tags
[i
].tag
== tag
)
15041 attr
= &arm_attr_public_tags
[i
];
15048 printf (" Tag_%s: ", attr
->name
);
15049 switch (attr
->type
)
15054 case 7: /* Tag_CPU_arch_profile. */
15055 READ_ULEB (val
, p
, end
);
15058 case 0: printf (_("None\n")); break;
15059 case 'A': printf (_("Application\n")); break;
15060 case 'R': printf (_("Realtime\n")); break;
15061 case 'M': printf (_("Microcontroller\n")); break;
15062 case 'S': printf (_("Application or Realtime\n")); break;
15063 default: printf ("??? (%d)\n", val
); break;
15067 case 24: /* Tag_align_needed. */
15068 READ_ULEB (val
, p
, end
);
15071 case 0: printf (_("None\n")); break;
15072 case 1: printf (_("8-byte\n")); break;
15073 case 2: printf (_("4-byte\n")); break;
15074 case 3: printf ("??? 3\n"); break;
15077 printf (_("8-byte and up to %d-byte extended\n"),
15080 printf ("??? (%d)\n", val
);
15085 case 25: /* Tag_align_preserved. */
15086 READ_ULEB (val
, p
, end
);
15089 case 0: printf (_("None\n")); break;
15090 case 1: printf (_("8-byte, except leaf SP\n")); break;
15091 case 2: printf (_("8-byte\n")); break;
15092 case 3: printf ("??? 3\n"); break;
15095 printf (_("8-byte and up to %d-byte extended\n"),
15098 printf ("??? (%d)\n", val
);
15103 case 32: /* Tag_compatibility. */
15105 READ_ULEB (val
, p
, end
);
15106 printf (_("flag = %d, vendor = "), val
);
15109 size_t maxlen
= (end
- p
) - 1;
15111 print_symbol ((int) maxlen
, (const char *) p
);
15112 p
+= strnlen ((char *) p
, maxlen
) + 1;
15116 printf (_("<corrupt>"));
15117 p
= (unsigned char *) end
;
15123 case 64: /* Tag_nodefaults. */
15124 /* PR 17531: file: 001-505008-0.01. */
15127 printf (_("True\n"));
15130 case 65: /* Tag_also_compatible_with. */
15131 READ_ULEB (val
, p
, end
);
15132 if (val
== 6 /* Tag_CPU_arch. */)
15134 READ_ULEB (val
, p
, end
);
15135 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15136 printf ("??? (%d)\n", val
);
15138 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15142 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15147 printf (_("<unknown: %d>\n"), tag
);
15153 return display_tag_value (-1, p
, end
);
15155 return display_tag_value (0, p
, end
);
15158 assert (attr
->type
& 0x80);
15159 READ_ULEB (val
, p
, end
);
15160 type
= attr
->type
& 0x7f;
15162 printf ("??? (%d)\n", val
);
15164 printf ("%s\n", attr
->table
[val
]);
15169 return display_tag_value (tag
, p
, end
);
15172 static unsigned char *
15173 display_gnu_attribute (unsigned char * p
,
15174 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15175 const unsigned char * const end
)
15180 READ_ULEB (tag
, p
, end
);
15182 /* Tag_compatibility is the only generic GNU attribute defined at
15186 READ_ULEB (val
, p
, end
);
15188 printf (_("flag = %d, vendor = "), val
);
15191 printf (_("<corrupt>\n"));
15192 warn (_("corrupt vendor attribute\n"));
15198 size_t maxlen
= (end
- p
) - 1;
15200 print_symbol ((int) maxlen
, (const char *) p
);
15201 p
+= strnlen ((char *) p
, maxlen
) + 1;
15205 printf (_("<corrupt>"));
15206 p
= (unsigned char *) end
;
15213 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15214 return display_proc_gnu_attribute (p
, tag
, end
);
15216 return display_tag_value (tag
, p
, end
);
15219 static unsigned char *
15220 display_power_gnu_attribute (unsigned char * p
,
15222 const unsigned char * const end
)
15226 if (tag
== Tag_GNU_Power_ABI_FP
)
15228 printf (" Tag_GNU_Power_ABI_FP: ");
15231 printf (_("<corrupt>\n"));
15234 READ_ULEB (val
, p
, end
);
15237 printf ("(%#x), ", val
);
15242 printf (_("unspecified hard/soft float, "));
15245 printf (_("hard float, "));
15248 printf (_("soft float, "));
15251 printf (_("single-precision hard float, "));
15258 printf (_("unspecified long double\n"));
15261 printf (_("128-bit IBM long double\n"));
15264 printf (_("64-bit long double\n"));
15267 printf (_("128-bit IEEE long double\n"));
15273 if (tag
== Tag_GNU_Power_ABI_Vector
)
15275 printf (" Tag_GNU_Power_ABI_Vector: ");
15278 printf (_("<corrupt>\n"));
15281 READ_ULEB (val
, p
, end
);
15284 printf ("(%#x), ", val
);
15289 printf (_("unspecified\n"));
15292 printf (_("generic\n"));
15295 printf ("AltiVec\n");
15304 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15306 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15309 printf (_("<corrupt>\n"));
15312 READ_ULEB (val
, p
, end
);
15315 printf ("(%#x), ", val
);
15320 printf (_("unspecified\n"));
15323 printf ("r3/r4\n");
15326 printf (_("memory\n"));
15335 return display_tag_value (tag
& 1, p
, end
);
15338 static unsigned char *
15339 display_s390_gnu_attribute (unsigned char * p
,
15341 const unsigned char * const end
)
15345 if (tag
== Tag_GNU_S390_ABI_Vector
)
15347 printf (" Tag_GNU_S390_ABI_Vector: ");
15348 READ_ULEB (val
, p
, end
);
15353 printf (_("any\n"));
15356 printf (_("software\n"));
15359 printf (_("hardware\n"));
15362 printf ("??? (%d)\n", val
);
15368 return display_tag_value (tag
& 1, p
, end
);
15372 display_sparc_hwcaps (unsigned int mask
)
15376 bfd_boolean first
= TRUE
;
15378 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15379 fputs ("mul32", stdout
), first
= FALSE
;
15380 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15381 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15382 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15383 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15384 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15385 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15386 if (mask
& ELF_SPARC_HWCAP_POPC
)
15387 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15388 if (mask
& ELF_SPARC_HWCAP_VIS
)
15389 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15390 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15391 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15392 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15393 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15394 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15395 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15396 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15397 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15398 if (mask
& ELF_SPARC_HWCAP_HPC
)
15399 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15400 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15401 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15402 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15403 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15404 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15405 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15406 if (mask
& ELF_SPARC_HWCAP_IMA
)
15407 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15408 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15409 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15412 fputc ('0', stdout
);
15413 fputc ('\n', stdout
);
15417 display_sparc_hwcaps2 (unsigned int mask
)
15421 bfd_boolean first
= TRUE
;
15423 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15424 fputs ("fjathplus", stdout
), first
= FALSE
;
15425 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15426 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15427 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15428 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15429 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15430 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15431 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15432 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15433 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15434 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15435 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15436 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15437 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15438 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15439 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15440 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15441 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15442 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15443 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15444 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15447 fputc ('0', stdout
);
15448 fputc ('\n', stdout
);
15451 static unsigned char *
15452 display_sparc_gnu_attribute (unsigned char * p
,
15454 const unsigned char * const end
)
15458 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15460 READ_ULEB (val
, p
, end
);
15461 printf (" Tag_GNU_Sparc_HWCAPS: ");
15462 display_sparc_hwcaps (val
);
15465 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15467 READ_ULEB (val
, p
, end
);
15468 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15469 display_sparc_hwcaps2 (val
);
15473 return display_tag_value (tag
, p
, end
);
15477 print_mips_fp_abi_value (unsigned int val
)
15481 case Val_GNU_MIPS_ABI_FP_ANY
:
15482 printf (_("Hard or soft float\n"));
15484 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15485 printf (_("Hard float (double precision)\n"));
15487 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15488 printf (_("Hard float (single precision)\n"));
15490 case Val_GNU_MIPS_ABI_FP_SOFT
:
15491 printf (_("Soft float\n"));
15493 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15494 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15496 case Val_GNU_MIPS_ABI_FP_XX
:
15497 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15499 case Val_GNU_MIPS_ABI_FP_64
:
15500 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15502 case Val_GNU_MIPS_ABI_FP_64A
:
15503 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15505 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15506 printf (_("NaN 2008 compatibility\n"));
15509 printf ("??? (%d)\n", val
);
15514 static unsigned char *
15515 display_mips_gnu_attribute (unsigned char * p
,
15517 const unsigned char * const end
)
15519 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15523 printf (" Tag_GNU_MIPS_ABI_FP: ");
15524 READ_ULEB (val
, p
, end
);
15525 print_mips_fp_abi_value (val
);
15529 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15533 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15534 READ_ULEB (val
, p
, end
);
15538 case Val_GNU_MIPS_ABI_MSA_ANY
:
15539 printf (_("Any MSA or not\n"));
15541 case Val_GNU_MIPS_ABI_MSA_128
:
15542 printf (_("128-bit MSA\n"));
15545 printf ("??? (%d)\n", val
);
15551 return display_tag_value (tag
& 1, p
, end
);
15554 static unsigned char *
15555 display_tic6x_attribute (unsigned char * p
,
15556 const unsigned char * const end
)
15561 READ_ULEB (tag
, p
, end
);
15566 printf (" Tag_ISA: ");
15567 READ_ULEB (val
, p
, end
);
15571 case C6XABI_Tag_ISA_none
:
15572 printf (_("None\n"));
15574 case C6XABI_Tag_ISA_C62X
:
15577 case C6XABI_Tag_ISA_C67X
:
15580 case C6XABI_Tag_ISA_C67XP
:
15581 printf ("C67x+\n");
15583 case C6XABI_Tag_ISA_C64X
:
15586 case C6XABI_Tag_ISA_C64XP
:
15587 printf ("C64x+\n");
15589 case C6XABI_Tag_ISA_C674X
:
15590 printf ("C674x\n");
15593 printf ("??? (%d)\n", val
);
15598 case Tag_ABI_wchar_t
:
15599 printf (" Tag_ABI_wchar_t: ");
15600 READ_ULEB (val
, p
, end
);
15604 printf (_("Not used\n"));
15607 printf (_("2 bytes\n"));
15610 printf (_("4 bytes\n"));
15613 printf ("??? (%d)\n", val
);
15618 case Tag_ABI_stack_align_needed
:
15619 printf (" Tag_ABI_stack_align_needed: ");
15620 READ_ULEB (val
, p
, end
);
15624 printf (_("8-byte\n"));
15627 printf (_("16-byte\n"));
15630 printf ("??? (%d)\n", val
);
15635 case Tag_ABI_stack_align_preserved
:
15636 READ_ULEB (val
, p
, end
);
15637 printf (" Tag_ABI_stack_align_preserved: ");
15641 printf (_("8-byte\n"));
15644 printf (_("16-byte\n"));
15647 printf ("??? (%d)\n", val
);
15653 READ_ULEB (val
, p
, end
);
15654 printf (" Tag_ABI_DSBT: ");
15658 printf (_("DSBT addressing not used\n"));
15661 printf (_("DSBT addressing used\n"));
15664 printf ("??? (%d)\n", val
);
15670 READ_ULEB (val
, p
, end
);
15671 printf (" Tag_ABI_PID: ");
15675 printf (_("Data addressing position-dependent\n"));
15678 printf (_("Data addressing position-independent, GOT near DP\n"));
15681 printf (_("Data addressing position-independent, GOT far from DP\n"));
15684 printf ("??? (%d)\n", val
);
15690 READ_ULEB (val
, p
, end
);
15691 printf (" Tag_ABI_PIC: ");
15695 printf (_("Code addressing position-dependent\n"));
15698 printf (_("Code addressing position-independent\n"));
15701 printf ("??? (%d)\n", val
);
15706 case Tag_ABI_array_object_alignment
:
15707 READ_ULEB (val
, p
, end
);
15708 printf (" Tag_ABI_array_object_alignment: ");
15712 printf (_("8-byte\n"));
15715 printf (_("4-byte\n"));
15718 printf (_("16-byte\n"));
15721 printf ("??? (%d)\n", val
);
15726 case Tag_ABI_array_object_align_expected
:
15727 READ_ULEB (val
, p
, end
);
15728 printf (" Tag_ABI_array_object_align_expected: ");
15732 printf (_("8-byte\n"));
15735 printf (_("4-byte\n"));
15738 printf (_("16-byte\n"));
15741 printf ("??? (%d)\n", val
);
15746 case Tag_ABI_compatibility
:
15748 READ_ULEB (val
, p
, end
);
15749 printf (" Tag_ABI_compatibility: ");
15750 printf (_("flag = %d, vendor = "), val
);
15753 size_t maxlen
= (end
- p
) - 1;
15755 print_symbol ((int) maxlen
, (const char *) p
);
15756 p
+= strnlen ((char *) p
, maxlen
) + 1;
15760 printf (_("<corrupt>"));
15761 p
= (unsigned char *) end
;
15767 case Tag_ABI_conformance
:
15769 printf (" Tag_ABI_conformance: \"");
15772 size_t maxlen
= (end
- p
) - 1;
15774 print_symbol ((int) maxlen
, (const char *) p
);
15775 p
+= strnlen ((char *) p
, maxlen
) + 1;
15779 printf (_("<corrupt>"));
15780 p
= (unsigned char *) end
;
15787 return display_tag_value (tag
, p
, end
);
15791 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15793 unsigned long addr
= 0;
15794 size_t bytes
= end
- p
;
15801 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15803 printf (" 0x%8.8lx ", addr
);
15805 for (j
= 0; j
< 16; j
++)
15808 printf ("%2.2x", p
[j
]);
15816 for (j
= 0; j
< lbytes
; j
++)
15819 if (k
>= ' ' && k
< 0x7f)
15835 static unsigned char *
15836 display_msp430x_attribute (unsigned char * p
,
15837 const unsigned char * const end
)
15842 READ_ULEB (tag
, p
, end
);
15846 case OFBA_MSPABI_Tag_ISA
:
15847 printf (" Tag_ISA: ");
15848 READ_ULEB (val
, p
, end
);
15851 case 0: printf (_("None\n")); break;
15852 case 1: printf (_("MSP430\n")); break;
15853 case 2: printf (_("MSP430X\n")); break;
15854 default: printf ("??? (%d)\n", val
); break;
15858 case OFBA_MSPABI_Tag_Code_Model
:
15859 printf (" Tag_Code_Model: ");
15860 READ_ULEB (val
, p
, end
);
15863 case 0: printf (_("None\n")); break;
15864 case 1: printf (_("Small\n")); break;
15865 case 2: printf (_("Large\n")); break;
15866 default: printf ("??? (%d)\n", val
); break;
15870 case OFBA_MSPABI_Tag_Data_Model
:
15871 printf (" Tag_Data_Model: ");
15872 READ_ULEB (val
, p
, end
);
15875 case 0: printf (_("None\n")); break;
15876 case 1: printf (_("Small\n")); break;
15877 case 2: printf (_("Large\n")); break;
15878 case 3: printf (_("Restricted Large\n")); break;
15879 default: printf ("??? (%d)\n", val
); break;
15884 printf (_(" <unknown tag %d>: "), tag
);
15891 size_t maxlen
= (end
- p
) - 1;
15893 print_symbol ((int) maxlen
, (const char *) p
);
15894 p
+= strnlen ((char *) p
, maxlen
) + 1;
15898 printf (_("<corrupt>"));
15899 p
= (unsigned char *) end
;
15905 READ_ULEB (val
, p
, end
);
15906 printf ("%d (0x%x)\n", val
, val
);
15915 static unsigned char *
15916 display_msp430_gnu_attribute (unsigned char * p
,
15918 const unsigned char * const end
)
15920 if (tag
== Tag_GNU_MSP430_Data_Region
)
15924 printf (" Tag_GNU_MSP430_Data_Region: ");
15925 READ_ULEB (val
, p
, end
);
15929 case Val_GNU_MSP430_Data_Region_Any
:
15930 printf (_("Any Region\n"));
15932 case Val_GNU_MSP430_Data_Region_Lower
:
15933 printf (_("Lower Region Only\n"));
15936 printf ("??? (%u)\n", val
);
15940 return display_tag_value (tag
& 1, p
, end
);
15943 struct riscv_attr_tag_t
{
15948 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15950 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15953 T(priv_spec_minor
),
15954 T(priv_spec_revision
),
15955 T(unaligned_access
),
15960 static unsigned char *
15961 display_riscv_attribute (unsigned char *p
,
15962 const unsigned char * const end
)
15966 struct riscv_attr_tag_t
*attr
= NULL
;
15969 READ_ULEB (tag
, p
, end
);
15971 /* Find the name of attribute. */
15972 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
15974 if (riscv_attr_tag
[i
].tag
== tag
)
15976 attr
= &riscv_attr_tag
[i
];
15982 printf (" %s: ", attr
->name
);
15984 return display_tag_value (tag
, p
, end
);
15988 case Tag_RISCV_priv_spec
:
15989 case Tag_RISCV_priv_spec_minor
:
15990 case Tag_RISCV_priv_spec_revision
:
15991 READ_ULEB (val
, p
, end
);
15992 printf (_("%u\n"), val
);
15994 case Tag_RISCV_unaligned_access
:
15995 READ_ULEB (val
, p
, end
);
15999 printf (_("No unaligned access\n"));
16002 printf (_("Unaligned access\n"));
16006 case Tag_RISCV_stack_align
:
16007 READ_ULEB (val
, p
, end
);
16008 printf (_("%u-bytes\n"), val
);
16010 case Tag_RISCV_arch
:
16011 p
= display_tag_value (-1, p
, end
);
16014 return display_tag_value (tag
, p
, end
);
16021 process_attributes (Filedata
* filedata
,
16022 const char * public_name
,
16023 unsigned int proc_type
,
16024 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16025 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16027 Elf_Internal_Shdr
* sect
;
16029 bfd_boolean res
= TRUE
;
16031 /* Find the section header so that we get the size. */
16032 for (i
= 0, sect
= filedata
->section_headers
;
16033 i
< filedata
->file_header
.e_shnum
;
16036 unsigned char * contents
;
16039 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16042 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16043 sect
->sh_size
, _("attributes"));
16044 if (contents
== NULL
)
16051 /* The first character is the version of the attributes.
16052 Currently only version 1, (aka 'A') is recognised here. */
16055 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16060 bfd_vma section_len
;
16062 section_len
= sect
->sh_size
- 1;
16065 while (section_len
> 0)
16068 unsigned int namelen
;
16069 bfd_boolean public_section
;
16070 bfd_boolean gnu_section
;
16072 if (section_len
<= 4)
16074 error (_("Tag section ends prematurely\n"));
16078 attr_len
= byte_get (p
, 4);
16081 if (attr_len
> section_len
)
16083 error (_("Bad attribute length (%u > %u)\n"),
16084 (unsigned) attr_len
, (unsigned) section_len
);
16085 attr_len
= section_len
;
16088 /* PR 17531: file: 001-101425-0.004 */
16089 else if (attr_len
< 5)
16091 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16096 section_len
-= attr_len
;
16099 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16100 if (namelen
== 0 || namelen
>= attr_len
)
16102 error (_("Corrupt attribute section name\n"));
16107 printf (_("Attribute Section: "));
16108 print_symbol (INT_MAX
, (const char *) p
);
16111 if (public_name
&& streq ((char *) p
, public_name
))
16112 public_section
= TRUE
;
16114 public_section
= FALSE
;
16116 if (streq ((char *) p
, "gnu"))
16117 gnu_section
= TRUE
;
16119 gnu_section
= FALSE
;
16122 attr_len
-= namelen
;
16124 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16129 unsigned char * end
;
16131 /* PR binutils/17531: Safe handling of corrupt files. */
16134 error (_("Unused bytes at end of section\n"));
16141 size
= byte_get (p
, 4);
16142 if (size
> attr_len
)
16144 error (_("Bad subsection length (%u > %u)\n"),
16145 (unsigned) size
, (unsigned) attr_len
);
16149 /* PR binutils/17531: Safe handling of corrupt files. */
16152 error (_("Bad subsection length (%u < 6)\n"),
16160 end
= p
+ size
- 1;
16161 assert (end
<= contents
+ sect
->sh_size
);
16167 printf (_("File Attributes\n"));
16170 printf (_("Section Attributes:"));
16173 printf (_("Symbol Attributes:"));
16174 /* Fall through. */
16178 READ_ULEB (val
, p
, end
);
16181 printf (" %d", val
);
16186 printf (_("Unknown tag: %d\n"), tag
);
16187 public_section
= FALSE
;
16191 if (public_section
&& display_pub_attribute
!= NULL
)
16194 p
= display_pub_attribute (p
, end
);
16197 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16200 p
= display_gnu_attribute (p
,
16201 display_proc_gnu_attribute
,
16207 printf (_(" Unknown attribute:\n"));
16208 display_raw_attribute (p
, end
);
16223 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16224 Print the Address, Access and Initial fields of an entry at VMA ADDR
16225 and return the VMA of the next entry, or -1 if there was a problem.
16226 Does not read from DATA_END or beyond. */
16229 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16230 unsigned char * data_end
)
16233 print_vma (addr
, LONG_HEX
);
16235 if (addr
< pltgot
+ 0xfff0)
16236 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16238 printf ("%10s", "");
16241 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16245 unsigned char * from
= data
+ addr
- pltgot
;
16247 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16249 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16250 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16251 return (bfd_vma
) -1;
16255 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16256 print_vma (entry
, LONG_HEX
);
16259 return addr
+ (is_32bit_elf
? 4 : 8);
16262 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16263 PLTGOT. Print the Address and Initial fields of an entry at VMA
16264 ADDR and return the VMA of the next entry. */
16267 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16270 print_vma (addr
, LONG_HEX
);
16273 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16278 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16279 print_vma (entry
, LONG_HEX
);
16281 return addr
+ (is_32bit_elf
? 4 : 8);
16285 print_mips_ases (unsigned int mask
)
16287 if (mask
& AFL_ASE_DSP
)
16288 fputs ("\n\tDSP ASE", stdout
);
16289 if (mask
& AFL_ASE_DSPR2
)
16290 fputs ("\n\tDSP R2 ASE", stdout
);
16291 if (mask
& AFL_ASE_DSPR3
)
16292 fputs ("\n\tDSP R3 ASE", stdout
);
16293 if (mask
& AFL_ASE_EVA
)
16294 fputs ("\n\tEnhanced VA Scheme", stdout
);
16295 if (mask
& AFL_ASE_MCU
)
16296 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16297 if (mask
& AFL_ASE_MDMX
)
16298 fputs ("\n\tMDMX ASE", stdout
);
16299 if (mask
& AFL_ASE_MIPS3D
)
16300 fputs ("\n\tMIPS-3D ASE", stdout
);
16301 if (mask
& AFL_ASE_MT
)
16302 fputs ("\n\tMT ASE", stdout
);
16303 if (mask
& AFL_ASE_SMARTMIPS
)
16304 fputs ("\n\tSmartMIPS ASE", stdout
);
16305 if (mask
& AFL_ASE_VIRT
)
16306 fputs ("\n\tVZ ASE", stdout
);
16307 if (mask
& AFL_ASE_MSA
)
16308 fputs ("\n\tMSA ASE", stdout
);
16309 if (mask
& AFL_ASE_MIPS16
)
16310 fputs ("\n\tMIPS16 ASE", stdout
);
16311 if (mask
& AFL_ASE_MICROMIPS
)
16312 fputs ("\n\tMICROMIPS ASE", stdout
);
16313 if (mask
& AFL_ASE_XPA
)
16314 fputs ("\n\tXPA ASE", stdout
);
16315 if (mask
& AFL_ASE_MIPS16E2
)
16316 fputs ("\n\tMIPS16e2 ASE", stdout
);
16317 if (mask
& AFL_ASE_CRC
)
16318 fputs ("\n\tCRC ASE", stdout
);
16319 if (mask
& AFL_ASE_GINV
)
16320 fputs ("\n\tGINV ASE", stdout
);
16321 if (mask
& AFL_ASE_LOONGSON_MMI
)
16322 fputs ("\n\tLoongson MMI ASE", stdout
);
16323 if (mask
& AFL_ASE_LOONGSON_CAM
)
16324 fputs ("\n\tLoongson CAM ASE", stdout
);
16325 if (mask
& AFL_ASE_LOONGSON_EXT
)
16326 fputs ("\n\tLoongson EXT ASE", stdout
);
16327 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16328 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16330 fprintf (stdout
, "\n\t%s", _("None"));
16331 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16332 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16336 print_mips_isa_ext (unsigned int isa_ext
)
16341 fputs (_("None"), stdout
);
16344 fputs ("RMI XLR", stdout
);
16346 case AFL_EXT_OCTEON3
:
16347 fputs ("Cavium Networks Octeon3", stdout
);
16349 case AFL_EXT_OCTEON2
:
16350 fputs ("Cavium Networks Octeon2", stdout
);
16352 case AFL_EXT_OCTEONP
:
16353 fputs ("Cavium Networks OcteonP", stdout
);
16355 case AFL_EXT_OCTEON
:
16356 fputs ("Cavium Networks Octeon", stdout
);
16359 fputs ("Toshiba R5900", stdout
);
16362 fputs ("MIPS R4650", stdout
);
16365 fputs ("LSI R4010", stdout
);
16368 fputs ("NEC VR4100", stdout
);
16371 fputs ("Toshiba R3900", stdout
);
16373 case AFL_EXT_10000
:
16374 fputs ("MIPS R10000", stdout
);
16377 fputs ("Broadcom SB-1", stdout
);
16380 fputs ("NEC VR4111/VR4181", stdout
);
16383 fputs ("NEC VR4120", stdout
);
16386 fputs ("NEC VR5400", stdout
);
16389 fputs ("NEC VR5500", stdout
);
16391 case AFL_EXT_LOONGSON_2E
:
16392 fputs ("ST Microelectronics Loongson 2E", stdout
);
16394 case AFL_EXT_LOONGSON_2F
:
16395 fputs ("ST Microelectronics Loongson 2F", stdout
);
16397 case AFL_EXT_INTERAPTIV_MR2
:
16398 fputs ("Imagination interAptiv MR2", stdout
);
16401 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16406 get_mips_reg_size (int reg_size
)
16408 return (reg_size
== AFL_REG_NONE
) ? 0
16409 : (reg_size
== AFL_REG_32
) ? 32
16410 : (reg_size
== AFL_REG_64
) ? 64
16411 : (reg_size
== AFL_REG_128
) ? 128
16416 process_mips_specific (Filedata
* filedata
)
16418 Elf_Internal_Dyn
* entry
;
16419 Elf_Internal_Shdr
*sect
= NULL
;
16420 size_t liblist_offset
= 0;
16421 size_t liblistno
= 0;
16422 size_t conflictsno
= 0;
16423 size_t options_offset
= 0;
16424 size_t conflicts_offset
= 0;
16425 size_t pltrelsz
= 0;
16427 bfd_vma pltgot
= 0;
16428 bfd_vma mips_pltgot
= 0;
16429 bfd_vma jmprel
= 0;
16430 bfd_vma local_gotno
= 0;
16431 bfd_vma gotsym
= 0;
16432 bfd_vma symtabno
= 0;
16433 bfd_boolean res
= TRUE
;
16435 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16436 display_mips_gnu_attribute
))
16439 sect
= find_section (filedata
, ".MIPS.abiflags");
16443 Elf_External_ABIFlags_v0
*abiflags_ext
;
16444 Elf_Internal_ABIFlags_v0 abiflags_in
;
16446 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16448 error (_("Corrupt MIPS ABI Flags section.\n"));
16453 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16454 sect
->sh_size
, _("MIPS ABI Flags section"));
16457 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16458 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16459 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16460 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16461 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16462 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16463 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16464 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16465 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16466 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16467 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16469 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16470 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16471 if (abiflags_in
.isa_rev
> 1)
16472 printf ("r%d", abiflags_in
.isa_rev
);
16473 printf ("\nGPR size: %d",
16474 get_mips_reg_size (abiflags_in
.gpr_size
));
16475 printf ("\nCPR1 size: %d",
16476 get_mips_reg_size (abiflags_in
.cpr1_size
));
16477 printf ("\nCPR2 size: %d",
16478 get_mips_reg_size (abiflags_in
.cpr2_size
));
16479 fputs ("\nFP ABI: ", stdout
);
16480 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16481 fputs ("ISA Extension: ", stdout
);
16482 print_mips_isa_ext (abiflags_in
.isa_ext
);
16483 fputs ("\nASEs:", stdout
);
16484 print_mips_ases (abiflags_in
.ases
);
16485 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16486 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16487 fputc ('\n', stdout
);
16488 free (abiflags_ext
);
16493 /* We have a lot of special sections. Thanks SGI! */
16494 if (dynamic_section
== NULL
)
16496 /* No dynamic information available. See if there is static GOT. */
16497 sect
= find_section (filedata
, ".got");
16500 unsigned char *data_end
;
16501 unsigned char *data
;
16505 pltgot
= sect
->sh_addr
;
16508 addr_size
= (is_32bit_elf
? 4 : 8);
16509 end
= pltgot
+ sect
->sh_size
;
16511 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16513 _("Global Offset Table data"));
16514 /* PR 12855: Null data is handled gracefully throughout. */
16515 data_end
= data
+ (end
- pltgot
);
16517 printf (_("\nStatic GOT:\n"));
16518 printf (_(" Canonical gp value: "));
16519 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16522 /* In a dynamic binary GOT[0] is reserved for the dynamic
16523 loader to store the lazy resolver pointer, however in
16524 a static binary it may well have been omitted and GOT
16525 reduced to a table of addresses.
16526 PR 21344: Check for the entry being fully available
16527 before fetching it. */
16529 && data
+ ent
- pltgot
+ addr_size
<= data_end
16530 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16532 printf (_(" Reserved entries:\n"));
16533 printf (_(" %*s %10s %*s\n"),
16534 addr_size
* 2, _("Address"), _("Access"),
16535 addr_size
* 2, _("Value"));
16536 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16538 if (ent
== (bfd_vma
) -1)
16539 goto sgot_print_fail
;
16541 /* Check for the MSB of GOT[1] being set, identifying a
16542 GNU object. This entry will be used by some runtime
16543 loaders, to store the module pointer. Otherwise this
16544 is an ordinary local entry.
16545 PR 21344: Check for the entry being fully available
16546 before fetching it. */
16548 && data
+ ent
- pltgot
+ addr_size
<= data_end
16549 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16550 >> (addr_size
* 8 - 1)) != 0)
16552 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16554 if (ent
== (bfd_vma
) -1)
16555 goto sgot_print_fail
;
16560 if (data
!= NULL
&& ent
< end
)
16562 printf (_(" Local entries:\n"));
16563 printf (" %*s %10s %*s\n",
16564 addr_size
* 2, _("Address"), _("Access"),
16565 addr_size
* 2, _("Value"));
16568 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16570 if (ent
== (bfd_vma
) -1)
16571 goto sgot_print_fail
;
16583 for (entry
= dynamic_section
;
16584 /* PR 17531 file: 012-50589-0.004. */
16585 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16587 switch (entry
->d_tag
)
16589 case DT_MIPS_LIBLIST
:
16591 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16592 liblistno
* sizeof (Elf32_External_Lib
));
16594 case DT_MIPS_LIBLISTNO
:
16595 liblistno
= entry
->d_un
.d_val
;
16597 case DT_MIPS_OPTIONS
:
16598 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16600 case DT_MIPS_CONFLICT
:
16602 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16603 conflictsno
* sizeof (Elf32_External_Conflict
));
16605 case DT_MIPS_CONFLICTNO
:
16606 conflictsno
= entry
->d_un
.d_val
;
16609 pltgot
= entry
->d_un
.d_ptr
;
16611 case DT_MIPS_LOCAL_GOTNO
:
16612 local_gotno
= entry
->d_un
.d_val
;
16614 case DT_MIPS_GOTSYM
:
16615 gotsym
= entry
->d_un
.d_val
;
16617 case DT_MIPS_SYMTABNO
:
16618 symtabno
= entry
->d_un
.d_val
;
16620 case DT_MIPS_PLTGOT
:
16621 mips_pltgot
= entry
->d_un
.d_ptr
;
16624 pltrel
= entry
->d_un
.d_val
;
16627 pltrelsz
= entry
->d_un
.d_val
;
16630 jmprel
= entry
->d_un
.d_ptr
;
16636 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16638 Elf32_External_Lib
* elib
;
16641 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16643 sizeof (Elf32_External_Lib
),
16644 _("liblist section data"));
16647 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16648 "\nSection '.liblist' contains %lu entries:\n",
16649 (unsigned long) liblistno
),
16650 (unsigned long) liblistno
);
16651 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16654 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16661 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16662 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16663 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16664 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16665 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16667 tmp
= gmtime (&atime
);
16668 snprintf (timebuf
, sizeof (timebuf
),
16669 "%04u-%02u-%02uT%02u:%02u:%02u",
16670 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16671 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16673 printf ("%3lu: ", (unsigned long) cnt
);
16674 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16675 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16677 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16678 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16679 liblist
.l_version
);
16681 if (liblist
.l_flags
== 0)
16685 static const struct
16692 { " EXACT_MATCH", LL_EXACT_MATCH
},
16693 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16694 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16695 { " EXPORTS", LL_EXPORTS
},
16696 { " DELAY_LOAD", LL_DELAY_LOAD
},
16697 { " DELTA", LL_DELTA
}
16699 int flags
= liblist
.l_flags
;
16702 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16703 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16705 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16706 flags
^= l_flags_vals
[fcnt
].bit
;
16709 printf (" %#x", (unsigned int) flags
);
16721 if (options_offset
!= 0)
16723 Elf_External_Options
* eopt
;
16726 sect
= filedata
->section_headers
;
16728 /* Find the section header so that we get the size. */
16729 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16730 /* PR 17533 file: 012-277276-0.004. */
16733 error (_("No MIPS_OPTIONS header found\n"));
16737 if (sect
->sh_size
< sizeof (* eopt
))
16739 error (_("The MIPS options section is too small.\n"));
16743 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16744 sect
->sh_size
, _("options"));
16747 Elf_Internal_Options
* iopt
;
16748 Elf_Internal_Options
* option
;
16749 Elf_Internal_Options
* iopt_end
;
16751 iopt
= (Elf_Internal_Options
*)
16752 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16755 error (_("Out of memory allocating space for MIPS options\n"));
16761 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16763 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16765 Elf_External_Options
* eoption
;
16767 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16769 option
->kind
= BYTE_GET (eoption
->kind
);
16770 option
->size
= BYTE_GET (eoption
->size
);
16771 option
->section
= BYTE_GET (eoption
->section
);
16772 option
->info
= BYTE_GET (eoption
->info
);
16774 /* PR 17531: file: ffa0fa3b. */
16775 if (option
->size
< sizeof (* eopt
)
16776 || offset
+ option
->size
> sect
->sh_size
)
16778 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16781 offset
+= option
->size
;
16787 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16788 "\nSection '%s' contains %d entries:\n",
16790 printable_section_name (filedata
, sect
), cnt
);
16799 switch (option
->kind
)
16802 /* This shouldn't happen. */
16803 printf (" NULL %d %lx", option
->section
, option
->info
);
16807 printf (" REGINFO ");
16808 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16810 Elf32_External_RegInfo
* ereg
;
16811 Elf32_RegInfo reginfo
;
16814 if (option
+ 2 > iopt_end
)
16816 printf (_("<corrupt>\n"));
16817 error (_("Truncated MIPS REGINFO option\n"));
16822 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16824 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16825 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16826 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16827 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16828 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16829 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16831 printf ("GPR %08lx GP 0x%lx\n",
16832 reginfo
.ri_gprmask
,
16833 (unsigned long) reginfo
.ri_gp_value
);
16834 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16835 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16836 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16841 Elf64_External_RegInfo
* ereg
;
16842 Elf64_Internal_RegInfo reginfo
;
16844 if (option
+ 2 > iopt_end
)
16846 printf (_("<corrupt>\n"));
16847 error (_("Truncated MIPS REGINFO option\n"));
16852 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16853 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16854 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16855 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16856 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16857 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16858 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16860 printf ("GPR %08lx GP 0x",
16861 reginfo
.ri_gprmask
);
16862 printf_vma (reginfo
.ri_gp_value
);
16865 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16866 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16867 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16872 case ODK_EXCEPTIONS
:
16873 fputs (" EXCEPTIONS fpe_min(", stdout
);
16874 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16875 fputs (") fpe_max(", stdout
);
16876 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16877 fputs (")", stdout
);
16879 if (option
->info
& OEX_PAGE0
)
16880 fputs (" PAGE0", stdout
);
16881 if (option
->info
& OEX_SMM
)
16882 fputs (" SMM", stdout
);
16883 if (option
->info
& OEX_FPDBUG
)
16884 fputs (" FPDBUG", stdout
);
16885 if (option
->info
& OEX_DISMISS
)
16886 fputs (" DISMISS", stdout
);
16890 fputs (" PAD ", stdout
);
16891 if (option
->info
& OPAD_PREFIX
)
16892 fputs (" PREFIX", stdout
);
16893 if (option
->info
& OPAD_POSTFIX
)
16894 fputs (" POSTFIX", stdout
);
16895 if (option
->info
& OPAD_SYMBOL
)
16896 fputs (" SYMBOL", stdout
);
16900 fputs (" HWPATCH ", stdout
);
16901 if (option
->info
& OHW_R4KEOP
)
16902 fputs (" R4KEOP", stdout
);
16903 if (option
->info
& OHW_R8KPFETCH
)
16904 fputs (" R8KPFETCH", stdout
);
16905 if (option
->info
& OHW_R5KEOP
)
16906 fputs (" R5KEOP", stdout
);
16907 if (option
->info
& OHW_R5KCVTL
)
16908 fputs (" R5KCVTL", stdout
);
16912 fputs (" FILL ", stdout
);
16913 /* XXX Print content of info word? */
16917 fputs (" TAGS ", stdout
);
16918 /* XXX Print content of info word? */
16922 fputs (" HWAND ", stdout
);
16923 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16924 fputs (" R4KEOP_CHECKED", stdout
);
16925 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16926 fputs (" R4KEOP_CLEAN", stdout
);
16930 fputs (" HWOR ", stdout
);
16931 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16932 fputs (" R4KEOP_CHECKED", stdout
);
16933 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16934 fputs (" R4KEOP_CLEAN", stdout
);
16938 printf (" GP_GROUP %#06lx self-contained %#06lx",
16939 option
->info
& OGP_GROUP
,
16940 (option
->info
& OGP_SELF
) >> 16);
16944 printf (" IDENT %#06lx self-contained %#06lx",
16945 option
->info
& OGP_GROUP
,
16946 (option
->info
& OGP_SELF
) >> 16);
16950 /* This shouldn't happen. */
16951 printf (" %3d ??? %d %lx",
16952 option
->kind
, option
->section
, option
->info
);
16956 len
= sizeof (* eopt
);
16957 while (len
< option
->size
)
16959 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16961 if (ISPRINT (datum
))
16962 printf ("%c", datum
);
16964 printf ("\\%03o", datum
);
16967 fputs ("\n", stdout
);
16969 offset
+= option
->size
;
16979 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16981 Elf32_Conflict
* iconf
;
16984 if (dynamic_symbols
== NULL
)
16986 error (_("conflict list found without a dynamic symbol table\n"));
16990 /* PR 21345 - print a slightly more helpful error message
16991 if we are sure that the cmalloc will fail. */
16992 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16994 error (_("Overlarge number of conflicts detected: %lx\n"),
16995 (long) conflictsno
);
16999 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17002 error (_("Out of memory allocating space for dynamic conflicts\n"));
17008 Elf32_External_Conflict
* econf32
;
17010 econf32
= (Elf32_External_Conflict
*)
17011 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
17012 sizeof (* econf32
), _("conflict"));
17016 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17017 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17023 Elf64_External_Conflict
* econf64
;
17025 econf64
= (Elf64_External_Conflict
*)
17026 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
17027 sizeof (* econf64
), _("conflict"));
17031 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17032 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17037 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17038 "\nSection '.conflict' contains %lu entries:\n",
17039 (unsigned long) conflictsno
),
17040 (unsigned long) conflictsno
);
17041 puts (_(" Num: Index Value Name"));
17043 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17045 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17047 if (iconf
[cnt
] >= num_dynamic_syms
)
17048 printf (_("<corrupt symbol index>"));
17051 Elf_Internal_Sym
* psym
;
17053 psym
= & dynamic_symbols
[iconf
[cnt
]];
17054 print_vma (psym
->st_value
, FULL_HEX
);
17056 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17057 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
17059 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17067 if (pltgot
!= 0 && local_gotno
!= 0)
17069 bfd_vma ent
, local_end
, global_end
;
17071 unsigned char * data
;
17072 unsigned char * data_end
;
17076 addr_size
= (is_32bit_elf
? 4 : 8);
17077 local_end
= pltgot
+ local_gotno
* addr_size
;
17079 /* PR binutils/17533 file: 012-111227-0.004 */
17080 if (symtabno
< gotsym
)
17082 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17083 (unsigned long) gotsym
, (unsigned long) symtabno
);
17087 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17088 /* PR 17531: file: 54c91a34. */
17089 if (global_end
< local_end
)
17091 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17095 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17096 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17097 global_end
- pltgot
, 1,
17098 _("Global Offset Table data"));
17099 /* PR 12855: Null data is handled gracefully throughout. */
17100 data_end
= data
+ (global_end
- pltgot
);
17102 printf (_("\nPrimary GOT:\n"));
17103 printf (_(" Canonical gp value: "));
17104 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17107 printf (_(" Reserved entries:\n"));
17108 printf (_(" %*s %10s %*s Purpose\n"),
17109 addr_size
* 2, _("Address"), _("Access"),
17110 addr_size
* 2, _("Initial"));
17111 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17112 printf (_(" Lazy resolver\n"));
17113 if (ent
== (bfd_vma
) -1)
17114 goto got_print_fail
;
17116 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17117 This entry will be used by some runtime loaders, to store the
17118 module pointer. Otherwise this is an ordinary local entry.
17119 PR 21344: Check for the entry being fully available before
17122 && data
+ ent
- pltgot
+ addr_size
<= data_end
17123 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17124 >> (addr_size
* 8 - 1)) != 0)
17126 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17127 printf (_(" Module pointer (GNU extension)\n"));
17128 if (ent
== (bfd_vma
) -1)
17129 goto got_print_fail
;
17133 if (data
!= NULL
&& ent
< local_end
)
17135 printf (_(" Local entries:\n"));
17136 printf (" %*s %10s %*s\n",
17137 addr_size
* 2, _("Address"), _("Access"),
17138 addr_size
* 2, _("Initial"));
17139 while (ent
< local_end
)
17141 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17143 if (ent
== (bfd_vma
) -1)
17144 goto got_print_fail
;
17149 if (data
!= NULL
&& gotsym
< symtabno
)
17153 printf (_(" Global entries:\n"));
17154 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17155 addr_size
* 2, _("Address"),
17157 addr_size
* 2, _("Initial"),
17158 addr_size
* 2, _("Sym.Val."),
17160 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17161 _("Ndx"), _("Name"));
17163 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17165 for (i
= gotsym
; i
< symtabno
; i
++)
17167 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17170 if (dynamic_symbols
== NULL
)
17171 printf (_("<no dynamic symbols>"));
17172 else if (i
< num_dynamic_syms
)
17174 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17176 print_vma (psym
->st_value
, LONG_HEX
);
17177 printf (" %-7s %3s ",
17178 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17179 get_symbol_index_type (filedata
, psym
->st_shndx
));
17181 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17182 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17184 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17187 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17188 (unsigned long) i
);
17191 if (ent
== (bfd_vma
) -1)
17202 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17205 size_t offset
, rel_offset
;
17206 unsigned long count
, i
;
17207 unsigned char * data
;
17208 int addr_size
, sym_width
;
17209 Elf_Internal_Rela
* rels
;
17211 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17212 if (pltrel
== DT_RELA
)
17214 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17219 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17224 addr_size
= (is_32bit_elf
? 4 : 8);
17225 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17227 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17228 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17229 1, _("Procedure Linkage Table data"));
17233 printf ("\nPLT GOT:\n\n");
17234 printf (_(" Reserved entries:\n"));
17235 printf (_(" %*s %*s Purpose\n"),
17236 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17237 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17238 printf (_(" PLT lazy resolver\n"));
17239 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17240 printf (_(" Module pointer\n"));
17243 printf (_(" Entries:\n"));
17244 printf (" %*s %*s %*s %-7s %3s %s\n",
17245 addr_size
* 2, _("Address"),
17246 addr_size
* 2, _("Initial"),
17247 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17248 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17249 for (i
= 0; i
< count
; i
++)
17251 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17253 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17256 if (idx
>= num_dynamic_syms
)
17257 printf (_("<corrupt symbol index: %lu>"), idx
);
17260 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17262 print_vma (psym
->st_value
, LONG_HEX
);
17263 printf (" %-7s %3s ",
17264 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17265 get_symbol_index_type (filedata
, psym
->st_shndx
));
17266 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17267 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17269 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17284 process_nds32_specific (Filedata
* filedata
)
17286 Elf_Internal_Shdr
*sect
= NULL
;
17288 sect
= find_section (filedata
, ".nds32_e_flags");
17291 unsigned int *flag
;
17293 printf ("\nNDS32 elf flags section:\n");
17294 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17295 sect
->sh_size
, _("NDS32 elf flags section"));
17300 switch ((*flag
) & 0x3)
17303 printf ("(VEC_SIZE):\tNo entry.\n");
17306 printf ("(VEC_SIZE):\t4 bytes\n");
17309 printf ("(VEC_SIZE):\t16 bytes\n");
17312 printf ("(VEC_SIZE):\treserved\n");
17321 process_gnu_liblist (Filedata
* filedata
)
17323 Elf_Internal_Shdr
* section
;
17324 Elf_Internal_Shdr
* string_sec
;
17325 Elf32_External_Lib
* elib
;
17327 size_t strtab_size
;
17329 unsigned long num_liblist
;
17331 bfd_boolean res
= TRUE
;
17336 for (i
= 0, section
= filedata
->section_headers
;
17337 i
< filedata
->file_header
.e_shnum
;
17340 switch (section
->sh_type
)
17342 case SHT_GNU_LIBLIST
:
17343 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17346 elib
= (Elf32_External_Lib
*)
17347 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17348 _("liblist section data"));
17356 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17357 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17358 string_sec
->sh_size
,
17359 _("liblist string table"));
17361 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17368 strtab_size
= string_sec
->sh_size
;
17370 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17371 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17372 "\nLibrary list section '%s' contains %lu entries:\n",
17374 printable_section_name (filedata
, section
),
17377 puts (_(" Library Time Stamp Checksum Version Flags"));
17379 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17387 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17388 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17389 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17390 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17391 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17393 tmp
= gmtime (&atime
);
17394 snprintf (timebuf
, sizeof (timebuf
),
17395 "%04u-%02u-%02uT%02u:%02u:%02u",
17396 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17397 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17399 printf ("%3lu: ", (unsigned long) cnt
);
17401 printf ("%-20s", liblist
.l_name
< strtab_size
17402 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17404 printf ("%-20.20s", liblist
.l_name
< strtab_size
17405 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17406 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17407 liblist
.l_version
, liblist
.l_flags
);
17418 static const char *
17419 get_note_type (Filedata
* filedata
, unsigned e_type
)
17421 static char buff
[64];
17423 if (filedata
->file_header
.e_type
== ET_CORE
)
17427 return _("NT_AUXV (auxiliary vector)");
17429 return _("NT_PRSTATUS (prstatus structure)");
17431 return _("NT_FPREGSET (floating point registers)");
17433 return _("NT_PRPSINFO (prpsinfo structure)");
17434 case NT_TASKSTRUCT
:
17435 return _("NT_TASKSTRUCT (task structure)");
17437 return _("NT_PRXFPREG (user_xfpregs structure)");
17439 return _("NT_PPC_VMX (ppc Altivec registers)");
17441 return _("NT_PPC_VSX (ppc VSX registers)");
17443 return _("NT_PPC_TAR (ppc TAR register)");
17445 return _("NT_PPC_PPR (ppc PPR register)");
17447 return _("NT_PPC_DSCR (ppc DSCR register)");
17449 return _("NT_PPC_EBB (ppc EBB registers)");
17451 return _("NT_PPC_PMU (ppc PMU registers)");
17452 case NT_PPC_TM_CGPR
:
17453 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17454 case NT_PPC_TM_CFPR
:
17455 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17456 case NT_PPC_TM_CVMX
:
17457 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17458 case NT_PPC_TM_CVSX
:
17459 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17460 case NT_PPC_TM_SPR
:
17461 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17462 case NT_PPC_TM_CTAR
:
17463 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17464 case NT_PPC_TM_CPPR
:
17465 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17466 case NT_PPC_TM_CDSCR
:
17467 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17469 return _("NT_386_TLS (x86 TLS information)");
17470 case NT_386_IOPERM
:
17471 return _("NT_386_IOPERM (x86 I/O permissions)");
17472 case NT_X86_XSTATE
:
17473 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17474 case NT_S390_HIGH_GPRS
:
17475 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17476 case NT_S390_TIMER
:
17477 return _("NT_S390_TIMER (s390 timer register)");
17478 case NT_S390_TODCMP
:
17479 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17480 case NT_S390_TODPREG
:
17481 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17483 return _("NT_S390_CTRS (s390 control registers)");
17484 case NT_S390_PREFIX
:
17485 return _("NT_S390_PREFIX (s390 prefix register)");
17486 case NT_S390_LAST_BREAK
:
17487 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17488 case NT_S390_SYSTEM_CALL
:
17489 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17491 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17492 case NT_S390_VXRS_LOW
:
17493 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17494 case NT_S390_VXRS_HIGH
:
17495 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17496 case NT_S390_GS_CB
:
17497 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17498 case NT_S390_GS_BC
:
17499 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17501 return _("NT_ARM_VFP (arm VFP registers)");
17503 return _("NT_ARM_TLS (AArch TLS registers)");
17504 case NT_ARM_HW_BREAK
:
17505 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17506 case NT_ARM_HW_WATCH
:
17507 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17509 return _("NT_PSTATUS (pstatus structure)");
17511 return _("NT_FPREGS (floating point registers)");
17513 return _("NT_PSINFO (psinfo structure)");
17515 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17517 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17518 case NT_WIN32PSTATUS
:
17519 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17521 return _("NT_SIGINFO (siginfo_t data)");
17523 return _("NT_FILE (mapped files)");
17531 return _("NT_VERSION (version)");
17533 return _("NT_ARCH (architecture)");
17534 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17536 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17542 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17547 print_core_note (Elf_Internal_Note
*pnote
)
17549 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17550 bfd_vma count
, page_size
;
17551 unsigned char *descdata
, *filenames
, *descend
;
17553 if (pnote
->type
!= NT_FILE
)
17563 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17564 /* Still "successful". */
17569 if (pnote
->descsz
< 2 * addr_size
)
17571 error (_(" Malformed note - too short for header\n"));
17575 descdata
= (unsigned char *) pnote
->descdata
;
17576 descend
= descdata
+ pnote
->descsz
;
17578 if (descdata
[pnote
->descsz
- 1] != '\0')
17580 error (_(" Malformed note - does not end with \\0\n"));
17584 count
= byte_get (descdata
, addr_size
);
17585 descdata
+= addr_size
;
17587 page_size
= byte_get (descdata
, addr_size
);
17588 descdata
+= addr_size
;
17590 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17591 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17593 error (_(" Malformed note - too short for supplied file count\n"));
17597 printf (_(" Page size: "));
17598 print_vma (page_size
, DEC
);
17601 printf (_(" %*s%*s%*s\n"),
17602 (int) (2 + 2 * addr_size
), _("Start"),
17603 (int) (4 + 2 * addr_size
), _("End"),
17604 (int) (4 + 2 * addr_size
), _("Page Offset"));
17605 filenames
= descdata
+ count
* 3 * addr_size
;
17606 while (count
-- > 0)
17608 bfd_vma start
, end
, file_ofs
;
17610 if (filenames
== descend
)
17612 error (_(" Malformed note - filenames end too early\n"));
17616 start
= byte_get (descdata
, addr_size
);
17617 descdata
+= addr_size
;
17618 end
= byte_get (descdata
, addr_size
);
17619 descdata
+= addr_size
;
17620 file_ofs
= byte_get (descdata
, addr_size
);
17621 descdata
+= addr_size
;
17624 print_vma (start
, FULL_HEX
);
17626 print_vma (end
, FULL_HEX
);
17628 print_vma (file_ofs
, FULL_HEX
);
17629 printf ("\n %s\n", filenames
);
17631 filenames
+= 1 + strlen ((char *) filenames
);
17637 static const char *
17638 get_gnu_elf_note_type (unsigned e_type
)
17640 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17643 case NT_GNU_ABI_TAG
:
17644 return _("NT_GNU_ABI_TAG (ABI version tag)");
17646 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17647 case NT_GNU_BUILD_ID
:
17648 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17649 case NT_GNU_GOLD_VERSION
:
17650 return _("NT_GNU_GOLD_VERSION (gold version)");
17651 case NT_GNU_PROPERTY_TYPE_0
:
17652 return _("NT_GNU_PROPERTY_TYPE_0");
17653 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17654 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17655 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17656 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17659 static char buff
[64];
17661 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17668 decode_x86_compat_isa (unsigned int bitmask
)
17672 unsigned int bit
= bitmask
& (- bitmask
);
17677 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17680 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17683 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17686 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17689 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17692 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17695 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17698 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17701 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17704 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17707 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17710 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17711 printf ("AVX512F");
17713 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17714 printf ("AVX512CD");
17716 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17717 printf ("AVX512ER");
17719 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17720 printf ("AVX512PF");
17722 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17723 printf ("AVX512VL");
17725 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17726 printf ("AVX512DQ");
17728 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17729 printf ("AVX512BW");
17732 printf (_("<unknown: %x>"), bit
);
17741 decode_x86_isa (unsigned int bitmask
)
17745 printf (_("<None>"));
17751 unsigned int bit
= bitmask
& (- bitmask
);
17756 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17759 case GNU_PROPERTY_X86_ISA_1_SSE
:
17762 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17765 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17768 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17771 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17774 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17777 case GNU_PROPERTY_X86_ISA_1_AVX
:
17780 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17783 case GNU_PROPERTY_X86_ISA_1_FMA
:
17786 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17787 printf ("AVX512F");
17789 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17790 printf ("AVX512CD");
17792 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17793 printf ("AVX512ER");
17795 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17796 printf ("AVX512PF");
17798 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17799 printf ("AVX512VL");
17801 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17802 printf ("AVX512DQ");
17804 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17805 printf ("AVX512BW");
17807 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17808 printf ("AVX512_4FMAPS");
17810 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17811 printf ("AVX512_4VNNIW");
17813 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17814 printf ("AVX512_BITALG");
17816 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17817 printf ("AVX512_IFMA");
17819 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17820 printf ("AVX512_VBMI");
17822 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17823 printf ("AVX512_VBMI2");
17825 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17826 printf ("AVX512_VNNI");
17828 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17829 printf ("AVX512_BF16");
17832 printf (_("<unknown: %x>"), bit
);
17841 decode_x86_feature_1 (unsigned int bitmask
)
17845 printf (_("<None>"));
17851 unsigned int bit
= bitmask
& (- bitmask
);
17856 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17859 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17863 printf (_("<unknown: %x>"), bit
);
17872 decode_x86_feature_2 (unsigned int bitmask
)
17876 printf (_("<None>"));
17882 unsigned int bit
= bitmask
& (- bitmask
);
17887 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17890 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17893 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17896 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17899 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17902 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17905 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17908 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17911 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17912 printf ("XSAVEOPT");
17914 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17918 printf (_("<unknown: %x>"), bit
);
17927 decode_aarch64_feature_1_and (unsigned int bitmask
)
17931 unsigned int bit
= bitmask
& (- bitmask
);
17936 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17940 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17945 printf (_("<unknown: %x>"), bit
);
17954 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17956 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17957 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17958 unsigned int size
= is_32bit_elf
? 4 : 8;
17960 printf (_(" Properties: "));
17962 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17964 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17968 while (ptr
< ptr_end
)
17972 unsigned int datasz
;
17974 if ((size_t) (ptr_end
- ptr
) < 8)
17976 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17980 type
= byte_get (ptr
, 4);
17981 datasz
= byte_get (ptr
+ 4, 4);
17985 if (datasz
> (size_t) (ptr_end
- ptr
))
17987 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17992 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17994 if (filedata
->file_header
.e_machine
== EM_X86_64
17995 || filedata
->file_header
.e_machine
== EM_IAMCU
17996 || filedata
->file_header
.e_machine
== EM_386
)
17998 unsigned int bitmask
;
18001 bitmask
= byte_get (ptr
, 4);
18007 case GNU_PROPERTY_X86_ISA_1_USED
:
18009 printf (_("x86 ISA used: <corrupt length: %#x> "),
18013 printf ("x86 ISA used: ");
18014 decode_x86_isa (bitmask
);
18018 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18020 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18024 printf ("x86 ISA needed: ");
18025 decode_x86_isa (bitmask
);
18029 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18031 printf (_("x86 feature: <corrupt length: %#x> "),
18035 printf ("x86 feature: ");
18036 decode_x86_feature_1 (bitmask
);
18040 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18042 printf (_("x86 feature used: <corrupt length: %#x> "),
18046 printf ("x86 feature used: ");
18047 decode_x86_feature_2 (bitmask
);
18051 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18053 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18056 printf ("x86 feature needed: ");
18057 decode_x86_feature_2 (bitmask
);
18061 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18063 printf (_("x86 ISA used: <corrupt length: %#x> "),
18067 printf ("x86 ISA used: ");
18068 decode_x86_compat_isa (bitmask
);
18072 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18074 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18078 printf ("x86 ISA needed: ");
18079 decode_x86_compat_isa (bitmask
);
18087 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18089 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18091 printf ("AArch64 feature: ");
18093 printf (_("<corrupt length: %#x> "), datasz
);
18095 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18104 case GNU_PROPERTY_STACK_SIZE
:
18105 printf (_("stack size: "));
18106 if (datasz
!= size
)
18107 printf (_("<corrupt length: %#x> "), datasz
);
18109 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18112 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18113 printf ("no copy on protected ");
18115 printf (_("<corrupt length: %#x> "), datasz
);
18123 if (type
< GNU_PROPERTY_LOPROC
)
18124 printf (_("<unknown type %#x data: "), type
);
18125 else if (type
< GNU_PROPERTY_LOUSER
)
18126 printf (_("<procesor-specific type %#x data: "), type
);
18128 printf (_("<application-specific type %#x data: "), type
);
18129 for (j
= 0; j
< datasz
; ++j
)
18130 printf ("%02x ", ptr
[j
] & 0xff);
18134 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18135 if (ptr
== ptr_end
)
18148 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18150 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18151 switch (pnote
->type
)
18153 case NT_GNU_BUILD_ID
:
18157 printf (_(" Build ID: "));
18158 for (i
= 0; i
< pnote
->descsz
; ++i
)
18159 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18164 case NT_GNU_ABI_TAG
:
18166 unsigned long os
, major
, minor
, subminor
;
18167 const char *osname
;
18169 /* PR 17531: file: 030-599401-0.004. */
18170 if (pnote
->descsz
< 16)
18172 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18176 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18177 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18178 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18179 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18183 case GNU_ABI_TAG_LINUX
:
18186 case GNU_ABI_TAG_HURD
:
18189 case GNU_ABI_TAG_SOLARIS
:
18190 osname
= "Solaris";
18192 case GNU_ABI_TAG_FREEBSD
:
18193 osname
= "FreeBSD";
18195 case GNU_ABI_TAG_NETBSD
:
18198 case GNU_ABI_TAG_SYLLABLE
:
18199 osname
= "Syllable";
18201 case GNU_ABI_TAG_NACL
:
18205 osname
= "Unknown";
18209 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18210 major
, minor
, subminor
);
18214 case NT_GNU_GOLD_VERSION
:
18218 printf (_(" Version: "));
18219 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18220 printf ("%c", pnote
->descdata
[i
]);
18227 unsigned long num_entries
, mask
;
18229 /* Hardware capabilities information. Word 0 is the number of entries.
18230 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18231 is a series of entries, where each entry is a single byte followed
18232 by a nul terminated string. The byte gives the bit number to test
18233 if enabled in the bitmask. */
18234 printf (_(" Hardware Capabilities: "));
18235 if (pnote
->descsz
< 8)
18237 error (_("<corrupt GNU_HWCAP>\n"));
18240 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18241 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18242 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18243 /* FIXME: Add code to display the entries... */
18247 case NT_GNU_PROPERTY_TYPE_0
:
18248 print_gnu_property_note (filedata
, pnote
);
18252 /* Handle unrecognised types. An error message should have already been
18253 created by get_gnu_elf_note_type(), so all that we need to do is to
18254 display the data. */
18258 printf (_(" Description data: "));
18259 for (i
= 0; i
< pnote
->descsz
; ++i
)
18260 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18269 static const char *
18270 get_v850_elf_note_type (enum v850_notes n_type
)
18272 static char buff
[64];
18276 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18277 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18278 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18279 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18280 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18281 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18283 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18289 print_v850_note (Elf_Internal_Note
* pnote
)
18293 if (pnote
->descsz
!= 4)
18296 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18300 printf (_("not set\n"));
18304 switch (pnote
->type
)
18306 case V850_NOTE_ALIGNMENT
:
18309 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18310 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18314 case V850_NOTE_DATA_SIZE
:
18317 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18318 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18322 case V850_NOTE_FPU_INFO
:
18325 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18326 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18330 case V850_NOTE_MMU_INFO
:
18331 case V850_NOTE_CACHE_INFO
:
18332 case V850_NOTE_SIMD_INFO
:
18333 if (val
== EF_RH850_SIMD
)
18335 printf (_("yes\n"));
18341 /* An 'unknown note type' message will already have been displayed. */
18345 printf (_("unknown value: %x\n"), val
);
18350 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18352 unsigned int version
;
18354 switch (pnote
->type
)
18356 case NT_NETBSD_IDENT
:
18357 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18358 if ((version
/ 10000) % 100)
18359 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18360 version
, version
/ 100000000, (version
/ 1000000) % 100,
18361 (version
/ 10000) % 100 > 26 ? "Z" : "",
18362 'A' + (version
/ 10000) % 26);
18364 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18365 version
, version
/ 100000000, (version
/ 1000000) % 100,
18366 (version
/ 100) % 100);
18369 case NT_NETBSD_MARCH
:
18370 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18374 #ifdef NT_NETBSD_PAX
18375 case NT_NETBSD_PAX
:
18376 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18377 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18378 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18379 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18380 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18381 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18382 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18383 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18388 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
18394 static const char *
18395 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18399 case NT_FREEBSD_THRMISC
:
18400 return _("NT_THRMISC (thrmisc structure)");
18401 case NT_FREEBSD_PROCSTAT_PROC
:
18402 return _("NT_PROCSTAT_PROC (proc data)");
18403 case NT_FREEBSD_PROCSTAT_FILES
:
18404 return _("NT_PROCSTAT_FILES (files data)");
18405 case NT_FREEBSD_PROCSTAT_VMMAP
:
18406 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18407 case NT_FREEBSD_PROCSTAT_GROUPS
:
18408 return _("NT_PROCSTAT_GROUPS (groups data)");
18409 case NT_FREEBSD_PROCSTAT_UMASK
:
18410 return _("NT_PROCSTAT_UMASK (umask data)");
18411 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18412 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18413 case NT_FREEBSD_PROCSTAT_OSREL
:
18414 return _("NT_PROCSTAT_OSREL (osreldate data)");
18415 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18416 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18417 case NT_FREEBSD_PROCSTAT_AUXV
:
18418 return _("NT_PROCSTAT_AUXV (auxv data)");
18419 case NT_FREEBSD_PTLWPINFO
:
18420 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18422 return get_note_type (filedata
, e_type
);
18425 static const char *
18426 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18428 static char buff
[64];
18432 case NT_NETBSDCORE_PROCINFO
:
18433 /* NetBSD core "procinfo" structure. */
18434 return _("NetBSD procinfo structure");
18436 #ifdef NT_NETBSDCORE_AUXV
18437 case NT_NETBSDCORE_AUXV
:
18438 return _("NetBSD ELF auxiliary vector data");
18442 /* As of Jan 2002 there are no other machine-independent notes
18443 defined for NetBSD core files. If the note type is less
18444 than the start of the machine-dependent note types, we don't
18447 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18449 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18455 switch (filedata
->file_header
.e_machine
)
18457 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18458 and PT_GETFPREGS == mach+2. */
18463 case EM_SPARC32PLUS
:
18467 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18468 return _("PT_GETREGS (reg structure)");
18469 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18470 return _("PT_GETFPREGS (fpreg structure)");
18476 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18477 There's also old PT___GETREGS40 == mach + 1 for old reg
18478 structure which lacks GBR. */
18482 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18483 return _("PT___GETREGS40 (old reg structure)");
18484 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18485 return _("PT_GETREGS (reg structure)");
18486 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18487 return _("PT_GETFPREGS (fpreg structure)");
18493 /* On all other arch's, PT_GETREGS == mach+1 and
18494 PT_GETFPREGS == mach+3. */
18498 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18499 return _("PT_GETREGS (reg structure)");
18500 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18501 return _("PT_GETFPREGS (fpreg structure)");
18507 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18508 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18512 static const char *
18513 get_stapsdt_note_type (unsigned e_type
)
18515 static char buff
[64];
18520 return _("NT_STAPSDT (SystemTap probe descriptors)");
18526 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18531 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18533 size_t len
, maxlen
;
18534 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18535 char *data
= pnote
->descdata
;
18536 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18537 bfd_vma pc
, base_addr
, semaphore
;
18538 char *provider
, *probe
, *arg_fmt
;
18540 if (pnote
->descsz
< (addr_size
* 3))
18541 goto stapdt_note_too_small
;
18543 pc
= byte_get ((unsigned char *) data
, addr_size
);
18546 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18549 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18552 if (data
>= data_end
)
18553 goto stapdt_note_too_small
;
18554 maxlen
= data_end
- data
;
18555 len
= strnlen (data
, maxlen
);
18562 goto stapdt_note_too_small
;
18564 if (data
>= data_end
)
18565 goto stapdt_note_too_small
;
18566 maxlen
= data_end
- data
;
18567 len
= strnlen (data
, maxlen
);
18574 goto stapdt_note_too_small
;
18576 if (data
>= data_end
)
18577 goto stapdt_note_too_small
;
18578 maxlen
= data_end
- data
;
18579 len
= strnlen (data
, maxlen
);
18586 goto stapdt_note_too_small
;
18588 printf (_(" Provider: %s\n"), provider
);
18589 printf (_(" Name: %s\n"), probe
);
18590 printf (_(" Location: "));
18591 print_vma (pc
, FULL_HEX
);
18592 printf (_(", Base: "));
18593 print_vma (base_addr
, FULL_HEX
);
18594 printf (_(", Semaphore: "));
18595 print_vma (semaphore
, FULL_HEX
);
18597 printf (_(" Arguments: %s\n"), arg_fmt
);
18599 return data
== data_end
;
18601 stapdt_note_too_small
:
18602 printf (_(" <corrupt - note is too small>\n"));
18603 error (_("corrupt stapdt note - the data size is too small\n"));
18607 static const char *
18608 get_ia64_vms_note_type (unsigned e_type
)
18610 static char buff
[64];
18615 return _("NT_VMS_MHD (module header)");
18617 return _("NT_VMS_LNM (language name)");
18619 return _("NT_VMS_SRC (source files)");
18621 return "NT_VMS_TITLE";
18623 return _("NT_VMS_EIDC (consistency check)");
18624 case NT_VMS_FPMODE
:
18625 return _("NT_VMS_FPMODE (FP mode)");
18626 case NT_VMS_LINKTIME
:
18627 return "NT_VMS_LINKTIME";
18628 case NT_VMS_IMGNAM
:
18629 return _("NT_VMS_IMGNAM (image name)");
18631 return _("NT_VMS_IMGID (image id)");
18632 case NT_VMS_LINKID
:
18633 return _("NT_VMS_LINKID (link id)");
18634 case NT_VMS_IMGBID
:
18635 return _("NT_VMS_IMGBID (build id)");
18636 case NT_VMS_GSTNAM
:
18637 return _("NT_VMS_GSTNAM (sym table name)");
18638 case NT_VMS_ORIG_DYN
:
18639 return "NT_VMS_ORIG_DYN";
18640 case NT_VMS_PATCHTIME
:
18641 return "NT_VMS_PATCHTIME";
18643 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18649 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18651 int maxlen
= pnote
->descsz
;
18653 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18654 goto desc_size_fail
;
18656 switch (pnote
->type
)
18660 goto desc_size_fail
;
18662 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18664 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18665 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18666 if (l
+ 34 < maxlen
)
18668 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18669 if (l
+ 35 < maxlen
)
18670 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18672 printf (_(" Module version : <missing>\n"));
18676 printf (_(" Module name : <missing>\n"));
18677 printf (_(" Module version : <missing>\n"));
18682 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18686 case NT_VMS_FPMODE
:
18687 printf (_(" Floating Point mode: "));
18689 goto desc_size_fail
;
18690 /* FIXME: Generate an error if descsz > 8 ? */
18692 printf ("0x%016" BFD_VMA_FMT
"x\n",
18693 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18696 case NT_VMS_LINKTIME
:
18697 printf (_(" Link time: "));
18699 goto desc_size_fail
;
18700 /* FIXME: Generate an error if descsz > 8 ? */
18703 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18707 case NT_VMS_PATCHTIME
:
18708 printf (_(" Patch time: "));
18710 goto desc_size_fail
;
18711 /* FIXME: Generate an error if descsz > 8 ? */
18714 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18718 case NT_VMS_ORIG_DYN
:
18720 goto desc_size_fail
;
18722 printf (_(" Major id: %u, minor id: %u\n"),
18723 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18724 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18725 printf (_(" Last modified : "));
18727 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18728 printf (_("\n Link flags : "));
18729 printf ("0x%016" BFD_VMA_FMT
"x\n",
18730 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18731 printf (_(" Header flags: 0x%08x\n"),
18732 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18733 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18737 case NT_VMS_IMGNAM
:
18738 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18741 case NT_VMS_GSTNAM
:
18742 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18746 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18749 case NT_VMS_LINKID
:
18750 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18760 printf (_(" <corrupt - data size is too small>\n"));
18761 error (_("corrupt IA64 note: data size is too small\n"));
18765 /* Find the symbol associated with a build attribute that is attached
18766 to address OFFSET. If PNAME is non-NULL then store the name of
18767 the symbol (if found) in the provided pointer, Returns NULL if a
18768 symbol could not be found. */
18770 static Elf_Internal_Sym
*
18771 get_symbol_for_build_attribute (Filedata
* filedata
,
18772 unsigned long offset
,
18773 bfd_boolean is_open_attr
,
18774 const char ** pname
)
18776 static Filedata
* saved_filedata
= NULL
;
18777 static char * strtab
;
18778 static unsigned long strtablen
;
18779 static Elf_Internal_Sym
* symtab
;
18780 static unsigned long nsyms
;
18781 Elf_Internal_Sym
* saved_sym
= NULL
;
18782 Elf_Internal_Sym
* sym
;
18784 if (filedata
->section_headers
!= NULL
18785 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
18787 Elf_Internal_Shdr
* symsec
;
18789 /* Load the symbol and string sections. */
18790 for (symsec
= filedata
->section_headers
;
18791 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18794 if (symsec
->sh_type
== SHT_SYMTAB
)
18796 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
18798 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18800 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
18802 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18803 1, strtab_sec
->sh_size
,
18804 _("string table"));
18805 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
18809 saved_filedata
= filedata
;
18812 if (symtab
== NULL
|| strtab
== NULL
)
18815 /* Find a symbol whose value matches offset. */
18816 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
18817 if (sym
->st_value
== offset
)
18819 if (sym
->st_name
>= strtablen
)
18820 /* Huh ? This should not happen. */
18823 if (strtab
[sym
->st_name
] == 0)
18826 /* The AArch64 and ARM architectures define mapping symbols
18827 (eg $d, $x, $t) which we want to ignore. */
18828 if (strtab
[sym
->st_name
] == '$'
18829 && strtab
[sym
->st_name
+ 1] != 0
18830 && strtab
[sym
->st_name
+ 2] == 0)
18835 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18836 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18837 FUNC symbols entirely. */
18838 switch (ELF_ST_TYPE (sym
->st_info
))
18845 /* If the symbol has a size associated
18846 with it then we can stop searching. */
18847 sym
= symtab
+ nsyms
;
18852 /* Ignore function symbols. */
18859 switch (ELF_ST_BIND (sym
->st_info
))
18862 if (saved_sym
== NULL
18863 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18868 if (saved_sym
== NULL
)
18878 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18886 if (saved_sym
&& pname
)
18887 * pname
= strtab
+ saved_sym
->st_name
;
18892 /* Returns true iff addr1 and addr2 are in the same section. */
18895 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18897 Elf_Internal_Shdr
* a1
;
18898 Elf_Internal_Shdr
* a2
;
18900 a1
= find_section_by_address (filedata
, addr1
);
18901 a2
= find_section_by_address (filedata
, addr2
);
18903 return a1
== a2
&& a1
!= NULL
;
18907 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18908 Filedata
* filedata
)
18910 static unsigned long global_offset
= 0;
18911 static unsigned long global_end
= 0;
18912 static unsigned long func_offset
= 0;
18913 static unsigned long func_end
= 0;
18915 Elf_Internal_Sym
* sym
;
18917 unsigned long start
;
18919 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18921 switch (pnote
->descsz
)
18924 /* A zero-length description means that the range of
18925 the previous note of the same type should be used. */
18928 if (global_end
> global_offset
)
18929 printf (_(" Applies to region from %#lx to %#lx\n"),
18930 global_offset
, global_end
);
18932 printf (_(" Applies to region from %#lx\n"), global_offset
);
18936 if (func_end
> func_offset
)
18937 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18939 printf (_(" Applies to region from %#lx\n"), func_offset
);
18944 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18951 /* FIXME: We should check that version 3+ notes are being used here... */
18952 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18953 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18957 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18963 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18964 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18968 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18969 printf (_(" <invalid descsz>"));
18974 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18975 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18976 in order to avoid them being confused with the start address of the
18977 first function in the file... */
18978 if (sym
== NULL
&& is_open_attr
)
18979 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18982 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18983 end
= start
+ sym
->st_size
;
18987 /* FIXME: Need to properly allow for section alignment.
18988 16 is just the alignment used on x86_64. */
18990 && start
> BFD_ALIGN (global_end
, 16)
18991 /* Build notes are not guaranteed to be organised in order of
18992 increasing address, but we should find the all of the notes
18993 for one section in the same place. */
18994 && same_section (filedata
, start
, global_end
))
18995 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18996 global_end
+ 1, start
- 1);
18998 printf (_(" Applies to region from %#lx"), start
);
18999 global_offset
= start
;
19003 printf (_(" to %#lx"), end
);
19009 printf (_(" Applies to region from %#lx"), start
);
19010 func_offset
= start
;
19014 printf (_(" to %#lx"), end
);
19020 printf (_(" (%s)"), name
);
19027 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19029 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19030 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19031 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19033 char name_attribute
;
19034 const char * expected_types
;
19035 const char * name
= pnote
->namedata
;
19039 if (name
== NULL
|| pnote
->namesz
< 2)
19041 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19042 print_symbol (-20, _(" <corrupt name>"));
19051 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19052 if (name
[0] == 'G' && name
[1] == 'A')
19054 if (pnote
->namesz
< 4)
19056 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19057 print_symbol (-20, _(" <corrupt name>"));
19066 switch ((name_type
= * name
))
19068 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19069 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19070 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19071 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19072 printf ("%c", * name
);
19076 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19077 print_symbol (-20, _("<unknown name type>"));
19084 switch ((name_attribute
= * name
))
19086 case GNU_BUILD_ATTRIBUTE_VERSION
:
19087 text
= _("<version>");
19088 expected_types
= string_expected
;
19091 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19092 text
= _("<stack prot>");
19093 expected_types
= "!+*";
19096 case GNU_BUILD_ATTRIBUTE_RELRO
:
19097 text
= _("<relro>");
19098 expected_types
= bool_expected
;
19101 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19102 text
= _("<stack size>");
19103 expected_types
= number_expected
;
19106 case GNU_BUILD_ATTRIBUTE_TOOL
:
19107 text
= _("<tool>");
19108 expected_types
= string_expected
;
19111 case GNU_BUILD_ATTRIBUTE_ABI
:
19113 expected_types
= "$*";
19116 case GNU_BUILD_ATTRIBUTE_PIC
:
19118 expected_types
= number_expected
;
19121 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19122 text
= _("<short enum>");
19123 expected_types
= bool_expected
;
19127 if (ISPRINT (* name
))
19129 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19131 if (len
> left
&& ! do_wide
)
19133 printf ("%.*s:", len
, name
);
19139 static char tmpbuf
[128];
19141 error (_("unrecognised byte in name field: %d\n"), * name
);
19142 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19146 expected_types
= "*$!+";
19151 left
-= printf ("%s", text
);
19153 if (strchr (expected_types
, name_type
) == NULL
)
19154 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19156 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19158 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19159 (unsigned long) pnote
->namesz
,
19160 (long) (name
- pnote
->namedata
));
19164 if (left
< 1 && ! do_wide
)
19169 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19171 unsigned int bytes
;
19172 unsigned long long val
= 0;
19173 unsigned int shift
= 0;
19174 char * decoded
= NULL
;
19176 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19178 /* The -1 is because the name field is always 0 terminated, and we
19179 want to be able to ensure that the shift in the while loop below
19180 will not overflow. */
19183 if (bytes
> sizeof (val
))
19185 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19187 bytes
= sizeof (val
);
19189 /* We do not bother to warn if bytes == 0 as this can
19190 happen with some early versions of the gcc plugin. */
19194 unsigned long byte
= (* name
++) & 0xff;
19196 val
|= byte
<< shift
;
19200 switch (name_attribute
)
19202 case GNU_BUILD_ATTRIBUTE_PIC
:
19205 case 0: decoded
= "static"; break;
19206 case 1: decoded
= "pic"; break;
19207 case 2: decoded
= "PIC"; break;
19208 case 3: decoded
= "pie"; break;
19209 case 4: decoded
= "PIE"; break;
19213 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19216 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19217 case 0: decoded
= "off"; break;
19218 case 1: decoded
= "on"; break;
19219 case 2: decoded
= "all"; break;
19220 case 3: decoded
= "strong"; break;
19221 case 4: decoded
= "explicit"; break;
19229 if (decoded
!= NULL
)
19231 print_symbol (-left
, decoded
);
19242 left
-= printf ("0x%llx", val
);
19244 left
-= printf ("0x%-.*llx", left
, val
);
19248 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19249 left
-= print_symbol (- left
, name
);
19251 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19252 left
-= print_symbol (- left
, "true");
19254 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19255 left
-= print_symbol (- left
, "false");
19259 if (do_wide
&& left
> 0)
19260 printf ("%-*s", left
, " ");
19265 /* Note that by the ELF standard, the name field is already null byte
19266 terminated, and namesz includes the terminating null byte.
19267 I.E. the value of namesz for the name "FSF" is 4.
19269 If the value of namesz is zero, there is no name present. */
19272 process_note (Elf_Internal_Note
* pnote
,
19273 Filedata
* filedata
)
19275 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19278 if (pnote
->namesz
== 0)
19279 /* If there is no note name, then use the default set of
19280 note type strings. */
19281 nt
= get_note_type (filedata
, pnote
->type
);
19283 else if (const_strneq (pnote
->namedata
, "GNU"))
19284 /* GNU-specific object file notes. */
19285 nt
= get_gnu_elf_note_type (pnote
->type
);
19287 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19288 /* FreeBSD-specific core file notes. */
19289 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19291 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19292 /* NetBSD-specific core file notes. */
19293 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19295 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19296 /* NetBSD-specific core file notes. */
19297 return process_netbsd_elf_note (pnote
);
19299 else if (const_strneq (pnote
->namedata
, "PaX"))
19300 /* NetBSD-specific core file notes. */
19301 return process_netbsd_elf_note (pnote
);
19303 else if (strneq (pnote
->namedata
, "SPU/", 4))
19305 /* SPU-specific core file notes. */
19306 nt
= pnote
->namedata
+ 4;
19310 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19311 /* VMS/ia64-specific file notes. */
19312 nt
= get_ia64_vms_note_type (pnote
->type
);
19314 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19315 nt
= get_stapsdt_note_type (pnote
->type
);
19318 /* Don't recognize this note name; just use the default set of
19319 note type strings. */
19320 nt
= get_note_type (filedata
, pnote
->type
);
19324 if (((const_strneq (pnote
->namedata
, "GA")
19325 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19326 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19327 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19328 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19329 print_gnu_build_attribute_name (pnote
);
19331 print_symbol (-20, name
);
19334 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19336 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19338 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19339 return print_ia64_vms_note (pnote
);
19340 else if (const_strneq (pnote
->namedata
, "GNU"))
19341 return print_gnu_note (filedata
, pnote
);
19342 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19343 return print_stapsdt_note (pnote
);
19344 else if (const_strneq (pnote
->namedata
, "CORE"))
19345 return print_core_note (pnote
);
19346 else if (((const_strneq (pnote
->namedata
, "GA")
19347 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19348 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19349 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19350 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19351 return print_gnu_build_attribute_description (pnote
, filedata
);
19357 printf (_(" description data: "));
19358 for (i
= 0; i
< pnote
->descsz
; i
++)
19359 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19371 process_notes_at (Filedata
* filedata
,
19372 Elf_Internal_Shdr
* section
,
19377 Elf_External_Note
* pnotes
;
19378 Elf_External_Note
* external
;
19380 bfd_boolean res
= TRUE
;
19387 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19390 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19395 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19398 if (pnotes
== NULL
)
19404 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19406 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19407 (unsigned long) offset
, (unsigned long) length
);
19409 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19410 specifies that notes should be aligned to 4 bytes in 32-bit
19411 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19412 we also support 4 byte alignment in 64-bit objects. If section
19413 alignment is less than 4, we treate alignment as 4 bytes. */
19416 else if (align
!= 4 && align
!= 8)
19418 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19424 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19426 end
= (char *) pnotes
+ length
;
19427 while ((char *) external
< end
)
19429 Elf_Internal_Note inote
;
19432 char * temp
= NULL
;
19433 size_t data_remaining
= end
- (char *) external
;
19435 if (!is_ia64_vms (filedata
))
19437 /* PR binutils/15191
19438 Make sure that there is enough data to read. */
19439 min_notesz
= offsetof (Elf_External_Note
, name
);
19440 if (data_remaining
< min_notesz
)
19442 warn (ngettext ("Corrupt note: only %ld byte remains, "
19443 "not enough for a full note\n",
19444 "Corrupt note: only %ld bytes remain, "
19445 "not enough for a full note\n",
19447 (long) data_remaining
);
19450 data_remaining
-= min_notesz
;
19452 inote
.type
= BYTE_GET (external
->type
);
19453 inote
.namesz
= BYTE_GET (external
->namesz
);
19454 inote
.namedata
= external
->name
;
19455 inote
.descsz
= BYTE_GET (external
->descsz
);
19456 inote
.descdata
= ((char *) external
19457 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19458 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19459 next
= ((char *) external
19460 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19464 Elf64_External_VMS_Note
*vms_external
;
19466 /* PR binutils/15191
19467 Make sure that there is enough data to read. */
19468 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19469 if (data_remaining
< min_notesz
)
19471 warn (ngettext ("Corrupt note: only %ld byte remains, "
19472 "not enough for a full note\n",
19473 "Corrupt note: only %ld bytes remain, "
19474 "not enough for a full note\n",
19476 (long) data_remaining
);
19479 data_remaining
-= min_notesz
;
19481 vms_external
= (Elf64_External_VMS_Note
*) external
;
19482 inote
.type
= BYTE_GET (vms_external
->type
);
19483 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19484 inote
.namedata
= vms_external
->name
;
19485 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19486 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19487 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19488 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19491 /* PR 17531: file: 3443835e. */
19492 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19493 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19494 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19495 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19496 || ((size_t) (next
- inote
.descdata
)
19497 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19499 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19500 (unsigned long) ((char *) external
- (char *) pnotes
));
19501 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19502 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19506 external
= (Elf_External_Note
*) next
;
19508 /* Verify that name is null terminated. It appears that at least
19509 one version of Linux (RedHat 6.0) generates corefiles that don't
19510 comply with the ELF spec by failing to include the null byte in
19512 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19514 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19516 temp
= (char *) malloc (inote
.namesz
+ 1);
19519 error (_("Out of memory allocating space for inote name\n"));
19524 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19525 inote
.namedata
= temp
;
19527 inote
.namedata
[inote
.namesz
] = 0;
19530 if (! process_note (& inote
, filedata
))
19546 process_corefile_note_segments (Filedata
* filedata
)
19548 Elf_Internal_Phdr
* segment
;
19550 bfd_boolean res
= TRUE
;
19552 if (! get_program_headers (filedata
))
19555 for (i
= 0, segment
= filedata
->program_headers
;
19556 i
< filedata
->file_header
.e_phnum
;
19559 if (segment
->p_type
== PT_NOTE
)
19560 if (! process_notes_at (filedata
, NULL
,
19561 (bfd_vma
) segment
->p_offset
,
19562 (bfd_vma
) segment
->p_filesz
,
19563 (bfd_vma
) segment
->p_align
))
19571 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19573 Elf_External_Note
* pnotes
;
19574 Elf_External_Note
* external
;
19576 bfd_boolean res
= TRUE
;
19581 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19583 if (pnotes
== NULL
)
19587 end
= (char*) pnotes
+ length
;
19589 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19590 (unsigned long) offset
, (unsigned long) length
);
19592 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19594 Elf_External_Note
* next
;
19595 Elf_Internal_Note inote
;
19597 inote
.type
= BYTE_GET (external
->type
);
19598 inote
.namesz
= BYTE_GET (external
->namesz
);
19599 inote
.namedata
= external
->name
;
19600 inote
.descsz
= BYTE_GET (external
->descsz
);
19601 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19602 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19604 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19606 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19607 inote
.descdata
= inote
.namedata
;
19611 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19613 if ( ((char *) next
> end
)
19614 || ((char *) next
< (char *) pnotes
))
19616 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19617 (unsigned long) ((char *) external
- (char *) pnotes
));
19618 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19619 inote
.type
, inote
.namesz
, inote
.descsz
);
19625 /* Prevent out-of-bounds indexing. */
19626 if ( inote
.namedata
+ inote
.namesz
> end
19627 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19629 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19630 (unsigned long) ((char *) external
- (char *) pnotes
));
19631 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19632 inote
.type
, inote
.namesz
, inote
.descsz
);
19636 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19638 if (! print_v850_note (& inote
))
19641 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19642 inote
.namesz
, inote
.descsz
);
19652 process_note_sections (Filedata
* filedata
)
19654 Elf_Internal_Shdr
* section
;
19656 unsigned int n
= 0;
19657 bfd_boolean res
= TRUE
;
19659 for (i
= 0, section
= filedata
->section_headers
;
19660 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19663 if (section
->sh_type
== SHT_NOTE
)
19665 if (! process_notes_at (filedata
, section
,
19666 (bfd_vma
) section
->sh_offset
,
19667 (bfd_vma
) section
->sh_size
,
19668 (bfd_vma
) section
->sh_addralign
))
19673 if (( filedata
->file_header
.e_machine
== EM_V800
19674 || filedata
->file_header
.e_machine
== EM_V850
19675 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19676 && section
->sh_type
== SHT_RENESAS_INFO
)
19678 if (! process_v850_notes (filedata
,
19679 (bfd_vma
) section
->sh_offset
,
19680 (bfd_vma
) section
->sh_size
))
19687 /* Try processing NOTE segments instead. */
19688 return process_corefile_note_segments (filedata
);
19694 process_notes (Filedata
* filedata
)
19696 /* If we have not been asked to display the notes then do nothing. */
19700 if (filedata
->file_header
.e_type
!= ET_CORE
)
19701 return process_note_sections (filedata
);
19703 /* No program headers means no NOTE segment. */
19704 if (filedata
->file_header
.e_phnum
> 0)
19705 return process_corefile_note_segments (filedata
);
19707 printf (_("No note segments present in the core file.\n"));
19711 static unsigned char *
19712 display_public_gnu_attributes (unsigned char * start
,
19713 const unsigned char * const end
)
19715 printf (_(" Unknown GNU attribute: %s\n"), start
);
19717 start
+= strnlen ((char *) start
, end
- start
);
19718 display_raw_attribute (start
, end
);
19720 return (unsigned char *) end
;
19723 static unsigned char *
19724 display_generic_attribute (unsigned char * start
,
19726 const unsigned char * const end
)
19729 return (unsigned char *) end
;
19731 return display_tag_value (tag
, start
, end
);
19735 process_arch_specific (Filedata
* filedata
)
19740 switch (filedata
->file_header
.e_machine
)
19743 case EM_ARC_COMPACT
:
19744 case EM_ARC_COMPACT2
:
19745 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19746 display_arc_attribute
,
19747 display_generic_attribute
);
19749 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19750 display_arm_attribute
,
19751 display_generic_attribute
);
19754 case EM_MIPS_RS3_LE
:
19755 return process_mips_specific (filedata
);
19758 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19759 display_msp430x_attribute
,
19760 display_msp430_gnu_attribute
);
19763 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19764 display_riscv_attribute
,
19765 display_generic_attribute
);
19768 return process_nds32_specific (filedata
);
19772 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19773 display_power_gnu_attribute
);
19777 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19778 display_s390_gnu_attribute
);
19781 case EM_SPARC32PLUS
:
19783 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19784 display_sparc_gnu_attribute
);
19787 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19788 display_tic6x_attribute
,
19789 display_generic_attribute
);
19792 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19793 display_public_gnu_attributes
,
19794 display_generic_attribute
);
19799 get_file_header (Filedata
* filedata
)
19801 /* Read in the identity array. */
19802 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19805 /* Determine how to read the rest of the header. */
19806 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19811 byte_get
= byte_get_little_endian
;
19812 byte_put
= byte_put_little_endian
;
19815 byte_get
= byte_get_big_endian
;
19816 byte_put
= byte_put_big_endian
;
19820 /* For now we only support 32 bit and 64 bit ELF files. */
19821 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19823 /* Read in the rest of the header. */
19826 Elf32_External_Ehdr ehdr32
;
19828 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19831 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19832 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19833 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19834 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19835 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19836 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19837 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19838 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19839 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19840 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19841 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19842 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19843 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19847 Elf64_External_Ehdr ehdr64
;
19849 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19850 we will not be able to cope with the 64bit data found in
19851 64 ELF files. Detect this now and abort before we start
19852 overwriting things. */
19853 if (sizeof (bfd_vma
) < 8)
19855 error (_("This instance of readelf has been built without support for a\n\
19856 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19860 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19863 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19864 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19865 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19866 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19867 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19868 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19869 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19870 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19871 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19872 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19873 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19874 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19875 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19878 if (filedata
->file_header
.e_shoff
)
19880 /* There may be some extensions in the first section header. Don't
19881 bomb if we can't read it. */
19883 get_32bit_section_headers (filedata
, TRUE
);
19885 get_64bit_section_headers (filedata
, TRUE
);
19892 close_file (Filedata
* filedata
)
19896 if (filedata
->handle
)
19897 fclose (filedata
->handle
);
19903 close_debug_file (void * data
)
19905 close_file ((Filedata
*) data
);
19909 open_file (const char * pathname
)
19911 struct stat statbuf
;
19912 Filedata
* filedata
= NULL
;
19914 if (stat (pathname
, & statbuf
) < 0
19915 || ! S_ISREG (statbuf
.st_mode
))
19918 filedata
= calloc (1, sizeof * filedata
);
19919 if (filedata
== NULL
)
19922 filedata
->handle
= fopen (pathname
, "rb");
19923 if (filedata
->handle
== NULL
)
19926 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19927 filedata
->file_name
= pathname
;
19929 if (! get_file_header (filedata
))
19932 if (filedata
->file_header
.e_shoff
)
19936 /* Read the section headers again, this time for real. */
19938 res
= get_32bit_section_headers (filedata
, FALSE
);
19940 res
= get_64bit_section_headers (filedata
, FALSE
);
19951 if (filedata
->handle
)
19952 fclose (filedata
->handle
);
19959 open_debug_file (const char * pathname
)
19961 return open_file (pathname
);
19964 /* Process one ELF object file according to the command line options.
19965 This file may actually be stored in an archive. The file is
19966 positioned at the start of the ELF object. Returns TRUE if no
19967 problems were encountered, FALSE otherwise. */
19970 process_object (Filedata
* filedata
)
19972 bfd_boolean have_separate_files
;
19974 bfd_boolean res
= TRUE
;
19976 if (! get_file_header (filedata
))
19978 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19982 /* Initialise per file variables. */
19983 for (i
= ARRAY_SIZE (version_info
); i
--;)
19984 version_info
[i
] = 0;
19986 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19987 dynamic_info
[i
] = 0;
19988 dynamic_info_DT_GNU_HASH
= 0;
19989 dynamic_info_DT_MIPS_XHASH
= 0;
19991 /* Process the file. */
19993 printf (_("\nFile: %s\n"), filedata
->file_name
);
19995 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19996 Note we do this even if cmdline_dump_sects is empty because we
19997 must make sure that the dump_sets array is zeroed out before each
19998 object file is processed. */
19999 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
20000 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
20002 if (cmdline
.num_dump_sects
> 0)
20004 if (filedata
->num_dump_sects
== 0)
20005 /* A sneaky way of allocating the dump_sects array. */
20006 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
20008 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
20009 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
20010 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
20013 if (! process_file_header (filedata
))
20016 if (! process_section_headers (filedata
))
20018 /* Without loaded section headers we cannot process lots of things. */
20019 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20021 if (! do_using_dynamic
)
20022 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20025 if (! process_section_groups (filedata
))
20026 /* Without loaded section groups we cannot process unwind. */
20029 if (process_program_headers (filedata
))
20030 process_dynamic_section (filedata
);
20034 if (! process_relocs (filedata
))
20037 if (! process_unwind (filedata
))
20040 if (! process_symbol_table (filedata
))
20043 if (! process_syminfo (filedata
))
20046 if (! process_version_sections (filedata
))
20049 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20050 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20052 have_separate_files
= FALSE
;
20054 if (! process_section_contents (filedata
))
20057 if (have_separate_files
)
20061 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20063 if (! process_section_headers (d
->handle
))
20065 else if (! process_section_contents (d
->handle
))
20069 /* The file handles are closed by the call to free_debug_memory() below. */
20072 if (! process_notes (filedata
))
20075 if (! process_gnu_liblist (filedata
))
20078 if (! process_arch_specific (filedata
))
20081 free (filedata
->program_headers
);
20082 filedata
->program_headers
= NULL
;
20084 free (filedata
->section_headers
);
20085 filedata
->section_headers
= NULL
;
20087 free (filedata
->string_table
);
20088 filedata
->string_table
= NULL
;
20089 filedata
->string_table_length
= 0;
20091 if (filedata
->dump_sects
!= NULL
)
20093 free (filedata
->dump_sects
);
20094 filedata
->dump_sects
= NULL
;
20095 filedata
->num_dump_sects
= 0;
20098 if (dynamic_strings
)
20100 free (dynamic_strings
);
20101 dynamic_strings
= NULL
;
20102 dynamic_strings_length
= 0;
20105 if (dynamic_symbols
)
20107 free (dynamic_symbols
);
20108 dynamic_symbols
= NULL
;
20109 num_dynamic_syms
= 0;
20112 if (dynamic_syminfo
)
20114 free (dynamic_syminfo
);
20115 dynamic_syminfo
= NULL
;
20118 if (dynamic_section
)
20120 free (dynamic_section
);
20121 dynamic_section
= NULL
;
20124 if (section_headers_groups
)
20126 free (section_headers_groups
);
20127 section_headers_groups
= NULL
;
20130 if (section_groups
)
20132 struct group_list
* g
;
20133 struct group_list
* next
;
20135 for (i
= 0; i
< group_count
; i
++)
20137 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
20144 free (section_groups
);
20145 section_groups
= NULL
;
20148 free_debug_memory ();
20153 /* Process an ELF archive.
20154 On entry the file is positioned just after the ARMAG string.
20155 Returns TRUE upon success, FALSE otherwise. */
20158 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20160 struct archive_info arch
;
20161 struct archive_info nested_arch
;
20163 bfd_boolean ret
= TRUE
;
20167 /* The ARCH structure is used to hold information about this archive. */
20168 arch
.file_name
= NULL
;
20170 arch
.index_array
= NULL
;
20171 arch
.sym_table
= NULL
;
20172 arch
.longnames
= NULL
;
20174 /* The NESTED_ARCH structure is used as a single-item cache of information
20175 about a nested archive (when members of a thin archive reside within
20176 another regular archive file). */
20177 nested_arch
.file_name
= NULL
;
20178 nested_arch
.file
= NULL
;
20179 nested_arch
.index_array
= NULL
;
20180 nested_arch
.sym_table
= NULL
;
20181 nested_arch
.longnames
= NULL
;
20183 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20184 is_thin_archive
, do_archive_index
) != 0)
20190 if (do_archive_index
)
20192 if (arch
.sym_table
== NULL
)
20193 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
20196 unsigned long i
, l
;
20197 unsigned long current_pos
;
20199 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20200 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
20202 current_pos
= ftell (filedata
->handle
);
20204 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20206 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
20208 char * member_name
;
20210 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
20212 if (member_name
!= NULL
)
20214 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
20216 if (qualified_name
!= NULL
)
20218 printf (_("Contents of binary %s at offset "), qualified_name
);
20219 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20221 free (qualified_name
);
20226 if (l
>= arch
.sym_size
)
20228 error (_("%s: end of the symbol table reached before the end of the index\n"),
20229 filedata
->file_name
);
20233 /* PR 17531: file: 0b6630b2. */
20234 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20235 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20238 if (arch
.uses_64bit_indices
)
20243 if (l
< arch
.sym_size
)
20245 error (ngettext ("%s: %ld byte remains in the symbol table, "
20246 "but without corresponding entries in "
20247 "the index table\n",
20248 "%s: %ld bytes remain in the symbol table, "
20249 "but without corresponding entries in "
20250 "the index table\n",
20251 arch
.sym_size
- l
),
20252 filedata
->file_name
, arch
.sym_size
- l
);
20256 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20258 error (_("%s: failed to seek back to start of object files in the archive\n"),
20259 filedata
->file_name
);
20265 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20266 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20267 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20268 && !do_section_groups
&& !do_dyn_syms
)
20270 ret
= TRUE
; /* Archive index only. */
20279 char * qualified_name
;
20281 /* Read the next archive header. */
20282 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20284 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
20287 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20288 if (got
!= sizeof arch
.arhdr
)
20292 /* PR 24049 - we cannot use filedata->file_name as this will
20293 have already been freed. */
20294 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20299 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20301 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
20306 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20308 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20309 if (archive_file_size
& 01)
20310 ++archive_file_size
;
20312 name
= get_archive_member_name (&arch
, &nested_arch
);
20315 error (_("%s: bad archive file name\n"), arch
.file_name
);
20319 namelen
= strlen (name
);
20321 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20322 if (qualified_name
== NULL
)
20324 error (_("%s: bad archive file name\n"), arch
.file_name
);
20329 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20331 /* This is a proxy for an external member of a thin archive. */
20332 Filedata
* member_filedata
;
20333 char * member_file_name
= adjust_relative_path
20334 (filedata
->file_name
, name
, namelen
);
20336 if (member_file_name
== NULL
)
20342 member_filedata
= open_file (member_file_name
);
20343 if (member_filedata
== NULL
)
20345 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20346 free (member_file_name
);
20351 archive_file_offset
= arch
.nested_member_origin
;
20352 member_filedata
->file_name
= qualified_name
;
20354 if (! process_object (member_filedata
))
20357 close_file (member_filedata
);
20358 free (member_file_name
);
20360 else if (is_thin_archive
)
20362 Filedata thin_filedata
;
20364 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20366 /* PR 15140: Allow for corrupt thin archives. */
20367 if (nested_arch
.file
== NULL
)
20369 error (_("%s: contains corrupt thin archive: %s\n"),
20370 qualified_name
, name
);
20375 /* This is a proxy for a member of a nested archive. */
20376 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20378 /* The nested archive file will have been opened and setup by
20379 get_archive_member_name. */
20380 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20382 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
20387 thin_filedata
.handle
= nested_arch
.file
;
20388 thin_filedata
.file_name
= qualified_name
;
20390 if (! process_object (& thin_filedata
))
20395 archive_file_offset
= arch
.next_arhdr_offset
;
20396 arch
.next_arhdr_offset
+= archive_file_size
;
20398 filedata
->file_name
= qualified_name
;
20399 if (! process_object (filedata
))
20403 free (qualified_name
);
20407 if (nested_arch
.file
!= NULL
)
20408 fclose (nested_arch
.file
);
20409 release_archive (&nested_arch
);
20410 release_archive (&arch
);
20416 process_file (char * file_name
)
20418 Filedata
* filedata
= NULL
;
20419 struct stat statbuf
;
20420 char armag
[SARMAG
];
20421 bfd_boolean ret
= TRUE
;
20423 if (stat (file_name
, &statbuf
) < 0)
20425 if (errno
== ENOENT
)
20426 error (_("'%s': No such file\n"), file_name
);
20428 error (_("Could not locate '%s'. System error message: %s\n"),
20429 file_name
, strerror (errno
));
20433 if (! S_ISREG (statbuf
.st_mode
))
20435 error (_("'%s' is not an ordinary file\n"), file_name
);
20439 filedata
= calloc (1, sizeof * filedata
);
20440 if (filedata
== NULL
)
20442 error (_("Out of memory allocating file data structure\n"));
20446 filedata
->file_name
= file_name
;
20447 filedata
->handle
= fopen (file_name
, "rb");
20448 if (filedata
->handle
== NULL
)
20450 error (_("Input file '%s' is not readable.\n"), file_name
);
20455 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20457 error (_("%s: Failed to read file's magic number\n"), file_name
);
20458 fclose (filedata
->handle
);
20463 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20465 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20467 if (! process_archive (filedata
, FALSE
))
20470 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20472 if ( ! process_archive (filedata
, TRUE
))
20477 if (do_archive_index
)
20478 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20481 rewind (filedata
->handle
);
20482 archive_file_size
= archive_file_offset
= 0;
20484 if (! process_object (filedata
))
20488 fclose (filedata
->handle
);
20494 #ifdef SUPPORT_DISASSEMBLY
20495 /* Needed by the i386 disassembler. For extra credit, someone could
20496 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20500 print_address (unsigned int addr
, FILE * outfile
)
20502 fprintf (outfile
,"0x%8.8x", addr
);
20505 /* Needed by the i386 disassembler. */
20508 db_task_printsym (unsigned int addr
)
20510 print_address (addr
, stderr
);
20515 main (int argc
, char ** argv
)
20519 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20520 setlocale (LC_MESSAGES
, "");
20522 #if defined (HAVE_SETLOCALE)
20523 setlocale (LC_CTYPE
, "");
20525 bindtextdomain (PACKAGE
, LOCALEDIR
);
20526 textdomain (PACKAGE
);
20528 expandargv (&argc
, &argv
);
20530 cmdline
.file_name
= "<cmdline>";
20531 parse_args (& cmdline
, argc
, argv
);
20533 if (optind
< (argc
- 1))
20535 else if (optind
>= argc
)
20537 warn (_("Nothing to do.\n"));
20542 while (optind
< argc
)
20543 if (! process_file (argv
[optind
++]))
20546 if (cmdline
.dump_sects
!= NULL
)
20547 free (cmdline
.dump_sects
);
20549 free (dump_ctf_symtab_name
);
20550 free (dump_ctf_strtab_name
);
20551 free (dump_ctf_parent_name
);
20553 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;