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
;
6079 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6080 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6084 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6086 if (size
< sizeof (* echdr
))
6088 error (_("Compressed section is too small even for a compression header\n"));
6092 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6093 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6094 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6095 return sizeof (*echdr
);
6099 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6101 if (size
< sizeof (* echdr
))
6103 error (_("Compressed section is too small even for a compression header\n"));
6107 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6108 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6109 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6110 return sizeof (*echdr
);
6115 process_section_headers (Filedata
* filedata
)
6117 Elf_Internal_Shdr
* section
;
6120 free (filedata
->section_headers
);
6121 filedata
->section_headers
= NULL
;
6123 if (filedata
->file_header
.e_shnum
== 0)
6125 /* PR binutils/12467. */
6126 if (filedata
->file_header
.e_shoff
!= 0)
6128 warn (_("possibly corrupt ELF file header - it has a non-zero"
6129 " section header offset, but no section headers\n"));
6132 else if (do_sections
)
6133 printf (_("\nThere are no sections in this file.\n"));
6138 if (do_sections
&& !do_header
)
6139 printf (ngettext ("There is %d section header, "
6140 "starting at offset 0x%lx:\n",
6141 "There are %d section headers, "
6142 "starting at offset 0x%lx:\n",
6143 filedata
->file_header
.e_shnum
),
6144 filedata
->file_header
.e_shnum
,
6145 (unsigned long) filedata
->file_header
.e_shoff
);
6149 if (! get_32bit_section_headers (filedata
, FALSE
))
6154 if (! get_64bit_section_headers (filedata
, FALSE
))
6158 /* Read in the string table, so that we have names to display. */
6159 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6160 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6162 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6164 if (section
->sh_size
!= 0)
6166 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6167 1, section
->sh_size
,
6170 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6174 /* Scan the sections for the dynamic symbol table
6175 and dynamic string table and debug sections. */
6176 free (dynamic_symbols
);
6177 dynamic_symbols
= NULL
;
6178 num_dynamic_syms
= 0;
6179 free (dynamic_strings
);
6180 dynamic_strings
= NULL
;
6181 dynamic_strings_length
= 0;
6182 free (dynamic_syminfo
);
6183 dynamic_syminfo
= NULL
;
6184 while (symtab_shndx_list
!= NULL
)
6186 elf_section_list
*next
= symtab_shndx_list
->next
;
6187 free (symtab_shndx_list
);
6188 symtab_shndx_list
= next
;
6191 eh_addr_size
= is_32bit_elf
? 4 : 8;
6192 switch (filedata
->file_header
.e_machine
)
6195 case EM_MIPS_RS3_LE
:
6196 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6197 FDE addresses. However, the ABI also has a semi-official ILP32
6198 variant for which the normal FDE address size rules apply.
6200 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6201 section, where XX is the size of longs in bits. Unfortunately,
6202 earlier compilers provided no way of distinguishing ILP32 objects
6203 from LP64 objects, so if there's any doubt, we should assume that
6204 the official LP64 form is being used. */
6205 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6206 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6212 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6214 case E_H8_MACH_H8300
:
6215 case E_H8_MACH_H8300HN
:
6216 case E_H8_MACH_H8300SN
:
6217 case E_H8_MACH_H8300SXN
:
6220 case E_H8_MACH_H8300H
:
6221 case E_H8_MACH_H8300S
:
6222 case E_H8_MACH_H8300SX
:
6230 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6232 case EF_M32C_CPU_M16C
:
6239 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6242 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6243 if (section->sh_entsize != expected_entsize) \
6246 sprintf_vma (buf, section->sh_entsize); \
6247 /* Note: coded this way so that there is a single string for \
6249 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6250 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6251 (unsigned) expected_entsize); \
6252 section->sh_entsize = expected_entsize; \
6257 #define CHECK_ENTSIZE(section, i, type) \
6258 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6259 sizeof (Elf64_External_##type))
6261 for (i
= 0, section
= filedata
->section_headers
;
6262 i
< filedata
->file_header
.e_shnum
;
6265 char * name
= SECTION_NAME (section
);
6267 if (section
->sh_type
== SHT_DYNSYM
)
6269 if (dynamic_symbols
!= NULL
)
6271 error (_("File contains multiple dynamic symbol tables\n"));
6275 CHECK_ENTSIZE (section
, i
, Sym
);
6276 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6278 else if (section
->sh_type
== SHT_STRTAB
6279 && streq (name
, ".dynstr"))
6281 if (dynamic_strings
!= NULL
)
6283 error (_("File contains multiple dynamic string tables\n"));
6287 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6288 1, section
->sh_size
,
6289 _("dynamic strings"));
6290 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6292 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6294 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6296 entry
->hdr
= section
;
6297 entry
->next
= symtab_shndx_list
;
6298 symtab_shndx_list
= entry
;
6300 else if (section
->sh_type
== SHT_SYMTAB
)
6301 CHECK_ENTSIZE (section
, i
, Sym
);
6302 else if (section
->sh_type
== SHT_GROUP
)
6303 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6304 else if (section
->sh_type
== SHT_REL
)
6305 CHECK_ENTSIZE (section
, i
, Rel
);
6306 else if (section
->sh_type
== SHT_RELA
)
6307 CHECK_ENTSIZE (section
, i
, Rela
);
6308 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6309 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6310 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6311 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6312 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6313 && (const_strneq (name
, ".debug_")
6314 || const_strneq (name
, ".zdebug_")))
6317 name
+= sizeof (".zdebug_") - 1;
6319 name
+= sizeof (".debug_") - 1;
6322 || (do_debug_info
&& const_strneq (name
, "info"))
6323 || (do_debug_info
&& const_strneq (name
, "types"))
6324 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6325 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6326 || (do_debug_lines
&& const_strneq (name
, "line."))
6327 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6328 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6329 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6330 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6331 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6332 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6333 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6334 || (do_debug_frames
&& const_strneq (name
, "frame"))
6335 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6336 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6337 || (do_debug_str
&& const_strneq (name
, "str"))
6338 || (do_debug_loc
&& const_strneq (name
, "loc"))
6339 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6340 || (do_debug_addr
&& const_strneq (name
, "addr"))
6341 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6342 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6344 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6346 /* Linkonce section to be combined with .debug_info at link time. */
6347 else if ((do_debugging
|| do_debug_info
)
6348 && const_strneq (name
, ".gnu.linkonce.wi."))
6349 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6350 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6351 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6352 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6353 || streq (name
, ".debug_names")))
6354 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6355 /* Trace sections for Itanium VMS. */
6356 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6357 || do_trace_aranges
)
6358 && const_strneq (name
, ".trace_"))
6360 name
+= sizeof (".trace_") - 1;
6363 || (do_trace_info
&& streq (name
, "info"))
6364 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6365 || (do_trace_aranges
&& streq (name
, "aranges"))
6367 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6369 else if ((do_debugging
|| do_debug_links
)
6370 && (const_strneq (name
, ".gnu_debuglink")
6371 || const_strneq (name
, ".gnu_debugaltlink")))
6372 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6378 if (filedata
->file_header
.e_shnum
> 1)
6379 printf (_("\nSection Headers:\n"));
6381 printf (_("\nSection Header:\n"));
6385 if (do_section_details
)
6387 printf (_(" [Nr] Name\n"));
6388 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6392 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6396 if (do_section_details
)
6398 printf (_(" [Nr] Name\n"));
6399 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6403 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6407 if (do_section_details
)
6409 printf (_(" [Nr] Name\n"));
6410 printf (_(" Type Address Offset Link\n"));
6411 printf (_(" Size EntSize Info Align\n"));
6415 printf (_(" [Nr] Name Type Address Offset\n"));
6416 printf (_(" Size EntSize Flags Link Info Align\n"));
6420 if (do_section_details
)
6421 printf (_(" Flags\n"));
6423 for (i
= 0, section
= filedata
->section_headers
;
6424 i
< filedata
->file_header
.e_shnum
;
6427 /* Run some sanity checks on the section header. */
6429 /* Check the sh_link field. */
6430 switch (section
->sh_type
)
6434 if (section
->sh_link
== 0
6435 && (filedata
->file_header
.e_type
== ET_EXEC
6436 || filedata
->file_header
.e_type
== ET_DYN
))
6437 /* A dynamic relocation section where all entries use a
6438 zero symbol index need not specify a symtab section. */
6441 case SHT_SYMTAB_SHNDX
:
6445 case SHT_GNU_versym
:
6446 if (section
->sh_link
== 0
6447 || section
->sh_link
>= filedata
->file_header
.e_shnum
6448 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6449 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6450 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6451 i
, section
->sh_link
);
6457 case SHT_GNU_verneed
:
6458 case SHT_GNU_verdef
:
6459 case SHT_GNU_LIBLIST
:
6460 if (section
->sh_link
== 0
6461 || section
->sh_link
>= filedata
->file_header
.e_shnum
6462 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6463 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6464 i
, section
->sh_link
);
6467 case SHT_INIT_ARRAY
:
6468 case SHT_FINI_ARRAY
:
6469 case SHT_PREINIT_ARRAY
:
6470 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6471 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6472 i
, section
->sh_link
);
6476 /* FIXME: Add support for target specific section types. */
6477 #if 0 /* Currently we do not check other section types as there are too
6478 many special cases. Stab sections for example have a type
6479 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6481 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6482 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6483 i
, section
->sh_link
);
6488 /* Check the sh_info field. */
6489 switch (section
->sh_type
)
6493 if (section
->sh_info
== 0
6494 && (filedata
->file_header
.e_type
== ET_EXEC
6495 || filedata
->file_header
.e_type
== ET_DYN
))
6496 /* Dynamic relocations apply to segments, so they do not
6497 need to specify the section they relocate. */
6499 if (section
->sh_info
== 0
6500 || section
->sh_info
>= filedata
->file_header
.e_shnum
6501 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6502 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6503 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6504 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6505 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6506 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6507 /* FIXME: Are other section types valid ? */
6508 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6509 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6510 i
, section
->sh_info
);
6515 case SHT_SYMTAB_SHNDX
:
6516 case SHT_INIT_ARRAY
:
6517 case SHT_FINI_ARRAY
:
6518 case SHT_PREINIT_ARRAY
:
6519 if (section
->sh_info
!= 0)
6520 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6521 i
, section
->sh_info
);
6527 /* A symbol index - we assume that it is valid. */
6531 /* FIXME: Add support for target specific section types. */
6532 if (section
->sh_type
== SHT_NOBITS
)
6533 /* NOBITS section headers with non-zero sh_info fields can be
6534 created when a binary is stripped of everything but its debug
6535 information. The stripped sections have their headers
6536 preserved but their types set to SHT_NOBITS. So do not check
6537 this type of section. */
6539 else if (section
->sh_flags
& SHF_INFO_LINK
)
6541 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6542 warn (_("[%2u]: Expected link to another section in info field"), i
);
6544 else if (section
->sh_type
< SHT_LOOS
6545 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6546 && section
->sh_info
!= 0)
6547 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6548 i
, section
->sh_info
);
6552 /* Check the sh_size field. */
6553 if (section
->sh_size
> filedata
->file_size
6554 && section
->sh_type
!= SHT_NOBITS
6555 && section
->sh_type
!= SHT_NULL
6556 && section
->sh_type
< SHT_LOOS
)
6557 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6559 printf (" [%2u] ", i
);
6560 if (do_section_details
)
6561 printf ("%s\n ", printable_section_name (filedata
, section
));
6563 print_symbol (-17, SECTION_NAME (section
));
6565 printf (do_wide
? " %-15s " : " %-15.15s ",
6566 get_section_type_name (filedata
, section
->sh_type
));
6570 const char * link_too_big
= NULL
;
6572 print_vma (section
->sh_addr
, LONG_HEX
);
6574 printf ( " %6.6lx %6.6lx %2.2lx",
6575 (unsigned long) section
->sh_offset
,
6576 (unsigned long) section
->sh_size
,
6577 (unsigned long) section
->sh_entsize
);
6579 if (do_section_details
)
6580 fputs (" ", stdout
);
6582 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6584 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6587 /* The sh_link value is out of range. Normally this indicates
6588 an error but it can have special values in Solaris binaries. */
6589 switch (filedata
->file_header
.e_machine
)
6596 case EM_OLD_SPARCV9
:
6597 case EM_SPARC32PLUS
:
6600 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6601 link_too_big
= "BEFORE";
6602 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6603 link_too_big
= "AFTER";
6610 if (do_section_details
)
6612 if (link_too_big
!= NULL
&& * link_too_big
)
6613 printf ("<%s> ", link_too_big
);
6615 printf ("%2u ", section
->sh_link
);
6616 printf ("%3u %2lu\n", section
->sh_info
,
6617 (unsigned long) section
->sh_addralign
);
6620 printf ("%2u %3u %2lu\n",
6623 (unsigned long) section
->sh_addralign
);
6625 if (link_too_big
&& ! * link_too_big
)
6626 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6627 i
, section
->sh_link
);
6631 print_vma (section
->sh_addr
, LONG_HEX
);
6633 if ((long) section
->sh_offset
== section
->sh_offset
)
6634 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6638 print_vma (section
->sh_offset
, LONG_HEX
);
6641 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6642 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6646 print_vma (section
->sh_size
, LONG_HEX
);
6649 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6650 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6654 print_vma (section
->sh_entsize
, LONG_HEX
);
6657 if (do_section_details
)
6658 fputs (" ", stdout
);
6660 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6662 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6664 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6665 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6668 print_vma (section
->sh_addralign
, DEC
);
6672 else if (do_section_details
)
6675 print_vma (section
->sh_addr
, LONG_HEX
);
6676 if ((long) section
->sh_offset
== section
->sh_offset
)
6677 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6681 print_vma (section
->sh_offset
, LONG_HEX
);
6683 printf (" %u\n ", section
->sh_link
);
6684 print_vma (section
->sh_size
, LONG_HEX
);
6686 print_vma (section
->sh_entsize
, LONG_HEX
);
6688 printf (" %-16u %lu\n",
6690 (unsigned long) section
->sh_addralign
);
6695 print_vma (section
->sh_addr
, LONG_HEX
);
6696 if ((long) section
->sh_offset
== section
->sh_offset
)
6697 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6701 print_vma (section
->sh_offset
, LONG_HEX
);
6704 print_vma (section
->sh_size
, LONG_HEX
);
6706 print_vma (section
->sh_entsize
, LONG_HEX
);
6708 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6710 printf (" %2u %3u %lu\n",
6713 (unsigned long) section
->sh_addralign
);
6716 if (do_section_details
)
6718 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6719 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6721 /* Minimum section size is 12 bytes for 32-bit compression
6722 header + 12 bytes for compressed data header. */
6723 unsigned char buf
[24];
6725 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6726 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6727 sizeof (buf
), _("compression header")))
6729 Elf_Internal_Chdr chdr
;
6731 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6732 printf (_(" [<corrupt>]\n"));
6735 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6738 printf (_(" [<unknown>: 0x%x], "),
6740 print_vma (chdr
.ch_size
, LONG_HEX
);
6741 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6748 if (!do_section_details
)
6750 /* The ordering of the letters shown here matches the ordering of the
6751 corresponding SHF_xxx values, and hence the order in which these
6752 letters will be displayed to the user. */
6753 printf (_("Key to Flags:\n\
6754 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6755 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6756 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6757 if (filedata
->file_header
.e_machine
== EM_X86_64
6758 || filedata
->file_header
.e_machine
== EM_L1OM
6759 || filedata
->file_header
.e_machine
== EM_K1OM
)
6760 printf (_("l (large), "));
6761 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6762 printf (_("y (purecode), "));
6763 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6764 printf (_("v (VLE), "));
6765 printf ("p (processor specific)\n");
6772 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
6773 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
6774 char **strtab
, unsigned long *strtablen
)
6778 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
6780 if (*symtab
== NULL
)
6783 if (symsec
->sh_link
!= 0)
6785 Elf_Internal_Shdr
*strsec
;
6787 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
6789 error (_("Bad sh_link in symbol table section\n"));
6796 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
6798 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
6799 1, strsec
->sh_size
, _("string table"));
6800 if (*strtab
== NULL
)
6807 *strtablen
= strsec
->sh_size
;
6813 get_group_flags (unsigned int flags
)
6815 static char buff
[128];
6819 else if (flags
== GRP_COMDAT
)
6822 snprintf (buff
, 14, _("[0x%x: "), flags
);
6824 flags
&= ~ GRP_COMDAT
;
6825 if (flags
& GRP_MASKOS
)
6827 strcat (buff
, "<OS specific>");
6828 flags
&= ~ GRP_MASKOS
;
6831 if (flags
& GRP_MASKPROC
)
6833 strcat (buff
, "<PROC specific>");
6834 flags
&= ~ GRP_MASKPROC
;
6838 strcat (buff
, "<unknown>");
6845 process_section_groups (Filedata
* filedata
)
6847 Elf_Internal_Shdr
* section
;
6849 struct group
* group
;
6850 Elf_Internal_Shdr
* symtab_sec
;
6851 Elf_Internal_Shdr
* strtab_sec
;
6852 Elf_Internal_Sym
* symtab
;
6853 unsigned long num_syms
;
6857 /* Don't process section groups unless needed. */
6858 if (!do_unwind
&& !do_section_groups
)
6861 if (filedata
->file_header
.e_shnum
== 0)
6863 if (do_section_groups
)
6864 printf (_("\nThere are no sections to group in this file.\n"));
6869 if (filedata
->section_headers
== NULL
)
6871 error (_("Section headers are not available!\n"));
6872 /* PR 13622: This can happen with a corrupt ELF header. */
6876 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6877 sizeof (struct group
*));
6879 if (section_headers_groups
== NULL
)
6881 error (_("Out of memory reading %u section group headers\n"),
6882 filedata
->file_header
.e_shnum
);
6886 /* Scan the sections for the group section. */
6888 for (i
= 0, section
= filedata
->section_headers
;
6889 i
< filedata
->file_header
.e_shnum
;
6891 if (section
->sh_type
== SHT_GROUP
)
6894 if (group_count
== 0)
6896 if (do_section_groups
)
6897 printf (_("\nThere are no section groups in this file.\n"));
6902 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6904 if (section_groups
== NULL
)
6906 error (_("Out of memory reading %lu groups\n"),
6907 (unsigned long) group_count
);
6917 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6918 i
< filedata
->file_header
.e_shnum
;
6921 if (section
->sh_type
== SHT_GROUP
)
6923 const char * name
= printable_section_name (filedata
, section
);
6924 const char * group_name
;
6925 unsigned char * start
;
6926 unsigned char * indices
;
6927 unsigned int entry
, j
, size
;
6928 Elf_Internal_Shdr
* sec
;
6929 Elf_Internal_Sym
* sym
;
6931 /* Get the symbol table. */
6932 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6933 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6936 error (_("Bad sh_link in group section `%s'\n"), name
);
6940 if (symtab_sec
!= sec
)
6945 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6950 error (_("Corrupt header in group section `%s'\n"), name
);
6954 if (section
->sh_info
>= num_syms
)
6956 error (_("Bad sh_info in group section `%s'\n"), name
);
6960 sym
= symtab
+ section
->sh_info
;
6962 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6964 if (sym
->st_shndx
== 0
6965 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6967 error (_("Bad sh_info in group section `%s'\n"), name
);
6971 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6980 /* Get the string table. */
6981 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6990 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6996 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6997 1, strtab_sec
->sh_size
,
6999 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7001 group_name
= sym
->st_name
< strtab_size
7002 ? strtab
+ sym
->st_name
: _("<corrupt>");
7005 /* PR 17531: file: loop. */
7006 if (section
->sh_entsize
> section
->sh_size
)
7008 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7009 printable_section_name (filedata
, section
),
7010 (unsigned long) section
->sh_entsize
,
7011 (unsigned long) section
->sh_size
);
7015 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7016 1, section
->sh_size
,
7022 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7023 entry
= byte_get (indices
, 4);
7026 if (do_section_groups
)
7028 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7029 get_group_flags (entry
), i
, name
, group_name
, size
);
7031 printf (_(" [Index] Name\n"));
7034 group
->group_index
= i
;
7036 for (j
= 0; j
< size
; j
++)
7038 struct group_list
* g
;
7040 entry
= byte_get (indices
, 4);
7043 if (entry
>= filedata
->file_header
.e_shnum
)
7045 static unsigned num_group_errors
= 0;
7047 if (num_group_errors
++ < 10)
7049 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7050 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7051 if (num_group_errors
== 10)
7052 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7057 if (section_headers_groups
[entry
] != NULL
)
7061 static unsigned num_errs
= 0;
7063 if (num_errs
++ < 10)
7065 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7067 section_headers_groups
[entry
]->group_index
);
7069 warn (_("Further error messages about already contained group sections suppressed\n"));
7075 /* Intel C/C++ compiler may put section 0 in a
7076 section group. We just warn it the first time
7077 and ignore it afterwards. */
7078 static bfd_boolean warned
= FALSE
;
7081 error (_("section 0 in group section [%5u]\n"),
7082 section_headers_groups
[entry
]->group_index
);
7088 section_headers_groups
[entry
] = group
;
7090 if (do_section_groups
)
7092 sec
= filedata
->section_headers
+ entry
;
7093 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7096 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7097 g
->section_index
= entry
;
7098 g
->next
= group
->root
;
7116 /* Data used to display dynamic fixups. */
7118 struct ia64_vms_dynfixup
7120 bfd_vma needed_ident
; /* Library ident number. */
7121 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7122 bfd_vma fixup_needed
; /* Index of the library. */
7123 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7124 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7127 /* Data used to display dynamic relocations. */
7129 struct ia64_vms_dynimgrela
7131 bfd_vma img_rela_cnt
; /* Number of relocations. */
7132 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7135 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7139 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7140 struct ia64_vms_dynfixup
* fixup
,
7141 const char * strtab
,
7142 unsigned int strtab_sz
)
7144 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7146 const char * lib_name
;
7148 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7149 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7150 _("dynamic section image fixups"));
7154 if (fixup
->needed
< strtab_sz
)
7155 lib_name
= strtab
+ fixup
->needed
;
7158 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7159 (unsigned long) fixup
->needed
);
7163 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7164 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7166 (_("Seg Offset Type SymVec DataType\n"));
7168 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7173 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7174 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7175 type
= BYTE_GET (imfs
[i
].type
);
7176 rtype
= elf_ia64_reloc_type (type
);
7178 printf (" 0x%08x ", type
);
7180 printf (" %-32s ", rtype
);
7181 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7182 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7189 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7192 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7194 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7197 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7198 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7199 _("dynamic section image relocations"));
7203 printf (_("\nImage relocs\n"));
7205 (_("Seg Offset Type Addend Seg Sym Off\n"));
7207 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7212 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7213 printf ("%08" BFD_VMA_FMT
"x ",
7214 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7215 type
= BYTE_GET (imrs
[i
].type
);
7216 rtype
= elf_ia64_reloc_type (type
);
7218 printf ("0x%08x ", type
);
7220 printf ("%-31s ", rtype
);
7221 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7222 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7223 printf ("%08" BFD_VMA_FMT
"x\n",
7224 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7231 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7234 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7236 struct ia64_vms_dynfixup fixup
;
7237 struct ia64_vms_dynimgrela imgrela
;
7238 Elf_Internal_Dyn
*entry
;
7239 bfd_vma strtab_off
= 0;
7240 bfd_vma strtab_sz
= 0;
7241 char *strtab
= NULL
;
7242 bfd_boolean res
= TRUE
;
7244 memset (&fixup
, 0, sizeof (fixup
));
7245 memset (&imgrela
, 0, sizeof (imgrela
));
7247 /* Note: the order of the entries is specified by the OpenVMS specs. */
7248 for (entry
= dynamic_section
;
7249 entry
< dynamic_section
+ dynamic_nent
;
7252 switch (entry
->d_tag
)
7254 case DT_IA_64_VMS_STRTAB_OFFSET
:
7255 strtab_off
= entry
->d_un
.d_val
;
7258 strtab_sz
= entry
->d_un
.d_val
;
7260 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7261 1, strtab_sz
, _("dynamic string section"));
7266 case DT_IA_64_VMS_NEEDED_IDENT
:
7267 fixup
.needed_ident
= entry
->d_un
.d_val
;
7270 fixup
.needed
= entry
->d_un
.d_val
;
7272 case DT_IA_64_VMS_FIXUP_NEEDED
:
7273 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7275 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7276 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7278 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7279 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7280 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7283 case DT_IA_64_VMS_IMG_RELA_CNT
:
7284 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7286 case DT_IA_64_VMS_IMG_RELA_OFF
:
7287 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7288 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7310 dynamic_relocations
[] =
7312 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7313 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7314 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7317 /* Process the reloc section. */
7320 process_relocs (Filedata
* filedata
)
7322 unsigned long rel_size
;
7323 unsigned long rel_offset
;
7328 if (do_using_dynamic
)
7332 bfd_boolean has_dynamic_reloc
;
7335 has_dynamic_reloc
= FALSE
;
7337 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7339 is_rela
= dynamic_relocations
[i
].rela
;
7340 name
= dynamic_relocations
[i
].name
;
7341 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7342 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7345 has_dynamic_reloc
= TRUE
;
7347 if (is_rela
== UNKNOWN
)
7349 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7350 switch (dynamic_info
[DT_PLTREL
])
7364 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7365 name
, rel_offset
, rel_size
);
7367 dump_relocations (filedata
,
7368 offset_from_vma (filedata
, rel_offset
, rel_size
),
7370 dynamic_symbols
, num_dynamic_syms
,
7371 dynamic_strings
, dynamic_strings_length
,
7372 is_rela
, TRUE
/* is_dynamic */);
7376 if (is_ia64_vms (filedata
))
7377 if (process_ia64_vms_dynamic_relocs (filedata
))
7378 has_dynamic_reloc
= TRUE
;
7380 if (! has_dynamic_reloc
)
7381 printf (_("\nThere are no dynamic relocations in this file.\n"));
7385 Elf_Internal_Shdr
* section
;
7387 bfd_boolean found
= FALSE
;
7389 for (i
= 0, section
= filedata
->section_headers
;
7390 i
< filedata
->file_header
.e_shnum
;
7393 if ( section
->sh_type
!= SHT_RELA
7394 && section
->sh_type
!= SHT_REL
)
7397 rel_offset
= section
->sh_offset
;
7398 rel_size
= section
->sh_size
;
7403 unsigned long num_rela
;
7405 printf (_("\nRelocation section "));
7407 if (filedata
->string_table
== NULL
)
7408 printf ("%d", section
->sh_name
);
7410 printf ("'%s'", printable_section_name (filedata
, section
));
7412 num_rela
= rel_size
/ section
->sh_entsize
;
7413 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7414 " at offset 0x%lx contains %lu entries:\n",
7416 rel_offset
, num_rela
);
7418 is_rela
= section
->sh_type
== SHT_RELA
;
7420 if (section
->sh_link
!= 0
7421 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7423 Elf_Internal_Shdr
* symsec
;
7424 Elf_Internal_Sym
* symtab
;
7425 unsigned long nsyms
;
7426 unsigned long strtablen
= 0;
7427 char * strtab
= NULL
;
7429 symsec
= filedata
->section_headers
+ section
->sh_link
;
7430 if (symsec
->sh_type
!= SHT_SYMTAB
7431 && symsec
->sh_type
!= SHT_DYNSYM
)
7434 if (!get_symtab (filedata
, symsec
,
7435 &symtab
, &nsyms
, &strtab
, &strtablen
))
7438 dump_relocations (filedata
, rel_offset
, rel_size
,
7439 symtab
, nsyms
, strtab
, strtablen
,
7441 symsec
->sh_type
== SHT_DYNSYM
);
7447 dump_relocations (filedata
, rel_offset
, rel_size
,
7448 NULL
, 0, NULL
, 0, is_rela
,
7449 FALSE
/* is_dynamic */);
7457 /* Users sometimes forget the -D option, so try to be helpful. */
7458 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7460 if (dynamic_info
[dynamic_relocations
[i
].size
])
7462 printf (_("\nThere are no static relocations in this file."));
7463 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7468 if (i
== ARRAY_SIZE (dynamic_relocations
))
7469 printf (_("\nThere are no relocations in this file.\n"));
7476 /* An absolute address consists of a section and an offset. If the
7477 section is NULL, the offset itself is the address, otherwise, the
7478 address equals to LOAD_ADDRESS(section) + offset. */
7482 unsigned short section
;
7486 /* Find the nearest symbol at or below ADDR. Returns the symbol
7487 name, if found, and the offset from the symbol to ADDR. */
7490 find_symbol_for_address (Filedata
* filedata
,
7491 Elf_Internal_Sym
* symtab
,
7492 unsigned long nsyms
,
7493 const char * strtab
,
7494 unsigned long strtab_size
,
7495 struct absaddr addr
,
7496 const char ** symname
,
7499 bfd_vma dist
= 0x100000;
7500 Elf_Internal_Sym
* sym
;
7501 Elf_Internal_Sym
* beg
;
7502 Elf_Internal_Sym
* end
;
7503 Elf_Internal_Sym
* best
= NULL
;
7505 REMOVE_ARCH_BITS (addr
.offset
);
7507 end
= symtab
+ nsyms
;
7513 sym
= beg
+ (end
- beg
) / 2;
7515 value
= sym
->st_value
;
7516 REMOVE_ARCH_BITS (value
);
7518 if (sym
->st_name
!= 0
7519 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7520 && addr
.offset
>= value
7521 && addr
.offset
- value
< dist
)
7524 dist
= addr
.offset
- value
;
7529 if (addr
.offset
< value
)
7537 *symname
= (best
->st_name
>= strtab_size
7538 ? _("<corrupt>") : strtab
+ best
->st_name
);
7544 *offset
= addr
.offset
;
7547 static /* signed */ int
7548 symcmp (const void *p
, const void *q
)
7550 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7551 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7553 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7556 /* Process the unwind section. */
7558 #include "unwind-ia64.h"
7560 struct ia64_unw_table_entry
7562 struct absaddr start
;
7564 struct absaddr info
;
7567 struct ia64_unw_aux_info
7569 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7570 unsigned long table_len
; /* Length of unwind table. */
7571 unsigned char * info
; /* Unwind info. */
7572 unsigned long info_size
; /* Size of unwind info. */
7573 bfd_vma info_addr
; /* Starting address of unwind info. */
7574 bfd_vma seg_base
; /* Starting address of segment. */
7575 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7576 unsigned long nsyms
; /* Number of symbols. */
7577 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7578 unsigned long nfuns
; /* Number of entries in funtab. */
7579 char * strtab
; /* The string table. */
7580 unsigned long strtab_size
; /* Size of string table. */
7584 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7586 struct ia64_unw_table_entry
* tp
;
7587 unsigned long j
, nfuns
;
7589 bfd_boolean res
= TRUE
;
7591 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7592 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7593 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7594 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7596 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7598 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7602 const unsigned char * dp
;
7603 const unsigned char * head
;
7604 const unsigned char * end
;
7605 const char * procname
;
7607 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7608 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7610 fputs ("\n<", stdout
);
7614 fputs (procname
, stdout
);
7617 printf ("+%lx", (unsigned long) offset
);
7620 fputs (">: [", stdout
);
7621 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7622 fputc ('-', stdout
);
7623 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7624 printf ("], info at +0x%lx\n",
7625 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7627 /* PR 17531: file: 86232b32. */
7628 if (aux
->info
== NULL
)
7631 offset
= tp
->info
.offset
;
7632 if (tp
->info
.section
)
7634 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7636 warn (_("Invalid section %u in table entry %ld\n"),
7637 tp
->info
.section
, (long) (tp
- aux
->table
));
7641 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7643 offset
-= aux
->info_addr
;
7644 /* PR 17531: file: 0997b4d1. */
7645 if (offset
>= aux
->info_size
7646 || aux
->info_size
- offset
< 8)
7648 warn (_("Invalid offset %lx in table entry %ld\n"),
7649 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7654 head
= aux
->info
+ offset
;
7655 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7657 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7658 (unsigned) UNW_VER (stamp
),
7659 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7660 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7661 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7662 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7664 if (UNW_VER (stamp
) != 1)
7666 printf (_("\tUnknown version.\n"));
7671 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7672 /* PR 17531: file: 16ceda89. */
7673 if (end
> aux
->info
+ aux
->info_size
)
7674 end
= aux
->info
+ aux
->info_size
;
7675 for (dp
= head
+ 8; dp
< end
;)
7676 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7685 slurp_ia64_unwind_table (Filedata
* filedata
,
7686 struct ia64_unw_aux_info
* aux
,
7687 Elf_Internal_Shdr
* sec
)
7689 unsigned long size
, nrelas
, i
;
7690 Elf_Internal_Phdr
* seg
;
7691 struct ia64_unw_table_entry
* tep
;
7692 Elf_Internal_Shdr
* relsec
;
7693 Elf_Internal_Rela
* rela
;
7694 Elf_Internal_Rela
* rp
;
7695 unsigned char * table
;
7697 Elf_Internal_Sym
* sym
;
7698 const char * relname
;
7702 /* First, find the starting address of the segment that includes
7705 if (filedata
->file_header
.e_phnum
)
7707 if (! get_program_headers (filedata
))
7710 for (seg
= filedata
->program_headers
;
7711 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7714 if (seg
->p_type
!= PT_LOAD
)
7717 if (sec
->sh_addr
>= seg
->p_vaddr
7718 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7720 aux
->seg_base
= seg
->p_vaddr
;
7726 /* Second, build the unwind table from the contents of the unwind section: */
7727 size
= sec
->sh_size
;
7728 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7733 aux
->table_len
= size
/ (3 * eh_addr_size
);
7734 aux
->table
= (struct ia64_unw_table_entry
*)
7735 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7738 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7740 tep
->start
.section
= SHN_UNDEF
;
7741 tep
->end
.section
= SHN_UNDEF
;
7742 tep
->info
.section
= SHN_UNDEF
;
7743 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7744 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7745 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7746 tep
->start
.offset
+= aux
->seg_base
;
7747 tep
->end
.offset
+= aux
->seg_base
;
7748 tep
->info
.offset
+= aux
->seg_base
;
7752 /* Third, apply any relocations to the unwind table: */
7753 for (relsec
= filedata
->section_headers
;
7754 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7757 if (relsec
->sh_type
!= SHT_RELA
7758 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7759 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7762 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7771 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7773 unsigned int sym_ndx
;
7774 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7775 relname
= elf_ia64_reloc_type (r_type
);
7777 /* PR 17531: file: 9fa67536. */
7778 if (relname
== NULL
)
7780 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7784 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7786 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7790 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7792 /* PR 17531: file: 5bc8d9bf. */
7793 if (i
>= aux
->table_len
)
7795 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7799 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7800 if (sym_ndx
>= aux
->nsyms
)
7802 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7806 sym
= aux
->symtab
+ sym_ndx
;
7808 switch (rp
->r_offset
/ eh_addr_size
% 3)
7811 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7812 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7815 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7816 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7819 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7820 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7834 ia64_process_unwind (Filedata
* filedata
)
7836 Elf_Internal_Shdr
* sec
;
7837 Elf_Internal_Shdr
* unwsec
= NULL
;
7838 unsigned long i
, unwcount
= 0, unwstart
= 0;
7839 struct ia64_unw_aux_info aux
;
7840 bfd_boolean res
= TRUE
;
7842 memset (& aux
, 0, sizeof (aux
));
7844 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7846 if (sec
->sh_type
== SHT_SYMTAB
)
7850 error (_("Multiple symbol tables encountered\n"));
7856 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
7857 &aux
.strtab
, &aux
.strtab_size
))
7860 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7865 printf (_("\nThere are no unwind sections in this file.\n"));
7867 while (unwcount
-- > 0)
7872 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7873 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7874 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7879 /* We have already counted the number of SHT_IA64_UNWIND
7880 sections so the loop above should never fail. */
7881 assert (unwsec
!= NULL
);
7884 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7886 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7888 /* We need to find which section group it is in. */
7889 struct group_list
* g
;
7891 if (section_headers_groups
== NULL
7892 || section_headers_groups
[i
] == NULL
)
7893 i
= filedata
->file_header
.e_shnum
;
7896 g
= section_headers_groups
[i
]->root
;
7898 for (; g
!= NULL
; g
= g
->next
)
7900 sec
= filedata
->section_headers
+ g
->section_index
;
7902 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7907 i
= filedata
->file_header
.e_shnum
;
7910 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7912 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7913 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7914 suffix
= SECTION_NAME (unwsec
) + len
;
7915 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7917 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7918 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7923 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7924 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7925 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7926 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7928 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7929 suffix
= SECTION_NAME (unwsec
) + len
;
7930 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7932 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7933 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7937 if (i
== filedata
->file_header
.e_shnum
)
7939 printf (_("\nCould not find unwind info section for "));
7941 if (filedata
->string_table
== NULL
)
7942 printf ("%d", unwsec
->sh_name
);
7944 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7948 aux
.info_addr
= sec
->sh_addr
;
7949 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7952 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7954 printf (_("\nUnwind section "));
7956 if (filedata
->string_table
== NULL
)
7957 printf ("%d", unwsec
->sh_name
);
7959 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7961 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7962 (unsigned long) unwsec
->sh_offset
,
7963 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7965 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7966 && aux
.table_len
> 0)
7967 dump_ia64_unwind (filedata
, & aux
);
7970 free ((char *) aux
.table
);
7972 free ((char *) aux
.info
);
7981 free ((char *) aux
.strtab
);
7986 struct hppa_unw_table_entry
7988 struct absaddr start
;
7990 unsigned int Cannot_unwind
:1; /* 0 */
7991 unsigned int Millicode
:1; /* 1 */
7992 unsigned int Millicode_save_sr0
:1; /* 2 */
7993 unsigned int Region_description
:2; /* 3..4 */
7994 unsigned int reserved1
:1; /* 5 */
7995 unsigned int Entry_SR
:1; /* 6 */
7996 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7997 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7998 unsigned int Args_stored
:1; /* 16 */
7999 unsigned int Variable_Frame
:1; /* 17 */
8000 unsigned int Separate_Package_Body
:1; /* 18 */
8001 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8002 unsigned int Stack_Overflow_Check
:1; /* 20 */
8003 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8004 unsigned int Ada_Region
:1; /* 22 */
8005 unsigned int cxx_info
:1; /* 23 */
8006 unsigned int cxx_try_catch
:1; /* 24 */
8007 unsigned int sched_entry_seq
:1; /* 25 */
8008 unsigned int reserved2
:1; /* 26 */
8009 unsigned int Save_SP
:1; /* 27 */
8010 unsigned int Save_RP
:1; /* 28 */
8011 unsigned int Save_MRP_in_frame
:1; /* 29 */
8012 unsigned int extn_ptr_defined
:1; /* 30 */
8013 unsigned int Cleanup_defined
:1; /* 31 */
8015 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8016 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8017 unsigned int Large_frame
:1; /* 2 */
8018 unsigned int Pseudo_SP_Set
:1; /* 3 */
8019 unsigned int reserved4
:1; /* 4 */
8020 unsigned int Total_frame_size
:27; /* 5..31 */
8023 struct hppa_unw_aux_info
8025 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8026 unsigned long table_len
; /* Length of unwind table. */
8027 bfd_vma seg_base
; /* Starting address of segment. */
8028 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8029 unsigned long nsyms
; /* Number of symbols. */
8030 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8031 unsigned long nfuns
; /* Number of entries in funtab. */
8032 char * strtab
; /* The string table. */
8033 unsigned long strtab_size
; /* Size of string table. */
8037 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8039 struct hppa_unw_table_entry
* tp
;
8040 unsigned long j
, nfuns
;
8041 bfd_boolean res
= TRUE
;
8043 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8044 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8045 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8046 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8048 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8050 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8053 const char * procname
;
8055 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8056 aux
->strtab_size
, tp
->start
, &procname
,
8059 fputs ("\n<", stdout
);
8063 fputs (procname
, stdout
);
8066 printf ("+%lx", (unsigned long) offset
);
8069 fputs (">: [", stdout
);
8070 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8071 fputc ('-', stdout
);
8072 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8075 #define PF(_m) if (tp->_m) printf (#_m " ");
8076 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8079 PF(Millicode_save_sr0
);
8080 /* PV(Region_description); */
8086 PF(Separate_Package_Body
);
8087 PF(Frame_Extension_Millicode
);
8088 PF(Stack_Overflow_Check
);
8089 PF(Two_Instruction_SP_Increment
);
8093 PF(sched_entry_seq
);
8096 PF(Save_MRP_in_frame
);
8097 PF(extn_ptr_defined
);
8098 PF(Cleanup_defined
);
8099 PF(MPE_XL_interrupt_marker
);
8100 PF(HP_UX_interrupt_marker
);
8103 PV(Total_frame_size
);
8116 slurp_hppa_unwind_table (Filedata
* filedata
,
8117 struct hppa_unw_aux_info
* aux
,
8118 Elf_Internal_Shdr
* sec
)
8120 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8121 Elf_Internal_Phdr
* seg
;
8122 struct hppa_unw_table_entry
* tep
;
8123 Elf_Internal_Shdr
* relsec
;
8124 Elf_Internal_Rela
* rela
;
8125 Elf_Internal_Rela
* rp
;
8126 unsigned char * table
;
8128 Elf_Internal_Sym
* sym
;
8129 const char * relname
;
8131 /* First, find the starting address of the segment that includes
8133 if (filedata
->file_header
.e_phnum
)
8135 if (! get_program_headers (filedata
))
8138 for (seg
= filedata
->program_headers
;
8139 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8142 if (seg
->p_type
!= PT_LOAD
)
8145 if (sec
->sh_addr
>= seg
->p_vaddr
8146 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8148 aux
->seg_base
= seg
->p_vaddr
;
8154 /* Second, build the unwind table from the contents of the unwind
8156 size
= sec
->sh_size
;
8157 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8163 nentries
= size
/ unw_ent_size
;
8164 size
= unw_ent_size
* nentries
;
8166 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8167 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8169 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8171 unsigned int tmp1
, tmp2
;
8173 tep
->start
.section
= SHN_UNDEF
;
8174 tep
->end
.section
= SHN_UNDEF
;
8176 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8177 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8178 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8179 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8181 tep
->start
.offset
+= aux
->seg_base
;
8182 tep
->end
.offset
+= aux
->seg_base
;
8184 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8185 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8186 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8187 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8188 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8189 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8190 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8191 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8192 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8193 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8194 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8195 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8196 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8197 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8198 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8199 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8200 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8201 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8202 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8203 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8204 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8205 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8206 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8207 tep
->Cleanup_defined
= tmp1
& 0x1;
8209 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8210 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8211 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8212 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8213 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8214 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8218 /* Third, apply any relocations to the unwind table. */
8219 for (relsec
= filedata
->section_headers
;
8220 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8223 if (relsec
->sh_type
!= SHT_RELA
8224 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8225 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8228 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8232 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8234 unsigned int sym_ndx
;
8235 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8236 relname
= elf_hppa_reloc_type (r_type
);
8238 if (relname
== NULL
)
8240 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8244 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8245 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8247 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8251 i
= rp
->r_offset
/ unw_ent_size
;
8252 if (i
>= aux
->table_len
)
8254 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8258 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8259 if (sym_ndx
>= aux
->nsyms
)
8261 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8265 sym
= aux
->symtab
+ sym_ndx
;
8267 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8270 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8271 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8274 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8275 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8285 aux
->table_len
= nentries
;
8291 hppa_process_unwind (Filedata
* filedata
)
8293 struct hppa_unw_aux_info aux
;
8294 Elf_Internal_Shdr
* unwsec
= NULL
;
8295 Elf_Internal_Shdr
* sec
;
8297 bfd_boolean res
= TRUE
;
8299 if (filedata
->string_table
== NULL
)
8302 memset (& aux
, 0, sizeof (aux
));
8304 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8306 if (sec
->sh_type
== SHT_SYMTAB
)
8310 error (_("Multiple symbol tables encountered\n"));
8316 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8317 &aux
.strtab
, &aux
.strtab_size
))
8320 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8325 printf (_("\nThere are no unwind sections in this file.\n"));
8327 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8329 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8331 unsigned long num_unwind
= sec
->sh_size
/ 16;
8333 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8334 "contains %lu entry:\n",
8335 "\nUnwind section '%s' at offset 0x%lx "
8336 "contains %lu entries:\n",
8338 printable_section_name (filedata
, sec
),
8339 (unsigned long) sec
->sh_offset
,
8342 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8345 if (res
&& aux
.table_len
> 0)
8347 if (! dump_hppa_unwind (filedata
, &aux
))
8352 free ((char *) aux
.table
);
8360 free ((char *) aux
.strtab
);
8367 unsigned char * data
; /* The unwind data. */
8368 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8369 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8370 unsigned long nrelas
; /* The number of relocations. */
8371 unsigned int rel_type
; /* REL or RELA ? */
8372 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8375 struct arm_unw_aux_info
8377 Filedata
* filedata
; /* The file containing the unwind sections. */
8378 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8379 unsigned long nsyms
; /* Number of symbols. */
8380 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8381 unsigned long nfuns
; /* Number of these symbols. */
8382 char * strtab
; /* The file's string table. */
8383 unsigned long strtab_size
; /* Size of string table. */
8387 arm_print_vma_and_name (Filedata
* filedata
,
8388 struct arm_unw_aux_info
* aux
,
8390 struct absaddr addr
)
8392 const char *procname
;
8395 if (addr
.section
== SHN_UNDEF
)
8398 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8399 aux
->strtab_size
, addr
, &procname
,
8402 print_vma (fn
, PREFIX_HEX
);
8406 fputs (" <", stdout
);
8407 fputs (procname
, stdout
);
8410 printf ("+0x%lx", (unsigned long) sym_offset
);
8411 fputc ('>', stdout
);
8418 arm_free_section (struct arm_section
*arm_sec
)
8420 if (arm_sec
->data
!= NULL
)
8421 free (arm_sec
->data
);
8423 if (arm_sec
->rela
!= NULL
)
8424 free (arm_sec
->rela
);
8427 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8428 cached section and install SEC instead.
8429 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8430 and return its valued in * WORDP, relocating if necessary.
8431 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8432 relocation's offset in ADDR.
8433 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8434 into the string table of the symbol associated with the reloc. If no
8435 reloc was applied store -1 there.
8436 5) Return TRUE upon success, FALSE otherwise. */
8439 get_unwind_section_word (Filedata
* filedata
,
8440 struct arm_unw_aux_info
* aux
,
8441 struct arm_section
* arm_sec
,
8442 Elf_Internal_Shdr
* sec
,
8443 bfd_vma word_offset
,
8444 unsigned int * wordp
,
8445 struct absaddr
* addr
,
8448 Elf_Internal_Rela
*rp
;
8449 Elf_Internal_Sym
*sym
;
8450 const char * relname
;
8452 bfd_boolean wrapped
;
8454 if (sec
== NULL
|| arm_sec
== NULL
)
8457 addr
->section
= SHN_UNDEF
;
8460 if (sym_name
!= NULL
)
8461 *sym_name
= (bfd_vma
) -1;
8463 /* If necessary, update the section cache. */
8464 if (sec
!= arm_sec
->sec
)
8466 Elf_Internal_Shdr
*relsec
;
8468 arm_free_section (arm_sec
);
8471 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8472 sec
->sh_size
, _("unwind data"));
8473 arm_sec
->rela
= NULL
;
8474 arm_sec
->nrelas
= 0;
8476 for (relsec
= filedata
->section_headers
;
8477 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8480 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8481 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8482 /* PR 15745: Check the section type as well. */
8483 || (relsec
->sh_type
!= SHT_REL
8484 && relsec
->sh_type
!= SHT_RELA
))
8487 arm_sec
->rel_type
= relsec
->sh_type
;
8488 if (relsec
->sh_type
== SHT_REL
)
8490 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8492 & arm_sec
->rela
, & arm_sec
->nrelas
))
8495 else /* relsec->sh_type == SHT_RELA */
8497 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8499 & arm_sec
->rela
, & arm_sec
->nrelas
))
8505 arm_sec
->next_rela
= arm_sec
->rela
;
8508 /* If there is no unwind data we can do nothing. */
8509 if (arm_sec
->data
== NULL
)
8512 /* If the offset is invalid then fail. */
8513 if (/* PR 21343 *//* PR 18879 */
8515 || word_offset
> (sec
->sh_size
- 4)
8516 || ((bfd_signed_vma
) word_offset
) < 0)
8519 /* Get the word at the required offset. */
8520 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8522 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8523 if (arm_sec
->rela
== NULL
)
8529 /* Look through the relocs to find the one that applies to the provided offset. */
8531 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8533 bfd_vma prelval
, offset
;
8535 if (rp
->r_offset
> word_offset
&& !wrapped
)
8540 if (rp
->r_offset
> word_offset
)
8543 if (rp
->r_offset
& 3)
8545 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8546 (unsigned long) rp
->r_offset
);
8550 if (rp
->r_offset
< word_offset
)
8553 /* PR 17531: file: 027-161405-0.004 */
8554 if (aux
->symtab
== NULL
)
8557 if (arm_sec
->rel_type
== SHT_REL
)
8559 offset
= word
& 0x7fffffff;
8560 if (offset
& 0x40000000)
8561 offset
|= ~ (bfd_vma
) 0x7fffffff;
8563 else if (arm_sec
->rel_type
== SHT_RELA
)
8564 offset
= rp
->r_addend
;
8567 error (_("Unknown section relocation type %d encountered\n"),
8572 /* PR 17531 file: 027-1241568-0.004. */
8573 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8575 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8576 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8580 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8581 offset
+= sym
->st_value
;
8582 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8584 /* Check that we are processing the expected reloc type. */
8585 if (filedata
->file_header
.e_machine
== EM_ARM
)
8587 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8588 if (relname
== NULL
)
8590 warn (_("Skipping unknown ARM relocation type: %d\n"),
8591 (int) ELF32_R_TYPE (rp
->r_info
));
8595 if (streq (relname
, "R_ARM_NONE"))
8598 if (! streq (relname
, "R_ARM_PREL31"))
8600 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8604 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8606 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8607 if (relname
== NULL
)
8609 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8610 (int) ELF32_R_TYPE (rp
->r_info
));
8614 if (streq (relname
, "R_C6000_NONE"))
8617 if (! streq (relname
, "R_C6000_PREL31"))
8619 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8627 /* This function currently only supports ARM and TI unwinders. */
8628 warn (_("Only TI and ARM unwinders are currently supported\n"));
8632 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8633 addr
->section
= sym
->st_shndx
;
8634 addr
->offset
= offset
;
8637 * sym_name
= sym
->st_name
;
8642 arm_sec
->next_rela
= rp
;
8647 static const char *tic6x_unwind_regnames
[16] =
8649 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8650 "A14", "A13", "A12", "A11", "A10",
8651 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8655 decode_tic6x_unwind_regmask (unsigned int mask
)
8659 for (i
= 12; mask
; mask
>>= 1, i
--)
8663 fputs (tic6x_unwind_regnames
[i
], stdout
);
8665 fputs (", ", stdout
);
8671 if (remaining == 0 && more_words) \
8674 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8675 data_offset, & word, & addr, NULL)) \
8681 #define GET_OP(OP) \
8686 (OP) = word >> 24; \
8691 printf (_("[Truncated opcode]\n")); \
8694 printf ("0x%02x ", OP)
8697 decode_arm_unwind_bytecode (Filedata
* filedata
,
8698 struct arm_unw_aux_info
* aux
,
8700 unsigned int remaining
,
8701 unsigned int more_words
,
8702 bfd_vma data_offset
,
8703 Elf_Internal_Shdr
* data_sec
,
8704 struct arm_section
* data_arm_sec
)
8706 struct absaddr addr
;
8707 bfd_boolean res
= TRUE
;
8709 /* Decode the unwinding instructions. */
8712 unsigned int op
, op2
;
8721 printf (" 0x%02x ", op
);
8723 if ((op
& 0xc0) == 0x00)
8725 int offset
= ((op
& 0x3f) << 2) + 4;
8727 printf (" vsp = vsp + %d", offset
);
8729 else if ((op
& 0xc0) == 0x40)
8731 int offset
= ((op
& 0x3f) << 2) + 4;
8733 printf (" vsp = vsp - %d", offset
);
8735 else if ((op
& 0xf0) == 0x80)
8738 if (op
== 0x80 && op2
== 0)
8739 printf (_("Refuse to unwind"));
8742 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8743 bfd_boolean first
= TRUE
;
8747 for (i
= 0; i
< 12; i
++)
8748 if (mask
& (1 << i
))
8754 printf ("r%d", 4 + i
);
8759 else if ((op
& 0xf0) == 0x90)
8761 if (op
== 0x9d || op
== 0x9f)
8762 printf (_(" [Reserved]"));
8764 printf (" vsp = r%d", op
& 0x0f);
8766 else if ((op
& 0xf0) == 0xa0)
8768 int end
= 4 + (op
& 0x07);
8769 bfd_boolean first
= TRUE
;
8773 for (i
= 4; i
<= end
; i
++)
8789 else if (op
== 0xb0)
8790 printf (_(" finish"));
8791 else if (op
== 0xb1)
8794 if (op2
== 0 || (op2
& 0xf0) != 0)
8795 printf (_("[Spare]"));
8798 unsigned int mask
= op2
& 0x0f;
8799 bfd_boolean first
= TRUE
;
8803 for (i
= 0; i
< 12; i
++)
8804 if (mask
& (1 << i
))
8815 else if (op
== 0xb2)
8817 unsigned char buf
[9];
8818 unsigned int i
, len
;
8819 unsigned long offset
;
8821 for (i
= 0; i
< sizeof (buf
); i
++)
8824 if ((buf
[i
] & 0x80) == 0)
8827 if (i
== sizeof (buf
))
8829 error (_("corrupt change to vsp\n"));
8834 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8835 assert (len
== i
+ 1);
8836 offset
= offset
* 4 + 0x204;
8837 printf ("vsp = vsp + %ld", offset
);
8840 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8842 unsigned int first
, last
;
8849 printf ("pop {D%d", first
);
8851 printf ("-D%d", first
+ last
);
8854 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8856 unsigned int count
= op
& 0x07;
8860 printf ("-D%d", 8 + count
);
8863 else if (op
>= 0xc0 && op
<= 0xc5)
8865 unsigned int count
= op
& 0x07;
8867 printf (" pop {wR10");
8869 printf ("-wR%d", 10 + count
);
8872 else if (op
== 0xc6)
8874 unsigned int first
, last
;
8879 printf ("pop {wR%d", first
);
8881 printf ("-wR%d", first
+ last
);
8884 else if (op
== 0xc7)
8887 if (op2
== 0 || (op2
& 0xf0) != 0)
8888 printf (_("[Spare]"));
8891 unsigned int mask
= op2
& 0x0f;
8892 bfd_boolean first
= TRUE
;
8896 for (i
= 0; i
< 4; i
++)
8897 if (mask
& (1 << i
))
8903 printf ("wCGR%d", i
);
8910 printf (_(" [unsupported opcode]"));
8921 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8922 struct arm_unw_aux_info
* aux
,
8924 unsigned int remaining
,
8925 unsigned int more_words
,
8926 bfd_vma data_offset
,
8927 Elf_Internal_Shdr
* data_sec
,
8928 struct arm_section
* data_arm_sec
)
8930 struct absaddr addr
;
8932 /* Decode the unwinding instructions. */
8935 unsigned int op
, op2
;
8944 printf (" 0x%02x ", op
);
8946 if ((op
& 0xc0) == 0x00)
8948 int offset
= ((op
& 0x3f) << 3) + 8;
8949 printf (" sp = sp + %d", offset
);
8951 else if ((op
& 0xc0) == 0x80)
8954 if (op
== 0x80 && op2
== 0)
8955 printf (_("Refuse to unwind"));
8958 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8960 printf ("pop compact {");
8964 decode_tic6x_unwind_regmask (mask
);
8968 else if ((op
& 0xf0) == 0xc0)
8976 unsigned int offset
;
8980 /* Scan entire instruction first so that GET_OP output is not
8981 interleaved with disassembly. */
8983 for (i
= 0; nregs
< (op
& 0xf); i
++)
8989 regpos
[nregs
].offset
= i
* 2;
8990 regpos
[nregs
].reg
= reg
;
8997 regpos
[nregs
].offset
= i
* 2 + 1;
8998 regpos
[nregs
].reg
= reg
;
9003 printf (_("pop frame {"));
9006 printf (_("*corrupt* - no registers specified"));
9011 for (i
= i
* 2; i
> 0; i
--)
9013 if (regpos
[reg
].offset
== i
- 1)
9015 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9022 fputs (name
, stdout
);
9030 else if (op
== 0xd0)
9031 printf (" MOV FP, SP");
9032 else if (op
== 0xd1)
9033 printf (" __c6xabi_pop_rts");
9034 else if (op
== 0xd2)
9036 unsigned char buf
[9];
9037 unsigned int i
, len
;
9038 unsigned long offset
;
9040 for (i
= 0; i
< sizeof (buf
); i
++)
9043 if ((buf
[i
] & 0x80) == 0)
9046 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9047 if (i
== sizeof (buf
))
9049 warn (_("Corrupt stack pointer adjustment detected\n"));
9053 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9054 assert (len
== i
+ 1);
9055 offset
= offset
* 8 + 0x408;
9056 printf (_("sp = sp + %ld"), offset
);
9058 else if ((op
& 0xf0) == 0xe0)
9060 if ((op
& 0x0f) == 7)
9063 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9067 printf (_(" [unsupported opcode]"));
9076 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9080 offset
= word
& 0x7fffffff;
9081 if (offset
& 0x40000000)
9082 offset
|= ~ (bfd_vma
) 0x7fffffff;
9084 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9087 return offset
+ where
;
9091 decode_arm_unwind (Filedata
* filedata
,
9092 struct arm_unw_aux_info
* aux
,
9094 unsigned int remaining
,
9095 bfd_vma data_offset
,
9096 Elf_Internal_Shdr
* data_sec
,
9097 struct arm_section
* data_arm_sec
)
9100 unsigned int more_words
= 0;
9101 struct absaddr addr
;
9102 bfd_vma sym_name
= (bfd_vma
) -1;
9103 bfd_boolean res
= TRUE
;
9107 /* Fetch the first word.
9108 Note - when decoding an object file the address extracted
9109 here will always be 0. So we also pass in the sym_name
9110 parameter so that we can find the symbol associated with
9111 the personality routine. */
9112 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9113 & word
, & addr
, & sym_name
))
9120 addr
.section
= SHN_UNDEF
;
9124 if ((word
& 0x80000000) == 0)
9126 /* Expand prel31 for personality routine. */
9128 const char *procname
;
9130 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9131 printf (_(" Personality routine: "));
9133 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9134 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9136 procname
= aux
->strtab
+ sym_name
;
9137 print_vma (fn
, PREFIX_HEX
);
9140 fputs (" <", stdout
);
9141 fputs (procname
, stdout
);
9142 fputc ('>', stdout
);
9146 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9147 fputc ('\n', stdout
);
9149 /* The GCC personality routines use the standard compact
9150 encoding, starting with one byte giving the number of
9152 if (procname
!= NULL
9153 && (const_strneq (procname
, "__gcc_personality_v0")
9154 || const_strneq (procname
, "__gxx_personality_v0")
9155 || const_strneq (procname
, "__gcj_personality_v0")
9156 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9163 printf (_(" [Truncated data]\n"));
9166 more_words
= word
>> 24;
9176 /* ARM EHABI Section 6.3:
9178 An exception-handling table entry for the compact model looks like:
9182 1 0 index Data for personalityRoutine[index] */
9184 if (filedata
->file_header
.e_machine
== EM_ARM
9185 && (word
& 0x70000000))
9187 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9191 per_index
= (word
>> 24) & 0x7f;
9192 printf (_(" Compact model index: %d\n"), per_index
);
9199 else if (per_index
< 3)
9201 more_words
= (word
>> 16) & 0xff;
9207 switch (filedata
->file_header
.e_machine
)
9212 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9213 data_offset
, data_sec
, data_arm_sec
))
9218 warn (_("Unknown ARM compact model index encountered\n"));
9219 printf (_(" [reserved]\n"));
9227 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9228 data_offset
, data_sec
, data_arm_sec
))
9231 else if (per_index
< 5)
9233 if (((word
>> 17) & 0x7f) == 0x7f)
9234 printf (_(" Restore stack from frame pointer\n"));
9236 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9237 printf (_(" Registers restored: "));
9239 printf (" (compact) ");
9240 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9242 printf (_(" Return register: %s\n"),
9243 tic6x_unwind_regnames
[word
& 0xf]);
9246 printf (_(" [reserved (%d)]\n"), per_index
);
9250 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9251 filedata
->file_header
.e_machine
);
9255 /* Decode the descriptors. Not implemented. */
9261 dump_arm_unwind (Filedata
* filedata
,
9262 struct arm_unw_aux_info
* aux
,
9263 Elf_Internal_Shdr
* exidx_sec
)
9265 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9266 unsigned int i
, exidx_len
;
9267 unsigned long j
, nfuns
;
9268 bfd_boolean res
= TRUE
;
9270 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9271 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9272 exidx_len
= exidx_sec
->sh_size
/ 8;
9274 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9275 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9276 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9277 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9279 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9281 for (i
= 0; i
< exidx_len
; i
++)
9283 unsigned int exidx_fn
, exidx_entry
;
9284 struct absaddr fn_addr
, entry_addr
;
9287 fputc ('\n', stdout
);
9289 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9290 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9291 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9292 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9295 arm_free_section (& exidx_arm_sec
);
9296 arm_free_section (& extab_arm_sec
);
9300 /* ARM EHABI, Section 5:
9301 An index table entry consists of 2 words.
9302 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9303 if (exidx_fn
& 0x80000000)
9305 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9309 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9311 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9312 fputs (": ", stdout
);
9314 if (exidx_entry
== 1)
9316 print_vma (exidx_entry
, PREFIX_HEX
);
9317 fputs (" [cantunwind]\n", stdout
);
9319 else if (exidx_entry
& 0x80000000)
9321 print_vma (exidx_entry
, PREFIX_HEX
);
9322 fputc ('\n', stdout
);
9323 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9327 bfd_vma table
, table_offset
= 0;
9328 Elf_Internal_Shdr
*table_sec
;
9330 fputs ("@", stdout
);
9331 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9332 print_vma (table
, PREFIX_HEX
);
9335 /* Locate the matching .ARM.extab. */
9336 if (entry_addr
.section
!= SHN_UNDEF
9337 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9339 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9340 table_offset
= entry_addr
.offset
;
9342 if (table_offset
> table_sec
->sh_size
9343 || ((bfd_signed_vma
) table_offset
) < 0)
9345 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9346 (unsigned long) table_offset
,
9347 printable_section_name (filedata
, table_sec
));
9354 table_sec
= find_section_by_address (filedata
, table
);
9355 if (table_sec
!= NULL
)
9356 table_offset
= table
- table_sec
->sh_addr
;
9359 if (table_sec
== NULL
)
9361 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9362 (unsigned long) table
);
9367 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9376 arm_free_section (&exidx_arm_sec
);
9377 arm_free_section (&extab_arm_sec
);
9382 /* Used for both ARM and C6X unwinding tables. */
9385 arm_process_unwind (Filedata
* filedata
)
9387 struct arm_unw_aux_info aux
;
9388 Elf_Internal_Shdr
*unwsec
= NULL
;
9389 Elf_Internal_Shdr
*sec
;
9391 unsigned int sec_type
;
9392 bfd_boolean res
= TRUE
;
9394 switch (filedata
->file_header
.e_machine
)
9397 sec_type
= SHT_ARM_EXIDX
;
9401 sec_type
= SHT_C6000_UNWIND
;
9405 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9406 filedata
->file_header
.e_machine
);
9410 if (filedata
->string_table
== NULL
)
9413 memset (& aux
, 0, sizeof (aux
));
9414 aux
.filedata
= filedata
;
9416 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9418 if (sec
->sh_type
== SHT_SYMTAB
)
9422 error (_("Multiple symbol tables encountered\n"));
9428 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9429 &aux
.strtab
, &aux
.strtab_size
))
9432 else if (sec
->sh_type
== sec_type
)
9437 printf (_("\nThere are no unwind sections in this file.\n"));
9439 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9441 if (sec
->sh_type
== sec_type
)
9443 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9444 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9445 "contains %lu entry:\n",
9446 "\nUnwind section '%s' at offset 0x%lx "
9447 "contains %lu entries:\n",
9449 printable_section_name (filedata
, sec
),
9450 (unsigned long) sec
->sh_offset
,
9453 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9461 free ((char *) aux
.strtab
);
9467 process_unwind (Filedata
* filedata
)
9469 struct unwind_handler
9471 unsigned int machtype
;
9472 bfd_boolean (* handler
)(Filedata
*);
9475 { EM_ARM
, arm_process_unwind
},
9476 { EM_IA_64
, ia64_process_unwind
},
9477 { EM_PARISC
, hppa_process_unwind
},
9478 { EM_TI_C6000
, arm_process_unwind
},
9486 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9487 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9488 return handlers
[i
].handler (filedata
);
9490 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9491 get_machine_name (filedata
->file_header
.e_machine
));
9496 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9498 switch (entry
->d_tag
)
9500 case DT_AARCH64_BTI_PLT
:
9501 case DT_AARCH64_PAC_PLT
:
9504 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9511 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9513 switch (entry
->d_tag
)
9516 if (entry
->d_un
.d_val
== 0)
9520 static const char * opts
[] =
9522 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9523 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9524 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9525 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9529 bfd_boolean first
= TRUE
;
9531 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9532 if (entry
->d_un
.d_val
& (1 << cnt
))
9534 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9540 case DT_MIPS_IVERSION
:
9541 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9542 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9546 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9547 /* Note: coded this way so that there is a single string for translation. */
9548 printf (_("<corrupt: %s>"), buf
);
9552 case DT_MIPS_TIME_STAMP
:
9556 time_t atime
= entry
->d_un
.d_val
;
9558 tmp
= gmtime (&atime
);
9559 /* PR 17531: file: 6accc532. */
9561 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9563 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9564 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9565 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9566 printf (_("Time Stamp: %s"), timebuf
);
9570 case DT_MIPS_RLD_VERSION
:
9571 case DT_MIPS_LOCAL_GOTNO
:
9572 case DT_MIPS_CONFLICTNO
:
9573 case DT_MIPS_LIBLISTNO
:
9574 case DT_MIPS_SYMTABNO
:
9575 case DT_MIPS_UNREFEXTNO
:
9576 case DT_MIPS_HIPAGENO
:
9577 case DT_MIPS_DELTA_CLASS_NO
:
9578 case DT_MIPS_DELTA_INSTANCE_NO
:
9579 case DT_MIPS_DELTA_RELOC_NO
:
9580 case DT_MIPS_DELTA_SYM_NO
:
9581 case DT_MIPS_DELTA_CLASSSYM_NO
:
9582 case DT_MIPS_COMPACT_SIZE
:
9583 print_vma (entry
->d_un
.d_val
, DEC
);
9587 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9588 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9589 /* Falls through. */
9592 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9598 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9600 switch (entry
->d_tag
)
9602 case DT_HP_DLD_FLAGS
:
9611 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9612 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9613 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9614 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9615 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9616 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9617 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9618 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9619 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9620 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9621 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9622 { DT_HP_GST
, "HP_GST" },
9623 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9624 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9625 { DT_HP_NODELETE
, "HP_NODELETE" },
9626 { DT_HP_GROUP
, "HP_GROUP" },
9627 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9629 bfd_boolean first
= TRUE
;
9631 bfd_vma val
= entry
->d_un
.d_val
;
9633 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9634 if (val
& flags
[cnt
].bit
)
9638 fputs (flags
[cnt
].str
, stdout
);
9640 val
^= flags
[cnt
].bit
;
9643 if (val
!= 0 || first
)
9647 print_vma (val
, HEX
);
9653 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9661 /* VMS vs Unix time offset and factor. */
9663 #define VMS_EPOCH_OFFSET 35067168000000000LL
9664 #define VMS_GRANULARITY_FACTOR 10000000
9666 /* Display a VMS time in a human readable format. */
9669 print_vms_time (bfd_int64_t vmstime
)
9674 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9675 tm
= gmtime (&unxtime
);
9676 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9677 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9678 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9683 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9685 switch (entry
->d_tag
)
9687 case DT_IA_64_PLT_RESERVE
:
9688 /* First 3 slots reserved. */
9689 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9691 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9694 case DT_IA_64_VMS_LINKTIME
:
9696 print_vms_time (entry
->d_un
.d_val
);
9700 case DT_IA_64_VMS_LNKFLAGS
:
9701 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9702 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9703 printf (" CALL_DEBUG");
9704 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9705 printf (" NOP0BUFS");
9706 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9707 printf (" P0IMAGE");
9708 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9709 printf (" MKTHREADS");
9710 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9711 printf (" UPCALLS");
9712 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9714 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9715 printf (" INITIALIZE");
9716 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9718 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9719 printf (" EXE_INIT");
9720 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9721 printf (" TBK_IN_IMG");
9722 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9723 printf (" DBG_IN_IMG");
9724 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9725 printf (" TBK_IN_DSF");
9726 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9727 printf (" DBG_IN_DSF");
9728 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9729 printf (" SIGNATURES");
9730 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9731 printf (" REL_SEG_OFF");
9735 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9742 get_32bit_dynamic_section (Filedata
* filedata
)
9744 Elf32_External_Dyn
* edyn
;
9745 Elf32_External_Dyn
* ext
;
9746 Elf_Internal_Dyn
* entry
;
9748 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9749 dynamic_size
, _("dynamic section"));
9753 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9754 might not have the luxury of section headers. Look for the DT_NULL
9755 terminator to determine the number of entries. */
9756 for (ext
= edyn
, dynamic_nent
= 0;
9757 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9761 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9765 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9767 if (dynamic_section
== NULL
)
9769 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9770 (unsigned long) dynamic_nent
);
9775 for (ext
= edyn
, entry
= dynamic_section
;
9776 entry
< dynamic_section
+ dynamic_nent
;
9779 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9780 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9789 get_64bit_dynamic_section (Filedata
* filedata
)
9791 Elf64_External_Dyn
* edyn
;
9792 Elf64_External_Dyn
* ext
;
9793 Elf_Internal_Dyn
* entry
;
9795 /* Read in the data. */
9796 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9797 dynamic_size
, _("dynamic section"));
9801 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9802 might not have the luxury of section headers. Look for the DT_NULL
9803 terminator to determine the number of entries. */
9804 for (ext
= edyn
, dynamic_nent
= 0;
9805 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9806 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9810 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9814 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9816 if (dynamic_section
== NULL
)
9818 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9819 (unsigned long) dynamic_nent
);
9824 /* Convert from external to internal formats. */
9825 for (ext
= edyn
, entry
= dynamic_section
;
9826 entry
< dynamic_section
+ dynamic_nent
;
9829 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9830 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9839 print_dynamic_flags (bfd_vma flags
)
9841 bfd_boolean first
= TRUE
;
9847 flag
= flags
& - flags
;
9857 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9858 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9859 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9860 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9861 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9862 default: fputs (_("unknown"), stdout
); break;
9868 /* Parse and display the contents of the dynamic section. */
9871 process_dynamic_section (Filedata
* filedata
)
9873 Elf_Internal_Dyn
* entry
;
9875 if (dynamic_size
== 0)
9878 printf (_("\nThere is no dynamic section in this file.\n"));
9885 if (! get_32bit_dynamic_section (filedata
))
9890 if (! get_64bit_dynamic_section (filedata
))
9894 /* Find the appropriate symbol table. */
9895 if (dynamic_symbols
== NULL
)
9897 for (entry
= dynamic_section
;
9898 entry
< dynamic_section
+ dynamic_nent
;
9901 Elf_Internal_Shdr section
;
9903 if (entry
->d_tag
!= DT_SYMTAB
)
9906 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9908 /* Since we do not know how big the symbol table is,
9909 we default to reading in the entire file (!) and
9910 processing that. This is overkill, I know, but it
9912 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9913 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9915 /* See PR 21379 for a reproducer. */
9916 error (_("Invalid DT_SYMTAB entry: %lx\n"),
9917 (long) section
.sh_offset
);
9921 if (archive_file_offset
!= 0)
9922 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9924 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9927 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9929 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9930 section
.sh_name
= filedata
->string_table_length
;
9932 if (dynamic_symbols
!= NULL
)
9934 error (_("Multiple dynamic symbol table sections found\n"));
9935 free (dynamic_symbols
);
9937 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9938 if (num_dynamic_syms
< 1)
9940 error (_("Unable to determine the number of symbols to load\n"));
9946 /* Similarly find a string table. */
9947 if (dynamic_strings
== NULL
)
9949 for (entry
= dynamic_section
;
9950 entry
< dynamic_section
+ dynamic_nent
;
9953 unsigned long offset
;
9956 if (entry
->d_tag
!= DT_STRTAB
)
9959 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9961 /* Since we do not know how big the string table is,
9962 we default to reading in the entire file (!) and
9963 processing that. This is overkill, I know, but it
9966 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9968 if (archive_file_offset
!= 0)
9969 str_tab_len
= archive_file_size
- offset
;
9971 str_tab_len
= filedata
->file_size
- offset
;
9973 if (str_tab_len
< 1)
9976 (_("Unable to determine the length of the dynamic string table\n"));
9980 if (dynamic_strings
!= NULL
)
9982 error (_("Multiple dynamic string tables found\n"));
9983 free (dynamic_strings
);
9986 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9988 _("dynamic string table"));
9989 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9993 /* And find the syminfo section if available. */
9994 if (dynamic_syminfo
== NULL
)
9996 unsigned long syminsz
= 0;
9998 for (entry
= dynamic_section
;
9999 entry
< dynamic_section
+ dynamic_nent
;
10002 if (entry
->d_tag
== DT_SYMINENT
)
10004 /* Note: these braces are necessary to avoid a syntax
10005 error from the SunOS4 C compiler. */
10006 /* PR binutils/17531: A corrupt file can trigger this test.
10007 So do not use an assert, instead generate an error message. */
10008 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10009 error (_("Bad value (%d) for SYMINENT entry\n"),
10010 (int) entry
->d_un
.d_val
);
10012 else if (entry
->d_tag
== DT_SYMINSZ
)
10013 syminsz
= entry
->d_un
.d_val
;
10014 else if (entry
->d_tag
== DT_SYMINFO
)
10015 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
10019 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10021 Elf_External_Syminfo
* extsyminfo
;
10022 Elf_External_Syminfo
* extsym
;
10023 Elf_Internal_Syminfo
* syminfo
;
10025 /* There is a syminfo section. Read the data. */
10026 extsyminfo
= (Elf_External_Syminfo
*)
10027 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
10028 _("symbol information"));
10032 if (dynamic_syminfo
!= NULL
)
10034 error (_("Multiple dynamic symbol information sections found\n"));
10035 free (dynamic_syminfo
);
10037 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10038 if (dynamic_syminfo
== NULL
)
10040 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10041 (unsigned long) syminsz
);
10045 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10046 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10047 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10048 ++syminfo
, ++extsym
)
10050 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10051 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10058 if (do_dynamic
&& dynamic_addr
)
10059 printf (ngettext ("\nDynamic section at offset 0x%lx "
10060 "contains %lu entry:\n",
10061 "\nDynamic section at offset 0x%lx "
10062 "contains %lu entries:\n",
10064 dynamic_addr
, (unsigned long) dynamic_nent
);
10066 printf (_(" Tag Type Name/Value\n"));
10068 for (entry
= dynamic_section
;
10069 entry
< dynamic_section
+ dynamic_nent
;
10074 const char * dtype
;
10077 print_vma (entry
->d_tag
, FULL_HEX
);
10078 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10079 printf (" (%s)%*s", dtype
,
10080 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10083 switch (entry
->d_tag
)
10087 print_dynamic_flags (entry
->d_un
.d_val
);
10097 switch (entry
->d_tag
)
10100 printf (_("Auxiliary library"));
10104 printf (_("Filter library"));
10108 printf (_("Configuration file"));
10112 printf (_("Dependency audit library"));
10116 printf (_("Audit library"));
10120 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10121 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10125 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10134 printf (_("Flags:"));
10136 if (entry
->d_un
.d_val
== 0)
10137 printf (_(" None\n"));
10140 unsigned long int val
= entry
->d_un
.d_val
;
10142 if (val
& DTF_1_PARINIT
)
10144 printf (" PARINIT");
10145 val
^= DTF_1_PARINIT
;
10147 if (val
& DTF_1_CONFEXP
)
10149 printf (" CONFEXP");
10150 val
^= DTF_1_CONFEXP
;
10153 printf (" %lx", val
);
10162 printf (_("Flags:"));
10164 if (entry
->d_un
.d_val
== 0)
10165 printf (_(" None\n"));
10168 unsigned long int val
= entry
->d_un
.d_val
;
10170 if (val
& DF_P1_LAZYLOAD
)
10172 printf (" LAZYLOAD");
10173 val
^= DF_P1_LAZYLOAD
;
10175 if (val
& DF_P1_GROUPPERM
)
10177 printf (" GROUPPERM");
10178 val
^= DF_P1_GROUPPERM
;
10181 printf (" %lx", val
);
10190 printf (_("Flags:"));
10191 if (entry
->d_un
.d_val
== 0)
10192 printf (_(" None\n"));
10195 unsigned long int val
= entry
->d_un
.d_val
;
10197 if (val
& DF_1_NOW
)
10202 if (val
& DF_1_GLOBAL
)
10204 printf (" GLOBAL");
10205 val
^= DF_1_GLOBAL
;
10207 if (val
& DF_1_GROUP
)
10212 if (val
& DF_1_NODELETE
)
10214 printf (" NODELETE");
10215 val
^= DF_1_NODELETE
;
10217 if (val
& DF_1_LOADFLTR
)
10219 printf (" LOADFLTR");
10220 val
^= DF_1_LOADFLTR
;
10222 if (val
& DF_1_INITFIRST
)
10224 printf (" INITFIRST");
10225 val
^= DF_1_INITFIRST
;
10227 if (val
& DF_1_NOOPEN
)
10229 printf (" NOOPEN");
10230 val
^= DF_1_NOOPEN
;
10232 if (val
& DF_1_ORIGIN
)
10234 printf (" ORIGIN");
10235 val
^= DF_1_ORIGIN
;
10237 if (val
& DF_1_DIRECT
)
10239 printf (" DIRECT");
10240 val
^= DF_1_DIRECT
;
10242 if (val
& DF_1_TRANS
)
10247 if (val
& DF_1_INTERPOSE
)
10249 printf (" INTERPOSE");
10250 val
^= DF_1_INTERPOSE
;
10252 if (val
& DF_1_NODEFLIB
)
10254 printf (" NODEFLIB");
10255 val
^= DF_1_NODEFLIB
;
10257 if (val
& DF_1_NODUMP
)
10259 printf (" NODUMP");
10260 val
^= DF_1_NODUMP
;
10262 if (val
& DF_1_CONFALT
)
10264 printf (" CONFALT");
10265 val
^= DF_1_CONFALT
;
10267 if (val
& DF_1_ENDFILTEE
)
10269 printf (" ENDFILTEE");
10270 val
^= DF_1_ENDFILTEE
;
10272 if (val
& DF_1_DISPRELDNE
)
10274 printf (" DISPRELDNE");
10275 val
^= DF_1_DISPRELDNE
;
10277 if (val
& DF_1_DISPRELPND
)
10279 printf (" DISPRELPND");
10280 val
^= DF_1_DISPRELPND
;
10282 if (val
& DF_1_NODIRECT
)
10284 printf (" NODIRECT");
10285 val
^= DF_1_NODIRECT
;
10287 if (val
& DF_1_IGNMULDEF
)
10289 printf (" IGNMULDEF");
10290 val
^= DF_1_IGNMULDEF
;
10292 if (val
& DF_1_NOKSYMS
)
10294 printf (" NOKSYMS");
10295 val
^= DF_1_NOKSYMS
;
10297 if (val
& DF_1_NOHDR
)
10302 if (val
& DF_1_EDITED
)
10304 printf (" EDITED");
10305 val
^= DF_1_EDITED
;
10307 if (val
& DF_1_NORELOC
)
10309 printf (" NORELOC");
10310 val
^= DF_1_NORELOC
;
10312 if (val
& DF_1_SYMINTPOSE
)
10314 printf (" SYMINTPOSE");
10315 val
^= DF_1_SYMINTPOSE
;
10317 if (val
& DF_1_GLOBAUDIT
)
10319 printf (" GLOBAUDIT");
10320 val
^= DF_1_GLOBAUDIT
;
10322 if (val
& DF_1_SINGLETON
)
10324 printf (" SINGLETON");
10325 val
^= DF_1_SINGLETON
;
10327 if (val
& DF_1_STUB
)
10332 if (val
& DF_1_PIE
)
10337 if (val
& DF_1_KMOD
)
10342 if (val
& DF_1_WEAKFILTER
)
10344 printf (" WEAKFILTER");
10345 val
^= DF_1_WEAKFILTER
;
10347 if (val
& DF_1_NOCOMMON
)
10349 printf (" NOCOMMON");
10350 val
^= DF_1_NOCOMMON
;
10353 printf (" %lx", val
);
10360 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10362 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10382 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10388 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10389 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10395 switch (entry
->d_tag
)
10398 printf (_("Shared library: [%s]"), name
);
10400 if (streq (name
, program_interpreter
))
10401 printf (_(" program interpreter"));
10405 printf (_("Library soname: [%s]"), name
);
10409 printf (_("Library rpath: [%s]"), name
);
10413 printf (_("Library runpath: [%s]"), name
);
10417 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10422 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10435 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10436 /* Fall through. */
10440 case DT_INIT_ARRAYSZ
:
10441 case DT_FINI_ARRAYSZ
:
10442 case DT_GNU_CONFLICTSZ
:
10443 case DT_GNU_LIBLISTSZ
:
10446 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10447 printf (_(" (bytes)\n"));
10452 case DT_VERNEEDNUM
:
10457 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10466 case DT_INIT_ARRAY
:
10467 case DT_FINI_ARRAY
:
10470 if (entry
->d_tag
== DT_USED
10471 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10473 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10477 printf (_("Not needed object: [%s]\n"), name
);
10482 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10488 /* The value of this entry is ignored. */
10493 case DT_GNU_PRELINKED
:
10497 time_t atime
= entry
->d_un
.d_val
;
10499 tmp
= gmtime (&atime
);
10500 /* PR 17533 file: 041-1244816-0.004. */
10502 printf (_("<corrupt time val: %lx"),
10503 (unsigned long) atime
);
10505 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10506 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10507 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10513 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10516 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10522 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10523 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10528 switch (filedata
->file_header
.e_machine
)
10531 dynamic_section_aarch64_val (entry
);
10534 case EM_MIPS_RS3_LE
:
10535 dynamic_section_mips_val (entry
);
10538 dynamic_section_parisc_val (entry
);
10541 dynamic_section_ia64_val (entry
);
10544 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10556 get_ver_flags (unsigned int flags
)
10558 static char buff
[128];
10565 if (flags
& VER_FLG_BASE
)
10566 strcat (buff
, "BASE");
10568 if (flags
& VER_FLG_WEAK
)
10570 if (flags
& VER_FLG_BASE
)
10571 strcat (buff
, " | ");
10573 strcat (buff
, "WEAK");
10576 if (flags
& VER_FLG_INFO
)
10578 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10579 strcat (buff
, " | ");
10581 strcat (buff
, "INFO");
10584 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10586 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10587 strcat (buff
, " | ");
10589 strcat (buff
, _("<unknown>"));
10595 /* Display the contents of the version sections. */
10598 process_version_sections (Filedata
* filedata
)
10600 Elf_Internal_Shdr
* section
;
10602 bfd_boolean found
= FALSE
;
10607 for (i
= 0, section
= filedata
->section_headers
;
10608 i
< filedata
->file_header
.e_shnum
;
10611 switch (section
->sh_type
)
10613 case SHT_GNU_verdef
:
10615 Elf_External_Verdef
* edefs
;
10622 printf (ngettext ("\nVersion definition section '%s' "
10623 "contains %u entry:\n",
10624 "\nVersion definition section '%s' "
10625 "contains %u entries:\n",
10627 printable_section_name (filedata
, section
),
10630 printf (_(" Addr: 0x"));
10631 printf_vma (section
->sh_addr
);
10632 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10633 (unsigned long) section
->sh_offset
, section
->sh_link
,
10634 printable_section_name_from_index (filedata
, section
->sh_link
));
10636 edefs
= (Elf_External_Verdef
*)
10637 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10638 _("version definition section"));
10641 endbuf
= (char *) edefs
+ section
->sh_size
;
10643 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10646 Elf_External_Verdef
* edef
;
10647 Elf_Internal_Verdef ent
;
10648 Elf_External_Verdaux
* eaux
;
10649 Elf_Internal_Verdaux aux
;
10650 unsigned long isum
;
10653 vstart
= ((char *) edefs
) + idx
;
10654 if (vstart
+ sizeof (*edef
) > endbuf
)
10657 edef
= (Elf_External_Verdef
*) vstart
;
10659 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10660 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10661 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10662 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10663 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10664 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10665 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10667 printf (_(" %#06lx: Rev: %d Flags: %s"),
10668 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10670 printf (_(" Index: %d Cnt: %d "),
10671 ent
.vd_ndx
, ent
.vd_cnt
);
10673 /* Check for overflow. */
10674 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10677 vstart
+= ent
.vd_aux
;
10679 if (vstart
+ sizeof (*eaux
) > endbuf
)
10681 eaux
= (Elf_External_Verdaux
*) vstart
;
10683 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10684 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10686 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10687 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10689 printf (_("Name index: %ld\n"), aux
.vda_name
);
10691 isum
= idx
+ ent
.vd_aux
;
10693 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10695 if (aux
.vda_next
< sizeof (*eaux
)
10696 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10698 warn (_("Invalid vda_next field of %lx\n"),
10703 /* Check for overflow. */
10704 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10707 isum
+= aux
.vda_next
;
10708 vstart
+= aux
.vda_next
;
10710 if (vstart
+ sizeof (*eaux
) > endbuf
)
10712 eaux
= (Elf_External_Verdaux
*) vstart
;
10714 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10715 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10717 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10718 printf (_(" %#06lx: Parent %d: %s\n"),
10719 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10721 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10722 isum
, j
, aux
.vda_name
);
10725 if (j
< ent
.vd_cnt
)
10726 printf (_(" Version def aux past end of section\n"));
10729 file: id:000001,src:000172+005151,op:splice,rep:2. */
10730 if (ent
.vd_next
< sizeof (*edef
)
10731 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10733 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10734 cnt
= section
->sh_info
;
10737 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10740 idx
+= ent
.vd_next
;
10743 if (cnt
< section
->sh_info
)
10744 printf (_(" Version definition past end of section\n"));
10750 case SHT_GNU_verneed
:
10752 Elf_External_Verneed
* eneed
;
10759 printf (ngettext ("\nVersion needs section '%s' "
10760 "contains %u entry:\n",
10761 "\nVersion needs section '%s' "
10762 "contains %u entries:\n",
10764 printable_section_name (filedata
, section
), section
->sh_info
);
10766 printf (_(" Addr: 0x"));
10767 printf_vma (section
->sh_addr
);
10768 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10769 (unsigned long) section
->sh_offset
, section
->sh_link
,
10770 printable_section_name_from_index (filedata
, section
->sh_link
));
10772 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10773 section
->sh_offset
, 1,
10775 _("Version Needs section"));
10778 endbuf
= (char *) eneed
+ section
->sh_size
;
10780 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10782 Elf_External_Verneed
* entry
;
10783 Elf_Internal_Verneed ent
;
10784 unsigned long isum
;
10788 vstart
= ((char *) eneed
) + idx
;
10789 if (vstart
+ sizeof (*entry
) > endbuf
)
10792 entry
= (Elf_External_Verneed
*) vstart
;
10794 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10795 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10796 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10797 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10798 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10800 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10802 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10803 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10805 printf (_(" File: %lx"), ent
.vn_file
);
10807 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10809 /* Check for overflow. */
10810 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10812 vstart
+= ent
.vn_aux
;
10814 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10816 Elf_External_Vernaux
* eaux
;
10817 Elf_Internal_Vernaux aux
;
10819 if (vstart
+ sizeof (*eaux
) > endbuf
)
10821 eaux
= (Elf_External_Vernaux
*) vstart
;
10823 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10824 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10825 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10826 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10827 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10829 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10830 printf (_(" %#06lx: Name: %s"),
10831 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10833 printf (_(" %#06lx: Name index: %lx"),
10834 isum
, aux
.vna_name
);
10836 printf (_(" Flags: %s Version: %d\n"),
10837 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10839 if (aux
.vna_next
< sizeof (*eaux
)
10840 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10842 warn (_("Invalid vna_next field of %lx\n"),
10847 /* Check for overflow. */
10848 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10850 isum
+= aux
.vna_next
;
10851 vstart
+= aux
.vna_next
;
10854 if (j
< ent
.vn_cnt
)
10855 warn (_("Missing Version Needs auxillary information\n"));
10857 if (ent
.vn_next
< sizeof (*entry
)
10858 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10860 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10861 cnt
= section
->sh_info
;
10864 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10866 idx
+= ent
.vn_next
;
10869 if (cnt
< section
->sh_info
)
10870 warn (_("Missing Version Needs information\n"));
10876 case SHT_GNU_versym
:
10878 Elf_Internal_Shdr
* link_section
;
10881 unsigned char * edata
;
10882 unsigned short * data
;
10884 Elf_Internal_Sym
* symbols
;
10885 Elf_Internal_Shdr
* string_sec
;
10886 unsigned long num_syms
;
10889 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10892 link_section
= filedata
->section_headers
+ section
->sh_link
;
10893 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10895 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10900 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10901 if (symbols
== NULL
)
10904 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10906 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10907 string_sec
->sh_size
,
10908 _("version string table"));
10915 printf (ngettext ("\nVersion symbols section '%s' "
10916 "contains %lu entry:\n",
10917 "\nVersion symbols section '%s' "
10918 "contains %lu entries:\n",
10920 printable_section_name (filedata
, section
), (unsigned long) total
);
10922 printf (_(" Addr: 0x"));
10923 printf_vma (section
->sh_addr
);
10924 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10925 (unsigned long) section
->sh_offset
, section
->sh_link
,
10926 printable_section_name (filedata
, link_section
));
10928 off
= offset_from_vma (filedata
,
10929 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10930 total
* sizeof (short));
10931 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
10932 sizeof (short), total
,
10933 _("version symbol data"));
10941 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10943 for (cnt
= total
; cnt
--;)
10944 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10949 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10953 char *invalid
= _("*invalid*");
10955 printf (" %03x:", cnt
);
10957 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10958 switch (data
[cnt
+ j
])
10961 fputs (_(" 0 (*local*) "), stdout
);
10965 fputs (_(" 1 (*global*) "), stdout
);
10969 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10970 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10972 /* If this index value is greater than the size of the symbols
10973 array, break to avoid an out-of-bounds read. */
10974 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10976 warn (_("invalid index into symbol array\n"));
10981 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10983 Elf_Internal_Verneed ivn
;
10984 unsigned long offset
;
10986 offset
= offset_from_vma
10987 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10988 sizeof (Elf_External_Verneed
));
10992 Elf_Internal_Vernaux ivna
;
10993 Elf_External_Verneed evn
;
10994 Elf_External_Vernaux evna
;
10995 unsigned long a_off
;
10997 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10998 _("version need")) == NULL
)
11001 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11002 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11004 a_off
= offset
+ ivn
.vn_aux
;
11008 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11009 1, _("version need aux (2)")) == NULL
)
11012 ivna
.vna_other
= 0;
11016 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11017 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11020 a_off
+= ivna
.vna_next
;
11022 while (ivna
.vna_other
!= data
[cnt
+ j
]
11023 && ivna
.vna_next
!= 0);
11025 if (ivna
.vna_other
== data
[cnt
+ j
])
11027 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11029 if (ivna
.vna_name
>= string_sec
->sh_size
)
11032 name
= strtab
+ ivna
.vna_name
;
11036 offset
+= ivn
.vn_next
;
11038 while (ivn
.vn_next
);
11041 if (data
[cnt
+ j
] != 0x8001
11042 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11044 Elf_Internal_Verdef ivd
;
11045 Elf_External_Verdef evd
;
11046 unsigned long offset
;
11048 offset
= offset_from_vma
11049 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11054 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11055 _("version def")) == NULL
)
11058 /* PR 17531: file: 046-1082287-0.004. */
11059 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11064 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11065 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11068 offset
+= ivd
.vd_next
;
11070 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11071 && ivd
.vd_next
!= 0);
11073 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11075 Elf_External_Verdaux evda
;
11076 Elf_Internal_Verdaux ivda
;
11078 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11080 if (get_data (&evda
, filedata
,
11081 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11083 _("version def aux")) == NULL
)
11086 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11088 if (ivda
.vda_name
>= string_sec
->sh_size
)
11090 else if (name
!= NULL
&& name
!= invalid
)
11091 name
= _("*both*");
11093 name
= strtab
+ ivda
.vda_name
;
11097 nn
+= printf ("(%s%-*s",
11099 12 - (int) strlen (name
),
11103 printf ("%*c", 18 - nn
, ' ');
11121 printf (_("\nNo version information found in this file.\n"));
11126 static const char *
11127 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11129 static char buff
[32];
11133 case STB_LOCAL
: return "LOCAL";
11134 case STB_GLOBAL
: return "GLOBAL";
11135 case STB_WEAK
: return "WEAK";
11137 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11138 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11140 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11142 if (binding
== STB_GNU_UNIQUE
11143 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11145 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11148 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11153 static const char *
11154 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11156 static char buff
[32];
11160 case STT_NOTYPE
: return "NOTYPE";
11161 case STT_OBJECT
: return "OBJECT";
11162 case STT_FUNC
: return "FUNC";
11163 case STT_SECTION
: return "SECTION";
11164 case STT_FILE
: return "FILE";
11165 case STT_COMMON
: return "COMMON";
11166 case STT_TLS
: return "TLS";
11167 case STT_RELC
: return "RELC";
11168 case STT_SRELC
: return "SRELC";
11170 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11172 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11173 return "THUMB_FUNC";
11175 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11178 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11179 return "PARISC_MILLI";
11181 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11183 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11185 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11187 if (type
== STT_HP_OPAQUE
)
11188 return "HP_OPAQUE";
11189 if (type
== STT_HP_STUB
)
11193 if (type
== STT_GNU_IFUNC
11194 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11195 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11198 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11201 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11206 static const char *
11207 get_symbol_visibility (unsigned int visibility
)
11209 switch (visibility
)
11211 case STV_DEFAULT
: return "DEFAULT";
11212 case STV_INTERNAL
: return "INTERNAL";
11213 case STV_HIDDEN
: return "HIDDEN";
11214 case STV_PROTECTED
: return "PROTECTED";
11216 error (_("Unrecognized visibility value: %u\n"), visibility
);
11217 return _("<unknown>");
11221 static const char *
11222 get_alpha_symbol_other (unsigned int other
)
11226 case STO_ALPHA_NOPV
: return "NOPV";
11227 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11229 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11230 return _("<unknown>");
11234 static const char *
11235 get_solaris_symbol_visibility (unsigned int visibility
)
11237 switch (visibility
)
11239 case 4: return "EXPORTED";
11240 case 5: return "SINGLETON";
11241 case 6: return "ELIMINATE";
11242 default: return get_symbol_visibility (visibility
);
11246 static const char *
11247 get_aarch64_symbol_other (unsigned int other
)
11249 static char buf
[32];
11251 if (other
& STO_AARCH64_VARIANT_PCS
)
11253 other
&= ~STO_AARCH64_VARIANT_PCS
;
11255 return "VARIANT_PCS";
11256 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11262 static const char *
11263 get_mips_symbol_other (unsigned int other
)
11267 case STO_OPTIONAL
: return "OPTIONAL";
11268 case STO_MIPS_PLT
: return "MIPS PLT";
11269 case STO_MIPS_PIC
: return "MIPS PIC";
11270 case STO_MICROMIPS
: return "MICROMIPS";
11271 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11272 case STO_MIPS16
: return "MIPS16";
11273 default: return NULL
;
11277 static const char *
11278 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11280 if (is_ia64_vms (filedata
))
11282 static char res
[32];
11286 /* Function types is for images and .STB files only. */
11287 switch (filedata
->file_header
.e_type
)
11291 switch (VMS_ST_FUNC_TYPE (other
))
11293 case VMS_SFT_CODE_ADDR
:
11294 strcat (res
, " CA");
11296 case VMS_SFT_SYMV_IDX
:
11297 strcat (res
, " VEC");
11300 strcat (res
, " FD");
11302 case VMS_SFT_RESERVE
:
11303 strcat (res
, " RSV");
11306 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11307 VMS_ST_FUNC_TYPE (other
));
11308 strcat (res
, " <unknown>");
11315 switch (VMS_ST_LINKAGE (other
))
11317 case VMS_STL_IGNORE
:
11318 strcat (res
, " IGN");
11320 case VMS_STL_RESERVE
:
11321 strcat (res
, " RSV");
11324 strcat (res
, " STD");
11327 strcat (res
, " LNK");
11330 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11331 VMS_ST_LINKAGE (other
));
11332 strcat (res
, " <unknown>");
11344 static const char *
11345 get_ppc64_symbol_other (unsigned int other
)
11347 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11350 other
>>= STO_PPC64_LOCAL_BIT
;
11353 static char buf
[32];
11355 other
= ppc64_decode_local_entry (other
);
11356 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11362 static const char *
11363 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11365 const char * result
= NULL
;
11366 static char buff
[32];
11371 switch (filedata
->file_header
.e_machine
)
11374 result
= get_alpha_symbol_other (other
);
11377 result
= get_aarch64_symbol_other (other
);
11380 result
= get_mips_symbol_other (other
);
11383 result
= get_ia64_symbol_other (filedata
, other
);
11386 result
= get_ppc64_symbol_other (other
);
11396 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11400 static const char *
11401 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11403 static char buff
[32];
11407 case SHN_UNDEF
: return "UND";
11408 case SHN_ABS
: return "ABS";
11409 case SHN_COMMON
: return "COM";
11411 if (type
== SHN_IA_64_ANSI_COMMON
11412 && filedata
->file_header
.e_machine
== EM_IA_64
11413 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11415 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11416 || filedata
->file_header
.e_machine
== EM_L1OM
11417 || filedata
->file_header
.e_machine
== EM_K1OM
)
11418 && type
== SHN_X86_64_LCOMMON
)
11419 return "LARGE_COM";
11420 else if ((type
== SHN_MIPS_SCOMMON
11421 && filedata
->file_header
.e_machine
== EM_MIPS
)
11422 || (type
== SHN_TIC6X_SCOMMON
11423 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11425 else if (type
== SHN_MIPS_SUNDEFINED
11426 && filedata
->file_header
.e_machine
== EM_MIPS
)
11428 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11429 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11430 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11431 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11432 else if (type
>= SHN_LORESERVE
)
11433 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11434 else if (type
>= filedata
->file_header
.e_shnum
)
11435 sprintf (buff
, _("bad section index[%3d]"), type
);
11437 sprintf (buff
, "%3d", type
);
11445 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11447 unsigned char * e_data
;
11450 /* If the size_t type is smaller than the bfd_size_type, eg because
11451 you are building a 32-bit tool on a 64-bit host, then make sure
11452 that when (number) is cast to (size_t) no information is lost. */
11453 if (sizeof (size_t) < sizeof (bfd_size_type
)
11454 && (bfd_size_type
) ((size_t) number
) != number
)
11456 error (_("Size truncation prevents reading %s elements of size %u\n"),
11457 bfd_vmatoa ("u", number
), ent_size
);
11461 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
11462 attempting to allocate memory when the read is bound to fail. */
11463 if (ent_size
* number
> filedata
->file_size
)
11465 error (_("Invalid number of dynamic entries: %s\n"),
11466 bfd_vmatoa ("u", number
));
11470 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11471 if (e_data
== NULL
)
11473 error (_("Out of memory reading %s dynamic entries\n"),
11474 bfd_vmatoa ("u", number
));
11478 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11480 error (_("Unable to read in %s bytes of dynamic data\n"),
11481 bfd_vmatoa ("u", number
* ent_size
));
11486 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11487 if (i_data
== NULL
)
11489 error (_("Out of memory allocating space for %s dynamic entries\n"),
11490 bfd_vmatoa ("u", number
));
11496 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11504 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11506 Elf_Internal_Sym
* psym
;
11509 n
= print_vma (si
, DEC_5
);
11511 fputs (&" "[n
], stdout
);
11512 printf (" %3lu: ", hn
);
11514 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11516 printf (_("<No info available for dynamic symbol number %lu>\n"),
11517 (unsigned long) si
);
11521 psym
= dynamic_symbols
+ si
;
11522 print_vma (psym
->st_value
, LONG_HEX
);
11524 print_vma (psym
->st_size
, DEC_5
);
11526 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11527 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11529 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11530 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11533 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11535 printf (" %-7s", get_symbol_visibility (vis
));
11536 /* Check to see if any other bits in the st_other field are set.
11537 Note - displaying this information disrupts the layout of the
11538 table being generated, but for the moment this case is very
11540 if (psym
->st_other
^ vis
)
11541 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11544 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11545 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11546 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11548 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11552 static const char *
11553 get_symbol_version_string (Filedata
* filedata
,
11554 bfd_boolean is_dynsym
,
11555 const char * strtab
,
11556 unsigned long int strtab_size
,
11558 Elf_Internal_Sym
* psym
,
11559 enum versioned_symbol_info
* sym_info
,
11560 unsigned short * vna_other
)
11562 unsigned char data
[2];
11563 unsigned short vers_data
;
11564 unsigned long offset
;
11565 unsigned short max_vd_ndx
;
11568 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11571 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11572 sizeof data
+ si
* sizeof (vers_data
));
11574 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11575 sizeof (data
), 1, _("version data")) == NULL
)
11578 vers_data
= byte_get (data
, 2);
11580 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11583 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11586 /* Usually we'd only see verdef for defined symbols, and verneed for
11587 undefined symbols. However, symbols defined by the linker in
11588 .dynbss for variables copied from a shared library in order to
11589 avoid text relocations are defined yet have verneed. We could
11590 use a heuristic to detect the special case, for example, check
11591 for verneed first on symbols defined in SHT_NOBITS sections, but
11592 it is simpler and more reliable to just look for both verdef and
11593 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11595 if (psym
->st_shndx
!= SHN_UNDEF
11596 && vers_data
!= 0x8001
11597 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11599 Elf_Internal_Verdef ivd
;
11600 Elf_Internal_Verdaux ivda
;
11601 Elf_External_Verdaux evda
;
11604 off
= offset_from_vma (filedata
,
11605 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11606 sizeof (Elf_External_Verdef
));
11610 Elf_External_Verdef evd
;
11612 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11613 _("version def")) == NULL
)
11622 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11623 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11624 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11625 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11628 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11629 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11631 off
+= ivd
.vd_next
;
11633 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11635 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11637 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11640 off
-= ivd
.vd_next
;
11643 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11644 _("version def aux")) != NULL
)
11646 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11648 if (psym
->st_name
!= ivda
.vda_name
)
11649 return (ivda
.vda_name
< strtab_size
11650 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11655 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11657 Elf_External_Verneed evn
;
11658 Elf_Internal_Verneed ivn
;
11659 Elf_Internal_Vernaux ivna
;
11661 offset
= offset_from_vma (filedata
,
11662 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11666 unsigned long vna_off
;
11668 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11669 _("version need")) == NULL
)
11672 ivna
.vna_other
= 0;
11677 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11678 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11680 vna_off
= offset
+ ivn
.vn_aux
;
11684 Elf_External_Vernaux evna
;
11686 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11687 _("version need aux (3)")) == NULL
)
11690 ivna
.vna_other
= 0;
11695 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11696 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11697 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11700 vna_off
+= ivna
.vna_next
;
11702 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11704 if (ivna
.vna_other
== vers_data
)
11707 offset
+= ivn
.vn_next
;
11709 while (ivn
.vn_next
!= 0);
11711 if (ivna
.vna_other
== vers_data
)
11713 *sym_info
= symbol_undefined
;
11714 *vna_other
= ivna
.vna_other
;
11715 return (ivna
.vna_name
< strtab_size
11716 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11718 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11719 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11720 return _("<corrupt>");
11725 /* Dump the symbol table. */
11727 process_symbol_table (Filedata
* filedata
)
11729 Elf_Internal_Shdr
* section
;
11730 bfd_size_type nbuckets
= 0;
11731 bfd_size_type nchains
= 0;
11732 bfd_vma
* buckets
= NULL
;
11733 bfd_vma
* chains
= NULL
;
11734 bfd_vma ngnubuckets
= 0;
11735 bfd_vma
* gnubuckets
= NULL
;
11736 bfd_vma
* gnuchains
= NULL
;
11737 bfd_vma
* mipsxlat
= NULL
;
11738 bfd_vma gnusymidx
= 0;
11739 bfd_size_type ngnuchains
= 0;
11741 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11744 if (dynamic_info
[DT_HASH
]
11746 || (do_using_dynamic
11748 && dynamic_strings
!= NULL
)))
11750 unsigned char nb
[8];
11751 unsigned char nc
[8];
11752 unsigned int hash_ent_size
= 4;
11754 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11755 || filedata
->file_header
.e_machine
== EM_S390
11756 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11757 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11760 if (fseek (filedata
->handle
,
11761 (archive_file_offset
11762 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11763 sizeof nb
+ sizeof nc
)),
11766 error (_("Unable to seek to start of dynamic information\n"));
11770 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11772 error (_("Failed to read in number of buckets\n"));
11776 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11778 error (_("Failed to read in number of chains\n"));
11782 nbuckets
= byte_get (nb
, hash_ent_size
);
11783 nchains
= byte_get (nc
, hash_ent_size
);
11785 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11786 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11788 if (buckets
== NULL
|| chains
== NULL
)
11797 if (do_using_dynamic
)
11802 if (dynamic_info_DT_GNU_HASH
11804 || (do_using_dynamic
11806 && dynamic_strings
!= NULL
)))
11808 unsigned char nb
[16];
11809 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11810 bfd_vma buckets_vma
;
11812 if (fseek (filedata
->handle
,
11813 (archive_file_offset
11814 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11818 error (_("Unable to seek to start of dynamic information\n"));
11822 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11824 error (_("Failed to read in number of buckets\n"));
11828 ngnubuckets
= byte_get (nb
, 4);
11829 gnusymidx
= byte_get (nb
+ 4, 4);
11830 bitmaskwords
= byte_get (nb
+ 8, 4);
11831 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11833 buckets_vma
+= bitmaskwords
* 4;
11835 buckets_vma
+= bitmaskwords
* 8;
11837 if (fseek (filedata
->handle
,
11838 (archive_file_offset
11839 + offset_from_vma (filedata
, buckets_vma
, 4)),
11842 error (_("Unable to seek to start of dynamic information\n"));
11846 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11848 if (gnubuckets
== NULL
)
11851 for (i
= 0; i
< ngnubuckets
; i
++)
11852 if (gnubuckets
[i
] != 0)
11854 if (gnubuckets
[i
] < gnusymidx
)
11857 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11858 maxchain
= gnubuckets
[i
];
11861 if (maxchain
== 0xffffffff)
11864 maxchain
-= gnusymidx
;
11866 if (fseek (filedata
->handle
,
11867 (archive_file_offset
11868 + offset_from_vma (filedata
, buckets_vma
11869 + 4 * (ngnubuckets
+ maxchain
), 4)),
11872 error (_("Unable to seek to start of dynamic information\n"));
11878 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11880 error (_("Failed to determine last chain length\n"));
11884 if (maxchain
+ 1 == 0)
11889 while ((byte_get (nb
, 4) & 1) == 0);
11891 if (fseek (filedata
->handle
,
11892 (archive_file_offset
11893 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11896 error (_("Unable to seek to start of dynamic information\n"));
11900 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11901 ngnuchains
= maxchain
;
11903 if (gnuchains
== NULL
)
11906 if (dynamic_info_DT_MIPS_XHASH
)
11908 if (fseek (filedata
->handle
,
11909 (archive_file_offset
11910 + offset_from_vma (filedata
, (buckets_vma
11915 error (_("Unable to seek to start of dynamic information\n"));
11919 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11920 if (mipsxlat
== NULL
)
11928 if (do_using_dynamic
)
11934 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11936 && do_using_dynamic
11937 && dynamic_strings
!= NULL
11938 && dynamic_symbols
!= NULL
)
11942 if (dynamic_info
[DT_HASH
])
11947 printf (_("\nSymbol table for image:\n"));
11949 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11951 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11953 visited
= xcmalloc (nchains
, 1);
11954 memset (visited
, 0, nchains
);
11955 for (hn
= 0; hn
< nbuckets
; hn
++)
11957 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11959 print_dynamic_symbol (filedata
, si
, hn
);
11960 if (si
>= nchains
|| visited
[si
])
11962 error (_("histogram chain is corrupt\n"));
11971 if (dynamic_info_DT_GNU_HASH
)
11973 printf (_("\nSymbol table of `%s' for image:\n"),
11974 GNU_HASH_SECTION_NAME
);
11976 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11978 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11980 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11981 if (gnubuckets
[hn
] != 0)
11983 bfd_vma si
= gnubuckets
[hn
];
11984 bfd_vma off
= si
- gnusymidx
;
11988 if (dynamic_info_DT_MIPS_XHASH
)
11989 print_dynamic_symbol (filedata
, mipsxlat
[off
], hn
);
11991 print_dynamic_symbol (filedata
, si
, hn
);
11994 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11998 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11999 && filedata
->section_headers
!= NULL
)
12003 for (i
= 0, section
= filedata
->section_headers
;
12004 i
< filedata
->file_header
.e_shnum
;
12007 char * strtab
= NULL
;
12008 unsigned long int strtab_size
= 0;
12009 Elf_Internal_Sym
* symtab
;
12010 Elf_Internal_Sym
* psym
;
12011 unsigned long si
, num_syms
;
12013 if ((section
->sh_type
!= SHT_SYMTAB
12014 && section
->sh_type
!= SHT_DYNSYM
)
12016 && section
->sh_type
== SHT_SYMTAB
))
12019 if (section
->sh_entsize
== 0)
12021 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12022 printable_section_name (filedata
, section
));
12026 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12027 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12028 "\nSymbol table '%s' contains %lu entries:\n",
12030 printable_section_name (filedata
, section
),
12034 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12036 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12038 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12039 if (symtab
== NULL
)
12042 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12044 strtab
= filedata
->string_table
;
12045 strtab_size
= filedata
->string_table_length
;
12047 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12049 Elf_Internal_Shdr
* string_sec
;
12051 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12053 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12054 1, string_sec
->sh_size
,
12055 _("string table"));
12056 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12059 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
12061 const char *version_string
;
12062 enum versioned_symbol_info sym_info
;
12063 unsigned short vna_other
;
12065 printf ("%6ld: ", si
);
12066 print_vma (psym
->st_value
, LONG_HEX
);
12068 print_vma (psym
->st_size
, DEC_5
);
12069 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12070 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12071 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12072 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12075 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12077 printf (" %-7s", get_symbol_visibility (vis
));
12078 /* Check to see if any other bits in the st_other field are set.
12079 Note - displaying this information disrupts the layout of the
12080 table being generated, but for the moment this case is very rare. */
12081 if (psym
->st_other
^ vis
)
12082 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12084 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12085 print_symbol (25, psym
->st_name
< strtab_size
12086 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12089 = get_symbol_version_string (filedata
,
12090 section
->sh_type
== SHT_DYNSYM
,
12091 strtab
, strtab_size
, si
,
12092 psym
, &sym_info
, &vna_other
);
12093 if (version_string
)
12095 if (sym_info
== symbol_undefined
)
12096 printf ("@%s (%d)", version_string
, vna_other
);
12098 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12104 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12105 && si
>= section
->sh_info
12106 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12107 && filedata
->file_header
.e_machine
!= EM_MIPS
12108 /* Solaris binaries have been found to violate this requirement as
12109 well. Not sure if this is a bug or an ABI requirement. */
12110 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12111 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12112 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12116 if (strtab
!= filedata
->string_table
)
12122 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12124 if (do_histogram
&& buckets
!= NULL
)
12126 unsigned long * lengths
;
12127 unsigned long * counts
;
12130 unsigned long maxlength
= 0;
12131 unsigned long nzero_counts
= 0;
12132 unsigned long nsyms
= 0;
12135 printf (ngettext ("\nHistogram for bucket list length "
12136 "(total of %lu bucket):\n",
12137 "\nHistogram for bucket list length "
12138 "(total of %lu buckets):\n",
12139 (unsigned long) nbuckets
),
12140 (unsigned long) nbuckets
);
12142 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12143 if (lengths
== NULL
)
12145 error (_("Out of memory allocating space for histogram buckets\n"));
12148 visited
= xcmalloc (nchains
, 1);
12149 memset (visited
, 0, nchains
);
12151 printf (_(" Length Number %% of total Coverage\n"));
12152 for (hn
= 0; hn
< nbuckets
; ++hn
)
12154 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12157 if (maxlength
< ++lengths
[hn
])
12159 if (si
>= nchains
|| visited
[si
])
12161 error (_("histogram chain is corrupt\n"));
12169 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12170 if (counts
== NULL
)
12173 error (_("Out of memory allocating space for histogram counts\n"));
12177 for (hn
= 0; hn
< nbuckets
; ++hn
)
12178 ++counts
[lengths
[hn
]];
12183 printf (" 0 %-10lu (%5.1f%%)\n",
12184 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12185 for (i
= 1; i
<= maxlength
; ++i
)
12187 nzero_counts
+= counts
[i
] * i
;
12188 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12189 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12190 (nzero_counts
* 100.0) / nsyms
);
12203 if (do_histogram
&& gnubuckets
!= NULL
)
12205 unsigned long * lengths
;
12206 unsigned long * counts
;
12208 unsigned long maxlength
= 0;
12209 unsigned long nzero_counts
= 0;
12210 unsigned long nsyms
= 0;
12212 printf (ngettext ("\nHistogram for `%s' bucket list length "
12213 "(total of %lu bucket):\n",
12214 "\nHistogram for `%s' bucket list length "
12215 "(total of %lu buckets):\n",
12216 (unsigned long) ngnubuckets
),
12217 GNU_HASH_SECTION_NAME
,
12218 (unsigned long) ngnubuckets
);
12220 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12221 if (lengths
== NULL
)
12223 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12227 printf (_(" Length Number %% of total Coverage\n"));
12229 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12230 if (gnubuckets
[hn
] != 0)
12232 bfd_vma off
, length
= 1;
12234 for (off
= gnubuckets
[hn
] - gnusymidx
;
12235 /* PR 17531 file: 010-77222-0.004. */
12236 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12239 lengths
[hn
] = length
;
12240 if (length
> maxlength
)
12241 maxlength
= length
;
12245 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12246 if (counts
== NULL
)
12249 error (_("Out of memory allocating space for gnu histogram counts\n"));
12253 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12254 ++counts
[lengths
[hn
]];
12256 if (ngnubuckets
> 0)
12259 printf (" 0 %-10lu (%5.1f%%)\n",
12260 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12261 for (j
= 1; j
<= maxlength
; ++j
)
12263 nzero_counts
+= counts
[j
] * j
;
12264 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12265 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12266 (nzero_counts
* 100.0) / nsyms
);
12288 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12292 if (dynamic_syminfo
== NULL
12294 /* No syminfo, this is ok. */
12297 /* There better should be a dynamic symbol section. */
12298 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12302 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12303 "contains %d entry:\n",
12304 "\nDynamic info segment at offset 0x%lx "
12305 "contains %d entries:\n",
12306 dynamic_syminfo_nent
),
12307 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12309 printf (_(" Num: Name BoundTo Flags\n"));
12310 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12312 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12314 printf ("%4d: ", i
);
12315 if (i
>= num_dynamic_syms
)
12316 printf (_("<corrupt index>"));
12317 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12318 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12320 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12323 switch (dynamic_syminfo
[i
].si_boundto
)
12325 case SYMINFO_BT_SELF
:
12326 fputs ("SELF ", stdout
);
12328 case SYMINFO_BT_PARENT
:
12329 fputs ("PARENT ", stdout
);
12332 if (dynamic_syminfo
[i
].si_boundto
> 0
12333 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12334 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12336 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12340 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12344 if (flags
& SYMINFO_FLG_DIRECT
)
12345 printf (" DIRECT");
12346 if (flags
& SYMINFO_FLG_PASSTHRU
)
12347 printf (" PASSTHRU");
12348 if (flags
& SYMINFO_FLG_COPY
)
12350 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12351 printf (" LAZYLOAD");
12359 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12360 is contained by the region START .. END. The types of ADDR, START
12361 and END should all be the same. Note both ADDR + NELEM and END
12362 point to just beyond the end of the regions that are being tested. */
12363 #define IN_RANGE(START,END,ADDR,NELEM) \
12364 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12366 /* Check to see if the given reloc needs to be handled in a target specific
12367 manner. If so then process the reloc and return TRUE otherwise return
12370 If called with reloc == NULL, then this is a signal that reloc processing
12371 for the current section has finished, and any saved state should be
12375 target_specific_reloc_handling (Filedata
* filedata
,
12376 Elf_Internal_Rela
* reloc
,
12377 unsigned char * start
,
12378 unsigned char * end
,
12379 Elf_Internal_Sym
* symtab
,
12380 unsigned long num_syms
)
12382 unsigned int reloc_type
= 0;
12383 unsigned long sym_index
= 0;
12387 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12388 sym_index
= get_reloc_symindex (reloc
->r_info
);
12391 switch (filedata
->file_header
.e_machine
)
12394 case EM_MSP430_OLD
:
12396 static Elf_Internal_Sym
* saved_sym
= NULL
;
12404 switch (reloc_type
)
12406 case 10: /* R_MSP430_SYM_DIFF */
12407 if (uses_msp430x_relocs (filedata
))
12409 /* Fall through. */
12410 case 21: /* R_MSP430X_SYM_DIFF */
12412 if (sym_index
>= num_syms
)
12413 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12416 saved_sym
= symtab
+ sym_index
;
12419 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12420 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12421 goto handle_sym_diff
;
12423 case 5: /* R_MSP430_16_BYTE */
12424 case 9: /* R_MSP430_8 */
12425 if (uses_msp430x_relocs (filedata
))
12427 goto handle_sym_diff
;
12429 case 2: /* R_MSP430_ABS16 */
12430 case 15: /* R_MSP430X_ABS16 */
12431 if (! uses_msp430x_relocs (filedata
))
12433 goto handle_sym_diff
;
12436 if (saved_sym
!= NULL
)
12438 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12441 if (sym_index
>= num_syms
)
12442 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12446 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12447 - saved_sym
->st_value
);
12449 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12450 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12453 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12454 (long) reloc
->r_offset
);
12463 if (saved_sym
!= NULL
)
12464 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12471 case EM_CYGNUS_MN10300
:
12473 static Elf_Internal_Sym
* saved_sym
= NULL
;
12481 switch (reloc_type
)
12483 case 34: /* R_MN10300_ALIGN */
12485 case 33: /* R_MN10300_SYM_DIFF */
12486 if (sym_index
>= num_syms
)
12487 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12490 saved_sym
= symtab
+ sym_index
;
12493 case 1: /* R_MN10300_32 */
12494 case 2: /* R_MN10300_16 */
12495 if (saved_sym
!= NULL
)
12497 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12500 if (sym_index
>= num_syms
)
12501 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12505 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12506 - saved_sym
->st_value
);
12508 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12509 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12511 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12512 (long) reloc
->r_offset
);
12520 if (saved_sym
!= NULL
)
12521 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12529 static bfd_vma saved_sym1
= 0;
12530 static bfd_vma saved_sym2
= 0;
12531 static bfd_vma value
;
12535 saved_sym1
= saved_sym2
= 0;
12539 switch (reloc_type
)
12541 case 0x80: /* R_RL78_SYM. */
12542 saved_sym1
= saved_sym2
;
12543 if (sym_index
>= num_syms
)
12544 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12548 saved_sym2
= symtab
[sym_index
].st_value
;
12549 saved_sym2
+= reloc
->r_addend
;
12553 case 0x83: /* R_RL78_OPsub. */
12554 value
= saved_sym1
- saved_sym2
;
12555 saved_sym2
= saved_sym1
= 0;
12559 case 0x41: /* R_RL78_ABS32. */
12560 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12561 byte_put (start
+ reloc
->r_offset
, value
, 4);
12563 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12564 (long) reloc
->r_offset
);
12568 case 0x43: /* R_RL78_ABS16. */
12569 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12570 byte_put (start
+ reloc
->r_offset
, value
, 2);
12572 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12573 (long) reloc
->r_offset
);
12587 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12588 DWARF debug sections. This is a target specific test. Note - we do not
12589 go through the whole including-target-headers-multiple-times route, (as
12590 we have already done with <elf/h8.h>) because this would become very
12591 messy and even then this function would have to contain target specific
12592 information (the names of the relocs instead of their numeric values).
12593 FIXME: This is not the correct way to solve this problem. The proper way
12594 is to have target specific reloc sizing and typing functions created by
12595 the reloc-macros.h header, in the same way that it already creates the
12596 reloc naming functions. */
12599 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12601 /* Please keep this table alpha-sorted for ease of visual lookup. */
12602 switch (filedata
->file_header
.e_machine
)
12606 return reloc_type
== 1; /* R_386_32. */
12608 return reloc_type
== 1; /* R_68K_32. */
12610 return reloc_type
== 1; /* R_860_32. */
12612 return reloc_type
== 2; /* R_960_32. */
12614 return (reloc_type
== 258
12615 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12617 return reloc_type
== 11; /* R_BPF_DATA_32 */
12618 case EM_ADAPTEVA_EPIPHANY
:
12619 return reloc_type
== 3;
12621 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12623 return reloc_type
== 1; /* R_ARC_32. */
12624 case EM_ARC_COMPACT
:
12625 case EM_ARC_COMPACT2
:
12626 return reloc_type
== 4; /* R_ARC_32. */
12628 return reloc_type
== 2; /* R_ARM_ABS32 */
12631 return reloc_type
== 1;
12633 return reloc_type
== 0x12; /* R_byte4_data. */
12635 return reloc_type
== 3; /* R_CRIS_32. */
12637 return reloc_type
== 3; /* R_CR16_NUM32. */
12639 return reloc_type
== 15; /* R_CRX_NUM32. */
12641 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12642 case EM_CYGNUS_FRV
:
12643 return reloc_type
== 1;
12644 case EM_CYGNUS_D10V
:
12646 return reloc_type
== 6; /* R_D10V_32. */
12647 case EM_CYGNUS_D30V
:
12649 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12651 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12652 case EM_CYGNUS_FR30
:
12654 return reloc_type
== 3; /* R_FR30_32. */
12656 return reloc_type
== 1; /* R_FT32_32. */
12660 return reloc_type
== 1; /* R_H8_DIR32. */
12662 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12663 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12664 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12665 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12668 return reloc_type
== 2; /* R_IP2K_32. */
12670 return reloc_type
== 2; /* R_IQ2000_32. */
12671 case EM_LATTICEMICO32
:
12672 return reloc_type
== 3; /* R_LM32_32. */
12675 return reloc_type
== 3; /* R_M32C_32. */
12677 return reloc_type
== 34; /* R_M32R_32_RELA. */
12680 return reloc_type
== 6; /* R_M68HC11_32. */
12682 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12683 reloc_type
== 6; /* R_S12Z_CW32. */
12685 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12686 case EM_CYGNUS_MEP
:
12687 return reloc_type
== 4; /* R_MEP_32. */
12689 return reloc_type
== 2; /* R_METAG_ADDR32. */
12690 case EM_MICROBLAZE
:
12691 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12693 return reloc_type
== 2; /* R_MIPS_32. */
12695 return reloc_type
== 4; /* R_MMIX_32. */
12696 case EM_CYGNUS_MN10200
:
12698 return reloc_type
== 1; /* R_MN10200_32. */
12699 case EM_CYGNUS_MN10300
:
12701 return reloc_type
== 1; /* R_MN10300_32. */
12703 return reloc_type
== 1; /* R_MOXIE_32. */
12704 case EM_MSP430_OLD
:
12706 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12708 return reloc_type
== 2; /* R_MT_32. */
12710 return reloc_type
== 20; /* R_NDS32_RELA. */
12711 case EM_ALTERA_NIOS2
:
12712 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12714 return reloc_type
== 1; /* R_NIOS_32. */
12716 return reloc_type
== 1; /* R_OR1K_32. */
12718 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12719 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12720 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12723 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12725 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12727 return reloc_type
== 1; /* R_PPC_ADDR32. */
12729 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12731 return reloc_type
== 1; /* R_RISCV_32. */
12733 return reloc_type
== 1; /* R_RL78_DIR32. */
12735 return reloc_type
== 1; /* R_RX_DIR32. */
12737 return reloc_type
== 1; /* R_I370_ADDR31. */
12740 return reloc_type
== 4; /* R_S390_32. */
12742 return reloc_type
== 8; /* R_SCORE_ABS32. */
12744 return reloc_type
== 1; /* R_SH_DIR32. */
12745 case EM_SPARC32PLUS
:
12748 return reloc_type
== 3 /* R_SPARC_32. */
12749 || reloc_type
== 23; /* R_SPARC_UA32. */
12751 return reloc_type
== 6; /* R_SPU_ADDR32 */
12753 return reloc_type
== 1; /* R_C6000_ABS32. */
12755 return reloc_type
== 2; /* R_TILEGX_32. */
12757 return reloc_type
== 1; /* R_TILEPRO_32. */
12758 case EM_CYGNUS_V850
:
12760 return reloc_type
== 6; /* R_V850_ABS32. */
12762 return reloc_type
== 0x33; /* R_V810_WORD. */
12764 return reloc_type
== 1; /* R_VAX_32. */
12766 return reloc_type
== 3; /* R_VISIUM_32. */
12767 case EM_WEBASSEMBLY
:
12768 return reloc_type
== 1; /* R_WASM32_32. */
12772 return reloc_type
== 10; /* R_X86_64_32. */
12775 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12777 return reloc_type
== 4; /* R_XGATE_32. */
12779 return reloc_type
== 1; /* R_XSTROMY16_32. */
12780 case EM_XTENSA_OLD
:
12782 return reloc_type
== 1; /* R_XTENSA_32. */
12784 return reloc_type
== 6; /* R_Z80_32. */
12787 static unsigned int prev_warn
= 0;
12789 /* Avoid repeating the same warning multiple times. */
12790 if (prev_warn
!= filedata
->file_header
.e_machine
)
12791 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12792 filedata
->file_header
.e_machine
);
12793 prev_warn
= filedata
->file_header
.e_machine
;
12799 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12800 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12803 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12805 switch (filedata
->file_header
.e_machine
)
12806 /* Please keep this table alpha-sorted for ease of visual lookup. */
12810 return reloc_type
== 2; /* R_386_PC32. */
12812 return reloc_type
== 4; /* R_68K_PC32. */
12814 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12815 case EM_ADAPTEVA_EPIPHANY
:
12816 return reloc_type
== 6;
12818 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12819 case EM_ARC_COMPACT
:
12820 case EM_ARC_COMPACT2
:
12821 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12823 return reloc_type
== 3; /* R_ARM_REL32 */
12826 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12827 case EM_MICROBLAZE
:
12828 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12830 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12832 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12834 return reloc_type
== 26; /* R_PPC_REL32. */
12836 return reloc_type
== 26; /* R_PPC64_REL32. */
12838 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12841 return reloc_type
== 5; /* R_390_PC32. */
12843 return reloc_type
== 2; /* R_SH_REL32. */
12844 case EM_SPARC32PLUS
:
12847 return reloc_type
== 6; /* R_SPARC_DISP32. */
12849 return reloc_type
== 13; /* R_SPU_REL32. */
12851 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12853 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12855 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12859 return reloc_type
== 2; /* R_X86_64_PC32. */
12861 return reloc_type
== 4; /* R_VAX_PCREL32. */
12862 case EM_XTENSA_OLD
:
12864 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12866 /* Do not abort or issue an error message here. Not all targets use
12867 pc-relative 32-bit relocs in their DWARF debug information and we
12868 have already tested for target coverage in is_32bit_abs_reloc. A
12869 more helpful warning message will be generated by apply_relocations
12870 anyway, so just return. */
12875 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12876 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12879 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12881 switch (filedata
->file_header
.e_machine
)
12884 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12886 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12888 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12889 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12891 return reloc_type
== 80; /* R_PARISC_DIR64. */
12893 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12895 return reloc_type
== 2; /* R_RISCV_64. */
12896 case EM_SPARC32PLUS
:
12899 return reloc_type
== 32 /* R_SPARC_64. */
12900 || reloc_type
== 54; /* R_SPARC_UA64. */
12904 return reloc_type
== 1; /* R_X86_64_64. */
12907 return reloc_type
== 22; /* R_S390_64. */
12909 return reloc_type
== 1; /* R_TILEGX_64. */
12911 return reloc_type
== 18; /* R_MIPS_64. */
12917 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12918 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12921 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12923 switch (filedata
->file_header
.e_machine
)
12926 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12928 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12930 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12931 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12933 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12935 return reloc_type
== 44; /* R_PPC64_REL64. */
12936 case EM_SPARC32PLUS
:
12939 return reloc_type
== 46; /* R_SPARC_DISP64. */
12943 return reloc_type
== 24; /* R_X86_64_PC64. */
12946 return reloc_type
== 23; /* R_S390_PC64. */
12948 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12954 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12955 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12958 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12960 switch (filedata
->file_header
.e_machine
)
12962 case EM_CYGNUS_MN10200
:
12964 return reloc_type
== 4; /* R_MN10200_24. */
12966 return reloc_type
== 5; /* R_FT32_20. */
12968 return reloc_type
== 5; /* R_Z80_24. */
12974 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12975 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12978 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12980 /* Please keep this table alpha-sorted for ease of visual lookup. */
12981 switch (filedata
->file_header
.e_machine
)
12984 case EM_ARC_COMPACT
:
12985 case EM_ARC_COMPACT2
:
12986 return reloc_type
== 2; /* R_ARC_16. */
12987 case EM_ADAPTEVA_EPIPHANY
:
12988 return reloc_type
== 5;
12991 return reloc_type
== 4; /* R_AVR_16. */
12992 case EM_CYGNUS_D10V
:
12994 return reloc_type
== 3; /* R_D10V_16. */
12996 return reloc_type
== 2; /* R_FT32_16. */
13000 return reloc_type
== R_H8_DIR16
;
13003 return reloc_type
== 1; /* R_IP2K_16. */
13006 return reloc_type
== 1; /* R_M32C_16 */
13007 case EM_CYGNUS_MN10200
:
13009 return reloc_type
== 2; /* R_MN10200_16. */
13010 case EM_CYGNUS_MN10300
:
13012 return reloc_type
== 2; /* R_MN10300_16. */
13014 if (uses_msp430x_relocs (filedata
))
13015 return reloc_type
== 2; /* R_MSP430_ABS16. */
13016 /* Fall through. */
13017 case EM_MSP430_OLD
:
13018 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13020 return reloc_type
== 19; /* R_NDS32_RELA. */
13021 case EM_ALTERA_NIOS2
:
13022 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13024 return reloc_type
== 9; /* R_NIOS_16. */
13026 return reloc_type
== 2; /* R_OR1K_16. */
13028 return reloc_type
== 55; /* R_RISCV_SET16. */
13030 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13032 return reloc_type
== 2; /* R_C6000_ABS16. */
13034 return reloc_type
== 2; /* R_VISIUM_16. */
13037 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13039 return reloc_type
== 3; /* R_XGATE_16. */
13041 return reloc_type
== 4; /* R_Z80_16. */
13047 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13048 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13051 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13053 switch (filedata
->file_header
.e_machine
)
13056 return reloc_type
== 54; /* R_RISCV_SET8. */
13058 return reloc_type
== 1; /* R_Z80_8. */
13064 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13065 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13068 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13070 switch (filedata
->file_header
.e_machine
)
13073 return reloc_type
== 53; /* R_RISCV_SET6. */
13079 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13080 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13083 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13085 /* Please keep this table alpha-sorted for ease of visual lookup. */
13086 switch (filedata
->file_header
.e_machine
)
13089 return reloc_type
== 35; /* R_RISCV_ADD32. */
13095 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13096 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13099 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13101 /* Please keep this table alpha-sorted for ease of visual lookup. */
13102 switch (filedata
->file_header
.e_machine
)
13105 return reloc_type
== 39; /* R_RISCV_SUB32. */
13111 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13112 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13115 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13117 /* Please keep this table alpha-sorted for ease of visual lookup. */
13118 switch (filedata
->file_header
.e_machine
)
13121 return reloc_type
== 36; /* R_RISCV_ADD64. */
13127 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13128 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13131 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13133 /* Please keep this table alpha-sorted for ease of visual lookup. */
13134 switch (filedata
->file_header
.e_machine
)
13137 return reloc_type
== 40; /* R_RISCV_SUB64. */
13143 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13144 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13147 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13149 /* Please keep this table alpha-sorted for ease of visual lookup. */
13150 switch (filedata
->file_header
.e_machine
)
13153 return reloc_type
== 34; /* R_RISCV_ADD16. */
13159 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13160 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13163 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13165 /* Please keep this table alpha-sorted for ease of visual lookup. */
13166 switch (filedata
->file_header
.e_machine
)
13169 return reloc_type
== 38; /* R_RISCV_SUB16. */
13175 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13176 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13179 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13181 /* Please keep this table alpha-sorted for ease of visual lookup. */
13182 switch (filedata
->file_header
.e_machine
)
13185 return reloc_type
== 33; /* R_RISCV_ADD8. */
13191 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13192 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13195 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13197 /* Please keep this table alpha-sorted for ease of visual lookup. */
13198 switch (filedata
->file_header
.e_machine
)
13201 return reloc_type
== 37; /* R_RISCV_SUB8. */
13207 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13208 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13211 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13213 switch (filedata
->file_header
.e_machine
)
13216 return reloc_type
== 52; /* R_RISCV_SUB6. */
13222 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13223 relocation entries (possibly formerly used for SHT_GROUP sections). */
13226 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13228 switch (filedata
->file_header
.e_machine
)
13230 case EM_386
: /* R_386_NONE. */
13231 case EM_68K
: /* R_68K_NONE. */
13232 case EM_ADAPTEVA_EPIPHANY
:
13233 case EM_ALPHA
: /* R_ALPHA_NONE. */
13234 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13235 case EM_ARC
: /* R_ARC_NONE. */
13236 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13237 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13238 case EM_ARM
: /* R_ARM_NONE. */
13239 case EM_C166
: /* R_XC16X_NONE. */
13240 case EM_CRIS
: /* R_CRIS_NONE. */
13241 case EM_FT32
: /* R_FT32_NONE. */
13242 case EM_IA_64
: /* R_IA64_NONE. */
13243 case EM_K1OM
: /* R_X86_64_NONE. */
13244 case EM_L1OM
: /* R_X86_64_NONE. */
13245 case EM_M32R
: /* R_M32R_NONE. */
13246 case EM_MIPS
: /* R_MIPS_NONE. */
13247 case EM_MN10300
: /* R_MN10300_NONE. */
13248 case EM_MOXIE
: /* R_MOXIE_NONE. */
13249 case EM_NIOS32
: /* R_NIOS_NONE. */
13250 case EM_OR1K
: /* R_OR1K_NONE. */
13251 case EM_PARISC
: /* R_PARISC_NONE. */
13252 case EM_PPC64
: /* R_PPC64_NONE. */
13253 case EM_PPC
: /* R_PPC_NONE. */
13254 case EM_RISCV
: /* R_RISCV_NONE. */
13255 case EM_S390
: /* R_390_NONE. */
13257 case EM_SH
: /* R_SH_NONE. */
13258 case EM_SPARC32PLUS
:
13259 case EM_SPARC
: /* R_SPARC_NONE. */
13261 case EM_TILEGX
: /* R_TILEGX_NONE. */
13262 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13263 case EM_TI_C6000
:/* R_C6000_NONE. */
13264 case EM_X86_64
: /* R_X86_64_NONE. */
13266 case EM_Z80
: /* R_Z80_NONE. */
13267 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13268 return reloc_type
== 0;
13271 return reloc_type
== 0 || reloc_type
== 256;
13274 return (reloc_type
== 0 /* R_AVR_NONE. */
13275 || reloc_type
== 30 /* R_AVR_DIFF8. */
13276 || reloc_type
== 31 /* R_AVR_DIFF16. */
13277 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13279 return reloc_type
== 3; /* R_METAG_NONE. */
13281 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13282 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13283 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13284 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13285 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13287 return (reloc_type
== 0 /* R_PRU_NONE. */
13288 || reloc_type
== 65 /* R_PRU_DIFF8. */
13289 || reloc_type
== 66 /* R_PRU_DIFF16. */
13290 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13291 case EM_XTENSA_OLD
:
13293 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13294 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13295 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13296 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13301 /* Returns TRUE if there is a relocation against
13302 section NAME at OFFSET bytes. */
13305 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13307 Elf_Internal_Rela
* relocs
;
13308 Elf_Internal_Rela
* rp
;
13310 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13313 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13315 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13316 if (rp
->r_offset
== offset
)
13322 /* Apply relocations to a section.
13323 Returns TRUE upon success, FALSE otherwise.
13324 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13325 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13326 will be set to the number of relocs loaded.
13328 Note: So far support has been added only for those relocations
13329 which can be found in debug sections. FIXME: Add support for
13330 more relocations ? */
13333 apply_relocations (Filedata
* filedata
,
13334 const Elf_Internal_Shdr
* section
,
13335 unsigned char * start
,
13336 bfd_size_type size
,
13337 void ** relocs_return
,
13338 unsigned long * num_relocs_return
)
13340 Elf_Internal_Shdr
* relsec
;
13341 unsigned char * end
= start
+ size
;
13343 if (relocs_return
!= NULL
)
13345 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13346 * num_relocs_return
= 0;
13349 if (filedata
->file_header
.e_type
!= ET_REL
)
13350 /* No relocs to apply. */
13353 /* Find the reloc section associated with the section. */
13354 for (relsec
= filedata
->section_headers
;
13355 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13358 bfd_boolean is_rela
;
13359 unsigned long num_relocs
;
13360 Elf_Internal_Rela
* relocs
;
13361 Elf_Internal_Rela
* rp
;
13362 Elf_Internal_Shdr
* symsec
;
13363 Elf_Internal_Sym
* symtab
;
13364 unsigned long num_syms
;
13365 Elf_Internal_Sym
* sym
;
13367 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13368 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13369 || filedata
->section_headers
+ relsec
->sh_info
!= section
13370 || relsec
->sh_size
== 0
13371 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13374 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13375 if (symsec
->sh_type
!= SHT_SYMTAB
13376 && symsec
->sh_type
!= SHT_DYNSYM
)
13379 is_rela
= relsec
->sh_type
== SHT_RELA
;
13383 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13384 relsec
->sh_size
, & relocs
, & num_relocs
))
13389 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13390 relsec
->sh_size
, & relocs
, & num_relocs
))
13394 /* SH uses RELA but uses in place value instead of the addend field. */
13395 if (filedata
->file_header
.e_machine
== EM_SH
)
13398 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13400 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13403 unsigned int reloc_type
;
13404 unsigned int reloc_size
;
13405 bfd_boolean reloc_inplace
= FALSE
;
13406 bfd_boolean reloc_subtract
= FALSE
;
13407 unsigned char * rloc
;
13408 unsigned long sym_index
;
13410 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13412 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13414 else if (is_none_reloc (filedata
, reloc_type
))
13416 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13417 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13419 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13420 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13422 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13424 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13426 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13427 || is_6bit_abs_reloc (filedata
, reloc_type
))
13429 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13431 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13434 reloc_inplace
= TRUE
;
13436 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13438 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13441 reloc_inplace
= TRUE
;
13443 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13445 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13448 reloc_inplace
= TRUE
;
13450 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13452 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13455 reloc_inplace
= TRUE
;
13457 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13461 reloc_inplace
= TRUE
;
13465 static unsigned int prev_reloc
= 0;
13467 if (reloc_type
!= prev_reloc
)
13468 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13469 reloc_type
, printable_section_name (filedata
, section
));
13470 prev_reloc
= reloc_type
;
13474 rloc
= start
+ rp
->r_offset
;
13475 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13477 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13478 (unsigned long) rp
->r_offset
,
13479 printable_section_name (filedata
, section
));
13483 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13484 if (sym_index
>= num_syms
)
13486 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13487 sym_index
, printable_section_name (filedata
, section
));
13490 sym
= symtab
+ sym_index
;
13492 /* If the reloc has a symbol associated with it,
13493 make sure that it is of an appropriate type.
13495 Relocations against symbols without type can happen.
13496 Gcc -feliminate-dwarf2-dups may generate symbols
13497 without type for debug info.
13499 Icc generates relocations against function symbols
13500 instead of local labels.
13502 Relocations against object symbols can happen, eg when
13503 referencing a global array. For an example of this see
13504 the _clz.o binary in libgcc.a. */
13506 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13507 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13509 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13510 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13511 printable_section_name (filedata
, relsec
),
13512 (long int)(rp
- relocs
));
13518 addend
+= rp
->r_addend
;
13519 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13520 partial_inplace. */
13522 || (filedata
->file_header
.e_machine
== EM_XTENSA
13523 && reloc_type
== 1)
13524 || ((filedata
->file_header
.e_machine
== EM_PJ
13525 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13526 && reloc_type
== 1)
13527 || ((filedata
->file_header
.e_machine
== EM_D30V
13528 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13529 && reloc_type
== 12)
13532 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13533 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13535 addend
+= byte_get (rloc
, reloc_size
);
13538 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13539 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13541 /* On HPPA, all pc-relative relocations are biased by 8. */
13542 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13544 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13547 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13548 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13550 if (reloc_subtract
)
13551 addend
-= sym
->st_value
;
13553 addend
+= sym
->st_value
;
13554 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13555 byte_put (rloc
, addend
, reloc_size
);
13557 else if (reloc_subtract
)
13558 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13560 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13564 /* Let the target specific reloc processing code know that
13565 we have finished with these relocs. */
13566 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13570 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13571 * num_relocs_return
= num_relocs
;
13582 #ifdef SUPPORT_DISASSEMBLY
13584 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13586 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13588 /* FIXME: XXX -- to be done --- XXX */
13594 /* Reads in the contents of SECTION from FILE, returning a pointer
13595 to a malloc'ed buffer or NULL if something went wrong. */
13598 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13600 bfd_size_type num_bytes
= section
->sh_size
;
13602 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13604 printf (_("Section '%s' has no data to dump.\n"),
13605 printable_section_name (filedata
, section
));
13609 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13610 _("section contents"));
13613 /* Uncompresses a section that was compressed using zlib, in place. */
13616 uncompress_section_contents (unsigned char ** buffer
,
13617 dwarf_size_type uncompressed_size
,
13618 dwarf_size_type
* size
)
13620 dwarf_size_type compressed_size
= *size
;
13621 unsigned char * compressed_buffer
= *buffer
;
13622 unsigned char * uncompressed_buffer
;
13626 /* It is possible the section consists of several compressed
13627 buffers concatenated together, so we uncompress in a loop. */
13628 /* PR 18313: The state field in the z_stream structure is supposed
13629 to be invisible to the user (ie us), but some compilers will
13630 still complain about it being used without initialisation. So
13631 we first zero the entire z_stream structure and then set the fields
13633 memset (& strm
, 0, sizeof strm
);
13634 strm
.avail_in
= compressed_size
;
13635 strm
.next_in
= (Bytef
*) compressed_buffer
;
13636 strm
.avail_out
= uncompressed_size
;
13637 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13639 rc
= inflateInit (& strm
);
13640 while (strm
.avail_in
> 0)
13644 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13645 + (uncompressed_size
- strm
.avail_out
));
13646 rc
= inflate (&strm
, Z_FINISH
);
13647 if (rc
!= Z_STREAM_END
)
13649 rc
= inflateReset (& strm
);
13651 rc
= inflateEnd (& strm
);
13653 || strm
.avail_out
!= 0)
13656 *buffer
= uncompressed_buffer
;
13657 *size
= uncompressed_size
;
13661 free (uncompressed_buffer
);
13662 /* Indicate decompression failure. */
13668 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13670 Elf_Internal_Shdr
* relsec
;
13671 bfd_size_type num_bytes
;
13672 unsigned char * data
;
13673 unsigned char * end
;
13674 unsigned char * real_start
;
13675 unsigned char * start
;
13676 bfd_boolean some_strings_shown
;
13678 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13680 /* PR 21820: Do not fail if the section was empty. */
13681 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13683 num_bytes
= section
->sh_size
;
13685 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13687 if (decompress_dumps
)
13689 dwarf_size_type new_size
= num_bytes
;
13690 dwarf_size_type uncompressed_size
= 0;
13692 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13694 Elf_Internal_Chdr chdr
;
13695 unsigned int compression_header_size
13696 = get_compression_header (& chdr
, (unsigned char *) start
,
13698 if (compression_header_size
== 0)
13699 /* An error message will have already been generated
13700 by get_compression_header. */
13703 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13705 warn (_("section '%s' has unsupported compress type: %d\n"),
13706 printable_section_name (filedata
, section
), chdr
.ch_type
);
13709 uncompressed_size
= chdr
.ch_size
;
13710 start
+= compression_header_size
;
13711 new_size
-= compression_header_size
;
13713 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13715 /* Read the zlib header. In this case, it should be "ZLIB"
13716 followed by the uncompressed section size, 8 bytes in
13717 big-endian order. */
13718 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13719 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13720 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13721 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13722 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13723 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13724 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13725 uncompressed_size
+= start
[11];
13730 if (uncompressed_size
)
13732 if (uncompress_section_contents (& start
,
13733 uncompressed_size
, & new_size
))
13734 num_bytes
= new_size
;
13737 error (_("Unable to decompress section %s\n"),
13738 printable_section_name (filedata
, section
));
13743 start
= real_start
;
13746 /* If the section being dumped has relocations against it the user might
13747 be expecting these relocations to have been applied. Check for this
13748 case and issue a warning message in order to avoid confusion.
13749 FIXME: Maybe we ought to have an option that dumps a section with
13750 relocs applied ? */
13751 for (relsec
= filedata
->section_headers
;
13752 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13755 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13756 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13757 || filedata
->section_headers
+ relsec
->sh_info
!= section
13758 || relsec
->sh_size
== 0
13759 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13762 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13767 end
= start
+ num_bytes
;
13768 some_strings_shown
= FALSE
;
13770 #ifdef HAVE_MBSTATE_T
13772 /* Initialise the multibyte conversion state. */
13773 memset (& state
, 0, sizeof (state
));
13776 bfd_boolean continuing
= FALSE
;
13780 while (!ISPRINT (* data
))
13781 if (++ data
>= end
)
13786 size_t maxlen
= end
- data
;
13791 continuing
= FALSE
;
13796 /* PR 11128: Use two separate invocations in order to work
13797 around bugs in the Solaris 8 implementation of printf. */
13798 printf (" [%6tx] ", data
- start
);
13800 printf (" [%6Ix] ", (size_t) (data
- start
));
13815 /* PR 25543: Treat new-lines as string-ending characters. */
13824 /* Do not print control characters directly as they can affect terminal
13825 settings. Such characters usually appear in the names generated
13826 by the assembler for local labels. */
13829 printf ("^%c", c
+ 0x40);
13831 else if (ISPRINT (c
))
13838 #ifdef HAVE_MBSTATE_T
13841 /* Let printf do the hard work of displaying multibyte characters. */
13842 printf ("%.1s", data
- 1);
13843 #ifdef HAVE_MBSTATE_T
13844 /* Try to find out how many bytes made up the character that was
13845 just printed. Advance the symbol pointer past the bytes that
13847 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
13851 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
13861 printf (_("<corrupt>\n"));
13864 some_strings_shown
= TRUE
;
13868 if (! some_strings_shown
)
13869 printf (_(" No strings found in this section."));
13882 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13883 Filedata
* filedata
,
13884 bfd_boolean relocate
)
13886 Elf_Internal_Shdr
* relsec
;
13887 bfd_size_type bytes
;
13888 bfd_size_type section_size
;
13890 unsigned char * data
;
13891 unsigned char * real_start
;
13892 unsigned char * start
;
13894 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13896 /* PR 21820: Do not fail if the section was empty. */
13897 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13899 section_size
= section
->sh_size
;
13901 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13903 if (decompress_dumps
)
13905 dwarf_size_type new_size
= section_size
;
13906 dwarf_size_type uncompressed_size
= 0;
13908 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13910 Elf_Internal_Chdr chdr
;
13911 unsigned int compression_header_size
13912 = get_compression_header (& chdr
, start
, section_size
);
13914 if (compression_header_size
== 0)
13915 /* An error message will have already been generated
13916 by get_compression_header. */
13919 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13921 warn (_("section '%s' has unsupported compress type: %d\n"),
13922 printable_section_name (filedata
, section
), chdr
.ch_type
);
13925 uncompressed_size
= chdr
.ch_size
;
13926 start
+= compression_header_size
;
13927 new_size
-= compression_header_size
;
13929 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13931 /* Read the zlib header. In this case, it should be "ZLIB"
13932 followed by the uncompressed section size, 8 bytes in
13933 big-endian order. */
13934 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13935 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13936 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13937 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13938 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13939 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13940 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13941 uncompressed_size
+= start
[11];
13946 if (uncompressed_size
)
13948 if (uncompress_section_contents (& start
, uncompressed_size
,
13951 section_size
= new_size
;
13955 error (_("Unable to decompress section %s\n"),
13956 printable_section_name (filedata
, section
));
13957 /* FIXME: Print the section anyway ? */
13962 start
= real_start
;
13967 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13972 /* If the section being dumped has relocations against it the user might
13973 be expecting these relocations to have been applied. Check for this
13974 case and issue a warning message in order to avoid confusion.
13975 FIXME: Maybe we ought to have an option that dumps a section with
13976 relocs applied ? */
13977 for (relsec
= filedata
->section_headers
;
13978 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13981 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13982 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13983 || filedata
->section_headers
+ relsec
->sh_info
!= section
13984 || relsec
->sh_size
== 0
13985 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13988 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13993 addr
= section
->sh_addr
;
13994 bytes
= section_size
;
14003 lbytes
= (bytes
> 16 ? 16 : bytes
);
14005 printf (" 0x%8.8lx ", (unsigned long) addr
);
14007 for (j
= 0; j
< 16; j
++)
14010 printf ("%2.2x", data
[j
]);
14018 for (j
= 0; j
< lbytes
; j
++)
14021 if (k
>= ' ' && k
< 0x7f)
14044 static ctf_sect_t
*
14045 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14047 buf
->cts_name
= SECTION_NAME (shdr
);
14048 buf
->cts_size
= shdr
->sh_size
;
14049 buf
->cts_entsize
= shdr
->sh_entsize
;
14054 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14055 it is passed, or a pointer to newly-allocated storage, in which case
14056 dump_ctf() will free it when it no longer needs it. */
14058 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14059 char *s
, void *arg
)
14061 const char *blanks
= arg
;
14064 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14070 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14072 Elf_Internal_Shdr
* parent_sec
= NULL
;
14073 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14074 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14075 void * data
= NULL
;
14076 void * symdata
= NULL
;
14077 void * strdata
= NULL
;
14078 void * parentdata
= NULL
;
14079 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14080 ctf_sect_t
* symsectp
= NULL
;
14081 ctf_sect_t
* strsectp
= NULL
;
14082 ctf_file_t
* ctf
= NULL
;
14083 ctf_file_t
* parent
= NULL
;
14085 const char *things
[] = {"Header", "Labels", "Data objects",
14086 "Function objects", "Variables", "Types", "Strings",
14088 const char **thing
;
14090 bfd_boolean ret
= FALSE
;
14093 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14094 data
= get_section_contents (section
, filedata
);
14095 ctfsect
.cts_data
= data
;
14097 if (!dump_ctf_symtab_name
)
14098 dump_ctf_symtab_name
= strdup (".symtab");
14100 if (!dump_ctf_strtab_name
)
14101 dump_ctf_strtab_name
= strdup (".strtab");
14103 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14105 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14107 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14110 if ((symdata
= (void *) get_data (NULL
, filedata
,
14111 symtab_sec
->sh_offset
, 1,
14112 symtab_sec
->sh_size
,
14113 _("symbols"))) == NULL
)
14115 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14116 symsect
.cts_data
= symdata
;
14118 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14120 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14122 error (_("No string table section named %s\n"),
14123 dump_ctf_strtab_name
);
14126 if ((strdata
= (void *) get_data (NULL
, filedata
,
14127 strtab_sec
->sh_offset
, 1,
14128 strtab_sec
->sh_size
,
14129 _("strings"))) == NULL
)
14131 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14132 strsect
.cts_data
= strdata
;
14134 if (dump_ctf_parent_name
)
14136 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14138 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14141 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14142 parent_sec
->sh_offset
, 1,
14143 parent_sec
->sh_size
,
14144 _("CTF parent"))) == NULL
)
14146 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14147 parentsect
.cts_data
= parentdata
;
14150 /* Load the CTF file and dump it. */
14152 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14154 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14160 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14162 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14166 ctf_import (ctf
, parent
);
14171 printf (_("\nDump of CTF section '%s':\n"),
14172 printable_section_name (filedata
, section
));
14174 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14176 ctf_dump_state_t
*s
= NULL
;
14179 printf ("\n %s:\n", *thing
);
14180 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14181 (void *) " ")) != NULL
)
14183 printf ("%s\n", item
);
14187 if (ctf_errno (ctf
))
14189 error (_("Iteration failed: %s, %s\n"), *thing
,
14190 ctf_errmsg (ctf_errno (ctf
)));
14196 ctf_file_close (ctf
);
14197 ctf_file_close (parent
);
14206 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14207 const Elf_Internal_Shdr
* sec
,
14210 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14212 Filedata
* filedata
= (Filedata
*) data
;
14214 if (section
->start
!= NULL
)
14216 /* If it is already loaded, do nothing. */
14217 if (streq (section
->filename
, filedata
->file_name
))
14219 free (section
->start
);
14222 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14223 section
->address
= sec
->sh_addr
;
14224 section
->user_data
= NULL
;
14225 section
->filename
= filedata
->file_name
;
14226 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14228 sec
->sh_size
, buf
);
14229 if (section
->start
== NULL
)
14233 unsigned char *start
= section
->start
;
14234 dwarf_size_type size
= sec
->sh_size
;
14235 dwarf_size_type uncompressed_size
= 0;
14237 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14239 Elf_Internal_Chdr chdr
;
14240 unsigned int compression_header_size
;
14242 if (size
< (is_32bit_elf
14243 ? sizeof (Elf32_External_Chdr
)
14244 : sizeof (Elf64_External_Chdr
)))
14246 warn (_("compressed section %s is too small to contain a compression header\n"),
14251 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14252 if (compression_header_size
== 0)
14253 /* An error message will have already been generated
14254 by get_compression_header. */
14257 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14259 warn (_("section '%s' has unsupported compress type: %d\n"),
14260 section
->name
, chdr
.ch_type
);
14263 uncompressed_size
= chdr
.ch_size
;
14264 start
+= compression_header_size
;
14265 size
-= compression_header_size
;
14267 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14269 /* Read the zlib header. In this case, it should be "ZLIB"
14270 followed by the uncompressed section size, 8 bytes in
14271 big-endian order. */
14272 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14273 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14274 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14275 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14276 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14277 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14278 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14279 uncompressed_size
+= start
[11];
14284 if (uncompressed_size
)
14286 if (uncompress_section_contents (&start
, uncompressed_size
,
14289 /* Free the compressed buffer, update the section buffer
14290 and the section size if uncompress is successful. */
14291 free (section
->start
);
14292 section
->start
= start
;
14296 error (_("Unable to decompress section %s\n"),
14297 printable_section_name (filedata
, sec
));
14302 section
->size
= size
;
14305 if (section
->start
== NULL
)
14308 if (debug_displays
[debug
].relocate
)
14310 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14311 & section
->reloc_info
, & section
->num_relocs
))
14316 section
->reloc_info
= NULL
;
14317 section
->num_relocs
= 0;
14323 #if HAVE_LIBDEBUGINFOD
14324 /* Return a hex string representation of the build-id. */
14326 get_build_id (void * data
)
14328 Filedata
* filedata
= (Filedata
*)data
;
14329 Elf_Internal_Shdr
* shdr
;
14332 /* Iterate through notes to find note.gnu.build-id.
14333 FIXME: Only the first note in any note section is examined. */
14334 for (i
= 0, shdr
= filedata
->section_headers
;
14335 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14338 if (shdr
->sh_type
!= SHT_NOTE
)
14343 size_t data_remaining
;
14345 Elf_External_Note
* enote
;
14346 Elf_Internal_Note inote
;
14348 bfd_vma offset
= shdr
->sh_offset
;
14349 bfd_vma align
= shdr
->sh_addralign
;
14350 bfd_vma length
= shdr
->sh_size
;
14352 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14358 else if (align
!= 4 && align
!= 8)
14364 end
= (char *) enote
+ length
;
14365 data_remaining
= end
- (char *) enote
;
14367 if (!is_ia64_vms (filedata
))
14369 min_notesz
= offsetof (Elf_External_Note
, name
);
14370 if (data_remaining
< min_notesz
)
14373 malformed note encountered in section %s whilst scanning for build-id note\n"),
14374 printable_section_name (filedata
, shdr
));
14378 data_remaining
-= min_notesz
;
14380 inote
.type
= BYTE_GET (enote
->type
);
14381 inote
.namesz
= BYTE_GET (enote
->namesz
);
14382 inote
.namedata
= enote
->name
;
14383 inote
.descsz
= BYTE_GET (enote
->descsz
);
14384 inote
.descdata
= ((char *) enote
14385 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14386 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14387 next
= ((char *) enote
14388 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14392 Elf64_External_VMS_Note
*vms_enote
;
14394 /* PR binutils/15191
14395 Make sure that there is enough data to read. */
14396 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14397 if (data_remaining
< min_notesz
)
14400 malformed note encountered in section %s whilst scanning for build-id note\n"),
14401 printable_section_name (filedata
, shdr
));
14405 data_remaining
-= min_notesz
;
14407 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14408 inote
.type
= BYTE_GET (vms_enote
->type
);
14409 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14410 inote
.namedata
= vms_enote
->name
;
14411 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14412 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14413 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14414 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14417 /* Skip malformed notes. */
14418 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14419 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14420 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14421 || ((size_t) (next
- inote
.descdata
)
14422 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14425 malformed note encountered in section %s whilst scanning for build-id note\n"),
14426 printable_section_name (filedata
, shdr
));
14431 /* Check if this is the build-id note. If so then convert the build-id
14432 bytes to a hex string. */
14433 if (inote
.namesz
> 0
14434 && const_strneq (inote
.namedata
, "GNU")
14435 && inote
.type
== NT_GNU_BUILD_ID
)
14440 build_id
= malloc (inote
.descsz
* 2 + 1);
14441 if (build_id
== NULL
)
14447 for (j
= 0; j
< inote
.descsz
; ++j
)
14448 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14449 build_id
[inote
.descsz
* 2] = '\0';
14452 return (unsigned char *) build_id
;
14459 #endif /* HAVE_LIBDEBUGINFOD */
14461 /* If this is not NULL, load_debug_section will only look for sections
14462 within the list of sections given here. */
14463 static unsigned int * section_subset
= NULL
;
14466 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14468 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14469 Elf_Internal_Shdr
* sec
;
14470 Filedata
* filedata
= (Filedata
*) data
;
14472 /* Without section headers we cannot find any sections. */
14473 if (filedata
->section_headers
== NULL
)
14476 if (filedata
->string_table
== NULL
14477 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14478 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14480 Elf_Internal_Shdr
* strs
;
14482 /* Read in the string table, so that we have section names to scan. */
14483 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14485 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14487 filedata
->string_table
14488 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14489 1, strs
->sh_size
, _("string table"));
14491 filedata
->string_table_length
14492 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14496 /* Locate the debug section. */
14497 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14499 section
->name
= section
->uncompressed_name
;
14502 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14504 section
->name
= section
->compressed_name
;
14509 /* If we're loading from a subset of sections, and we've loaded
14510 a section matching this name before, it's likely that it's a
14512 if (section_subset
!= NULL
)
14513 free_debug_section (debug
);
14515 return load_specific_debug_section (debug
, sec
, data
);
14519 free_debug_section (enum dwarf_section_display_enum debug
)
14521 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14523 if (section
->start
== NULL
)
14526 free ((char *) section
->start
);
14527 section
->start
= NULL
;
14528 section
->address
= 0;
14531 if (section
->reloc_info
!= NULL
)
14533 free (section
->reloc_info
);
14534 section
->reloc_info
= NULL
;
14535 section
->num_relocs
= 0;
14540 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14542 char * name
= SECTION_NAME (section
);
14543 const char * print_name
= printable_section_name (filedata
, section
);
14544 bfd_size_type length
;
14545 bfd_boolean result
= TRUE
;
14548 length
= section
->sh_size
;
14551 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14554 if (section
->sh_type
== SHT_NOBITS
)
14556 /* There is no point in dumping the contents of a debugging section
14557 which has the NOBITS type - the bits in the file will be random.
14558 This can happen when a file containing a .eh_frame section is
14559 stripped with the --only-keep-debug command line option. */
14560 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14565 if (const_strneq (name
, ".gnu.linkonce.wi."))
14566 name
= ".debug_info";
14568 /* See if we know how to display the contents of this section. */
14569 for (i
= 0; i
< max
; i
++)
14571 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14572 struct dwarf_section_display
* display
= debug_displays
+ i
;
14573 struct dwarf_section
* sec
= & display
->section
;
14575 if (streq (sec
->uncompressed_name
, name
)
14576 || (id
== line
&& const_strneq (name
, ".debug_line."))
14577 || streq (sec
->compressed_name
, name
))
14579 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14582 free_debug_section (id
);
14584 if (i
== line
&& const_strneq (name
, ".debug_line."))
14586 else if (streq (sec
->uncompressed_name
, name
))
14587 sec
->name
= sec
->uncompressed_name
;
14589 sec
->name
= sec
->compressed_name
;
14591 if (load_specific_debug_section (id
, section
, filedata
))
14593 /* If this debug section is part of a CU/TU set in a .dwp file,
14594 restrict load_debug_section to the sections in that set. */
14595 section_subset
= find_cu_tu_set (filedata
, shndx
);
14597 result
&= display
->display (sec
, filedata
);
14599 section_subset
= NULL
;
14601 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14602 free_debug_section (id
);
14610 printf (_("Unrecognized debug section: %s\n"), print_name
);
14617 /* Set DUMP_SECTS for all sections where dumps were requested
14618 based on section name. */
14621 initialise_dumps_byname (Filedata
* filedata
)
14623 struct dump_list_entry
* cur
;
14625 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14628 bfd_boolean any
= FALSE
;
14630 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14631 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14633 request_dump_bynumber (filedata
, i
, cur
->type
);
14638 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14644 process_section_contents (Filedata
* filedata
)
14646 Elf_Internal_Shdr
* section
;
14648 bfd_boolean res
= TRUE
;
14653 initialise_dumps_byname (filedata
);
14655 for (i
= 0, section
= filedata
->section_headers
;
14656 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14659 dump_type dump
= filedata
->dump_sects
[i
];
14661 #ifdef SUPPORT_DISASSEMBLY
14662 if (dump
& DISASS_DUMP
)
14664 if (! disassemble_section (section
, filedata
))
14668 if (dump
& HEX_DUMP
)
14670 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14674 if (dump
& RELOC_DUMP
)
14676 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14680 if (dump
& STRING_DUMP
)
14682 if (! dump_section_as_strings (section
, filedata
))
14686 if (dump
& DEBUG_DUMP
)
14688 if (! display_debug_section (i
, section
, filedata
))
14692 if (dump
& CTF_DUMP
)
14694 if (! dump_section_as_ctf (section
, filedata
))
14699 /* Check to see if the user requested a
14700 dump of a section that does not exist. */
14701 while (i
< filedata
->num_dump_sects
)
14703 if (filedata
->dump_sects
[i
])
14705 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14715 process_mips_fpe_exception (int mask
)
14719 bfd_boolean first
= TRUE
;
14721 if (mask
& OEX_FPU_INEX
)
14722 fputs ("INEX", stdout
), first
= FALSE
;
14723 if (mask
& OEX_FPU_UFLO
)
14724 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14725 if (mask
& OEX_FPU_OFLO
)
14726 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14727 if (mask
& OEX_FPU_DIV0
)
14728 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14729 if (mask
& OEX_FPU_INVAL
)
14730 printf ("%sINVAL", first
? "" : "|");
14733 fputs ("0", stdout
);
14736 /* Display's the value of TAG at location P. If TAG is
14737 greater than 0 it is assumed to be an unknown tag, and
14738 a message is printed to this effect. Otherwise it is
14739 assumed that a message has already been printed.
14741 If the bottom bit of TAG is set it assumed to have a
14742 string value, otherwise it is assumed to have an integer
14745 Returns an updated P pointing to the first unread byte
14746 beyond the end of TAG's value.
14748 Reads at or beyond END will not be made. */
14750 static unsigned char *
14751 display_tag_value (signed int tag
,
14753 const unsigned char * const end
)
14758 printf (" Tag_unknown_%d: ", tag
);
14762 warn (_("<corrupt tag>\n"));
14766 /* PR 17531 file: 027-19978-0.004. */
14767 size_t maxlen
= (end
- p
) - 1;
14772 print_symbol ((int) maxlen
, (const char *) p
);
14773 p
+= strnlen ((char *) p
, maxlen
) + 1;
14777 printf (_("<corrupt string tag>"));
14778 p
= (unsigned char *) end
;
14784 READ_ULEB (val
, p
, end
);
14785 printf ("%ld (0x%lx)\n", val
, val
);
14792 /* ARC ABI attributes section. */
14794 static unsigned char *
14795 display_arc_attribute (unsigned char * p
,
14796 const unsigned char * const end
)
14801 READ_ULEB (tag
, p
, end
);
14805 case Tag_ARC_PCS_config
:
14806 READ_ULEB (val
, p
, end
);
14807 printf (" Tag_ARC_PCS_config: ");
14811 printf (_("Absent/Non standard\n"));
14814 printf (_("Bare metal/mwdt\n"));
14817 printf (_("Bare metal/newlib\n"));
14820 printf (_("Linux/uclibc\n"));
14823 printf (_("Linux/glibc\n"));
14826 printf (_("Unknown\n"));
14831 case Tag_ARC_CPU_base
:
14832 READ_ULEB (val
, p
, end
);
14833 printf (" Tag_ARC_CPU_base: ");
14838 printf (_("Absent\n"));
14840 case TAG_CPU_ARC6xx
:
14841 printf ("ARC6xx\n");
14843 case TAG_CPU_ARC7xx
:
14844 printf ("ARC7xx\n");
14846 case TAG_CPU_ARCEM
:
14847 printf ("ARCEM\n");
14849 case TAG_CPU_ARCHS
:
14850 printf ("ARCHS\n");
14855 case Tag_ARC_CPU_variation
:
14856 READ_ULEB (val
, p
, end
);
14857 printf (" Tag_ARC_CPU_variation: ");
14861 if (val
> 0 && val
< 16)
14862 printf ("Core%d\n", val
);
14864 printf ("Unknown\n");
14868 printf (_("Absent\n"));
14873 case Tag_ARC_CPU_name
:
14874 printf (" Tag_ARC_CPU_name: ");
14875 p
= display_tag_value (-1, p
, end
);
14878 case Tag_ARC_ABI_rf16
:
14879 READ_ULEB (val
, p
, end
);
14880 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14883 case Tag_ARC_ABI_osver
:
14884 READ_ULEB (val
, p
, end
);
14885 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14888 case Tag_ARC_ABI_pic
:
14889 case Tag_ARC_ABI_sda
:
14890 READ_ULEB (val
, p
, end
);
14891 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14892 : " Tag_ARC_ABI_pic: ");
14896 printf (_("Absent\n"));
14905 printf (_("Unknown\n"));
14910 case Tag_ARC_ABI_tls
:
14911 READ_ULEB (val
, p
, end
);
14912 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14915 case Tag_ARC_ABI_enumsize
:
14916 READ_ULEB (val
, p
, end
);
14917 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14921 case Tag_ARC_ABI_exceptions
:
14922 READ_ULEB (val
, p
, end
);
14923 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14927 case Tag_ARC_ABI_double_size
:
14928 READ_ULEB (val
, p
, end
);
14929 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14932 case Tag_ARC_ISA_config
:
14933 printf (" Tag_ARC_ISA_config: ");
14934 p
= display_tag_value (-1, p
, end
);
14937 case Tag_ARC_ISA_apex
:
14938 printf (" Tag_ARC_ISA_apex: ");
14939 p
= display_tag_value (-1, p
, end
);
14942 case Tag_ARC_ISA_mpy_option
:
14943 READ_ULEB (val
, p
, end
);
14944 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14947 case Tag_ARC_ATR_version
:
14948 READ_ULEB (val
, p
, end
);
14949 printf (" Tag_ARC_ATR_version: %d\n", val
);
14953 return display_tag_value (tag
& 1, p
, end
);
14959 /* ARM EABI attributes section. */
14964 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14966 const char ** table
;
14967 } arm_attr_public_tag
;
14969 static const char * arm_attr_tag_CPU_arch
[] =
14970 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14971 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14972 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14973 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14974 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14975 {"No", "Thumb-1", "Thumb-2", "Yes"};
14976 static const char * arm_attr_tag_FP_arch
[] =
14977 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14978 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14979 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14980 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14981 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14982 "NEON for ARMv8.1"};
14983 static const char * arm_attr_tag_PCS_config
[] =
14984 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14985 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14986 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14987 {"V6", "SB", "TLS", "Unused"};
14988 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14989 {"Absolute", "PC-relative", "SB-relative", "None"};
14990 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14991 {"Absolute", "PC-relative", "None"};
14992 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14993 {"None", "direct", "GOT-indirect"};
14994 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14995 {"None", "??? 1", "2", "??? 3", "4"};
14996 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14997 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14998 {"Unused", "Needed", "Sign only"};
14999 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15000 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15001 static const char * arm_attr_tag_ABI_FP_number_model
[] =
15002 {"Unused", "Finite", "RTABI", "IEEE 754"};
15003 static const char * arm_attr_tag_ABI_enum_size
[] =
15004 {"Unused", "small", "int", "forced to int"};
15005 static const char * arm_attr_tag_ABI_HardFP_use
[] =
15006 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15007 static const char * arm_attr_tag_ABI_VFP_args
[] =
15008 {"AAPCS", "VFP registers", "custom", "compatible"};
15009 static const char * arm_attr_tag_ABI_WMMX_args
[] =
15010 {"AAPCS", "WMMX registers", "custom"};
15011 static const char * arm_attr_tag_ABI_optimization_goals
[] =
15012 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15013 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15014 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
15015 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15016 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15017 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15018 static const char * arm_attr_tag_FP_HP_extension
[] =
15019 {"Not Allowed", "Allowed"};
15020 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
15021 {"None", "IEEE 754", "Alternative Format"};
15022 static const char * arm_attr_tag_DSP_extension
[] =
15023 {"Follow architecture", "Allowed"};
15024 static const char * arm_attr_tag_MPextension_use
[] =
15025 {"Not Allowed", "Allowed"};
15026 static const char * arm_attr_tag_DIV_use
[] =
15027 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15028 "Allowed in v7-A with integer division extension"};
15029 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15030 static const char * arm_attr_tag_Virtualization_use
[] =
15031 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15032 "TrustZone and Virtualization Extensions"};
15033 static const char * arm_attr_tag_MPextension_use_legacy
[] =
15034 {"Not Allowed", "Allowed"};
15036 static const char * arm_attr_tag_MVE_arch
[] =
15037 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15039 #define LOOKUP(id, name) \
15040 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15041 static arm_attr_public_tag arm_attr_public_tags
[] =
15043 {4, "CPU_raw_name", 1, NULL
},
15044 {5, "CPU_name", 1, NULL
},
15045 LOOKUP(6, CPU_arch
),
15046 {7, "CPU_arch_profile", 0, NULL
},
15047 LOOKUP(8, ARM_ISA_use
),
15048 LOOKUP(9, THUMB_ISA_use
),
15049 LOOKUP(10, FP_arch
),
15050 LOOKUP(11, WMMX_arch
),
15051 LOOKUP(12, Advanced_SIMD_arch
),
15052 LOOKUP(13, PCS_config
),
15053 LOOKUP(14, ABI_PCS_R9_use
),
15054 LOOKUP(15, ABI_PCS_RW_data
),
15055 LOOKUP(16, ABI_PCS_RO_data
),
15056 LOOKUP(17, ABI_PCS_GOT_use
),
15057 LOOKUP(18, ABI_PCS_wchar_t
),
15058 LOOKUP(19, ABI_FP_rounding
),
15059 LOOKUP(20, ABI_FP_denormal
),
15060 LOOKUP(21, ABI_FP_exceptions
),
15061 LOOKUP(22, ABI_FP_user_exceptions
),
15062 LOOKUP(23, ABI_FP_number_model
),
15063 {24, "ABI_align_needed", 0, NULL
},
15064 {25, "ABI_align_preserved", 0, NULL
},
15065 LOOKUP(26, ABI_enum_size
),
15066 LOOKUP(27, ABI_HardFP_use
),
15067 LOOKUP(28, ABI_VFP_args
),
15068 LOOKUP(29, ABI_WMMX_args
),
15069 LOOKUP(30, ABI_optimization_goals
),
15070 LOOKUP(31, ABI_FP_optimization_goals
),
15071 {32, "compatibility", 0, NULL
},
15072 LOOKUP(34, CPU_unaligned_access
),
15073 LOOKUP(36, FP_HP_extension
),
15074 LOOKUP(38, ABI_FP_16bit_format
),
15075 LOOKUP(42, MPextension_use
),
15076 LOOKUP(44, DIV_use
),
15077 LOOKUP(46, DSP_extension
),
15078 LOOKUP(48, MVE_arch
),
15079 {64, "nodefaults", 0, NULL
},
15080 {65, "also_compatible_with", 0, NULL
},
15081 LOOKUP(66, T2EE_use
),
15082 {67, "conformance", 1, NULL
},
15083 LOOKUP(68, Virtualization_use
),
15084 LOOKUP(70, MPextension_use_legacy
)
15088 static unsigned char *
15089 display_arm_attribute (unsigned char * p
,
15090 const unsigned char * const end
)
15094 arm_attr_public_tag
* attr
;
15098 READ_ULEB (tag
, p
, end
);
15100 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15102 if (arm_attr_public_tags
[i
].tag
== tag
)
15104 attr
= &arm_attr_public_tags
[i
];
15111 printf (" Tag_%s: ", attr
->name
);
15112 switch (attr
->type
)
15117 case 7: /* Tag_CPU_arch_profile. */
15118 READ_ULEB (val
, p
, end
);
15121 case 0: printf (_("None\n")); break;
15122 case 'A': printf (_("Application\n")); break;
15123 case 'R': printf (_("Realtime\n")); break;
15124 case 'M': printf (_("Microcontroller\n")); break;
15125 case 'S': printf (_("Application or Realtime\n")); break;
15126 default: printf ("??? (%d)\n", val
); break;
15130 case 24: /* Tag_align_needed. */
15131 READ_ULEB (val
, p
, end
);
15134 case 0: printf (_("None\n")); break;
15135 case 1: printf (_("8-byte\n")); break;
15136 case 2: printf (_("4-byte\n")); break;
15137 case 3: printf ("??? 3\n"); break;
15140 printf (_("8-byte and up to %d-byte extended\n"),
15143 printf ("??? (%d)\n", val
);
15148 case 25: /* Tag_align_preserved. */
15149 READ_ULEB (val
, p
, end
);
15152 case 0: printf (_("None\n")); break;
15153 case 1: printf (_("8-byte, except leaf SP\n")); break;
15154 case 2: printf (_("8-byte\n")); break;
15155 case 3: printf ("??? 3\n"); break;
15158 printf (_("8-byte and up to %d-byte extended\n"),
15161 printf ("??? (%d)\n", val
);
15166 case 32: /* Tag_compatibility. */
15168 READ_ULEB (val
, p
, end
);
15169 printf (_("flag = %d, vendor = "), val
);
15172 size_t maxlen
= (end
- p
) - 1;
15174 print_symbol ((int) maxlen
, (const char *) p
);
15175 p
+= strnlen ((char *) p
, maxlen
) + 1;
15179 printf (_("<corrupt>"));
15180 p
= (unsigned char *) end
;
15186 case 64: /* Tag_nodefaults. */
15187 /* PR 17531: file: 001-505008-0.01. */
15190 printf (_("True\n"));
15193 case 65: /* Tag_also_compatible_with. */
15194 READ_ULEB (val
, p
, end
);
15195 if (val
== 6 /* Tag_CPU_arch. */)
15197 READ_ULEB (val
, p
, end
);
15198 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15199 printf ("??? (%d)\n", val
);
15201 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15205 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15210 printf (_("<unknown: %d>\n"), tag
);
15216 return display_tag_value (-1, p
, end
);
15218 return display_tag_value (0, p
, end
);
15221 assert (attr
->type
& 0x80);
15222 READ_ULEB (val
, p
, end
);
15223 type
= attr
->type
& 0x7f;
15225 printf ("??? (%d)\n", val
);
15227 printf ("%s\n", attr
->table
[val
]);
15232 return display_tag_value (tag
, p
, end
);
15235 static unsigned char *
15236 display_gnu_attribute (unsigned char * p
,
15237 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15238 const unsigned char * const end
)
15243 READ_ULEB (tag
, p
, end
);
15245 /* Tag_compatibility is the only generic GNU attribute defined at
15249 READ_ULEB (val
, p
, end
);
15251 printf (_("flag = %d, vendor = "), val
);
15254 printf (_("<corrupt>\n"));
15255 warn (_("corrupt vendor attribute\n"));
15261 size_t maxlen
= (end
- p
) - 1;
15263 print_symbol ((int) maxlen
, (const char *) p
);
15264 p
+= strnlen ((char *) p
, maxlen
) + 1;
15268 printf (_("<corrupt>"));
15269 p
= (unsigned char *) end
;
15276 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15277 return display_proc_gnu_attribute (p
, tag
, end
);
15279 return display_tag_value (tag
, p
, end
);
15282 static unsigned char *
15283 display_power_gnu_attribute (unsigned char * p
,
15285 const unsigned char * const end
)
15289 if (tag
== Tag_GNU_Power_ABI_FP
)
15291 printf (" Tag_GNU_Power_ABI_FP: ");
15294 printf (_("<corrupt>\n"));
15297 READ_ULEB (val
, p
, end
);
15300 printf ("(%#x), ", val
);
15305 printf (_("unspecified hard/soft float, "));
15308 printf (_("hard float, "));
15311 printf (_("soft float, "));
15314 printf (_("single-precision hard float, "));
15321 printf (_("unspecified long double\n"));
15324 printf (_("128-bit IBM long double\n"));
15327 printf (_("64-bit long double\n"));
15330 printf (_("128-bit IEEE long double\n"));
15336 if (tag
== Tag_GNU_Power_ABI_Vector
)
15338 printf (" Tag_GNU_Power_ABI_Vector: ");
15341 printf (_("<corrupt>\n"));
15344 READ_ULEB (val
, p
, end
);
15347 printf ("(%#x), ", val
);
15352 printf (_("unspecified\n"));
15355 printf (_("generic\n"));
15358 printf ("AltiVec\n");
15367 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15369 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15372 printf (_("<corrupt>\n"));
15375 READ_ULEB (val
, p
, end
);
15378 printf ("(%#x), ", val
);
15383 printf (_("unspecified\n"));
15386 printf ("r3/r4\n");
15389 printf (_("memory\n"));
15398 return display_tag_value (tag
& 1, p
, end
);
15401 static unsigned char *
15402 display_s390_gnu_attribute (unsigned char * p
,
15404 const unsigned char * const end
)
15408 if (tag
== Tag_GNU_S390_ABI_Vector
)
15410 printf (" Tag_GNU_S390_ABI_Vector: ");
15411 READ_ULEB (val
, p
, end
);
15416 printf (_("any\n"));
15419 printf (_("software\n"));
15422 printf (_("hardware\n"));
15425 printf ("??? (%d)\n", val
);
15431 return display_tag_value (tag
& 1, p
, end
);
15435 display_sparc_hwcaps (unsigned int mask
)
15439 bfd_boolean first
= TRUE
;
15441 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15442 fputs ("mul32", stdout
), first
= FALSE
;
15443 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15444 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15445 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15446 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15447 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15448 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15449 if (mask
& ELF_SPARC_HWCAP_POPC
)
15450 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15451 if (mask
& ELF_SPARC_HWCAP_VIS
)
15452 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15453 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15454 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15455 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15456 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15457 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15458 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15459 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15460 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15461 if (mask
& ELF_SPARC_HWCAP_HPC
)
15462 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15463 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15464 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15465 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15466 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15467 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15468 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15469 if (mask
& ELF_SPARC_HWCAP_IMA
)
15470 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15471 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15472 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15475 fputc ('0', stdout
);
15476 fputc ('\n', stdout
);
15480 display_sparc_hwcaps2 (unsigned int mask
)
15484 bfd_boolean first
= TRUE
;
15486 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15487 fputs ("fjathplus", stdout
), first
= FALSE
;
15488 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15489 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15490 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15491 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15492 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15493 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15494 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15495 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15496 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15497 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15498 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15499 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15500 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15501 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15502 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15503 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15504 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15505 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15506 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15507 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15510 fputc ('0', stdout
);
15511 fputc ('\n', stdout
);
15514 static unsigned char *
15515 display_sparc_gnu_attribute (unsigned char * p
,
15517 const unsigned char * const end
)
15521 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15523 READ_ULEB (val
, p
, end
);
15524 printf (" Tag_GNU_Sparc_HWCAPS: ");
15525 display_sparc_hwcaps (val
);
15528 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15530 READ_ULEB (val
, p
, end
);
15531 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15532 display_sparc_hwcaps2 (val
);
15536 return display_tag_value (tag
, p
, end
);
15540 print_mips_fp_abi_value (unsigned int val
)
15544 case Val_GNU_MIPS_ABI_FP_ANY
:
15545 printf (_("Hard or soft float\n"));
15547 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15548 printf (_("Hard float (double precision)\n"));
15550 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15551 printf (_("Hard float (single precision)\n"));
15553 case Val_GNU_MIPS_ABI_FP_SOFT
:
15554 printf (_("Soft float\n"));
15556 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15557 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15559 case Val_GNU_MIPS_ABI_FP_XX
:
15560 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15562 case Val_GNU_MIPS_ABI_FP_64
:
15563 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15565 case Val_GNU_MIPS_ABI_FP_64A
:
15566 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15568 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15569 printf (_("NaN 2008 compatibility\n"));
15572 printf ("??? (%d)\n", val
);
15577 static unsigned char *
15578 display_mips_gnu_attribute (unsigned char * p
,
15580 const unsigned char * const end
)
15582 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15586 printf (" Tag_GNU_MIPS_ABI_FP: ");
15587 READ_ULEB (val
, p
, end
);
15588 print_mips_fp_abi_value (val
);
15592 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15596 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15597 READ_ULEB (val
, p
, end
);
15601 case Val_GNU_MIPS_ABI_MSA_ANY
:
15602 printf (_("Any MSA or not\n"));
15604 case Val_GNU_MIPS_ABI_MSA_128
:
15605 printf (_("128-bit MSA\n"));
15608 printf ("??? (%d)\n", val
);
15614 return display_tag_value (tag
& 1, p
, end
);
15617 static unsigned char *
15618 display_tic6x_attribute (unsigned char * p
,
15619 const unsigned char * const end
)
15624 READ_ULEB (tag
, p
, end
);
15629 printf (" Tag_ISA: ");
15630 READ_ULEB (val
, p
, end
);
15634 case C6XABI_Tag_ISA_none
:
15635 printf (_("None\n"));
15637 case C6XABI_Tag_ISA_C62X
:
15640 case C6XABI_Tag_ISA_C67X
:
15643 case C6XABI_Tag_ISA_C67XP
:
15644 printf ("C67x+\n");
15646 case C6XABI_Tag_ISA_C64X
:
15649 case C6XABI_Tag_ISA_C64XP
:
15650 printf ("C64x+\n");
15652 case C6XABI_Tag_ISA_C674X
:
15653 printf ("C674x\n");
15656 printf ("??? (%d)\n", val
);
15661 case Tag_ABI_wchar_t
:
15662 printf (" Tag_ABI_wchar_t: ");
15663 READ_ULEB (val
, p
, end
);
15667 printf (_("Not used\n"));
15670 printf (_("2 bytes\n"));
15673 printf (_("4 bytes\n"));
15676 printf ("??? (%d)\n", val
);
15681 case Tag_ABI_stack_align_needed
:
15682 printf (" Tag_ABI_stack_align_needed: ");
15683 READ_ULEB (val
, p
, end
);
15687 printf (_("8-byte\n"));
15690 printf (_("16-byte\n"));
15693 printf ("??? (%d)\n", val
);
15698 case Tag_ABI_stack_align_preserved
:
15699 READ_ULEB (val
, p
, end
);
15700 printf (" Tag_ABI_stack_align_preserved: ");
15704 printf (_("8-byte\n"));
15707 printf (_("16-byte\n"));
15710 printf ("??? (%d)\n", val
);
15716 READ_ULEB (val
, p
, end
);
15717 printf (" Tag_ABI_DSBT: ");
15721 printf (_("DSBT addressing not used\n"));
15724 printf (_("DSBT addressing used\n"));
15727 printf ("??? (%d)\n", val
);
15733 READ_ULEB (val
, p
, end
);
15734 printf (" Tag_ABI_PID: ");
15738 printf (_("Data addressing position-dependent\n"));
15741 printf (_("Data addressing position-independent, GOT near DP\n"));
15744 printf (_("Data addressing position-independent, GOT far from DP\n"));
15747 printf ("??? (%d)\n", val
);
15753 READ_ULEB (val
, p
, end
);
15754 printf (" Tag_ABI_PIC: ");
15758 printf (_("Code addressing position-dependent\n"));
15761 printf (_("Code addressing position-independent\n"));
15764 printf ("??? (%d)\n", val
);
15769 case Tag_ABI_array_object_alignment
:
15770 READ_ULEB (val
, p
, end
);
15771 printf (" Tag_ABI_array_object_alignment: ");
15775 printf (_("8-byte\n"));
15778 printf (_("4-byte\n"));
15781 printf (_("16-byte\n"));
15784 printf ("??? (%d)\n", val
);
15789 case Tag_ABI_array_object_align_expected
:
15790 READ_ULEB (val
, p
, end
);
15791 printf (" Tag_ABI_array_object_align_expected: ");
15795 printf (_("8-byte\n"));
15798 printf (_("4-byte\n"));
15801 printf (_("16-byte\n"));
15804 printf ("??? (%d)\n", val
);
15809 case Tag_ABI_compatibility
:
15811 READ_ULEB (val
, p
, end
);
15812 printf (" Tag_ABI_compatibility: ");
15813 printf (_("flag = %d, vendor = "), val
);
15816 size_t maxlen
= (end
- p
) - 1;
15818 print_symbol ((int) maxlen
, (const char *) p
);
15819 p
+= strnlen ((char *) p
, maxlen
) + 1;
15823 printf (_("<corrupt>"));
15824 p
= (unsigned char *) end
;
15830 case Tag_ABI_conformance
:
15832 printf (" Tag_ABI_conformance: \"");
15835 size_t maxlen
= (end
- p
) - 1;
15837 print_symbol ((int) maxlen
, (const char *) p
);
15838 p
+= strnlen ((char *) p
, maxlen
) + 1;
15842 printf (_("<corrupt>"));
15843 p
= (unsigned char *) end
;
15850 return display_tag_value (tag
, p
, end
);
15854 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15856 unsigned long addr
= 0;
15857 size_t bytes
= end
- p
;
15864 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15866 printf (" 0x%8.8lx ", addr
);
15868 for (j
= 0; j
< 16; j
++)
15871 printf ("%2.2x", p
[j
]);
15879 for (j
= 0; j
< lbytes
; j
++)
15882 if (k
>= ' ' && k
< 0x7f)
15898 static unsigned char *
15899 display_msp430x_attribute (unsigned char * p
,
15900 const unsigned char * const end
)
15905 READ_ULEB (tag
, p
, end
);
15909 case OFBA_MSPABI_Tag_ISA
:
15910 printf (" Tag_ISA: ");
15911 READ_ULEB (val
, p
, end
);
15914 case 0: printf (_("None\n")); break;
15915 case 1: printf (_("MSP430\n")); break;
15916 case 2: printf (_("MSP430X\n")); break;
15917 default: printf ("??? (%d)\n", val
); break;
15921 case OFBA_MSPABI_Tag_Code_Model
:
15922 printf (" Tag_Code_Model: ");
15923 READ_ULEB (val
, p
, end
);
15926 case 0: printf (_("None\n")); break;
15927 case 1: printf (_("Small\n")); break;
15928 case 2: printf (_("Large\n")); break;
15929 default: printf ("??? (%d)\n", val
); break;
15933 case OFBA_MSPABI_Tag_Data_Model
:
15934 printf (" Tag_Data_Model: ");
15935 READ_ULEB (val
, p
, end
);
15938 case 0: printf (_("None\n")); break;
15939 case 1: printf (_("Small\n")); break;
15940 case 2: printf (_("Large\n")); break;
15941 case 3: printf (_("Restricted Large\n")); break;
15942 default: printf ("??? (%d)\n", val
); break;
15947 printf (_(" <unknown tag %d>: "), tag
);
15954 size_t maxlen
= (end
- p
) - 1;
15956 print_symbol ((int) maxlen
, (const char *) p
);
15957 p
+= strnlen ((char *) p
, maxlen
) + 1;
15961 printf (_("<corrupt>"));
15962 p
= (unsigned char *) end
;
15968 READ_ULEB (val
, p
, end
);
15969 printf ("%d (0x%x)\n", val
, val
);
15978 static unsigned char *
15979 display_msp430_gnu_attribute (unsigned char * p
,
15981 const unsigned char * const end
)
15983 if (tag
== Tag_GNU_MSP430_Data_Region
)
15987 printf (" Tag_GNU_MSP430_Data_Region: ");
15988 READ_ULEB (val
, p
, end
);
15992 case Val_GNU_MSP430_Data_Region_Any
:
15993 printf (_("Any Region\n"));
15995 case Val_GNU_MSP430_Data_Region_Lower
:
15996 printf (_("Lower Region Only\n"));
15999 printf ("??? (%u)\n", val
);
16003 return display_tag_value (tag
& 1, p
, end
);
16006 struct riscv_attr_tag_t
{
16011 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16013 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16016 T(priv_spec_minor
),
16017 T(priv_spec_revision
),
16018 T(unaligned_access
),
16023 static unsigned char *
16024 display_riscv_attribute (unsigned char *p
,
16025 const unsigned char * const end
)
16029 struct riscv_attr_tag_t
*attr
= NULL
;
16032 READ_ULEB (tag
, p
, end
);
16034 /* Find the name of attribute. */
16035 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16037 if (riscv_attr_tag
[i
].tag
== tag
)
16039 attr
= &riscv_attr_tag
[i
];
16045 printf (" %s: ", attr
->name
);
16047 return display_tag_value (tag
, p
, end
);
16051 case Tag_RISCV_priv_spec
:
16052 case Tag_RISCV_priv_spec_minor
:
16053 case Tag_RISCV_priv_spec_revision
:
16054 READ_ULEB (val
, p
, end
);
16055 printf (_("%u\n"), val
);
16057 case Tag_RISCV_unaligned_access
:
16058 READ_ULEB (val
, p
, end
);
16062 printf (_("No unaligned access\n"));
16065 printf (_("Unaligned access\n"));
16069 case Tag_RISCV_stack_align
:
16070 READ_ULEB (val
, p
, end
);
16071 printf (_("%u-bytes\n"), val
);
16073 case Tag_RISCV_arch
:
16074 p
= display_tag_value (-1, p
, end
);
16077 return display_tag_value (tag
, p
, end
);
16084 process_attributes (Filedata
* filedata
,
16085 const char * public_name
,
16086 unsigned int proc_type
,
16087 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16088 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16090 Elf_Internal_Shdr
* sect
;
16092 bfd_boolean res
= TRUE
;
16094 /* Find the section header so that we get the size. */
16095 for (i
= 0, sect
= filedata
->section_headers
;
16096 i
< filedata
->file_header
.e_shnum
;
16099 unsigned char * contents
;
16102 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16105 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16106 sect
->sh_size
, _("attributes"));
16107 if (contents
== NULL
)
16114 /* The first character is the version of the attributes.
16115 Currently only version 1, (aka 'A') is recognised here. */
16118 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16123 bfd_vma section_len
;
16125 section_len
= sect
->sh_size
- 1;
16128 while (section_len
> 0)
16131 unsigned int namelen
;
16132 bfd_boolean public_section
;
16133 bfd_boolean gnu_section
;
16135 if (section_len
<= 4)
16137 error (_("Tag section ends prematurely\n"));
16141 attr_len
= byte_get (p
, 4);
16144 if (attr_len
> section_len
)
16146 error (_("Bad attribute length (%u > %u)\n"),
16147 (unsigned) attr_len
, (unsigned) section_len
);
16148 attr_len
= section_len
;
16151 /* PR 17531: file: 001-101425-0.004 */
16152 else if (attr_len
< 5)
16154 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16159 section_len
-= attr_len
;
16162 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16163 if (namelen
== 0 || namelen
>= attr_len
)
16165 error (_("Corrupt attribute section name\n"));
16170 printf (_("Attribute Section: "));
16171 print_symbol (INT_MAX
, (const char *) p
);
16174 if (public_name
&& streq ((char *) p
, public_name
))
16175 public_section
= TRUE
;
16177 public_section
= FALSE
;
16179 if (streq ((char *) p
, "gnu"))
16180 gnu_section
= TRUE
;
16182 gnu_section
= FALSE
;
16185 attr_len
-= namelen
;
16187 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16192 unsigned char * end
;
16194 /* PR binutils/17531: Safe handling of corrupt files. */
16197 error (_("Unused bytes at end of section\n"));
16204 size
= byte_get (p
, 4);
16205 if (size
> attr_len
)
16207 error (_("Bad subsection length (%u > %u)\n"),
16208 (unsigned) size
, (unsigned) attr_len
);
16212 /* PR binutils/17531: Safe handling of corrupt files. */
16215 error (_("Bad subsection length (%u < 6)\n"),
16223 end
= p
+ size
- 1;
16224 assert (end
<= contents
+ sect
->sh_size
);
16230 printf (_("File Attributes\n"));
16233 printf (_("Section Attributes:"));
16236 printf (_("Symbol Attributes:"));
16237 /* Fall through. */
16241 READ_ULEB (val
, p
, end
);
16244 printf (" %d", val
);
16249 printf (_("Unknown tag: %d\n"), tag
);
16250 public_section
= FALSE
;
16254 if (public_section
&& display_pub_attribute
!= NULL
)
16257 p
= display_pub_attribute (p
, end
);
16260 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16263 p
= display_gnu_attribute (p
,
16264 display_proc_gnu_attribute
,
16270 printf (_(" Unknown attribute:\n"));
16271 display_raw_attribute (p
, end
);
16286 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16287 Print the Address, Access and Initial fields of an entry at VMA ADDR
16288 and return the VMA of the next entry, or -1 if there was a problem.
16289 Does not read from DATA_END or beyond. */
16292 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16293 unsigned char * data_end
)
16296 print_vma (addr
, LONG_HEX
);
16298 if (addr
< pltgot
+ 0xfff0)
16299 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16301 printf ("%10s", "");
16304 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16308 unsigned char * from
= data
+ addr
- pltgot
;
16310 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16312 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16313 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16314 return (bfd_vma
) -1;
16318 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16319 print_vma (entry
, LONG_HEX
);
16322 return addr
+ (is_32bit_elf
? 4 : 8);
16325 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16326 PLTGOT. Print the Address and Initial fields of an entry at VMA
16327 ADDR and return the VMA of the next entry. */
16330 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16333 print_vma (addr
, LONG_HEX
);
16336 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16341 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16342 print_vma (entry
, LONG_HEX
);
16344 return addr
+ (is_32bit_elf
? 4 : 8);
16348 print_mips_ases (unsigned int mask
)
16350 if (mask
& AFL_ASE_DSP
)
16351 fputs ("\n\tDSP ASE", stdout
);
16352 if (mask
& AFL_ASE_DSPR2
)
16353 fputs ("\n\tDSP R2 ASE", stdout
);
16354 if (mask
& AFL_ASE_DSPR3
)
16355 fputs ("\n\tDSP R3 ASE", stdout
);
16356 if (mask
& AFL_ASE_EVA
)
16357 fputs ("\n\tEnhanced VA Scheme", stdout
);
16358 if (mask
& AFL_ASE_MCU
)
16359 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16360 if (mask
& AFL_ASE_MDMX
)
16361 fputs ("\n\tMDMX ASE", stdout
);
16362 if (mask
& AFL_ASE_MIPS3D
)
16363 fputs ("\n\tMIPS-3D ASE", stdout
);
16364 if (mask
& AFL_ASE_MT
)
16365 fputs ("\n\tMT ASE", stdout
);
16366 if (mask
& AFL_ASE_SMARTMIPS
)
16367 fputs ("\n\tSmartMIPS ASE", stdout
);
16368 if (mask
& AFL_ASE_VIRT
)
16369 fputs ("\n\tVZ ASE", stdout
);
16370 if (mask
& AFL_ASE_MSA
)
16371 fputs ("\n\tMSA ASE", stdout
);
16372 if (mask
& AFL_ASE_MIPS16
)
16373 fputs ("\n\tMIPS16 ASE", stdout
);
16374 if (mask
& AFL_ASE_MICROMIPS
)
16375 fputs ("\n\tMICROMIPS ASE", stdout
);
16376 if (mask
& AFL_ASE_XPA
)
16377 fputs ("\n\tXPA ASE", stdout
);
16378 if (mask
& AFL_ASE_MIPS16E2
)
16379 fputs ("\n\tMIPS16e2 ASE", stdout
);
16380 if (mask
& AFL_ASE_CRC
)
16381 fputs ("\n\tCRC ASE", stdout
);
16382 if (mask
& AFL_ASE_GINV
)
16383 fputs ("\n\tGINV ASE", stdout
);
16384 if (mask
& AFL_ASE_LOONGSON_MMI
)
16385 fputs ("\n\tLoongson MMI ASE", stdout
);
16386 if (mask
& AFL_ASE_LOONGSON_CAM
)
16387 fputs ("\n\tLoongson CAM ASE", stdout
);
16388 if (mask
& AFL_ASE_LOONGSON_EXT
)
16389 fputs ("\n\tLoongson EXT ASE", stdout
);
16390 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16391 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16393 fprintf (stdout
, "\n\t%s", _("None"));
16394 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16395 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16399 print_mips_isa_ext (unsigned int isa_ext
)
16404 fputs (_("None"), stdout
);
16407 fputs ("RMI XLR", stdout
);
16409 case AFL_EXT_OCTEON3
:
16410 fputs ("Cavium Networks Octeon3", stdout
);
16412 case AFL_EXT_OCTEON2
:
16413 fputs ("Cavium Networks Octeon2", stdout
);
16415 case AFL_EXT_OCTEONP
:
16416 fputs ("Cavium Networks OcteonP", stdout
);
16418 case AFL_EXT_OCTEON
:
16419 fputs ("Cavium Networks Octeon", stdout
);
16422 fputs ("Toshiba R5900", stdout
);
16425 fputs ("MIPS R4650", stdout
);
16428 fputs ("LSI R4010", stdout
);
16431 fputs ("NEC VR4100", stdout
);
16434 fputs ("Toshiba R3900", stdout
);
16436 case AFL_EXT_10000
:
16437 fputs ("MIPS R10000", stdout
);
16440 fputs ("Broadcom SB-1", stdout
);
16443 fputs ("NEC VR4111/VR4181", stdout
);
16446 fputs ("NEC VR4120", stdout
);
16449 fputs ("NEC VR5400", stdout
);
16452 fputs ("NEC VR5500", stdout
);
16454 case AFL_EXT_LOONGSON_2E
:
16455 fputs ("ST Microelectronics Loongson 2E", stdout
);
16457 case AFL_EXT_LOONGSON_2F
:
16458 fputs ("ST Microelectronics Loongson 2F", stdout
);
16460 case AFL_EXT_INTERAPTIV_MR2
:
16461 fputs ("Imagination interAptiv MR2", stdout
);
16464 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16469 get_mips_reg_size (int reg_size
)
16471 return (reg_size
== AFL_REG_NONE
) ? 0
16472 : (reg_size
== AFL_REG_32
) ? 32
16473 : (reg_size
== AFL_REG_64
) ? 64
16474 : (reg_size
== AFL_REG_128
) ? 128
16479 process_mips_specific (Filedata
* filedata
)
16481 Elf_Internal_Dyn
* entry
;
16482 Elf_Internal_Shdr
*sect
= NULL
;
16483 size_t liblist_offset
= 0;
16484 size_t liblistno
= 0;
16485 size_t conflictsno
= 0;
16486 size_t options_offset
= 0;
16487 size_t conflicts_offset
= 0;
16488 size_t pltrelsz
= 0;
16490 bfd_vma pltgot
= 0;
16491 bfd_vma mips_pltgot
= 0;
16492 bfd_vma jmprel
= 0;
16493 bfd_vma local_gotno
= 0;
16494 bfd_vma gotsym
= 0;
16495 bfd_vma symtabno
= 0;
16496 bfd_boolean res
= TRUE
;
16498 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16499 display_mips_gnu_attribute
))
16502 sect
= find_section (filedata
, ".MIPS.abiflags");
16506 Elf_External_ABIFlags_v0
*abiflags_ext
;
16507 Elf_Internal_ABIFlags_v0 abiflags_in
;
16509 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16511 error (_("Corrupt MIPS ABI Flags section.\n"));
16516 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16517 sect
->sh_size
, _("MIPS ABI Flags section"));
16520 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16521 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16522 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16523 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16524 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16525 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16526 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16527 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16528 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16529 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16530 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16532 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16533 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16534 if (abiflags_in
.isa_rev
> 1)
16535 printf ("r%d", abiflags_in
.isa_rev
);
16536 printf ("\nGPR size: %d",
16537 get_mips_reg_size (abiflags_in
.gpr_size
));
16538 printf ("\nCPR1 size: %d",
16539 get_mips_reg_size (abiflags_in
.cpr1_size
));
16540 printf ("\nCPR2 size: %d",
16541 get_mips_reg_size (abiflags_in
.cpr2_size
));
16542 fputs ("\nFP ABI: ", stdout
);
16543 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16544 fputs ("ISA Extension: ", stdout
);
16545 print_mips_isa_ext (abiflags_in
.isa_ext
);
16546 fputs ("\nASEs:", stdout
);
16547 print_mips_ases (abiflags_in
.ases
);
16548 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16549 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16550 fputc ('\n', stdout
);
16551 free (abiflags_ext
);
16556 /* We have a lot of special sections. Thanks SGI! */
16557 if (dynamic_section
== NULL
)
16559 /* No dynamic information available. See if there is static GOT. */
16560 sect
= find_section (filedata
, ".got");
16563 unsigned char *data_end
;
16564 unsigned char *data
;
16568 pltgot
= sect
->sh_addr
;
16571 addr_size
= (is_32bit_elf
? 4 : 8);
16572 end
= pltgot
+ sect
->sh_size
;
16574 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16576 _("Global Offset Table data"));
16577 /* PR 12855: Null data is handled gracefully throughout. */
16578 data_end
= data
+ (end
- pltgot
);
16580 printf (_("\nStatic GOT:\n"));
16581 printf (_(" Canonical gp value: "));
16582 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16585 /* In a dynamic binary GOT[0] is reserved for the dynamic
16586 loader to store the lazy resolver pointer, however in
16587 a static binary it may well have been omitted and GOT
16588 reduced to a table of addresses.
16589 PR 21344: Check for the entry being fully available
16590 before fetching it. */
16592 && data
+ ent
- pltgot
+ addr_size
<= data_end
16593 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16595 printf (_(" Reserved entries:\n"));
16596 printf (_(" %*s %10s %*s\n"),
16597 addr_size
* 2, _("Address"), _("Access"),
16598 addr_size
* 2, _("Value"));
16599 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16601 if (ent
== (bfd_vma
) -1)
16602 goto sgot_print_fail
;
16604 /* Check for the MSB of GOT[1] being set, identifying a
16605 GNU object. This entry will be used by some runtime
16606 loaders, to store the module pointer. Otherwise this
16607 is an ordinary local entry.
16608 PR 21344: Check for the entry being fully available
16609 before fetching it. */
16611 && data
+ ent
- pltgot
+ addr_size
<= data_end
16612 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16613 >> (addr_size
* 8 - 1)) != 0)
16615 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16617 if (ent
== (bfd_vma
) -1)
16618 goto sgot_print_fail
;
16623 if (data
!= NULL
&& ent
< end
)
16625 printf (_(" Local entries:\n"));
16626 printf (" %*s %10s %*s\n",
16627 addr_size
* 2, _("Address"), _("Access"),
16628 addr_size
* 2, _("Value"));
16631 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16633 if (ent
== (bfd_vma
) -1)
16634 goto sgot_print_fail
;
16646 for (entry
= dynamic_section
;
16647 /* PR 17531 file: 012-50589-0.004. */
16648 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16650 switch (entry
->d_tag
)
16652 case DT_MIPS_LIBLIST
:
16654 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16655 liblistno
* sizeof (Elf32_External_Lib
));
16657 case DT_MIPS_LIBLISTNO
:
16658 liblistno
= entry
->d_un
.d_val
;
16660 case DT_MIPS_OPTIONS
:
16661 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16663 case DT_MIPS_CONFLICT
:
16665 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16666 conflictsno
* sizeof (Elf32_External_Conflict
));
16668 case DT_MIPS_CONFLICTNO
:
16669 conflictsno
= entry
->d_un
.d_val
;
16672 pltgot
= entry
->d_un
.d_ptr
;
16674 case DT_MIPS_LOCAL_GOTNO
:
16675 local_gotno
= entry
->d_un
.d_val
;
16677 case DT_MIPS_GOTSYM
:
16678 gotsym
= entry
->d_un
.d_val
;
16680 case DT_MIPS_SYMTABNO
:
16681 symtabno
= entry
->d_un
.d_val
;
16683 case DT_MIPS_PLTGOT
:
16684 mips_pltgot
= entry
->d_un
.d_ptr
;
16687 pltrel
= entry
->d_un
.d_val
;
16690 pltrelsz
= entry
->d_un
.d_val
;
16693 jmprel
= entry
->d_un
.d_ptr
;
16699 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16701 Elf32_External_Lib
* elib
;
16704 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16705 sizeof (Elf32_External_Lib
),
16707 _("liblist section data"));
16710 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16711 "\nSection '.liblist' contains %lu entries:\n",
16712 (unsigned long) liblistno
),
16713 (unsigned long) liblistno
);
16714 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16717 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16724 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16725 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16726 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16727 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16728 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16730 tmp
= gmtime (&atime
);
16731 snprintf (timebuf
, sizeof (timebuf
),
16732 "%04u-%02u-%02uT%02u:%02u:%02u",
16733 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16734 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16736 printf ("%3lu: ", (unsigned long) cnt
);
16737 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16738 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16740 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16741 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16742 liblist
.l_version
);
16744 if (liblist
.l_flags
== 0)
16748 static const struct
16755 { " EXACT_MATCH", LL_EXACT_MATCH
},
16756 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16757 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16758 { " EXPORTS", LL_EXPORTS
},
16759 { " DELAY_LOAD", LL_DELAY_LOAD
},
16760 { " DELTA", LL_DELTA
}
16762 int flags
= liblist
.l_flags
;
16765 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16766 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16768 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16769 flags
^= l_flags_vals
[fcnt
].bit
;
16772 printf (" %#x", (unsigned int) flags
);
16784 if (options_offset
!= 0)
16786 Elf_External_Options
* eopt
;
16789 sect
= filedata
->section_headers
;
16791 /* Find the section header so that we get the size. */
16792 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16793 /* PR 17533 file: 012-277276-0.004. */
16796 error (_("No MIPS_OPTIONS header found\n"));
16800 if (sect
->sh_size
< sizeof (* eopt
))
16802 error (_("The MIPS options section is too small.\n"));
16806 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16807 sect
->sh_size
, _("options"));
16810 Elf_Internal_Options
* iopt
;
16811 Elf_Internal_Options
* option
;
16812 Elf_Internal_Options
* iopt_end
;
16814 iopt
= (Elf_Internal_Options
*)
16815 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16818 error (_("Out of memory allocating space for MIPS options\n"));
16824 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16826 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16828 Elf_External_Options
* eoption
;
16830 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16832 option
->kind
= BYTE_GET (eoption
->kind
);
16833 option
->size
= BYTE_GET (eoption
->size
);
16834 option
->section
= BYTE_GET (eoption
->section
);
16835 option
->info
= BYTE_GET (eoption
->info
);
16837 /* PR 17531: file: ffa0fa3b. */
16838 if (option
->size
< sizeof (* eopt
)
16839 || offset
+ option
->size
> sect
->sh_size
)
16841 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16844 offset
+= option
->size
;
16850 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16851 "\nSection '%s' contains %d entries:\n",
16853 printable_section_name (filedata
, sect
), cnt
);
16862 switch (option
->kind
)
16865 /* This shouldn't happen. */
16866 printf (" NULL %d %lx", option
->section
, option
->info
);
16870 printf (" REGINFO ");
16871 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16873 Elf32_External_RegInfo
* ereg
;
16874 Elf32_RegInfo reginfo
;
16877 if (option
+ 2 > iopt_end
)
16879 printf (_("<corrupt>\n"));
16880 error (_("Truncated MIPS REGINFO option\n"));
16885 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16887 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16888 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16889 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16890 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16891 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16892 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16894 printf ("GPR %08lx GP 0x%lx\n",
16895 reginfo
.ri_gprmask
,
16896 (unsigned long) reginfo
.ri_gp_value
);
16897 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16898 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16899 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16904 Elf64_External_RegInfo
* ereg
;
16905 Elf64_Internal_RegInfo reginfo
;
16907 if (option
+ 2 > iopt_end
)
16909 printf (_("<corrupt>\n"));
16910 error (_("Truncated MIPS REGINFO option\n"));
16915 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16916 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16917 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16918 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16919 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16920 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16921 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16923 printf ("GPR %08lx GP 0x",
16924 reginfo
.ri_gprmask
);
16925 printf_vma (reginfo
.ri_gp_value
);
16928 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16929 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16930 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16935 case ODK_EXCEPTIONS
:
16936 fputs (" EXCEPTIONS fpe_min(", stdout
);
16937 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16938 fputs (") fpe_max(", stdout
);
16939 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16940 fputs (")", stdout
);
16942 if (option
->info
& OEX_PAGE0
)
16943 fputs (" PAGE0", stdout
);
16944 if (option
->info
& OEX_SMM
)
16945 fputs (" SMM", stdout
);
16946 if (option
->info
& OEX_FPDBUG
)
16947 fputs (" FPDBUG", stdout
);
16948 if (option
->info
& OEX_DISMISS
)
16949 fputs (" DISMISS", stdout
);
16953 fputs (" PAD ", stdout
);
16954 if (option
->info
& OPAD_PREFIX
)
16955 fputs (" PREFIX", stdout
);
16956 if (option
->info
& OPAD_POSTFIX
)
16957 fputs (" POSTFIX", stdout
);
16958 if (option
->info
& OPAD_SYMBOL
)
16959 fputs (" SYMBOL", stdout
);
16963 fputs (" HWPATCH ", stdout
);
16964 if (option
->info
& OHW_R4KEOP
)
16965 fputs (" R4KEOP", stdout
);
16966 if (option
->info
& OHW_R8KPFETCH
)
16967 fputs (" R8KPFETCH", stdout
);
16968 if (option
->info
& OHW_R5KEOP
)
16969 fputs (" R5KEOP", stdout
);
16970 if (option
->info
& OHW_R5KCVTL
)
16971 fputs (" R5KCVTL", stdout
);
16975 fputs (" FILL ", stdout
);
16976 /* XXX Print content of info word? */
16980 fputs (" TAGS ", stdout
);
16981 /* XXX Print content of info word? */
16985 fputs (" HWAND ", stdout
);
16986 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16987 fputs (" R4KEOP_CHECKED", stdout
);
16988 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16989 fputs (" R4KEOP_CLEAN", stdout
);
16993 fputs (" HWOR ", stdout
);
16994 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16995 fputs (" R4KEOP_CHECKED", stdout
);
16996 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16997 fputs (" R4KEOP_CLEAN", stdout
);
17001 printf (" GP_GROUP %#06lx self-contained %#06lx",
17002 option
->info
& OGP_GROUP
,
17003 (option
->info
& OGP_SELF
) >> 16);
17007 printf (" IDENT %#06lx self-contained %#06lx",
17008 option
->info
& OGP_GROUP
,
17009 (option
->info
& OGP_SELF
) >> 16);
17013 /* This shouldn't happen. */
17014 printf (" %3d ??? %d %lx",
17015 option
->kind
, option
->section
, option
->info
);
17019 len
= sizeof (* eopt
);
17020 while (len
< option
->size
)
17022 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
17024 if (ISPRINT (datum
))
17025 printf ("%c", datum
);
17027 printf ("\\%03o", datum
);
17030 fputs ("\n", stdout
);
17032 offset
+= option
->size
;
17042 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17044 Elf32_Conflict
* iconf
;
17047 if (dynamic_symbols
== NULL
)
17049 error (_("conflict list found without a dynamic symbol table\n"));
17053 /* PR 21345 - print a slightly more helpful error message
17054 if we are sure that the cmalloc will fail. */
17055 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
17057 error (_("Overlarge number of conflicts detected: %lx\n"),
17058 (long) conflictsno
);
17062 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17065 error (_("Out of memory allocating space for dynamic conflicts\n"));
17071 Elf32_External_Conflict
* econf32
;
17073 econf32
= (Elf32_External_Conflict
*)
17074 get_data (NULL
, filedata
, conflicts_offset
,
17075 sizeof (*econf32
), conflictsno
, _("conflict"));
17082 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17083 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17089 Elf64_External_Conflict
* econf64
;
17091 econf64
= (Elf64_External_Conflict
*)
17092 get_data (NULL
, filedata
, conflicts_offset
,
17093 sizeof (*econf64
), conflictsno
, _("conflict"));
17100 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17101 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17106 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17107 "\nSection '.conflict' contains %lu entries:\n",
17108 (unsigned long) conflictsno
),
17109 (unsigned long) conflictsno
);
17110 puts (_(" Num: Index Value Name"));
17112 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17114 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17116 if (iconf
[cnt
] >= num_dynamic_syms
)
17117 printf (_("<corrupt symbol index>"));
17120 Elf_Internal_Sym
* psym
;
17122 psym
= & dynamic_symbols
[iconf
[cnt
]];
17123 print_vma (psym
->st_value
, FULL_HEX
);
17125 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17126 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
17128 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17136 if (pltgot
!= 0 && local_gotno
!= 0)
17138 bfd_vma ent
, local_end
, global_end
;
17140 unsigned char * data
;
17141 unsigned char * data_end
;
17145 addr_size
= (is_32bit_elf
? 4 : 8);
17146 local_end
= pltgot
+ local_gotno
* addr_size
;
17148 /* PR binutils/17533 file: 012-111227-0.004 */
17149 if (symtabno
< gotsym
)
17151 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17152 (unsigned long) gotsym
, (unsigned long) symtabno
);
17156 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17157 /* PR 17531: file: 54c91a34. */
17158 if (global_end
< local_end
)
17160 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17164 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17165 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17166 global_end
- pltgot
, 1,
17167 _("Global Offset Table data"));
17168 /* PR 12855: Null data is handled gracefully throughout. */
17169 data_end
= data
+ (global_end
- pltgot
);
17171 printf (_("\nPrimary GOT:\n"));
17172 printf (_(" Canonical gp value: "));
17173 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17176 printf (_(" Reserved entries:\n"));
17177 printf (_(" %*s %10s %*s Purpose\n"),
17178 addr_size
* 2, _("Address"), _("Access"),
17179 addr_size
* 2, _("Initial"));
17180 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17181 printf (_(" Lazy resolver\n"));
17182 if (ent
== (bfd_vma
) -1)
17183 goto got_print_fail
;
17185 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17186 This entry will be used by some runtime loaders, to store the
17187 module pointer. Otherwise this is an ordinary local entry.
17188 PR 21344: Check for the entry being fully available before
17191 && data
+ ent
- pltgot
+ addr_size
<= data_end
17192 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17193 >> (addr_size
* 8 - 1)) != 0)
17195 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17196 printf (_(" Module pointer (GNU extension)\n"));
17197 if (ent
== (bfd_vma
) -1)
17198 goto got_print_fail
;
17202 if (data
!= NULL
&& ent
< local_end
)
17204 printf (_(" Local entries:\n"));
17205 printf (" %*s %10s %*s\n",
17206 addr_size
* 2, _("Address"), _("Access"),
17207 addr_size
* 2, _("Initial"));
17208 while (ent
< local_end
)
17210 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17212 if (ent
== (bfd_vma
) -1)
17213 goto got_print_fail
;
17218 if (data
!= NULL
&& gotsym
< symtabno
)
17222 printf (_(" Global entries:\n"));
17223 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17224 addr_size
* 2, _("Address"),
17226 addr_size
* 2, _("Initial"),
17227 addr_size
* 2, _("Sym.Val."),
17229 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17230 _("Ndx"), _("Name"));
17232 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17234 for (i
= gotsym
; i
< symtabno
; i
++)
17236 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17239 if (dynamic_symbols
== NULL
)
17240 printf (_("<no dynamic symbols>"));
17241 else if (i
< num_dynamic_syms
)
17243 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17245 print_vma (psym
->st_value
, LONG_HEX
);
17246 printf (" %-7s %3s ",
17247 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17248 get_symbol_index_type (filedata
, psym
->st_shndx
));
17250 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17251 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17253 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17256 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17257 (unsigned long) i
);
17260 if (ent
== (bfd_vma
) -1)
17271 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17274 size_t offset
, rel_offset
;
17275 unsigned long count
, i
;
17276 unsigned char * data
;
17277 int addr_size
, sym_width
;
17278 Elf_Internal_Rela
* rels
;
17280 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17281 if (pltrel
== DT_RELA
)
17283 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17288 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17293 addr_size
= (is_32bit_elf
? 4 : 8);
17294 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17296 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17297 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17298 1, _("Procedure Linkage Table data"));
17302 printf ("\nPLT GOT:\n\n");
17303 printf (_(" Reserved entries:\n"));
17304 printf (_(" %*s %*s Purpose\n"),
17305 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17306 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17307 printf (_(" PLT lazy resolver\n"));
17308 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17309 printf (_(" Module pointer\n"));
17312 printf (_(" Entries:\n"));
17313 printf (" %*s %*s %*s %-7s %3s %s\n",
17314 addr_size
* 2, _("Address"),
17315 addr_size
* 2, _("Initial"),
17316 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17317 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17318 for (i
= 0; i
< count
; i
++)
17320 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17322 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17325 if (idx
>= num_dynamic_syms
)
17326 printf (_("<corrupt symbol index: %lu>"), idx
);
17329 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17331 print_vma (psym
->st_value
, LONG_HEX
);
17332 printf (" %-7s %3s ",
17333 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17334 get_symbol_index_type (filedata
, psym
->st_shndx
));
17335 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17336 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17338 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17353 process_nds32_specific (Filedata
* filedata
)
17355 Elf_Internal_Shdr
*sect
= NULL
;
17357 sect
= find_section (filedata
, ".nds32_e_flags");
17360 unsigned int *flag
;
17362 printf ("\nNDS32 elf flags section:\n");
17363 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17364 sect
->sh_size
, _("NDS32 elf flags section"));
17369 switch ((*flag
) & 0x3)
17372 printf ("(VEC_SIZE):\tNo entry.\n");
17375 printf ("(VEC_SIZE):\t4 bytes\n");
17378 printf ("(VEC_SIZE):\t16 bytes\n");
17381 printf ("(VEC_SIZE):\treserved\n");
17390 process_gnu_liblist (Filedata
* filedata
)
17392 Elf_Internal_Shdr
* section
;
17393 Elf_Internal_Shdr
* string_sec
;
17394 Elf32_External_Lib
* elib
;
17396 size_t strtab_size
;
17398 unsigned long num_liblist
;
17400 bfd_boolean res
= TRUE
;
17405 for (i
= 0, section
= filedata
->section_headers
;
17406 i
< filedata
->file_header
.e_shnum
;
17409 switch (section
->sh_type
)
17411 case SHT_GNU_LIBLIST
:
17412 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17415 elib
= (Elf32_External_Lib
*)
17416 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17417 _("liblist section data"));
17425 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17426 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17427 string_sec
->sh_size
,
17428 _("liblist string table"));
17430 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17437 strtab_size
= string_sec
->sh_size
;
17439 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17440 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17441 "\nLibrary list section '%s' contains %lu entries:\n",
17443 printable_section_name (filedata
, section
),
17446 puts (_(" Library Time Stamp Checksum Version Flags"));
17448 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17456 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17457 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17458 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17459 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17460 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17462 tmp
= gmtime (&atime
);
17463 snprintf (timebuf
, sizeof (timebuf
),
17464 "%04u-%02u-%02uT%02u:%02u:%02u",
17465 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17466 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17468 printf ("%3lu: ", (unsigned long) cnt
);
17470 printf ("%-20s", liblist
.l_name
< strtab_size
17471 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17473 printf ("%-20.20s", liblist
.l_name
< strtab_size
17474 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17475 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17476 liblist
.l_version
, liblist
.l_flags
);
17487 static const char *
17488 get_note_type (Filedata
* filedata
, unsigned e_type
)
17490 static char buff
[64];
17492 if (filedata
->file_header
.e_type
== ET_CORE
)
17496 return _("NT_AUXV (auxiliary vector)");
17498 return _("NT_PRSTATUS (prstatus structure)");
17500 return _("NT_FPREGSET (floating point registers)");
17502 return _("NT_PRPSINFO (prpsinfo structure)");
17503 case NT_TASKSTRUCT
:
17504 return _("NT_TASKSTRUCT (task structure)");
17506 return _("NT_PRXFPREG (user_xfpregs structure)");
17508 return _("NT_PPC_VMX (ppc Altivec registers)");
17510 return _("NT_PPC_VSX (ppc VSX registers)");
17512 return _("NT_PPC_TAR (ppc TAR register)");
17514 return _("NT_PPC_PPR (ppc PPR register)");
17516 return _("NT_PPC_DSCR (ppc DSCR register)");
17518 return _("NT_PPC_EBB (ppc EBB registers)");
17520 return _("NT_PPC_PMU (ppc PMU registers)");
17521 case NT_PPC_TM_CGPR
:
17522 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17523 case NT_PPC_TM_CFPR
:
17524 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17525 case NT_PPC_TM_CVMX
:
17526 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17527 case NT_PPC_TM_CVSX
:
17528 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17529 case NT_PPC_TM_SPR
:
17530 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17531 case NT_PPC_TM_CTAR
:
17532 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17533 case NT_PPC_TM_CPPR
:
17534 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17535 case NT_PPC_TM_CDSCR
:
17536 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17538 return _("NT_386_TLS (x86 TLS information)");
17539 case NT_386_IOPERM
:
17540 return _("NT_386_IOPERM (x86 I/O permissions)");
17541 case NT_X86_XSTATE
:
17542 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17543 case NT_S390_HIGH_GPRS
:
17544 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17545 case NT_S390_TIMER
:
17546 return _("NT_S390_TIMER (s390 timer register)");
17547 case NT_S390_TODCMP
:
17548 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17549 case NT_S390_TODPREG
:
17550 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17552 return _("NT_S390_CTRS (s390 control registers)");
17553 case NT_S390_PREFIX
:
17554 return _("NT_S390_PREFIX (s390 prefix register)");
17555 case NT_S390_LAST_BREAK
:
17556 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17557 case NT_S390_SYSTEM_CALL
:
17558 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17560 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17561 case NT_S390_VXRS_LOW
:
17562 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17563 case NT_S390_VXRS_HIGH
:
17564 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17565 case NT_S390_GS_CB
:
17566 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17567 case NT_S390_GS_BC
:
17568 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17570 return _("NT_ARM_VFP (arm VFP registers)");
17572 return _("NT_ARM_TLS (AArch TLS registers)");
17573 case NT_ARM_HW_BREAK
:
17574 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17575 case NT_ARM_HW_WATCH
:
17576 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17578 return _("NT_PSTATUS (pstatus structure)");
17580 return _("NT_FPREGS (floating point registers)");
17582 return _("NT_PSINFO (psinfo structure)");
17584 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17586 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17587 case NT_WIN32PSTATUS
:
17588 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17590 return _("NT_SIGINFO (siginfo_t data)");
17592 return _("NT_FILE (mapped files)");
17600 return _("NT_VERSION (version)");
17602 return _("NT_ARCH (architecture)");
17603 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17605 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17611 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17616 print_core_note (Elf_Internal_Note
*pnote
)
17618 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17619 bfd_vma count
, page_size
;
17620 unsigned char *descdata
, *filenames
, *descend
;
17622 if (pnote
->type
!= NT_FILE
)
17632 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17633 /* Still "successful". */
17638 if (pnote
->descsz
< 2 * addr_size
)
17640 error (_(" Malformed note - too short for header\n"));
17644 descdata
= (unsigned char *) pnote
->descdata
;
17645 descend
= descdata
+ pnote
->descsz
;
17647 if (descdata
[pnote
->descsz
- 1] != '\0')
17649 error (_(" Malformed note - does not end with \\0\n"));
17653 count
= byte_get (descdata
, addr_size
);
17654 descdata
+= addr_size
;
17656 page_size
= byte_get (descdata
, addr_size
);
17657 descdata
+= addr_size
;
17659 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17660 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17662 error (_(" Malformed note - too short for supplied file count\n"));
17666 printf (_(" Page size: "));
17667 print_vma (page_size
, DEC
);
17670 printf (_(" %*s%*s%*s\n"),
17671 (int) (2 + 2 * addr_size
), _("Start"),
17672 (int) (4 + 2 * addr_size
), _("End"),
17673 (int) (4 + 2 * addr_size
), _("Page Offset"));
17674 filenames
= descdata
+ count
* 3 * addr_size
;
17675 while (count
-- > 0)
17677 bfd_vma start
, end
, file_ofs
;
17679 if (filenames
== descend
)
17681 error (_(" Malformed note - filenames end too early\n"));
17685 start
= byte_get (descdata
, addr_size
);
17686 descdata
+= addr_size
;
17687 end
= byte_get (descdata
, addr_size
);
17688 descdata
+= addr_size
;
17689 file_ofs
= byte_get (descdata
, addr_size
);
17690 descdata
+= addr_size
;
17693 print_vma (start
, FULL_HEX
);
17695 print_vma (end
, FULL_HEX
);
17697 print_vma (file_ofs
, FULL_HEX
);
17698 printf ("\n %s\n", filenames
);
17700 filenames
+= 1 + strlen ((char *) filenames
);
17706 static const char *
17707 get_gnu_elf_note_type (unsigned e_type
)
17709 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17712 case NT_GNU_ABI_TAG
:
17713 return _("NT_GNU_ABI_TAG (ABI version tag)");
17715 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17716 case NT_GNU_BUILD_ID
:
17717 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17718 case NT_GNU_GOLD_VERSION
:
17719 return _("NT_GNU_GOLD_VERSION (gold version)");
17720 case NT_GNU_PROPERTY_TYPE_0
:
17721 return _("NT_GNU_PROPERTY_TYPE_0");
17722 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17723 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17724 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17725 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17728 static char buff
[64];
17730 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17737 decode_x86_compat_isa (unsigned int bitmask
)
17741 unsigned int bit
= bitmask
& (- bitmask
);
17746 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17749 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17752 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17755 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17758 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17761 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17764 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17767 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17770 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17773 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17776 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17779 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17780 printf ("AVX512F");
17782 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17783 printf ("AVX512CD");
17785 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17786 printf ("AVX512ER");
17788 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17789 printf ("AVX512PF");
17791 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17792 printf ("AVX512VL");
17794 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17795 printf ("AVX512DQ");
17797 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17798 printf ("AVX512BW");
17801 printf (_("<unknown: %x>"), bit
);
17810 decode_x86_isa (unsigned int bitmask
)
17814 printf (_("<None>"));
17820 unsigned int bit
= bitmask
& (- bitmask
);
17825 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17828 case GNU_PROPERTY_X86_ISA_1_SSE
:
17831 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17834 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17837 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17840 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17843 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17846 case GNU_PROPERTY_X86_ISA_1_AVX
:
17849 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17852 case GNU_PROPERTY_X86_ISA_1_FMA
:
17855 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17856 printf ("AVX512F");
17858 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17859 printf ("AVX512CD");
17861 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17862 printf ("AVX512ER");
17864 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17865 printf ("AVX512PF");
17867 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17868 printf ("AVX512VL");
17870 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17871 printf ("AVX512DQ");
17873 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17874 printf ("AVX512BW");
17876 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17877 printf ("AVX512_4FMAPS");
17879 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17880 printf ("AVX512_4VNNIW");
17882 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17883 printf ("AVX512_BITALG");
17885 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17886 printf ("AVX512_IFMA");
17888 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17889 printf ("AVX512_VBMI");
17891 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17892 printf ("AVX512_VBMI2");
17894 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17895 printf ("AVX512_VNNI");
17897 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17898 printf ("AVX512_BF16");
17901 printf (_("<unknown: %x>"), bit
);
17910 decode_x86_feature_1 (unsigned int bitmask
)
17914 printf (_("<None>"));
17920 unsigned int bit
= bitmask
& (- bitmask
);
17925 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17928 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17932 printf (_("<unknown: %x>"), bit
);
17941 decode_x86_feature_2 (unsigned int bitmask
)
17945 printf (_("<None>"));
17951 unsigned int bit
= bitmask
& (- bitmask
);
17956 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17959 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17962 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17965 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17968 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17971 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17974 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17977 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17980 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17981 printf ("XSAVEOPT");
17983 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17987 printf (_("<unknown: %x>"), bit
);
17996 decode_aarch64_feature_1_and (unsigned int bitmask
)
18000 unsigned int bit
= bitmask
& (- bitmask
);
18005 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18009 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18014 printf (_("<unknown: %x>"), bit
);
18023 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18025 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18026 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18027 unsigned int size
= is_32bit_elf
? 4 : 8;
18029 printf (_(" Properties: "));
18031 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18033 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18037 while (ptr
< ptr_end
)
18041 unsigned int datasz
;
18043 if ((size_t) (ptr_end
- ptr
) < 8)
18045 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18049 type
= byte_get (ptr
, 4);
18050 datasz
= byte_get (ptr
+ 4, 4);
18054 if (datasz
> (size_t) (ptr_end
- ptr
))
18056 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18061 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18063 if (filedata
->file_header
.e_machine
== EM_X86_64
18064 || filedata
->file_header
.e_machine
== EM_IAMCU
18065 || filedata
->file_header
.e_machine
== EM_386
)
18067 unsigned int bitmask
;
18070 bitmask
= byte_get (ptr
, 4);
18076 case GNU_PROPERTY_X86_ISA_1_USED
:
18078 printf (_("x86 ISA used: <corrupt length: %#x> "),
18082 printf ("x86 ISA used: ");
18083 decode_x86_isa (bitmask
);
18087 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18089 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18093 printf ("x86 ISA needed: ");
18094 decode_x86_isa (bitmask
);
18098 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18100 printf (_("x86 feature: <corrupt length: %#x> "),
18104 printf ("x86 feature: ");
18105 decode_x86_feature_1 (bitmask
);
18109 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18111 printf (_("x86 feature used: <corrupt length: %#x> "),
18115 printf ("x86 feature used: ");
18116 decode_x86_feature_2 (bitmask
);
18120 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18122 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18125 printf ("x86 feature needed: ");
18126 decode_x86_feature_2 (bitmask
);
18130 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18132 printf (_("x86 ISA used: <corrupt length: %#x> "),
18136 printf ("x86 ISA used: ");
18137 decode_x86_compat_isa (bitmask
);
18141 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18143 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18147 printf ("x86 ISA needed: ");
18148 decode_x86_compat_isa (bitmask
);
18156 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18158 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18160 printf ("AArch64 feature: ");
18162 printf (_("<corrupt length: %#x> "), datasz
);
18164 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18173 case GNU_PROPERTY_STACK_SIZE
:
18174 printf (_("stack size: "));
18175 if (datasz
!= size
)
18176 printf (_("<corrupt length: %#x> "), datasz
);
18178 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18181 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18182 printf ("no copy on protected ");
18184 printf (_("<corrupt length: %#x> "), datasz
);
18192 if (type
< GNU_PROPERTY_LOPROC
)
18193 printf (_("<unknown type %#x data: "), type
);
18194 else if (type
< GNU_PROPERTY_LOUSER
)
18195 printf (_("<procesor-specific type %#x data: "), type
);
18197 printf (_("<application-specific type %#x data: "), type
);
18198 for (j
= 0; j
< datasz
; ++j
)
18199 printf ("%02x ", ptr
[j
] & 0xff);
18203 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18204 if (ptr
== ptr_end
)
18217 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18219 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18220 switch (pnote
->type
)
18222 case NT_GNU_BUILD_ID
:
18226 printf (_(" Build ID: "));
18227 for (i
= 0; i
< pnote
->descsz
; ++i
)
18228 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18233 case NT_GNU_ABI_TAG
:
18235 unsigned long os
, major
, minor
, subminor
;
18236 const char *osname
;
18238 /* PR 17531: file: 030-599401-0.004. */
18239 if (pnote
->descsz
< 16)
18241 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18245 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18246 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18247 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18248 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18252 case GNU_ABI_TAG_LINUX
:
18255 case GNU_ABI_TAG_HURD
:
18258 case GNU_ABI_TAG_SOLARIS
:
18259 osname
= "Solaris";
18261 case GNU_ABI_TAG_FREEBSD
:
18262 osname
= "FreeBSD";
18264 case GNU_ABI_TAG_NETBSD
:
18267 case GNU_ABI_TAG_SYLLABLE
:
18268 osname
= "Syllable";
18270 case GNU_ABI_TAG_NACL
:
18274 osname
= "Unknown";
18278 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18279 major
, minor
, subminor
);
18283 case NT_GNU_GOLD_VERSION
:
18287 printf (_(" Version: "));
18288 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18289 printf ("%c", pnote
->descdata
[i
]);
18296 unsigned long num_entries
, mask
;
18298 /* Hardware capabilities information. Word 0 is the number of entries.
18299 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18300 is a series of entries, where each entry is a single byte followed
18301 by a nul terminated string. The byte gives the bit number to test
18302 if enabled in the bitmask. */
18303 printf (_(" Hardware Capabilities: "));
18304 if (pnote
->descsz
< 8)
18306 error (_("<corrupt GNU_HWCAP>\n"));
18309 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18310 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18311 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18312 /* FIXME: Add code to display the entries... */
18316 case NT_GNU_PROPERTY_TYPE_0
:
18317 print_gnu_property_note (filedata
, pnote
);
18321 /* Handle unrecognised types. An error message should have already been
18322 created by get_gnu_elf_note_type(), so all that we need to do is to
18323 display the data. */
18327 printf (_(" Description data: "));
18328 for (i
= 0; i
< pnote
->descsz
; ++i
)
18329 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18338 static const char *
18339 get_v850_elf_note_type (enum v850_notes n_type
)
18341 static char buff
[64];
18345 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18346 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18347 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18348 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18349 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18350 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18352 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18358 print_v850_note (Elf_Internal_Note
* pnote
)
18362 if (pnote
->descsz
!= 4)
18365 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18369 printf (_("not set\n"));
18373 switch (pnote
->type
)
18375 case V850_NOTE_ALIGNMENT
:
18378 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18379 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18383 case V850_NOTE_DATA_SIZE
:
18386 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18387 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18391 case V850_NOTE_FPU_INFO
:
18394 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18395 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18399 case V850_NOTE_MMU_INFO
:
18400 case V850_NOTE_CACHE_INFO
:
18401 case V850_NOTE_SIMD_INFO
:
18402 if (val
== EF_RH850_SIMD
)
18404 printf (_("yes\n"));
18410 /* An 'unknown note type' message will already have been displayed. */
18414 printf (_("unknown value: %x\n"), val
);
18419 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18421 unsigned int version
;
18423 switch (pnote
->type
)
18425 case NT_NETBSD_IDENT
:
18426 if (pnote
->descsz
< 1)
18428 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18429 if ((version
/ 10000) % 100)
18430 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18431 version
, version
/ 100000000, (version
/ 1000000) % 100,
18432 (version
/ 10000) % 100 > 26 ? "Z" : "",
18433 'A' + (version
/ 10000) % 26);
18435 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18436 version
, version
/ 100000000, (version
/ 1000000) % 100,
18437 (version
/ 100) % 100);
18440 case NT_NETBSD_MARCH
:
18441 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18445 #ifdef NT_NETBSD_PAX
18446 case NT_NETBSD_PAX
:
18447 if (pnote
->descsz
< 1)
18449 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18450 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18451 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18452 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18453 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18454 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18455 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18456 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18461 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18462 pnote
->descsz
, pnote
->type
);
18466 static const char *
18467 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18471 case NT_FREEBSD_THRMISC
:
18472 return _("NT_THRMISC (thrmisc structure)");
18473 case NT_FREEBSD_PROCSTAT_PROC
:
18474 return _("NT_PROCSTAT_PROC (proc data)");
18475 case NT_FREEBSD_PROCSTAT_FILES
:
18476 return _("NT_PROCSTAT_FILES (files data)");
18477 case NT_FREEBSD_PROCSTAT_VMMAP
:
18478 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18479 case NT_FREEBSD_PROCSTAT_GROUPS
:
18480 return _("NT_PROCSTAT_GROUPS (groups data)");
18481 case NT_FREEBSD_PROCSTAT_UMASK
:
18482 return _("NT_PROCSTAT_UMASK (umask data)");
18483 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18484 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18485 case NT_FREEBSD_PROCSTAT_OSREL
:
18486 return _("NT_PROCSTAT_OSREL (osreldate data)");
18487 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18488 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18489 case NT_FREEBSD_PROCSTAT_AUXV
:
18490 return _("NT_PROCSTAT_AUXV (auxv data)");
18491 case NT_FREEBSD_PTLWPINFO
:
18492 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18494 return get_note_type (filedata
, e_type
);
18497 static const char *
18498 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18500 static char buff
[64];
18504 case NT_NETBSDCORE_PROCINFO
:
18505 /* NetBSD core "procinfo" structure. */
18506 return _("NetBSD procinfo structure");
18508 #ifdef NT_NETBSDCORE_AUXV
18509 case NT_NETBSDCORE_AUXV
:
18510 return _("NetBSD ELF auxiliary vector data");
18513 #ifdef NT_NETBSDCORE_LWPSTATUS
18514 case NT_NETBSDCORE_LWPSTATUS
:
18515 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18519 /* As of Jan 2020 there are no other machine-independent notes
18520 defined for NetBSD core files. If the note type is less
18521 than the start of the machine-dependent note types, we don't
18524 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18526 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18532 switch (filedata
->file_header
.e_machine
)
18534 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18535 and PT_GETFPREGS == mach+2. */
18540 case EM_SPARC32PLUS
:
18544 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18545 return _("PT_GETREGS (reg structure)");
18546 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18547 return _("PT_GETFPREGS (fpreg structure)");
18553 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18554 There's also old PT___GETREGS40 == mach + 1 for old reg
18555 structure which lacks GBR. */
18559 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18560 return _("PT___GETREGS40 (old reg structure)");
18561 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18562 return _("PT_GETREGS (reg structure)");
18563 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18564 return _("PT_GETFPREGS (fpreg structure)");
18570 /* On all other arch's, PT_GETREGS == mach+1 and
18571 PT_GETFPREGS == mach+3. */
18575 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18576 return _("PT_GETREGS (reg structure)");
18577 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18578 return _("PT_GETFPREGS (fpreg structure)");
18584 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18585 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18589 static const char *
18590 get_stapsdt_note_type (unsigned e_type
)
18592 static char buff
[64];
18597 return _("NT_STAPSDT (SystemTap probe descriptors)");
18603 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18608 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18610 size_t len
, maxlen
;
18611 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18612 char *data
= pnote
->descdata
;
18613 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18614 bfd_vma pc
, base_addr
, semaphore
;
18615 char *provider
, *probe
, *arg_fmt
;
18617 if (pnote
->descsz
< (addr_size
* 3))
18618 goto stapdt_note_too_small
;
18620 pc
= byte_get ((unsigned char *) data
, addr_size
);
18623 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18626 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18629 if (data
>= data_end
)
18630 goto stapdt_note_too_small
;
18631 maxlen
= data_end
- data
;
18632 len
= strnlen (data
, maxlen
);
18639 goto stapdt_note_too_small
;
18641 if (data
>= data_end
)
18642 goto stapdt_note_too_small
;
18643 maxlen
= data_end
- data
;
18644 len
= strnlen (data
, maxlen
);
18651 goto stapdt_note_too_small
;
18653 if (data
>= data_end
)
18654 goto stapdt_note_too_small
;
18655 maxlen
= data_end
- data
;
18656 len
= strnlen (data
, maxlen
);
18663 goto stapdt_note_too_small
;
18665 printf (_(" Provider: %s\n"), provider
);
18666 printf (_(" Name: %s\n"), probe
);
18667 printf (_(" Location: "));
18668 print_vma (pc
, FULL_HEX
);
18669 printf (_(", Base: "));
18670 print_vma (base_addr
, FULL_HEX
);
18671 printf (_(", Semaphore: "));
18672 print_vma (semaphore
, FULL_HEX
);
18674 printf (_(" Arguments: %s\n"), arg_fmt
);
18676 return data
== data_end
;
18678 stapdt_note_too_small
:
18679 printf (_(" <corrupt - note is too small>\n"));
18680 error (_("corrupt stapdt note - the data size is too small\n"));
18684 static const char *
18685 get_ia64_vms_note_type (unsigned e_type
)
18687 static char buff
[64];
18692 return _("NT_VMS_MHD (module header)");
18694 return _("NT_VMS_LNM (language name)");
18696 return _("NT_VMS_SRC (source files)");
18698 return "NT_VMS_TITLE";
18700 return _("NT_VMS_EIDC (consistency check)");
18701 case NT_VMS_FPMODE
:
18702 return _("NT_VMS_FPMODE (FP mode)");
18703 case NT_VMS_LINKTIME
:
18704 return "NT_VMS_LINKTIME";
18705 case NT_VMS_IMGNAM
:
18706 return _("NT_VMS_IMGNAM (image name)");
18708 return _("NT_VMS_IMGID (image id)");
18709 case NT_VMS_LINKID
:
18710 return _("NT_VMS_LINKID (link id)");
18711 case NT_VMS_IMGBID
:
18712 return _("NT_VMS_IMGBID (build id)");
18713 case NT_VMS_GSTNAM
:
18714 return _("NT_VMS_GSTNAM (sym table name)");
18715 case NT_VMS_ORIG_DYN
:
18716 return "NT_VMS_ORIG_DYN";
18717 case NT_VMS_PATCHTIME
:
18718 return "NT_VMS_PATCHTIME";
18720 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18726 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18728 int maxlen
= pnote
->descsz
;
18730 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18731 goto desc_size_fail
;
18733 switch (pnote
->type
)
18737 goto desc_size_fail
;
18739 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18741 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18742 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18743 if (l
+ 34 < maxlen
)
18745 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18746 if (l
+ 35 < maxlen
)
18747 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18749 printf (_(" Module version : <missing>\n"));
18753 printf (_(" Module name : <missing>\n"));
18754 printf (_(" Module version : <missing>\n"));
18759 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18763 case NT_VMS_FPMODE
:
18764 printf (_(" Floating Point mode: "));
18766 goto desc_size_fail
;
18767 /* FIXME: Generate an error if descsz > 8 ? */
18769 printf ("0x%016" BFD_VMA_FMT
"x\n",
18770 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18773 case NT_VMS_LINKTIME
:
18774 printf (_(" Link time: "));
18776 goto desc_size_fail
;
18777 /* FIXME: Generate an error if descsz > 8 ? */
18780 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18784 case NT_VMS_PATCHTIME
:
18785 printf (_(" Patch time: "));
18787 goto desc_size_fail
;
18788 /* FIXME: Generate an error if descsz > 8 ? */
18791 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18795 case NT_VMS_ORIG_DYN
:
18797 goto desc_size_fail
;
18799 printf (_(" Major id: %u, minor id: %u\n"),
18800 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18801 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18802 printf (_(" Last modified : "));
18804 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18805 printf (_("\n Link flags : "));
18806 printf ("0x%016" BFD_VMA_FMT
"x\n",
18807 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18808 printf (_(" Header flags: 0x%08x\n"),
18809 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18810 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18814 case NT_VMS_IMGNAM
:
18815 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18818 case NT_VMS_GSTNAM
:
18819 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18823 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18826 case NT_VMS_LINKID
:
18827 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18837 printf (_(" <corrupt - data size is too small>\n"));
18838 error (_("corrupt IA64 note: data size is too small\n"));
18842 struct build_attr_cache
{
18843 Filedata
*filedata
;
18845 unsigned long strtablen
;
18846 Elf_Internal_Sym
*symtab
;
18847 unsigned long nsyms
;
18850 /* Find the symbol associated with a build attribute that is attached
18851 to address OFFSET. If PNAME is non-NULL then store the name of
18852 the symbol (if found) in the provided pointer, Returns NULL if a
18853 symbol could not be found. */
18855 static Elf_Internal_Sym
*
18856 get_symbol_for_build_attribute (Filedata
* filedata
,
18857 unsigned long offset
,
18858 bfd_boolean is_open_attr
,
18859 const char ** pname
)
18861 Elf_Internal_Sym
*saved_sym
= NULL
;
18862 Elf_Internal_Sym
*sym
;
18864 if (filedata
->section_headers
!= NULL
18865 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
18867 Elf_Internal_Shdr
* symsec
;
18869 free (ba_cache
.strtab
);
18870 ba_cache
.strtab
= NULL
;
18871 free (ba_cache
.symtab
);
18872 ba_cache
.symtab
= NULL
;
18874 /* Load the symbol and string sections. */
18875 for (symsec
= filedata
->section_headers
;
18876 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18879 if (symsec
->sh_type
== SHT_SYMTAB
18880 && get_symtab (filedata
, symsec
,
18881 &ba_cache
.symtab
, &ba_cache
.nsyms
,
18882 &ba_cache
.strtab
, &ba_cache
.strtablen
))
18885 ba_cache
.filedata
= filedata
;
18888 if (ba_cache
.symtab
== NULL
)
18891 /* Find a symbol whose value matches offset. */
18892 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
18893 if (sym
->st_value
== offset
)
18895 if (sym
->st_name
>= ba_cache
.strtablen
)
18896 /* Huh ? This should not happen. */
18899 if (ba_cache
.strtab
[sym
->st_name
] == 0)
18902 /* The AArch64 and ARM architectures define mapping symbols
18903 (eg $d, $x, $t) which we want to ignore. */
18904 if (ba_cache
.strtab
[sym
->st_name
] == '$'
18905 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
18906 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
18911 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18912 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18913 FUNC symbols entirely. */
18914 switch (ELF_ST_TYPE (sym
->st_info
))
18921 /* If the symbol has a size associated
18922 with it then we can stop searching. */
18923 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
18928 /* Ignore function symbols. */
18935 switch (ELF_ST_BIND (sym
->st_info
))
18938 if (saved_sym
== NULL
18939 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18944 if (saved_sym
== NULL
)
18954 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18962 if (saved_sym
&& pname
)
18963 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
18968 /* Returns true iff addr1 and addr2 are in the same section. */
18971 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18973 Elf_Internal_Shdr
* a1
;
18974 Elf_Internal_Shdr
* a2
;
18976 a1
= find_section_by_address (filedata
, addr1
);
18977 a2
= find_section_by_address (filedata
, addr2
);
18979 return a1
== a2
&& a1
!= NULL
;
18983 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18984 Filedata
* filedata
)
18986 static unsigned long global_offset
= 0;
18987 static unsigned long global_end
= 0;
18988 static unsigned long func_offset
= 0;
18989 static unsigned long func_end
= 0;
18991 Elf_Internal_Sym
* sym
;
18993 unsigned long start
;
18995 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18997 switch (pnote
->descsz
)
19000 /* A zero-length description means that the range of
19001 the previous note of the same type should be used. */
19004 if (global_end
> global_offset
)
19005 printf (_(" Applies to region from %#lx to %#lx\n"),
19006 global_offset
, global_end
);
19008 printf (_(" Applies to region from %#lx\n"), global_offset
);
19012 if (func_end
> func_offset
)
19013 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19015 printf (_(" Applies to region from %#lx\n"), func_offset
);
19020 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19027 /* FIXME: We should check that version 3+ notes are being used here... */
19028 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19029 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19033 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19039 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19040 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19044 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19045 printf (_(" <invalid descsz>"));
19050 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19051 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19052 in order to avoid them being confused with the start address of the
19053 first function in the file... */
19054 if (sym
== NULL
&& is_open_attr
)
19055 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19058 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19059 end
= start
+ sym
->st_size
;
19063 /* FIXME: Need to properly allow for section alignment.
19064 16 is just the alignment used on x86_64. */
19066 && start
> BFD_ALIGN (global_end
, 16)
19067 /* Build notes are not guaranteed to be organised in order of
19068 increasing address, but we should find the all of the notes
19069 for one section in the same place. */
19070 && same_section (filedata
, start
, global_end
))
19071 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19072 global_end
+ 1, start
- 1);
19074 printf (_(" Applies to region from %#lx"), start
);
19075 global_offset
= start
;
19079 printf (_(" to %#lx"), end
);
19085 printf (_(" Applies to region from %#lx"), start
);
19086 func_offset
= start
;
19090 printf (_(" to %#lx"), end
);
19096 printf (_(" (%s)"), name
);
19103 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19105 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19106 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19107 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19109 char name_attribute
;
19110 const char * expected_types
;
19111 const char * name
= pnote
->namedata
;
19115 if (name
== NULL
|| pnote
->namesz
< 2)
19117 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19118 print_symbol (-20, _(" <corrupt name>"));
19127 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19128 if (name
[0] == 'G' && name
[1] == 'A')
19130 if (pnote
->namesz
< 4)
19132 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19133 print_symbol (-20, _(" <corrupt name>"));
19142 switch ((name_type
= * name
))
19144 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19145 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19146 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19147 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19148 printf ("%c", * name
);
19152 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19153 print_symbol (-20, _("<unknown name type>"));
19160 switch ((name_attribute
= * name
))
19162 case GNU_BUILD_ATTRIBUTE_VERSION
:
19163 text
= _("<version>");
19164 expected_types
= string_expected
;
19167 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19168 text
= _("<stack prot>");
19169 expected_types
= "!+*";
19172 case GNU_BUILD_ATTRIBUTE_RELRO
:
19173 text
= _("<relro>");
19174 expected_types
= bool_expected
;
19177 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19178 text
= _("<stack size>");
19179 expected_types
= number_expected
;
19182 case GNU_BUILD_ATTRIBUTE_TOOL
:
19183 text
= _("<tool>");
19184 expected_types
= string_expected
;
19187 case GNU_BUILD_ATTRIBUTE_ABI
:
19189 expected_types
= "$*";
19192 case GNU_BUILD_ATTRIBUTE_PIC
:
19194 expected_types
= number_expected
;
19197 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19198 text
= _("<short enum>");
19199 expected_types
= bool_expected
;
19203 if (ISPRINT (* name
))
19205 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19207 if (len
> left
&& ! do_wide
)
19209 printf ("%.*s:", len
, name
);
19215 static char tmpbuf
[128];
19217 error (_("unrecognised byte in name field: %d\n"), * name
);
19218 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19222 expected_types
= "*$!+";
19227 left
-= printf ("%s", text
);
19229 if (strchr (expected_types
, name_type
) == NULL
)
19230 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19232 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19234 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19235 (unsigned long) pnote
->namesz
,
19236 (long) (name
- pnote
->namedata
));
19240 if (left
< 1 && ! do_wide
)
19245 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19247 unsigned int bytes
;
19248 unsigned long long val
= 0;
19249 unsigned int shift
= 0;
19250 char * decoded
= NULL
;
19252 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19254 /* The -1 is because the name field is always 0 terminated, and we
19255 want to be able to ensure that the shift in the while loop below
19256 will not overflow. */
19259 if (bytes
> sizeof (val
))
19261 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19263 bytes
= sizeof (val
);
19265 /* We do not bother to warn if bytes == 0 as this can
19266 happen with some early versions of the gcc plugin. */
19270 unsigned long byte
= (* name
++) & 0xff;
19272 val
|= byte
<< shift
;
19276 switch (name_attribute
)
19278 case GNU_BUILD_ATTRIBUTE_PIC
:
19281 case 0: decoded
= "static"; break;
19282 case 1: decoded
= "pic"; break;
19283 case 2: decoded
= "PIC"; break;
19284 case 3: decoded
= "pie"; break;
19285 case 4: decoded
= "PIE"; break;
19289 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19292 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19293 case 0: decoded
= "off"; break;
19294 case 1: decoded
= "on"; break;
19295 case 2: decoded
= "all"; break;
19296 case 3: decoded
= "strong"; break;
19297 case 4: decoded
= "explicit"; break;
19305 if (decoded
!= NULL
)
19307 print_symbol (-left
, decoded
);
19318 left
-= printf ("0x%llx", val
);
19320 left
-= printf ("0x%-.*llx", left
, val
);
19324 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19325 left
-= print_symbol (- left
, name
);
19327 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19328 left
-= print_symbol (- left
, "true");
19330 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19331 left
-= print_symbol (- left
, "false");
19335 if (do_wide
&& left
> 0)
19336 printf ("%-*s", left
, " ");
19341 /* Note that by the ELF standard, the name field is already null byte
19342 terminated, and namesz includes the terminating null byte.
19343 I.E. the value of namesz for the name "FSF" is 4.
19345 If the value of namesz is zero, there is no name present. */
19348 process_note (Elf_Internal_Note
* pnote
,
19349 Filedata
* filedata
)
19351 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19354 if (pnote
->namesz
== 0)
19355 /* If there is no note name, then use the default set of
19356 note type strings. */
19357 nt
= get_note_type (filedata
, pnote
->type
);
19359 else if (const_strneq (pnote
->namedata
, "GNU"))
19360 /* GNU-specific object file notes. */
19361 nt
= get_gnu_elf_note_type (pnote
->type
);
19363 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19364 /* FreeBSD-specific core file notes. */
19365 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19367 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19368 /* NetBSD-specific core file notes. */
19369 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19371 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19372 /* NetBSD-specific core file notes. */
19373 return process_netbsd_elf_note (pnote
);
19375 else if (const_strneq (pnote
->namedata
, "PaX"))
19376 /* NetBSD-specific core file notes. */
19377 return process_netbsd_elf_note (pnote
);
19379 else if (strneq (pnote
->namedata
, "SPU/", 4))
19381 /* SPU-specific core file notes. */
19382 nt
= pnote
->namedata
+ 4;
19386 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19387 /* VMS/ia64-specific file notes. */
19388 nt
= get_ia64_vms_note_type (pnote
->type
);
19390 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19391 nt
= get_stapsdt_note_type (pnote
->type
);
19394 /* Don't recognize this note name; just use the default set of
19395 note type strings. */
19396 nt
= get_note_type (filedata
, pnote
->type
);
19400 if (((const_strneq (pnote
->namedata
, "GA")
19401 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19402 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19403 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19404 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19405 print_gnu_build_attribute_name (pnote
);
19407 print_symbol (-20, name
);
19410 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19412 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19414 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19415 return print_ia64_vms_note (pnote
);
19416 else if (const_strneq (pnote
->namedata
, "GNU"))
19417 return print_gnu_note (filedata
, pnote
);
19418 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19419 return print_stapsdt_note (pnote
);
19420 else if (const_strneq (pnote
->namedata
, "CORE"))
19421 return print_core_note (pnote
);
19422 else if (((const_strneq (pnote
->namedata
, "GA")
19423 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19424 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19425 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19426 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19427 return print_gnu_build_attribute_description (pnote
, filedata
);
19433 printf (_(" description data: "));
19434 for (i
= 0; i
< pnote
->descsz
; i
++)
19435 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19447 process_notes_at (Filedata
* filedata
,
19448 Elf_Internal_Shdr
* section
,
19453 Elf_External_Note
* pnotes
;
19454 Elf_External_Note
* external
;
19456 bfd_boolean res
= TRUE
;
19463 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19466 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19474 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19477 if (pnotes
== NULL
)
19483 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19485 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19486 (unsigned long) offset
, (unsigned long) length
);
19488 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19489 specifies that notes should be aligned to 4 bytes in 32-bit
19490 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19491 we also support 4 byte alignment in 64-bit objects. If section
19492 alignment is less than 4, we treate alignment as 4 bytes. */
19495 else if (align
!= 4 && align
!= 8)
19497 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19503 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19505 end
= (char *) pnotes
+ length
;
19506 while ((char *) external
< end
)
19508 Elf_Internal_Note inote
;
19511 char * temp
= NULL
;
19512 size_t data_remaining
= end
- (char *) external
;
19514 if (!is_ia64_vms (filedata
))
19516 /* PR binutils/15191
19517 Make sure that there is enough data to read. */
19518 min_notesz
= offsetof (Elf_External_Note
, name
);
19519 if (data_remaining
< min_notesz
)
19521 warn (ngettext ("Corrupt note: only %ld byte remains, "
19522 "not enough for a full note\n",
19523 "Corrupt note: only %ld bytes remain, "
19524 "not enough for a full note\n",
19526 (long) data_remaining
);
19529 data_remaining
-= min_notesz
;
19531 inote
.type
= BYTE_GET (external
->type
);
19532 inote
.namesz
= BYTE_GET (external
->namesz
);
19533 inote
.namedata
= external
->name
;
19534 inote
.descsz
= BYTE_GET (external
->descsz
);
19535 inote
.descdata
= ((char *) external
19536 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19537 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19538 next
= ((char *) external
19539 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19543 Elf64_External_VMS_Note
*vms_external
;
19545 /* PR binutils/15191
19546 Make sure that there is enough data to read. */
19547 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19548 if (data_remaining
< min_notesz
)
19550 warn (ngettext ("Corrupt note: only %ld byte remains, "
19551 "not enough for a full note\n",
19552 "Corrupt note: only %ld bytes remain, "
19553 "not enough for a full note\n",
19555 (long) data_remaining
);
19558 data_remaining
-= min_notesz
;
19560 vms_external
= (Elf64_External_VMS_Note
*) external
;
19561 inote
.type
= BYTE_GET (vms_external
->type
);
19562 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19563 inote
.namedata
= vms_external
->name
;
19564 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19565 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19566 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19567 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19570 /* PR 17531: file: 3443835e. */
19571 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19572 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19573 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19574 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19575 || ((size_t) (next
- inote
.descdata
)
19576 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19578 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19579 (unsigned long) ((char *) external
- (char *) pnotes
));
19580 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19581 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19585 external
= (Elf_External_Note
*) next
;
19587 /* Verify that name is null terminated. It appears that at least
19588 one version of Linux (RedHat 6.0) generates corefiles that don't
19589 comply with the ELF spec by failing to include the null byte in
19591 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19593 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19595 temp
= (char *) malloc (inote
.namesz
+ 1);
19598 error (_("Out of memory allocating space for inote name\n"));
19603 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19604 inote
.namedata
= temp
;
19606 inote
.namedata
[inote
.namesz
] = 0;
19609 if (! process_note (& inote
, filedata
))
19625 process_corefile_note_segments (Filedata
* filedata
)
19627 Elf_Internal_Phdr
* segment
;
19629 bfd_boolean res
= TRUE
;
19631 if (! get_program_headers (filedata
))
19634 for (i
= 0, segment
= filedata
->program_headers
;
19635 i
< filedata
->file_header
.e_phnum
;
19638 if (segment
->p_type
== PT_NOTE
)
19639 if (! process_notes_at (filedata
, NULL
,
19640 (bfd_vma
) segment
->p_offset
,
19641 (bfd_vma
) segment
->p_filesz
,
19642 (bfd_vma
) segment
->p_align
))
19650 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19652 Elf_External_Note
* pnotes
;
19653 Elf_External_Note
* external
;
19655 bfd_boolean res
= TRUE
;
19660 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19662 if (pnotes
== NULL
)
19666 end
= (char*) pnotes
+ length
;
19668 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19669 (unsigned long) offset
, (unsigned long) length
);
19671 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19673 Elf_External_Note
* next
;
19674 Elf_Internal_Note inote
;
19676 inote
.type
= BYTE_GET (external
->type
);
19677 inote
.namesz
= BYTE_GET (external
->namesz
);
19678 inote
.namedata
= external
->name
;
19679 inote
.descsz
= BYTE_GET (external
->descsz
);
19680 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19681 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19683 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19685 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19686 inote
.descdata
= inote
.namedata
;
19690 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19692 if ( ((char *) next
> end
)
19693 || ((char *) next
< (char *) pnotes
))
19695 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19696 (unsigned long) ((char *) external
- (char *) pnotes
));
19697 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19698 inote
.type
, inote
.namesz
, inote
.descsz
);
19704 /* Prevent out-of-bounds indexing. */
19705 if ( inote
.namedata
+ inote
.namesz
> end
19706 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19708 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19709 (unsigned long) ((char *) external
- (char *) pnotes
));
19710 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19711 inote
.type
, inote
.namesz
, inote
.descsz
);
19715 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19717 if (! print_v850_note (& inote
))
19720 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19721 inote
.namesz
, inote
.descsz
);
19731 process_note_sections (Filedata
* filedata
)
19733 Elf_Internal_Shdr
* section
;
19735 unsigned int n
= 0;
19736 bfd_boolean res
= TRUE
;
19738 for (i
= 0, section
= filedata
->section_headers
;
19739 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19742 if (section
->sh_type
== SHT_NOTE
)
19744 if (! process_notes_at (filedata
, section
,
19745 (bfd_vma
) section
->sh_offset
,
19746 (bfd_vma
) section
->sh_size
,
19747 (bfd_vma
) section
->sh_addralign
))
19752 if (( filedata
->file_header
.e_machine
== EM_V800
19753 || filedata
->file_header
.e_machine
== EM_V850
19754 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19755 && section
->sh_type
== SHT_RENESAS_INFO
)
19757 if (! process_v850_notes (filedata
,
19758 (bfd_vma
) section
->sh_offset
,
19759 (bfd_vma
) section
->sh_size
))
19766 /* Try processing NOTE segments instead. */
19767 return process_corefile_note_segments (filedata
);
19773 process_notes (Filedata
* filedata
)
19775 /* If we have not been asked to display the notes then do nothing. */
19779 if (filedata
->file_header
.e_type
!= ET_CORE
)
19780 return process_note_sections (filedata
);
19782 /* No program headers means no NOTE segment. */
19783 if (filedata
->file_header
.e_phnum
> 0)
19784 return process_corefile_note_segments (filedata
);
19786 printf (_("No note segments present in the core file.\n"));
19790 static unsigned char *
19791 display_public_gnu_attributes (unsigned char * start
,
19792 const unsigned char * const end
)
19794 printf (_(" Unknown GNU attribute: %s\n"), start
);
19796 start
+= strnlen ((char *) start
, end
- start
);
19797 display_raw_attribute (start
, end
);
19799 return (unsigned char *) end
;
19802 static unsigned char *
19803 display_generic_attribute (unsigned char * start
,
19805 const unsigned char * const end
)
19808 return (unsigned char *) end
;
19810 return display_tag_value (tag
, start
, end
);
19814 process_arch_specific (Filedata
* filedata
)
19819 switch (filedata
->file_header
.e_machine
)
19822 case EM_ARC_COMPACT
:
19823 case EM_ARC_COMPACT2
:
19824 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19825 display_arc_attribute
,
19826 display_generic_attribute
);
19828 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19829 display_arm_attribute
,
19830 display_generic_attribute
);
19833 case EM_MIPS_RS3_LE
:
19834 return process_mips_specific (filedata
);
19837 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19838 display_msp430x_attribute
,
19839 display_msp430_gnu_attribute
);
19842 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19843 display_riscv_attribute
,
19844 display_generic_attribute
);
19847 return process_nds32_specific (filedata
);
19851 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19852 display_power_gnu_attribute
);
19856 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19857 display_s390_gnu_attribute
);
19860 case EM_SPARC32PLUS
:
19862 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19863 display_sparc_gnu_attribute
);
19866 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19867 display_tic6x_attribute
,
19868 display_generic_attribute
);
19871 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19872 display_public_gnu_attributes
,
19873 display_generic_attribute
);
19878 get_file_header (Filedata
* filedata
)
19880 /* Read in the identity array. */
19881 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19884 /* Determine how to read the rest of the header. */
19885 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19890 byte_get
= byte_get_little_endian
;
19891 byte_put
= byte_put_little_endian
;
19894 byte_get
= byte_get_big_endian
;
19895 byte_put
= byte_put_big_endian
;
19899 /* For now we only support 32 bit and 64 bit ELF files. */
19900 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19902 /* Read in the rest of the header. */
19905 Elf32_External_Ehdr ehdr32
;
19907 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19910 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19911 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19912 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19913 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19914 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19915 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19916 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19917 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19918 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19919 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19920 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19921 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19922 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19926 Elf64_External_Ehdr ehdr64
;
19928 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19929 we will not be able to cope with the 64bit data found in
19930 64 ELF files. Detect this now and abort before we start
19931 overwriting things. */
19932 if (sizeof (bfd_vma
) < 8)
19934 error (_("This instance of readelf has been built without support for a\n\
19935 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19939 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19942 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19943 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19944 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19945 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19946 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19947 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19948 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19949 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19950 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19951 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19952 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19953 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19954 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19957 if (filedata
->file_header
.e_shoff
)
19959 /* There may be some extensions in the first section header. Don't
19960 bomb if we can't read it. */
19962 get_32bit_section_headers (filedata
, TRUE
);
19964 get_64bit_section_headers (filedata
, TRUE
);
19971 close_file (Filedata
* filedata
)
19975 if (filedata
->handle
)
19976 fclose (filedata
->handle
);
19982 close_debug_file (void * data
)
19984 close_file ((Filedata
*) data
);
19988 open_file (const char * pathname
)
19990 struct stat statbuf
;
19991 Filedata
* filedata
= NULL
;
19993 if (stat (pathname
, & statbuf
) < 0
19994 || ! S_ISREG (statbuf
.st_mode
))
19997 filedata
= calloc (1, sizeof * filedata
);
19998 if (filedata
== NULL
)
20001 filedata
->handle
= fopen (pathname
, "rb");
20002 if (filedata
->handle
== NULL
)
20005 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20006 filedata
->file_name
= pathname
;
20008 if (! get_file_header (filedata
))
20011 if (filedata
->file_header
.e_shoff
)
20015 /* Read the section headers again, this time for real. */
20017 res
= get_32bit_section_headers (filedata
, FALSE
);
20019 res
= get_64bit_section_headers (filedata
, FALSE
);
20030 if (filedata
->handle
)
20031 fclose (filedata
->handle
);
20038 open_debug_file (const char * pathname
)
20040 return open_file (pathname
);
20043 /* Process one ELF object file according to the command line options.
20044 This file may actually be stored in an archive. The file is
20045 positioned at the start of the ELF object. Returns TRUE if no
20046 problems were encountered, FALSE otherwise. */
20049 process_object (Filedata
* filedata
)
20051 bfd_boolean have_separate_files
;
20053 bfd_boolean res
= TRUE
;
20055 if (! get_file_header (filedata
))
20057 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20061 /* Initialise per file variables. */
20062 for (i
= ARRAY_SIZE (version_info
); i
--;)
20063 version_info
[i
] = 0;
20065 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
20066 dynamic_info
[i
] = 0;
20067 dynamic_info_DT_GNU_HASH
= 0;
20068 dynamic_info_DT_MIPS_XHASH
= 0;
20070 /* Process the file. */
20072 printf (_("\nFile: %s\n"), filedata
->file_name
);
20074 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20075 Note we do this even if cmdline_dump_sects is empty because we
20076 must make sure that the dump_sets array is zeroed out before each
20077 object file is processed. */
20078 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
20079 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
20081 if (cmdline
.num_dump_sects
> 0)
20083 if (filedata
->num_dump_sects
== 0)
20084 /* A sneaky way of allocating the dump_sects array. */
20085 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
20087 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
20088 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
20089 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
20092 if (! process_file_header (filedata
))
20095 if (! process_section_headers (filedata
))
20097 /* Without loaded section headers we cannot process lots of things. */
20098 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20100 if (! do_using_dynamic
)
20101 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20104 if (! process_section_groups (filedata
))
20105 /* Without loaded section groups we cannot process unwind. */
20108 if (process_program_headers (filedata
))
20109 process_dynamic_section (filedata
);
20113 if (! process_relocs (filedata
))
20116 if (! process_unwind (filedata
))
20119 if (! process_symbol_table (filedata
))
20122 if (! process_syminfo (filedata
))
20125 if (! process_version_sections (filedata
))
20128 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20129 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20131 have_separate_files
= FALSE
;
20133 if (! process_section_contents (filedata
))
20136 if (have_separate_files
)
20140 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20142 if (! process_section_headers (d
->handle
))
20144 else if (! process_section_contents (d
->handle
))
20148 /* The file handles are closed by the call to free_debug_memory() below. */
20151 if (! process_notes (filedata
))
20154 if (! process_gnu_liblist (filedata
))
20157 if (! process_arch_specific (filedata
))
20160 free (filedata
->program_headers
);
20161 filedata
->program_headers
= NULL
;
20163 free (filedata
->section_headers
);
20164 filedata
->section_headers
= NULL
;
20166 free (filedata
->string_table
);
20167 filedata
->string_table
= NULL
;
20168 filedata
->string_table_length
= 0;
20170 if (filedata
->dump_sects
!= NULL
)
20172 free (filedata
->dump_sects
);
20173 filedata
->dump_sects
= NULL
;
20174 filedata
->num_dump_sects
= 0;
20177 if (dynamic_strings
)
20179 free (dynamic_strings
);
20180 dynamic_strings
= NULL
;
20181 dynamic_strings_length
= 0;
20184 if (dynamic_symbols
)
20186 free (dynamic_symbols
);
20187 dynamic_symbols
= NULL
;
20188 num_dynamic_syms
= 0;
20191 if (dynamic_syminfo
)
20193 free (dynamic_syminfo
);
20194 dynamic_syminfo
= NULL
;
20197 if (dynamic_section
)
20199 free (dynamic_section
);
20200 dynamic_section
= NULL
;
20203 while (symtab_shndx_list
!= NULL
)
20205 elf_section_list
*next
= symtab_shndx_list
->next
;
20206 free (symtab_shndx_list
);
20207 symtab_shndx_list
= next
;
20210 if (section_headers_groups
)
20212 free (section_headers_groups
);
20213 section_headers_groups
= NULL
;
20216 if (section_groups
)
20218 struct group_list
* g
;
20219 struct group_list
* next
;
20221 for (i
= 0; i
< group_count
; i
++)
20223 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
20230 free (section_groups
);
20231 section_groups
= NULL
;
20234 free_debug_memory ();
20239 /* Process an ELF archive.
20240 On entry the file is positioned just after the ARMAG string.
20241 Returns TRUE upon success, FALSE otherwise. */
20244 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20246 struct archive_info arch
;
20247 struct archive_info nested_arch
;
20249 bfd_boolean ret
= TRUE
;
20253 /* The ARCH structure is used to hold information about this archive. */
20254 arch
.file_name
= NULL
;
20256 arch
.index_array
= NULL
;
20257 arch
.sym_table
= NULL
;
20258 arch
.longnames
= NULL
;
20260 /* The NESTED_ARCH structure is used as a single-item cache of information
20261 about a nested archive (when members of a thin archive reside within
20262 another regular archive file). */
20263 nested_arch
.file_name
= NULL
;
20264 nested_arch
.file
= NULL
;
20265 nested_arch
.index_array
= NULL
;
20266 nested_arch
.sym_table
= NULL
;
20267 nested_arch
.longnames
= NULL
;
20269 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20270 filedata
->file_size
, is_thin_archive
,
20271 do_archive_index
) != 0)
20277 if (do_archive_index
)
20279 if (arch
.sym_table
== NULL
)
20280 error (_("%s: unable to dump the index as none was found\n"),
20281 filedata
->file_name
);
20284 unsigned long i
, l
;
20285 unsigned long current_pos
;
20287 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20288 "in the symbol table)\n"),
20289 filedata
->file_name
, (unsigned long) arch
.index_num
,
20292 current_pos
= ftell (filedata
->handle
);
20294 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20297 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
20300 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
20303 if (member_name
!= NULL
)
20305 char * qualified_name
20306 = make_qualified_name (&arch
, &nested_arch
,
20309 if (qualified_name
!= NULL
)
20311 printf (_("Contents of binary %s at offset "),
20313 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20315 free (qualified_name
);
20317 free (member_name
);
20321 if (l
>= arch
.sym_size
)
20323 error (_("%s: end of the symbol table reached "
20324 "before the end of the index\n"),
20325 filedata
->file_name
);
20329 /* PR 17531: file: 0b6630b2. */
20330 printf ("\t%.*s\n",
20331 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20332 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20335 if (arch
.uses_64bit_indices
)
20340 if (l
< arch
.sym_size
)
20342 error (ngettext ("%s: %ld byte remains in the symbol table, "
20343 "but without corresponding entries in "
20344 "the index table\n",
20345 "%s: %ld bytes remain in the symbol table, "
20346 "but without corresponding entries in "
20347 "the index table\n",
20348 arch
.sym_size
- l
),
20349 filedata
->file_name
, arch
.sym_size
- l
);
20353 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20355 error (_("%s: failed to seek back to start of object files "
20356 "in the archive\n"),
20357 filedata
->file_name
);
20363 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20364 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20365 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20366 && !do_section_groups
&& !do_dyn_syms
)
20368 ret
= TRUE
; /* Archive index only. */
20377 char * qualified_name
;
20379 /* Read the next archive header. */
20380 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20382 error (_("%s: failed to seek to next archive header\n"),
20387 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20388 if (got
!= sizeof arch
.arhdr
)
20392 /* PR 24049 - we cannot use filedata->file_name as this will
20393 have already been freed. */
20394 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20399 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20401 error (_("%s: did not find a valid archive header\n"),
20407 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20409 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20410 if (archive_file_size
& 01)
20411 ++archive_file_size
;
20413 name
= get_archive_member_name (&arch
, &nested_arch
);
20416 error (_("%s: bad archive file name\n"), arch
.file_name
);
20420 namelen
= strlen (name
);
20422 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20423 if (qualified_name
== NULL
)
20425 error (_("%s: bad archive file name\n"), arch
.file_name
);
20431 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20433 /* This is a proxy for an external member of a thin archive. */
20434 Filedata
* member_filedata
;
20435 char * member_file_name
= adjust_relative_path
20436 (filedata
->file_name
, name
, namelen
);
20439 if (member_file_name
== NULL
)
20441 free (qualified_name
);
20446 member_filedata
= open_file (member_file_name
);
20447 if (member_filedata
== NULL
)
20449 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20450 free (member_file_name
);
20451 free (qualified_name
);
20456 archive_file_offset
= arch
.nested_member_origin
;
20457 member_filedata
->file_name
= qualified_name
;
20459 if (! process_object (member_filedata
))
20462 close_file (member_filedata
);
20463 free (member_file_name
);
20465 else if (is_thin_archive
)
20467 Filedata thin_filedata
;
20469 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20471 /* PR 15140: Allow for corrupt thin archives. */
20472 if (nested_arch
.file
== NULL
)
20474 error (_("%s: contains corrupt thin archive: %s\n"),
20475 qualified_name
, name
);
20476 free (qualified_name
);
20483 /* This is a proxy for a member of a nested archive. */
20484 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20486 /* The nested archive file will have been opened and setup by
20487 get_archive_member_name. */
20488 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20490 error (_("%s: failed to seek to archive member.\n"),
20491 nested_arch
.file_name
);
20492 free (qualified_name
);
20497 thin_filedata
.handle
= nested_arch
.file
;
20498 thin_filedata
.file_name
= qualified_name
;
20500 if (! process_object (& thin_filedata
))
20506 archive_file_offset
= arch
.next_arhdr_offset
;
20507 filedata
->file_name
= qualified_name
;
20508 if (! process_object (filedata
))
20510 arch
.next_arhdr_offset
+= archive_file_size
;
20511 /* Stop looping with "negative" archive_file_size. */
20512 if (arch
.next_arhdr_offset
< archive_file_size
)
20513 arch
.next_arhdr_offset
= -1ul;
20516 free (qualified_name
);
20520 if (nested_arch
.file
!= NULL
)
20521 fclose (nested_arch
.file
);
20522 release_archive (&nested_arch
);
20523 release_archive (&arch
);
20529 process_file (char * file_name
)
20531 Filedata
* filedata
= NULL
;
20532 struct stat statbuf
;
20533 char armag
[SARMAG
];
20534 bfd_boolean ret
= TRUE
;
20536 if (stat (file_name
, &statbuf
) < 0)
20538 if (errno
== ENOENT
)
20539 error (_("'%s': No such file\n"), file_name
);
20541 error (_("Could not locate '%s'. System error message: %s\n"),
20542 file_name
, strerror (errno
));
20546 if (! S_ISREG (statbuf
.st_mode
))
20548 error (_("'%s' is not an ordinary file\n"), file_name
);
20552 filedata
= calloc (1, sizeof * filedata
);
20553 if (filedata
== NULL
)
20555 error (_("Out of memory allocating file data structure\n"));
20559 filedata
->file_name
= file_name
;
20560 filedata
->handle
= fopen (file_name
, "rb");
20561 if (filedata
->handle
== NULL
)
20563 error (_("Input file '%s' is not readable.\n"), file_name
);
20568 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20570 error (_("%s: Failed to read file's magic number\n"), file_name
);
20571 fclose (filedata
->handle
);
20576 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20578 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20580 if (! process_archive (filedata
, FALSE
))
20583 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20585 if ( ! process_archive (filedata
, TRUE
))
20590 if (do_archive_index
)
20591 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20594 rewind (filedata
->handle
);
20595 archive_file_size
= archive_file_offset
= 0;
20597 if (! process_object (filedata
))
20601 fclose (filedata
->handle
);
20602 free (filedata
->section_headers
);
20603 free (filedata
->program_headers
);
20604 free (filedata
->string_table
);
20605 free (filedata
->dump_sects
);
20608 free (ba_cache
.strtab
);
20609 ba_cache
.strtab
= NULL
;
20610 free (ba_cache
.symtab
);
20611 ba_cache
.symtab
= NULL
;
20612 ba_cache
.filedata
= NULL
;
20617 #ifdef SUPPORT_DISASSEMBLY
20618 /* Needed by the i386 disassembler. For extra credit, someone could
20619 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20623 print_address (unsigned int addr
, FILE * outfile
)
20625 fprintf (outfile
,"0x%8.8x", addr
);
20628 /* Needed by the i386 disassembler. */
20631 db_task_printsym (unsigned int addr
)
20633 print_address (addr
, stderr
);
20638 main (int argc
, char ** argv
)
20642 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20643 setlocale (LC_MESSAGES
, "");
20645 #if defined (HAVE_SETLOCALE)
20646 setlocale (LC_CTYPE
, "");
20648 bindtextdomain (PACKAGE
, LOCALEDIR
);
20649 textdomain (PACKAGE
);
20651 expandargv (&argc
, &argv
);
20653 cmdline
.file_name
= "<cmdline>";
20654 parse_args (& cmdline
, argc
, argv
);
20656 if (optind
< (argc
- 1))
20658 else if (optind
>= argc
)
20660 warn (_("Nothing to do.\n"));
20665 while (optind
< argc
)
20666 if (! process_file (argv
[optind
++]))
20669 if (cmdline
.dump_sects
!= NULL
)
20670 free (cmdline
.dump_sects
);
20672 free (dump_ctf_symtab_name
);
20673 free (dump_ctf_strtab_name
);
20674 free (dump_ctf_parent_name
);
20676 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;