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"), (unsigned long) symtab_index
);
1637 Elf_Internal_Sym
* psym
;
1638 const char * version_string
;
1639 enum versioned_symbol_info sym_info
;
1640 unsigned short vna_other
;
1642 psym
= symtab
+ symtab_index
;
1645 = get_symbol_version_string (filedata
, is_dynsym
,
1654 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1658 unsigned int width
= is_32bit_elf
? 8 : 14;
1660 /* Relocations against GNU_IFUNC symbols do not use the value
1661 of the symbol as the address to relocate against. Instead
1662 they invoke the function named by the symbol and use its
1663 result as the address for relocation.
1665 To indicate this to the user, do not display the value of
1666 the symbol in the "Symbols's Value" field. Instead show
1667 its name followed by () as a hint that the symbol is
1671 || psym
->st_name
== 0
1672 || psym
->st_name
>= strtablen
)
1675 name
= strtab
+ psym
->st_name
;
1677 len
= print_symbol (width
, name
);
1679 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1681 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1685 print_vma (psym
->st_value
, LONG_HEX
);
1687 printf (is_32bit_elf
? " " : " ");
1690 if (psym
->st_name
== 0)
1692 const char * sec_name
= "<null>";
1695 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1697 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1698 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1699 else if (psym
->st_shndx
== SHN_ABS
)
1701 else if (psym
->st_shndx
== SHN_COMMON
)
1702 sec_name
= "COMMON";
1703 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1704 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1705 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1706 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1707 sec_name
= "SCOMMON";
1708 else if (filedata
->file_header
.e_machine
== EM_MIPS
1709 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1710 sec_name
= "SUNDEF";
1711 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1712 || filedata
->file_header
.e_machine
== EM_L1OM
1713 || filedata
->file_header
.e_machine
== EM_K1OM
)
1714 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1715 sec_name
= "LARGE_COMMON";
1716 else if (filedata
->file_header
.e_machine
== EM_IA_64
1717 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1718 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1719 sec_name
= "ANSI_COM";
1720 else if (is_ia64_vms (filedata
)
1721 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1722 sec_name
= "VMS_SYMVEC";
1725 sprintf (name_buf
, "<section 0x%x>",
1726 (unsigned int) psym
->st_shndx
);
1727 sec_name
= name_buf
;
1730 print_symbol (22, sec_name
);
1732 else if (strtab
== NULL
)
1733 printf (_("<string table index: %3ld>"), psym
->st_name
);
1734 else if (psym
->st_name
>= strtablen
)
1736 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1741 print_symbol (22, strtab
+ psym
->st_name
);
1743 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1749 bfd_vma off
= rels
[i
].r_addend
;
1751 if ((bfd_signed_vma
) off
< 0)
1752 printf (" - %" BFD_VMA_FMT
"x", - off
);
1754 printf (" + %" BFD_VMA_FMT
"x", off
);
1760 bfd_vma off
= rels
[i
].r_addend
;
1762 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1763 if ((bfd_signed_vma
) off
< 0)
1764 printf ("-%" BFD_VMA_FMT
"x", - off
);
1766 printf ("%" BFD_VMA_FMT
"x", off
);
1769 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1771 && streq (rtype
, "R_SPARC_OLO10"))
1772 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1777 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1779 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1780 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1781 const char * rtype2
= elf_mips_reloc_type (type2
);
1782 const char * rtype3
= elf_mips_reloc_type (type3
);
1784 printf (" Type2: ");
1787 printf (_("unrecognized: %-7lx"),
1788 (unsigned long) type2
& 0xffffffff);
1790 printf ("%-17.17s", rtype2
);
1792 printf ("\n Type3: ");
1795 printf (_("unrecognized: %-7lx"),
1796 (unsigned long) type3
& 0xffffffff);
1798 printf ("%-17.17s", rtype3
);
1811 get_aarch64_dynamic_type (unsigned long type
)
1815 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1816 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1817 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1824 get_mips_dynamic_type (unsigned long type
)
1828 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1829 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1830 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1831 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1832 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1833 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1834 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1835 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1836 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1837 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1838 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1839 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1840 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1841 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1842 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1843 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1844 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1845 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1846 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1847 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1848 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1849 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1850 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1851 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1852 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1853 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1854 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1855 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1856 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1857 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1858 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1859 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1860 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1861 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1862 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1863 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1864 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1865 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1866 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1867 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1868 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1869 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1870 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1871 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1872 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1873 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1874 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1881 get_sparc64_dynamic_type (unsigned long type
)
1885 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1892 get_ppc_dynamic_type (unsigned long type
)
1896 case DT_PPC_GOT
: return "PPC_GOT";
1897 case DT_PPC_OPT
: return "PPC_OPT";
1904 get_ppc64_dynamic_type (unsigned long type
)
1908 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1909 case DT_PPC64_OPD
: return "PPC64_OPD";
1910 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1911 case DT_PPC64_OPT
: return "PPC64_OPT";
1918 get_parisc_dynamic_type (unsigned long type
)
1922 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1923 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1924 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1925 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1926 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1927 case DT_HP_PREINIT
: return "HP_PREINIT";
1928 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1929 case DT_HP_NEEDED
: return "HP_NEEDED";
1930 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1931 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1932 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1933 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1934 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1935 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1936 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1937 case DT_HP_FILTERED
: return "HP_FILTERED";
1938 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1939 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1940 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1941 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1942 case DT_PLT
: return "PLT";
1943 case DT_PLT_SIZE
: return "PLT_SIZE";
1944 case DT_DLT
: return "DLT";
1945 case DT_DLT_SIZE
: return "DLT_SIZE";
1952 get_ia64_dynamic_type (unsigned long type
)
1956 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1957 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1958 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1959 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1960 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1961 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1962 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1963 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1964 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1965 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1966 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1967 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1968 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1969 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1970 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1971 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1972 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1973 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1974 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1975 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1976 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1977 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1978 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1979 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1980 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1981 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1982 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1983 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1984 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1985 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1986 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1993 get_solaris_section_type (unsigned long type
)
1997 case 0x6fffffee: return "SUNW_ancillary";
1998 case 0x6fffffef: return "SUNW_capchain";
1999 case 0x6ffffff0: return "SUNW_capinfo";
2000 case 0x6ffffff1: return "SUNW_symsort";
2001 case 0x6ffffff2: return "SUNW_tlssort";
2002 case 0x6ffffff3: return "SUNW_LDYNSYM";
2003 case 0x6ffffff4: return "SUNW_dof";
2004 case 0x6ffffff5: return "SUNW_cap";
2005 case 0x6ffffff6: return "SUNW_SIGNATURE";
2006 case 0x6ffffff7: return "SUNW_ANNOTATE";
2007 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2008 case 0x6ffffff9: return "SUNW_DEBUG";
2009 case 0x6ffffffa: return "SUNW_move";
2010 case 0x6ffffffb: return "SUNW_COMDAT";
2011 case 0x6ffffffc: return "SUNW_syminfo";
2012 case 0x6ffffffd: return "SUNW_verdef";
2013 case 0x6ffffffe: return "SUNW_verneed";
2014 case 0x6fffffff: return "SUNW_versym";
2015 case 0x70000000: return "SPARC_GOTDATA";
2016 default: return NULL
;
2021 get_alpha_dynamic_type (unsigned long type
)
2025 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2026 default: return NULL
;
2031 get_score_dynamic_type (unsigned long type
)
2035 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2036 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2037 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2038 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2039 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2040 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2041 default: return NULL
;
2046 get_tic6x_dynamic_type (unsigned long type
)
2050 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2051 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2052 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2053 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2054 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2055 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2056 default: return NULL
;
2061 get_nios2_dynamic_type (unsigned long type
)
2065 case DT_NIOS2_GP
: return "NIOS2_GP";
2066 default: return NULL
;
2071 get_solaris_dynamic_type (unsigned long type
)
2075 case 0x6000000d: return "SUNW_AUXILIARY";
2076 case 0x6000000e: return "SUNW_RTLDINF";
2077 case 0x6000000f: return "SUNW_FILTER";
2078 case 0x60000010: return "SUNW_CAP";
2079 case 0x60000011: return "SUNW_SYMTAB";
2080 case 0x60000012: return "SUNW_SYMSZ";
2081 case 0x60000013: return "SUNW_SORTENT";
2082 case 0x60000014: return "SUNW_SYMSORT";
2083 case 0x60000015: return "SUNW_SYMSORTSZ";
2084 case 0x60000016: return "SUNW_TLSSORT";
2085 case 0x60000017: return "SUNW_TLSSORTSZ";
2086 case 0x60000018: return "SUNW_CAPINFO";
2087 case 0x60000019: return "SUNW_STRPAD";
2088 case 0x6000001a: return "SUNW_CAPCHAIN";
2089 case 0x6000001b: return "SUNW_LDMACH";
2090 case 0x6000001d: return "SUNW_CAPCHAINENT";
2091 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2092 case 0x60000021: return "SUNW_PARENT";
2093 case 0x60000023: return "SUNW_ASLR";
2094 case 0x60000025: return "SUNW_RELAX";
2095 case 0x60000029: return "SUNW_NXHEAP";
2096 case 0x6000002b: return "SUNW_NXSTACK";
2098 case 0x70000001: return "SPARC_REGISTER";
2099 case 0x7ffffffd: return "AUXILIARY";
2100 case 0x7ffffffe: return "USED";
2101 case 0x7fffffff: return "FILTER";
2103 default: return NULL
;
2108 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2110 static char buff
[64];
2114 case DT_NULL
: return "NULL";
2115 case DT_NEEDED
: return "NEEDED";
2116 case DT_PLTRELSZ
: return "PLTRELSZ";
2117 case DT_PLTGOT
: return "PLTGOT";
2118 case DT_HASH
: return "HASH";
2119 case DT_STRTAB
: return "STRTAB";
2120 case DT_SYMTAB
: return "SYMTAB";
2121 case DT_RELA
: return "RELA";
2122 case DT_RELASZ
: return "RELASZ";
2123 case DT_RELAENT
: return "RELAENT";
2124 case DT_STRSZ
: return "STRSZ";
2125 case DT_SYMENT
: return "SYMENT";
2126 case DT_INIT
: return "INIT";
2127 case DT_FINI
: return "FINI";
2128 case DT_SONAME
: return "SONAME";
2129 case DT_RPATH
: return "RPATH";
2130 case DT_SYMBOLIC
: return "SYMBOLIC";
2131 case DT_REL
: return "REL";
2132 case DT_RELSZ
: return "RELSZ";
2133 case DT_RELENT
: return "RELENT";
2134 case DT_PLTREL
: return "PLTREL";
2135 case DT_DEBUG
: return "DEBUG";
2136 case DT_TEXTREL
: return "TEXTREL";
2137 case DT_JMPREL
: return "JMPREL";
2138 case DT_BIND_NOW
: return "BIND_NOW";
2139 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2140 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2141 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2142 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2143 case DT_RUNPATH
: return "RUNPATH";
2144 case DT_FLAGS
: return "FLAGS";
2146 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2147 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2148 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2150 case DT_CHECKSUM
: return "CHECKSUM";
2151 case DT_PLTPADSZ
: return "PLTPADSZ";
2152 case DT_MOVEENT
: return "MOVEENT";
2153 case DT_MOVESZ
: return "MOVESZ";
2154 case DT_FEATURE
: return "FEATURE";
2155 case DT_POSFLAG_1
: return "POSFLAG_1";
2156 case DT_SYMINSZ
: return "SYMINSZ";
2157 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2159 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2160 case DT_CONFIG
: return "CONFIG";
2161 case DT_DEPAUDIT
: return "DEPAUDIT";
2162 case DT_AUDIT
: return "AUDIT";
2163 case DT_PLTPAD
: return "PLTPAD";
2164 case DT_MOVETAB
: return "MOVETAB";
2165 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2167 case DT_VERSYM
: return "VERSYM";
2169 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2170 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2171 case DT_RELACOUNT
: return "RELACOUNT";
2172 case DT_RELCOUNT
: return "RELCOUNT";
2173 case DT_FLAGS_1
: return "FLAGS_1";
2174 case DT_VERDEF
: return "VERDEF";
2175 case DT_VERDEFNUM
: return "VERDEFNUM";
2176 case DT_VERNEED
: return "VERNEED";
2177 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2179 case DT_AUXILIARY
: return "AUXILIARY";
2180 case DT_USED
: return "USED";
2181 case DT_FILTER
: return "FILTER";
2183 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2184 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2185 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2186 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2187 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2188 case DT_GNU_HASH
: return "GNU_HASH";
2191 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2193 const char * result
;
2195 switch (filedata
->file_header
.e_machine
)
2198 result
= get_aarch64_dynamic_type (type
);
2201 case EM_MIPS_RS3_LE
:
2202 result
= get_mips_dynamic_type (type
);
2205 result
= get_sparc64_dynamic_type (type
);
2208 result
= get_ppc_dynamic_type (type
);
2211 result
= get_ppc64_dynamic_type (type
);
2214 result
= get_ia64_dynamic_type (type
);
2217 result
= get_alpha_dynamic_type (type
);
2220 result
= get_score_dynamic_type (type
);
2223 result
= get_tic6x_dynamic_type (type
);
2225 case EM_ALTERA_NIOS2
:
2226 result
= get_nios2_dynamic_type (type
);
2229 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2230 result
= get_solaris_dynamic_type (type
);
2239 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2241 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2242 || (filedata
->file_header
.e_machine
== EM_PARISC
2243 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2245 const char * result
;
2247 switch (filedata
->file_header
.e_machine
)
2250 result
= get_parisc_dynamic_type (type
);
2253 result
= get_ia64_dynamic_type (type
);
2256 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2257 result
= get_solaris_dynamic_type (type
);
2266 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2270 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2277 get_file_type (unsigned e_type
)
2279 static char buff
[32];
2283 case ET_NONE
: return _("NONE (None)");
2284 case ET_REL
: return _("REL (Relocatable file)");
2285 case ET_EXEC
: return _("EXEC (Executable file)");
2286 case ET_DYN
: return _("DYN (Shared object file)");
2287 case ET_CORE
: return _("CORE (Core file)");
2290 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2291 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2292 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2293 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2295 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2301 get_machine_name (unsigned e_machine
)
2303 static char buff
[64]; /* XXX */
2307 /* Please keep this switch table sorted by increasing EM_ value. */
2309 case EM_NONE
: return _("None");
2310 case EM_M32
: return "WE32100";
2311 case EM_SPARC
: return "Sparc";
2312 case EM_386
: return "Intel 80386";
2313 case EM_68K
: return "MC68000";
2314 case EM_88K
: return "MC88000";
2315 case EM_IAMCU
: return "Intel MCU";
2316 case EM_860
: return "Intel 80860";
2317 case EM_MIPS
: return "MIPS R3000";
2318 case EM_S370
: return "IBM System/370";
2320 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2321 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2322 case EM_PARISC
: return "HPPA";
2323 case EM_VPP550
: return "Fujitsu VPP500";
2324 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2325 case EM_960
: return "Intel 80960";
2326 case EM_PPC
: return "PowerPC";
2328 case EM_PPC64
: return "PowerPC64";
2330 case EM_S390
: return "IBM S/390";
2331 case EM_SPU
: return "SPU";
2333 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2334 case EM_FR20
: return "Fujitsu FR20";
2335 case EM_RH32
: return "TRW RH32";
2336 case EM_MCORE
: return "MCORE";
2338 case EM_ARM
: return "ARM";
2339 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2340 case EM_SH
: return "Renesas / SuperH SH";
2341 case EM_SPARCV9
: return "Sparc v9";
2342 case EM_TRICORE
: return "Siemens Tricore";
2343 case EM_ARC
: return "ARC";
2344 case EM_H8_300
: return "Renesas H8/300";
2345 case EM_H8_300H
: return "Renesas H8/300H";
2346 case EM_H8S
: return "Renesas H8S";
2347 case EM_H8_500
: return "Renesas H8/500";
2349 case EM_IA_64
: return "Intel IA-64";
2350 case EM_MIPS_X
: return "Stanford MIPS-X";
2351 case EM_COLDFIRE
: return "Motorola Coldfire";
2352 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2353 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2354 case EM_PCP
: return "Siemens PCP";
2355 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2356 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2357 case EM_STARCORE
: return "Motorola Star*Core processor";
2358 case EM_ME16
: return "Toyota ME16 processor";
2360 case EM_ST100
: return "STMicroelectronics ST100 processor";
2361 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2362 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2363 case EM_PDSP
: return "Sony DSP processor";
2364 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2365 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2366 case EM_FX66
: return "Siemens FX66 microcontroller";
2367 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2368 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2369 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2371 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2372 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2373 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2374 case EM_SVX
: return "Silicon Graphics SVx";
2375 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2376 case EM_VAX
: return "Digital VAX";
2377 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2378 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2379 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2380 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2382 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2383 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2384 case EM_PRISM
: return "Vitesse Prism";
2386 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2387 case EM_CYGNUS_FR30
:
2388 case EM_FR30
: return "Fujitsu FR30";
2389 case EM_CYGNUS_D10V
:
2390 case EM_D10V
: return "d10v";
2391 case EM_CYGNUS_D30V
:
2392 case EM_D30V
: return "d30v";
2393 case EM_CYGNUS_V850
:
2394 case EM_V850
: return "Renesas V850";
2395 case EM_CYGNUS_M32R
:
2396 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2397 case EM_CYGNUS_MN10300
:
2398 case EM_MN10300
: return "mn10300";
2400 case EM_CYGNUS_MN10200
:
2401 case EM_MN10200
: return "mn10200";
2402 case EM_PJ
: return "picoJava";
2403 case EM_OR1K
: return "OpenRISC 1000";
2404 case EM_ARC_COMPACT
: return "ARCompact";
2406 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2407 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2408 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2409 case EM_NS32K
: return "National Semiconductor 32000 series";
2410 case EM_TPC
: return "Tenor Network TPC processor";
2411 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2413 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2415 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2416 case EM_MAX
: return "MAX Processor";
2417 case EM_CR
: return "National Semiconductor CompactRISC";
2418 case EM_F2MC16
: return "Fujitsu F2MC16";
2419 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2420 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2421 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2422 case EM_SEP
: return "Sharp embedded microprocessor";
2423 case EM_ARCA
: return "Arca RISC microprocessor";
2425 case EM_UNICORE
: return "Unicore";
2426 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2427 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2428 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2429 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2430 case EM_XGATE
: return "Motorola XGATE embedded processor";
2432 case EM_XC16X
: return "Infineon Technologies xc16x";
2433 case EM_M16C
: return "Renesas M16C series microprocessors";
2434 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2435 case EM_CE
: return "Freescale Communication Engine RISC core";
2437 case EM_M32C
: return "Renesas M32c";
2439 case EM_TSK3000
: return "Altium TSK3000 core";
2440 case EM_RS08
: return "Freescale RS08 embedded processor";
2441 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2442 case EM_SCORE
: return "SUNPLUS S+Core";
2443 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2444 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2445 case EM_LATTICEMICO32
: return "Lattice Mico32";
2446 case EM_SE_C17
: return "Seiko Epson C17 family";
2448 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2449 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2450 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2451 case EM_TI_PRU
: return "TI PRU I/O processor";
2453 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2454 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2455 case EM_R32C
: return "Renesas R32C series microprocessors";
2456 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2457 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2458 case EM_8051
: return "Intel 8051 and variants";
2459 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2460 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2461 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2462 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2464 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2465 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2466 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2467 case EM_RX
: return "Renesas RX";
2468 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2469 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2470 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2473 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2474 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2475 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2477 case EM_L1OM
: return "Intel L1OM";
2478 case EM_K1OM
: return "Intel K1OM";
2479 case EM_INTEL182
: return "Intel (reserved)";
2480 case EM_AARCH64
: return "AArch64";
2481 case EM_ARM184
: return "ARM (reserved)";
2482 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2483 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2484 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2485 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2487 case EM_CUDA
: return "NVIDIA CUDA architecture";
2488 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2489 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2490 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2491 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2492 case EM_ARC_COMPACT2
: return "ARCv2";
2493 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2494 case EM_RL78
: return "Renesas RL78";
2495 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2496 case EM_78K0R
: return "Renesas 78K0R";
2498 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2499 case EM_BA1
: return "Beyond BA1 CPU architecture";
2500 case EM_BA2
: return "Beyond BA2 CPU architecture";
2501 case EM_XCORE
: return "XMOS xCORE processor family";
2502 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2504 case EM_KM32
: return "KM211 KM32 32-bit processor";
2505 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2506 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2507 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2508 case EM_KVARC
: return "KM211 KVARC processor";
2509 case EM_CDP
: return "Paneve CDP architecture family";
2510 case EM_COGE
: return "Cognitive Smart Memory Processor";
2511 case EM_COOL
: return "Bluechip Systems CoolEngine";
2512 case EM_NORC
: return "Nanoradio Optimized RISC";
2513 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2515 case EM_Z80
: return "Zilog Z80";
2516 case EM_VISIUM
: return "CDS VISIUMcore processor";
2517 case EM_FT32
: return "FTDI Chip FT32";
2518 case EM_MOXIE
: return "Moxie";
2519 case EM_AMDGPU
: return "AMD GPU";
2520 case EM_RISCV
: return "RISC-V";
2521 case EM_LANAI
: return "Lanai 32-bit processor";
2522 case EM_BPF
: return "Linux BPF";
2523 case EM_NFP
: return "Netronome Flow Processor";
2525 /* Large numbers... */
2526 case EM_MT
: return "Morpho Techologies MT processor";
2527 case EM_ALPHA
: return "Alpha";
2528 case EM_WEBASSEMBLY
: return "Web Assembly";
2529 case EM_DLX
: return "OpenDLX";
2530 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2531 case EM_IQ2000
: return "Vitesse IQ2000";
2533 case EM_NIOS32
: return "Altera Nios";
2534 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2535 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2536 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2537 case EM_S12Z
: return "Freescale S12Z";
2538 case EM_CSKY
: return "C-SKY";
2541 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2547 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2549 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2550 other compilers don't a specific architecture type in the e_flags, and
2551 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2552 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2555 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2556 but also sets a specific architecture type in the e_flags field.
2558 However, when decoding the flags we don't worry if we see an
2559 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2560 ARCEM architecture type. */
2562 switch (e_flags
& EF_ARC_MACH_MSK
)
2564 /* We only expect these to occur for EM_ARC_COMPACT2. */
2565 case EF_ARC_CPU_ARCV2EM
:
2566 strcat (buf
, ", ARC EM");
2568 case EF_ARC_CPU_ARCV2HS
:
2569 strcat (buf
, ", ARC HS");
2572 /* We only expect these to occur for EM_ARC_COMPACT. */
2573 case E_ARC_MACH_ARC600
:
2574 strcat (buf
, ", ARC600");
2576 case E_ARC_MACH_ARC601
:
2577 strcat (buf
, ", ARC601");
2579 case E_ARC_MACH_ARC700
:
2580 strcat (buf
, ", ARC700");
2583 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2584 new ELF with new architecture being read by an old version of
2585 readelf, or (c) An ELF built with non-GNU compiler that does not
2586 set the architecture in the e_flags. */
2588 if (e_machine
== EM_ARC_COMPACT
)
2589 strcat (buf
, ", Unknown ARCompact");
2591 strcat (buf
, ", Unknown ARC");
2595 switch (e_flags
& EF_ARC_OSABI_MSK
)
2597 case E_ARC_OSABI_ORIG
:
2598 strcat (buf
, ", (ABI:legacy)");
2600 case E_ARC_OSABI_V2
:
2601 strcat (buf
, ", (ABI:v2)");
2603 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2604 case E_ARC_OSABI_V3
:
2605 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2607 case E_ARC_OSABI_V4
:
2608 strcat (buf
, ", v4 ABI");
2611 strcat (buf
, ", unrecognised ARC OSABI flag");
2617 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2620 bfd_boolean unknown
= FALSE
;
2622 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2623 e_flags
&= ~ EF_ARM_EABIMASK
;
2625 /* Handle "generic" ARM flags. */
2626 if (e_flags
& EF_ARM_RELEXEC
)
2628 strcat (buf
, ", relocatable executable");
2629 e_flags
&= ~ EF_ARM_RELEXEC
;
2632 if (e_flags
& EF_ARM_PIC
)
2634 strcat (buf
, ", position independent");
2635 e_flags
&= ~ EF_ARM_PIC
;
2638 /* Now handle EABI specific flags. */
2642 strcat (buf
, ", <unrecognized EABI>");
2647 case EF_ARM_EABI_VER1
:
2648 strcat (buf
, ", Version1 EABI");
2653 /* Process flags one bit at a time. */
2654 flag
= e_flags
& - e_flags
;
2659 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2660 strcat (buf
, ", sorted symbol tables");
2670 case EF_ARM_EABI_VER2
:
2671 strcat (buf
, ", Version2 EABI");
2676 /* Process flags one bit at a time. */
2677 flag
= e_flags
& - e_flags
;
2682 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2683 strcat (buf
, ", sorted symbol tables");
2686 case EF_ARM_DYNSYMSUSESEGIDX
:
2687 strcat (buf
, ", dynamic symbols use segment index");
2690 case EF_ARM_MAPSYMSFIRST
:
2691 strcat (buf
, ", mapping symbols precede others");
2701 case EF_ARM_EABI_VER3
:
2702 strcat (buf
, ", Version3 EABI");
2705 case EF_ARM_EABI_VER4
:
2706 strcat (buf
, ", Version4 EABI");
2711 /* Process flags one bit at a time. */
2712 flag
= e_flags
& - e_flags
;
2718 strcat (buf
, ", BE8");
2722 strcat (buf
, ", LE8");
2732 case EF_ARM_EABI_VER5
:
2733 strcat (buf
, ", Version5 EABI");
2738 /* Process flags one bit at a time. */
2739 flag
= e_flags
& - e_flags
;
2745 strcat (buf
, ", BE8");
2749 strcat (buf
, ", LE8");
2752 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2753 strcat (buf
, ", soft-float ABI");
2756 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2757 strcat (buf
, ", hard-float ABI");
2767 case EF_ARM_EABI_UNKNOWN
:
2768 strcat (buf
, ", GNU EABI");
2773 /* Process flags one bit at a time. */
2774 flag
= e_flags
& - e_flags
;
2779 case EF_ARM_INTERWORK
:
2780 strcat (buf
, ", interworking enabled");
2783 case EF_ARM_APCS_26
:
2784 strcat (buf
, ", uses APCS/26");
2787 case EF_ARM_APCS_FLOAT
:
2788 strcat (buf
, ", uses APCS/float");
2792 strcat (buf
, ", position independent");
2796 strcat (buf
, ", 8 bit structure alignment");
2799 case EF_ARM_NEW_ABI
:
2800 strcat (buf
, ", uses new ABI");
2803 case EF_ARM_OLD_ABI
:
2804 strcat (buf
, ", uses old ABI");
2807 case EF_ARM_SOFT_FLOAT
:
2808 strcat (buf
, ", software FP");
2811 case EF_ARM_VFP_FLOAT
:
2812 strcat (buf
, ", VFP");
2815 case EF_ARM_MAVERICK_FLOAT
:
2816 strcat (buf
, ", Maverick FP");
2827 strcat (buf
,_(", <unknown>"));
2831 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2833 --size
; /* Leave space for null terminator. */
2835 switch (e_flags
& EF_AVR_MACH
)
2837 case E_AVR_MACH_AVR1
:
2838 strncat (buf
, ", avr:1", size
);
2840 case E_AVR_MACH_AVR2
:
2841 strncat (buf
, ", avr:2", size
);
2843 case E_AVR_MACH_AVR25
:
2844 strncat (buf
, ", avr:25", size
);
2846 case E_AVR_MACH_AVR3
:
2847 strncat (buf
, ", avr:3", size
);
2849 case E_AVR_MACH_AVR31
:
2850 strncat (buf
, ", avr:31", size
);
2852 case E_AVR_MACH_AVR35
:
2853 strncat (buf
, ", avr:35", size
);
2855 case E_AVR_MACH_AVR4
:
2856 strncat (buf
, ", avr:4", size
);
2858 case E_AVR_MACH_AVR5
:
2859 strncat (buf
, ", avr:5", size
);
2861 case E_AVR_MACH_AVR51
:
2862 strncat (buf
, ", avr:51", size
);
2864 case E_AVR_MACH_AVR6
:
2865 strncat (buf
, ", avr:6", size
);
2867 case E_AVR_MACH_AVRTINY
:
2868 strncat (buf
, ", avr:100", size
);
2870 case E_AVR_MACH_XMEGA1
:
2871 strncat (buf
, ", avr:101", size
);
2873 case E_AVR_MACH_XMEGA2
:
2874 strncat (buf
, ", avr:102", size
);
2876 case E_AVR_MACH_XMEGA3
:
2877 strncat (buf
, ", avr:103", size
);
2879 case E_AVR_MACH_XMEGA4
:
2880 strncat (buf
, ", avr:104", size
);
2882 case E_AVR_MACH_XMEGA5
:
2883 strncat (buf
, ", avr:105", size
);
2885 case E_AVR_MACH_XMEGA6
:
2886 strncat (buf
, ", avr:106", size
);
2888 case E_AVR_MACH_XMEGA7
:
2889 strncat (buf
, ", avr:107", size
);
2892 strncat (buf
, ", avr:<unknown>", size
);
2896 size
-= strlen (buf
);
2897 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2898 strncat (buf
, ", link-relax", size
);
2902 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2908 bfd_boolean has_fpu
= FALSE
;
2911 static const char *ABI_STRINGS
[] =
2913 "ABI v0", /* use r5 as return register; only used in N1213HC */
2914 "ABI v1", /* use r0 as return register */
2915 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2916 "ABI v2fp", /* for FPU */
2920 static const char *VER_STRINGS
[] =
2922 "Andes ELF V1.3 or older",
2926 static const char *ARCH_STRINGS
[] =
2935 abi
= EF_NDS_ABI
& e_flags
;
2936 arch
= EF_NDS_ARCH
& e_flags
;
2937 config
= EF_NDS_INST
& e_flags
;
2938 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2940 memset (buf
, 0, size
);
2947 case E_NDS_ABI_V2FP
:
2948 case E_NDS_ABI_AABI
:
2949 case E_NDS_ABI_V2FP_PLUS
:
2950 /* In case there are holes in the array. */
2951 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2955 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2961 case E_NDS32_ELF_VER_1_2
:
2962 case E_NDS32_ELF_VER_1_3
:
2963 case E_NDS32_ELF_VER_1_4
:
2964 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2968 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2972 if (E_NDS_ABI_V0
== abi
)
2974 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2975 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2976 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2977 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2983 case E_NDS_ARCH_STAR_V1_0
:
2984 case E_NDS_ARCH_STAR_V2_0
:
2985 case E_NDS_ARCH_STAR_V3_0
:
2986 case E_NDS_ARCH_STAR_V3_M
:
2987 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2991 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2992 /* ARCH version determines how the e_flags are interpreted.
2993 If it is unknown, we cannot proceed. */
2997 /* Newer ABI; Now handle architecture specific flags. */
2998 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3000 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3001 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3003 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3004 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3006 if (config
& E_NDS32_HAS_DIV_INST
)
3007 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3009 if (config
& E_NDS32_HAS_16BIT_INST
)
3010 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3014 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3016 if (version
<= E_NDS32_ELF_VER_1_3
)
3017 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3019 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3022 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3023 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3025 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3026 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3028 if (config
& E_NDS32_HAS_16BIT_INST
)
3030 if (version
<= E_NDS32_ELF_VER_1_3
)
3031 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3033 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3037 if (config
& E_NDS32_HAS_EXT_INST
)
3038 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3040 if (config
& E_NDS32_HAS_EXT2_INST
)
3041 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3043 if (config
& E_NDS32_HAS_FPU_INST
)
3046 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3049 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3052 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3055 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3058 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3063 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3065 case E_NDS32_FPU_REG_8SP_4DP
:
3066 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3068 case E_NDS32_FPU_REG_16SP_8DP
:
3069 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3071 case E_NDS32_FPU_REG_32SP_16DP
:
3072 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3074 case E_NDS32_FPU_REG_32SP_32DP
:
3075 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3080 if (config
& E_NDS32_HAS_AUDIO_INST
)
3081 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3083 if (config
& E_NDS32_HAS_STRING_INST
)
3084 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3086 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3087 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3089 if (config
& E_NDS32_HAS_VIDEO_INST
)
3091 if (version
<= E_NDS32_ELF_VER_1_3
)
3092 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3094 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3097 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3098 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3100 if (config
& E_NDS32_HAS_L2C_INST
)
3101 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3105 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3107 static char buf
[1024];
3118 case EM_ARC_COMPACT2
:
3119 case EM_ARC_COMPACT
:
3120 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3124 decode_ARM_machine_flags (e_flags
, buf
);
3128 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3132 if (e_flags
& EF_BFIN_PIC
)
3133 strcat (buf
, ", PIC");
3135 if (e_flags
& EF_BFIN_FDPIC
)
3136 strcat (buf
, ", FDPIC");
3138 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3139 strcat (buf
, ", code in L1");
3141 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3142 strcat (buf
, ", data in L1");
3147 switch (e_flags
& EF_FRV_CPU_MASK
)
3149 case EF_FRV_CPU_GENERIC
:
3153 strcat (buf
, ", fr???");
3156 case EF_FRV_CPU_FR300
:
3157 strcat (buf
, ", fr300");
3160 case EF_FRV_CPU_FR400
:
3161 strcat (buf
, ", fr400");
3163 case EF_FRV_CPU_FR405
:
3164 strcat (buf
, ", fr405");
3167 case EF_FRV_CPU_FR450
:
3168 strcat (buf
, ", fr450");
3171 case EF_FRV_CPU_FR500
:
3172 strcat (buf
, ", fr500");
3174 case EF_FRV_CPU_FR550
:
3175 strcat (buf
, ", fr550");
3178 case EF_FRV_CPU_SIMPLE
:
3179 strcat (buf
, ", simple");
3181 case EF_FRV_CPU_TOMCAT
:
3182 strcat (buf
, ", tomcat");
3188 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3189 strcat (buf
, ", m68000");
3190 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3191 strcat (buf
, ", cpu32");
3192 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3193 strcat (buf
, ", fido_a");
3196 char const * isa
= _("unknown");
3197 char const * mac
= _("unknown mac");
3198 char const * additional
= NULL
;
3200 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3202 case EF_M68K_CF_ISA_A_NODIV
:
3204 additional
= ", nodiv";
3206 case EF_M68K_CF_ISA_A
:
3209 case EF_M68K_CF_ISA_A_PLUS
:
3212 case EF_M68K_CF_ISA_B_NOUSP
:
3214 additional
= ", nousp";
3216 case EF_M68K_CF_ISA_B
:
3219 case EF_M68K_CF_ISA_C
:
3222 case EF_M68K_CF_ISA_C_NODIV
:
3224 additional
= ", nodiv";
3227 strcat (buf
, ", cf, isa ");
3230 strcat (buf
, additional
);
3231 if (e_flags
& EF_M68K_CF_FLOAT
)
3232 strcat (buf
, ", float");
3233 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3238 case EF_M68K_CF_MAC
:
3241 case EF_M68K_CF_EMAC
:
3244 case EF_M68K_CF_EMAC_B
:
3257 switch (e_flags
& EF_MEP_CPU_MASK
)
3259 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3260 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3261 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3262 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3263 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3264 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3265 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3268 switch (e_flags
& EF_MEP_COP_MASK
)
3270 case EF_MEP_COP_NONE
: break;
3271 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3272 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3273 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3274 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3275 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3278 if (e_flags
& EF_MEP_LIBRARY
)
3279 strcat (buf
, ", Built for Library");
3281 if (e_flags
& EF_MEP_INDEX_MASK
)
3282 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3283 e_flags
& EF_MEP_INDEX_MASK
);
3285 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3286 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3287 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3291 if (e_flags
& EF_PPC_EMB
)
3292 strcat (buf
, ", emb");
3294 if (e_flags
& EF_PPC_RELOCATABLE
)
3295 strcat (buf
, _(", relocatable"));
3297 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3298 strcat (buf
, _(", relocatable-lib"));
3302 if (e_flags
& EF_PPC64_ABI
)
3304 char abi
[] = ", abiv0";
3306 abi
[6] += e_flags
& EF_PPC64_ABI
;
3312 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3313 strcat (buf
, ", RH850 ABI");
3315 if (e_flags
& EF_V800_850E3
)
3316 strcat (buf
, ", V3 architecture");
3318 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3319 strcat (buf
, ", FPU not used");
3321 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3322 strcat (buf
, ", regmode: COMMON");
3324 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3325 strcat (buf
, ", r4 not used");
3327 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3328 strcat (buf
, ", r30 not used");
3330 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3331 strcat (buf
, ", r5 not used");
3333 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3334 strcat (buf
, ", r2 not used");
3336 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3338 switch (e_flags
& - e_flags
)
3340 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3341 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3342 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3343 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3344 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3345 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3346 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3347 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3348 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3349 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3350 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3351 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3358 case EM_CYGNUS_V850
:
3359 switch (e_flags
& EF_V850_ARCH
)
3361 case E_V850E3V5_ARCH
:
3362 strcat (buf
, ", v850e3v5");
3364 case E_V850E2V3_ARCH
:
3365 strcat (buf
, ", v850e2v3");
3368 strcat (buf
, ", v850e2");
3371 strcat (buf
, ", v850e1");
3374 strcat (buf
, ", v850e");
3377 strcat (buf
, ", v850");
3380 strcat (buf
, _(", unknown v850 architecture variant"));
3386 case EM_CYGNUS_M32R
:
3387 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3388 strcat (buf
, ", m32r");
3392 case EM_MIPS_RS3_LE
:
3393 if (e_flags
& EF_MIPS_NOREORDER
)
3394 strcat (buf
, ", noreorder");
3396 if (e_flags
& EF_MIPS_PIC
)
3397 strcat (buf
, ", pic");
3399 if (e_flags
& EF_MIPS_CPIC
)
3400 strcat (buf
, ", cpic");
3402 if (e_flags
& EF_MIPS_UCODE
)
3403 strcat (buf
, ", ugen_reserved");
3405 if (e_flags
& EF_MIPS_ABI2
)
3406 strcat (buf
, ", abi2");
3408 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3409 strcat (buf
, ", odk first");
3411 if (e_flags
& EF_MIPS_32BITMODE
)
3412 strcat (buf
, ", 32bitmode");
3414 if (e_flags
& EF_MIPS_NAN2008
)
3415 strcat (buf
, ", nan2008");
3417 if (e_flags
& EF_MIPS_FP64
)
3418 strcat (buf
, ", fp64");
3420 switch ((e_flags
& EF_MIPS_MACH
))
3422 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3423 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3424 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3425 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3426 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3427 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3428 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3429 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3430 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3431 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3432 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3433 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3434 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3435 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3436 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3437 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3438 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3439 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3440 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3441 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3442 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3444 /* We simply ignore the field in this case to avoid confusion:
3445 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3448 default: strcat (buf
, _(", unknown CPU")); break;
3451 switch ((e_flags
& EF_MIPS_ABI
))
3453 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3454 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3455 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3456 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3458 /* We simply ignore the field in this case to avoid confusion:
3459 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3460 This means it is likely to be an o32 file, but not for
3463 default: strcat (buf
, _(", unknown ABI")); break;
3466 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3467 strcat (buf
, ", mdmx");
3469 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3470 strcat (buf
, ", mips16");
3472 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3473 strcat (buf
, ", micromips");
3475 switch ((e_flags
& EF_MIPS_ARCH
))
3477 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3478 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3479 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3480 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3481 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3482 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3483 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3484 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3485 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3486 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3487 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3488 default: strcat (buf
, _(", unknown ISA")); break;
3493 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3497 switch (EF_NFP_MACH (e_flags
))
3499 case E_NFP_MACH_3200
:
3500 strcat (buf
, ", NFP-32xx");
3502 case E_NFP_MACH_6000
:
3503 strcat (buf
, ", NFP-6xxx");
3509 if (e_flags
& EF_RISCV_RVC
)
3510 strcat (buf
, ", RVC");
3512 if (e_flags
& EF_RISCV_RVE
)
3513 strcat (buf
, ", RVE");
3515 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3517 case EF_RISCV_FLOAT_ABI_SOFT
:
3518 strcat (buf
, ", soft-float ABI");
3521 case EF_RISCV_FLOAT_ABI_SINGLE
:
3522 strcat (buf
, ", single-float ABI");
3525 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3526 strcat (buf
, ", double-float ABI");
3529 case EF_RISCV_FLOAT_ABI_QUAD
:
3530 strcat (buf
, ", quad-float ABI");
3536 switch ((e_flags
& EF_SH_MACH_MASK
))
3538 case EF_SH1
: strcat (buf
, ", sh1"); break;
3539 case EF_SH2
: strcat (buf
, ", sh2"); break;
3540 case EF_SH3
: strcat (buf
, ", sh3"); break;
3541 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3542 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3543 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3544 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3545 case EF_SH4
: strcat (buf
, ", sh4"); break;
3546 case EF_SH5
: strcat (buf
, ", sh5"); break;
3547 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3548 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3549 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3550 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3551 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3552 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3553 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3554 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3555 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3556 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3557 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3558 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3559 default: strcat (buf
, _(", unknown ISA")); break;
3562 if (e_flags
& EF_SH_PIC
)
3563 strcat (buf
, ", pic");
3565 if (e_flags
& EF_SH_FDPIC
)
3566 strcat (buf
, ", fdpic");
3570 if (e_flags
& EF_OR1K_NODELAY
)
3571 strcat (buf
, ", no delay");
3575 if (e_flags
& EF_SPARC_32PLUS
)
3576 strcat (buf
, ", v8+");
3578 if (e_flags
& EF_SPARC_SUN_US1
)
3579 strcat (buf
, ", ultrasparcI");
3581 if (e_flags
& EF_SPARC_SUN_US3
)
3582 strcat (buf
, ", ultrasparcIII");
3584 if (e_flags
& EF_SPARC_HAL_R1
)
3585 strcat (buf
, ", halr1");
3587 if (e_flags
& EF_SPARC_LEDATA
)
3588 strcat (buf
, ", ledata");
3590 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3591 strcat (buf
, ", tso");
3593 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3594 strcat (buf
, ", pso");
3596 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3597 strcat (buf
, ", rmo");
3601 switch (e_flags
& EF_PARISC_ARCH
)
3603 case EFA_PARISC_1_0
:
3604 strcpy (buf
, ", PA-RISC 1.0");
3606 case EFA_PARISC_1_1
:
3607 strcpy (buf
, ", PA-RISC 1.1");
3609 case EFA_PARISC_2_0
:
3610 strcpy (buf
, ", PA-RISC 2.0");
3615 if (e_flags
& EF_PARISC_TRAPNIL
)
3616 strcat (buf
, ", trapnil");
3617 if (e_flags
& EF_PARISC_EXT
)
3618 strcat (buf
, ", ext");
3619 if (e_flags
& EF_PARISC_LSB
)
3620 strcat (buf
, ", lsb");
3621 if (e_flags
& EF_PARISC_WIDE
)
3622 strcat (buf
, ", wide");
3623 if (e_flags
& EF_PARISC_NO_KABP
)
3624 strcat (buf
, ", no kabp");
3625 if (e_flags
& EF_PARISC_LAZYSWAP
)
3626 strcat (buf
, ", lazyswap");
3631 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3632 strcat (buf
, ", new calling convention");
3634 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3635 strcat (buf
, ", gnu calling convention");
3639 if ((e_flags
& EF_IA_64_ABI64
))
3640 strcat (buf
, ", 64-bit");
3642 strcat (buf
, ", 32-bit");
3643 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3644 strcat (buf
, ", reduced fp model");
3645 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3646 strcat (buf
, ", no function descriptors, constant gp");
3647 else if ((e_flags
& EF_IA_64_CONS_GP
))
3648 strcat (buf
, ", constant gp");
3649 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3650 strcat (buf
, ", absolute");
3651 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3653 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3654 strcat (buf
, ", vms_linkages");
3655 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3657 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3659 case EF_IA_64_VMS_COMCOD_WARNING
:
3660 strcat (buf
, ", warning");
3662 case EF_IA_64_VMS_COMCOD_ERROR
:
3663 strcat (buf
, ", error");
3665 case EF_IA_64_VMS_COMCOD_ABORT
:
3666 strcat (buf
, ", abort");
3669 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3670 e_flags
& EF_IA_64_VMS_COMCOD
);
3671 strcat (buf
, ", <unknown>");
3677 if ((e_flags
& EF_VAX_NONPIC
))
3678 strcat (buf
, ", non-PIC");
3679 if ((e_flags
& EF_VAX_DFLOAT
))
3680 strcat (buf
, ", D-Float");
3681 if ((e_flags
& EF_VAX_GFLOAT
))
3682 strcat (buf
, ", G-Float");
3686 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3687 strcat (buf
, ", mcm");
3688 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3689 strcat (buf
, ", mcm24");
3690 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3691 strcat (buf
, ", gr6");
3695 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3697 case E_FLAG_RL78_ANY_CPU
: break;
3698 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3699 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3700 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3702 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3703 strcat (buf
, ", 64-bit doubles");
3707 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3708 strcat (buf
, ", 64-bit doubles");
3709 if (e_flags
& E_FLAG_RX_DSP
)
3710 strcat (buf
, ", dsp");
3711 if (e_flags
& E_FLAG_RX_PID
)
3712 strcat (buf
, ", pid");
3713 if (e_flags
& E_FLAG_RX_ABI
)
3714 strcat (buf
, ", RX ABI");
3715 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3716 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3717 ? ", uses String instructions" : ", bans String instructions");
3718 if (e_flags
& E_FLAG_RX_V2
)
3719 strcat (buf
, ", V2");
3720 if (e_flags
& E_FLAG_RX_V3
)
3721 strcat (buf
, ", V3");
3725 if (e_flags
& EF_S390_HIGH_GPRS
)
3726 strcat (buf
, ", highgprs");
3730 if ((e_flags
& EF_C6000_REL
))
3731 strcat (buf
, ", relocatable module");
3735 strcat (buf
, _(": architecture variant: "));
3736 switch (e_flags
& EF_MSP430_MACH
)
3738 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3739 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3740 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3741 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3742 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3743 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3744 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3745 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3746 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3747 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3748 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3749 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3750 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3751 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3752 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3754 strcat (buf
, _(": unknown")); break;
3757 if (e_flags
& ~ EF_MSP430_MACH
)
3758 strcat (buf
, _(": unknown extra flag bits also present"));
3762 switch (e_flags
& EF_Z80_MACH_MSK
)
3764 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3765 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3766 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3767 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3768 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3769 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3771 strcat (buf
, _(", unknown")); break;
3781 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3783 static char buff
[32];
3787 case ELFOSABI_NONE
: return "UNIX - System V";
3788 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3789 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3790 case ELFOSABI_GNU
: return "UNIX - GNU";
3791 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3792 case ELFOSABI_AIX
: return "UNIX - AIX";
3793 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3794 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3795 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3796 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3797 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3798 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3799 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3800 case ELFOSABI_AROS
: return "AROS";
3801 case ELFOSABI_FENIXOS
: return "FenixOS";
3802 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3803 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3806 switch (filedata
->file_header
.e_machine
)
3811 case ELFOSABI_ARM
: return "ARM";
3812 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3823 case ELFOSABI_STANDALONE
: return _("Standalone App");
3832 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3833 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3842 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3848 get_aarch64_segment_type (unsigned long type
)
3852 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3853 default: return NULL
;
3858 get_arm_segment_type (unsigned long type
)
3862 case PT_ARM_EXIDX
: return "EXIDX";
3863 default: return NULL
;
3868 get_s390_segment_type (unsigned long type
)
3872 case PT_S390_PGSTE
: return "S390_PGSTE";
3873 default: return NULL
;
3878 get_mips_segment_type (unsigned long type
)
3882 case PT_MIPS_REGINFO
: return "REGINFO";
3883 case PT_MIPS_RTPROC
: return "RTPROC";
3884 case PT_MIPS_OPTIONS
: return "OPTIONS";
3885 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3886 default: return NULL
;
3891 get_parisc_segment_type (unsigned long type
)
3895 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3896 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3897 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3898 default: return NULL
;
3903 get_ia64_segment_type (unsigned long type
)
3907 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3908 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3909 default: return NULL
;
3914 get_tic6x_segment_type (unsigned long type
)
3918 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3919 default: return NULL
;
3924 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3926 if (e_machine
== EM_PARISC
)
3929 case PT_HP_TLS
: return "HP_TLS";
3930 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3931 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3932 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3933 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3934 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3935 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3936 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3937 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3938 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3939 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3940 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3941 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3942 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3943 case PT_HP_STACK
: return "HP_STACK";
3944 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3945 default: return NULL
;
3948 if (e_machine
== EM_IA_64
)
3951 case PT_HP_TLS
: return "HP_TLS";
3952 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3953 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3954 case PT_IA_64_HP_STACK
: return "HP_STACK";
3955 default: return NULL
;
3962 get_solaris_segment_type (unsigned long type
)
3966 case 0x6464e550: return "PT_SUNW_UNWIND";
3967 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3968 case 0x6ffffff7: return "PT_LOSUNW";
3969 case 0x6ffffffa: return "PT_SUNWBSS";
3970 case 0x6ffffffb: return "PT_SUNWSTACK";
3971 case 0x6ffffffc: return "PT_SUNWDTRACE";
3972 case 0x6ffffffd: return "PT_SUNWCAP";
3973 case 0x6fffffff: return "PT_HISUNW";
3974 default: return NULL
;
3979 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3981 static char buff
[32];
3985 case PT_NULL
: return "NULL";
3986 case PT_LOAD
: return "LOAD";
3987 case PT_DYNAMIC
: return "DYNAMIC";
3988 case PT_INTERP
: return "INTERP";
3989 case PT_NOTE
: return "NOTE";
3990 case PT_SHLIB
: return "SHLIB";
3991 case PT_PHDR
: return "PHDR";
3992 case PT_TLS
: return "TLS";
3993 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3994 case PT_GNU_STACK
: return "GNU_STACK";
3995 case PT_GNU_RELRO
: return "GNU_RELRO";
3996 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
3999 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4001 const char * result
;
4003 switch (filedata
->file_header
.e_machine
)
4006 result
= get_aarch64_segment_type (p_type
);
4009 result
= get_arm_segment_type (p_type
);
4012 case EM_MIPS_RS3_LE
:
4013 result
= get_mips_segment_type (p_type
);
4016 result
= get_parisc_segment_type (p_type
);
4019 result
= get_ia64_segment_type (p_type
);
4022 result
= get_tic6x_segment_type (p_type
);
4026 result
= get_s390_segment_type (p_type
);
4036 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4038 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4040 const char * result
= NULL
;
4042 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4045 case ELFOSABI_FREEBSD
:
4046 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4048 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4053 result
= get_hpux_segment_type (p_type
,
4054 filedata
->file_header
.e_machine
);
4056 case ELFOSABI_SOLARIS
:
4057 result
= get_solaris_segment_type (p_type
);
4065 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4068 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4075 get_arc_section_type_name (unsigned int sh_type
)
4079 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4087 get_mips_section_type_name (unsigned int sh_type
)
4091 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4092 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4093 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4094 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4095 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4096 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4097 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4098 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4099 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4100 case SHT_MIPS_RELD
: return "MIPS_RELD";
4101 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4102 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4103 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4104 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4105 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4106 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4107 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4108 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4109 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4110 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4111 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4112 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4113 case SHT_MIPS_LINE
: return "MIPS_LINE";
4114 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4115 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4116 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4117 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4118 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4119 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4120 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4121 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4122 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4123 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4124 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4125 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4126 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4127 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4128 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4129 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4130 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4131 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4139 get_parisc_section_type_name (unsigned int sh_type
)
4143 case SHT_PARISC_EXT
: return "PARISC_EXT";
4144 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4145 case SHT_PARISC_DOC
: return "PARISC_DOC";
4146 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4147 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4148 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4149 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4150 default: return NULL
;
4155 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4157 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4158 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4159 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4163 case SHT_IA_64_EXT
: return "IA_64_EXT";
4164 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4165 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4166 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4167 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4168 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4169 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4170 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4171 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4172 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4180 get_x86_64_section_type_name (unsigned int sh_type
)
4184 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4185 default: return NULL
;
4190 get_aarch64_section_type_name (unsigned int sh_type
)
4194 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4195 default: return NULL
;
4200 get_arm_section_type_name (unsigned int sh_type
)
4204 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4205 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4206 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4207 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4208 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4209 default: return NULL
;
4214 get_tic6x_section_type_name (unsigned int sh_type
)
4218 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4219 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4220 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4221 case SHT_TI_ICODE
: return "TI_ICODE";
4222 case SHT_TI_XREF
: return "TI_XREF";
4223 case SHT_TI_HANDLER
: return "TI_HANDLER";
4224 case SHT_TI_INITINFO
: return "TI_INITINFO";
4225 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4226 default: return NULL
;
4231 get_msp430x_section_type_name (unsigned int sh_type
)
4235 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4236 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4237 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4238 default: return NULL
;
4243 get_nfp_section_type_name (unsigned int sh_type
)
4247 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4248 case SHT_NFP_INITREG
: return "NFP_INITREG";
4249 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4250 default: return NULL
;
4255 get_v850_section_type_name (unsigned int sh_type
)
4259 case SHT_V850_SCOMMON
: return "V850 Small Common";
4260 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4261 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4262 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4263 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4264 default: return NULL
;
4269 get_riscv_section_type_name (unsigned int sh_type
)
4273 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4274 default: return NULL
;
4279 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4281 static char buff
[32];
4282 const char * result
;
4286 case SHT_NULL
: return "NULL";
4287 case SHT_PROGBITS
: return "PROGBITS";
4288 case SHT_SYMTAB
: return "SYMTAB";
4289 case SHT_STRTAB
: return "STRTAB";
4290 case SHT_RELA
: return "RELA";
4291 case SHT_HASH
: return "HASH";
4292 case SHT_DYNAMIC
: return "DYNAMIC";
4293 case SHT_NOTE
: return "NOTE";
4294 case SHT_NOBITS
: return "NOBITS";
4295 case SHT_REL
: return "REL";
4296 case SHT_SHLIB
: return "SHLIB";
4297 case SHT_DYNSYM
: return "DYNSYM";
4298 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4299 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4300 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4301 case SHT_GNU_HASH
: return "GNU_HASH";
4302 case SHT_GROUP
: return "GROUP";
4303 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4304 case SHT_GNU_verdef
: return "VERDEF";
4305 case SHT_GNU_verneed
: return "VERNEED";
4306 case SHT_GNU_versym
: return "VERSYM";
4307 case 0x6ffffff0: return "VERSYM";
4308 case 0x6ffffffc: return "VERDEF";
4309 case 0x7ffffffd: return "AUXILIARY";
4310 case 0x7fffffff: return "FILTER";
4311 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4314 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4316 switch (filedata
->file_header
.e_machine
)
4319 case EM_ARC_COMPACT
:
4320 case EM_ARC_COMPACT2
:
4321 result
= get_arc_section_type_name (sh_type
);
4324 case EM_MIPS_RS3_LE
:
4325 result
= get_mips_section_type_name (sh_type
);
4328 result
= get_parisc_section_type_name (sh_type
);
4331 result
= get_ia64_section_type_name (filedata
, sh_type
);
4336 result
= get_x86_64_section_type_name (sh_type
);
4339 result
= get_aarch64_section_type_name (sh_type
);
4342 result
= get_arm_section_type_name (sh_type
);
4345 result
= get_tic6x_section_type_name (sh_type
);
4348 result
= get_msp430x_section_type_name (sh_type
);
4351 result
= get_nfp_section_type_name (sh_type
);
4355 case EM_CYGNUS_V850
:
4356 result
= get_v850_section_type_name (sh_type
);
4359 result
= get_riscv_section_type_name (sh_type
);
4369 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4371 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4373 switch (filedata
->file_header
.e_machine
)
4376 result
= get_ia64_section_type_name (filedata
, sh_type
);
4379 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4380 result
= get_solaris_section_type (sh_type
);
4385 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4386 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4387 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4388 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4400 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4402 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4404 switch (filedata
->file_header
.e_machine
)
4408 case EM_CYGNUS_V850
:
4409 result
= get_v850_section_type_name (sh_type
);
4419 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4422 /* This message is probably going to be displayed in a 15
4423 character wide field, so put the hex value first. */
4424 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4430 #define OPTION_DEBUG_DUMP 512
4431 #define OPTION_DYN_SYMS 513
4432 #define OPTION_DWARF_DEPTH 514
4433 #define OPTION_DWARF_START 515
4434 #define OPTION_DWARF_CHECK 516
4435 #define OPTION_CTF_DUMP 517
4436 #define OPTION_CTF_PARENT 518
4437 #define OPTION_CTF_SYMBOLS 519
4438 #define OPTION_CTF_STRINGS 520
4440 static struct option options
[] =
4442 {"all", no_argument
, 0, 'a'},
4443 {"file-header", no_argument
, 0, 'h'},
4444 {"program-headers", no_argument
, 0, 'l'},
4445 {"headers", no_argument
, 0, 'e'},
4446 {"histogram", no_argument
, 0, 'I'},
4447 {"segments", no_argument
, 0, 'l'},
4448 {"sections", no_argument
, 0, 'S'},
4449 {"section-headers", no_argument
, 0, 'S'},
4450 {"section-groups", no_argument
, 0, 'g'},
4451 {"section-details", no_argument
, 0, 't'},
4452 {"full-section-name",no_argument
, 0, 'N'},
4453 {"symbols", no_argument
, 0, 's'},
4454 {"syms", no_argument
, 0, 's'},
4455 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4456 {"relocs", no_argument
, 0, 'r'},
4457 {"notes", no_argument
, 0, 'n'},
4458 {"dynamic", no_argument
, 0, 'd'},
4459 {"arch-specific", no_argument
, 0, 'A'},
4460 {"version-info", no_argument
, 0, 'V'},
4461 {"use-dynamic", no_argument
, 0, 'D'},
4462 {"unwind", no_argument
, 0, 'u'},
4463 {"archive-index", no_argument
, 0, 'c'},
4464 {"hex-dump", required_argument
, 0, 'x'},
4465 {"relocated-dump", required_argument
, 0, 'R'},
4466 {"string-dump", required_argument
, 0, 'p'},
4467 {"decompress", no_argument
, 0, 'z'},
4468 #ifdef SUPPORT_DISASSEMBLY
4469 {"instruction-dump", required_argument
, 0, 'i'},
4471 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4473 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4474 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4475 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4477 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4479 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4480 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4481 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4483 {"version", no_argument
, 0, 'v'},
4484 {"wide", no_argument
, 0, 'W'},
4485 {"help", no_argument
, 0, 'H'},
4486 {0, no_argument
, 0, 0}
4490 usage (FILE * stream
)
4492 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4493 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4494 fprintf (stream
, _(" Options are:\n\
4495 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4496 -h --file-header Display the ELF file header\n\
4497 -l --program-headers Display the program headers\n\
4498 --segments An alias for --program-headers\n\
4499 -S --section-headers Display the sections' header\n\
4500 --sections An alias for --section-headers\n\
4501 -g --section-groups Display the section groups\n\
4502 -t --section-details Display the section details\n\
4503 -e --headers Equivalent to: -h -l -S\n\
4504 -s --syms Display the symbol table\n\
4505 --symbols An alias for --syms\n\
4506 --dyn-syms Display the dynamic symbol table\n\
4507 -n --notes Display the core notes (if present)\n\
4508 -r --relocs Display the relocations (if present)\n\
4509 -u --unwind Display the unwind info (if present)\n\
4510 -d --dynamic Display the dynamic section (if present)\n\
4511 -V --version-info Display the version sections (if present)\n\
4512 -A --arch-specific Display architecture specific information (if any)\n\
4513 -c --archive-index Display the symbol/file index in an archive\n\
4514 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4515 -x --hex-dump=<number|name>\n\
4516 Dump the contents of section <number|name> as bytes\n\
4517 -p --string-dump=<number|name>\n\
4518 Dump the contents of section <number|name> as strings\n\
4519 -R --relocated-dump=<number|name>\n\
4520 Dump the contents of section <number|name> as relocated bytes\n\
4521 -z --decompress Decompress section before dumping it\n\
4522 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4523 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4524 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4525 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4526 =addr,=cu_index,=links,=follow-links]\n\
4527 Display the contents of DWARF debug sections\n"));
4528 fprintf (stream
, _("\
4529 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4530 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4532 fprintf (stream
, _("\
4533 --ctf=<number|name> Display CTF info from section <number|name>\n\
4534 --ctf-parent=<number|name>\n\
4535 Use section <number|name> as the CTF parent\n\n\
4536 --ctf-symbols=<number|name>\n\
4537 Use section <number|name> as the CTF external symtab\n\n\
4538 --ctf-strings=<number|name>\n\
4539 Use section <number|name> as the CTF external strtab\n\n"));
4541 #ifdef SUPPORT_DISASSEMBLY
4542 fprintf (stream
, _("\
4543 -i --instruction-dump=<number|name>\n\
4544 Disassemble the contents of section <number|name>\n"));
4546 fprintf (stream
, _("\
4547 -I --histogram Display histogram of bucket list lengths\n\
4548 -W --wide Allow output width to exceed 80 characters\n\
4549 @<file> Read options from <file>\n\
4550 -H --help Display this information\n\
4551 -v --version Display the version number of readelf\n"));
4553 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4554 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4556 exit (stream
== stdout
? 0 : 1);
4559 /* Record the fact that the user wants the contents of section number
4560 SECTION to be displayed using the method(s) encoded as flags bits
4561 in TYPE. Note, TYPE can be zero if we are creating the array for
4565 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4567 if (section
>= filedata
->num_dump_sects
)
4569 dump_type
* new_dump_sects
;
4571 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4572 sizeof (* new_dump_sects
));
4574 if (new_dump_sects
== NULL
)
4575 error (_("Out of memory allocating dump request table.\n"));
4578 if (filedata
->dump_sects
)
4580 /* Copy current flag settings. */
4581 memcpy (new_dump_sects
, filedata
->dump_sects
,
4582 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4584 free (filedata
->dump_sects
);
4587 filedata
->dump_sects
= new_dump_sects
;
4588 filedata
->num_dump_sects
= section
+ 1;
4592 if (filedata
->dump_sects
)
4593 filedata
->dump_sects
[section
] |= type
;
4596 /* Request a dump by section name. */
4599 request_dump_byname (const char * section
, dump_type type
)
4601 struct dump_list_entry
* new_request
;
4603 new_request
= (struct dump_list_entry
*)
4604 malloc (sizeof (struct dump_list_entry
));
4606 error (_("Out of memory allocating dump request table.\n"));
4608 new_request
->name
= strdup (section
);
4609 if (!new_request
->name
)
4610 error (_("Out of memory allocating dump request table.\n"));
4612 new_request
->type
= type
;
4614 new_request
->next
= dump_sects_byname
;
4615 dump_sects_byname
= new_request
;
4619 request_dump (Filedata
* filedata
, dump_type type
)
4625 section
= strtoul (optarg
, & cp
, 0);
4627 if (! *cp
&& section
>= 0)
4628 request_dump_bynumber (filedata
, section
, type
);
4630 request_dump_byname (optarg
, type
);
4634 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4641 while ((c
= getopt_long
4642 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4660 do_section_groups
= TRUE
;
4663 do_histogram
= TRUE
;
4668 do_section_groups
= TRUE
;
4673 do_section_details
= TRUE
;
4684 do_using_dynamic
= TRUE
;
4708 do_histogram
= TRUE
;
4714 do_archive_index
= TRUE
;
4717 request_dump (filedata
, HEX_DUMP
);
4720 request_dump (filedata
, STRING_DUMP
);
4723 request_dump (filedata
, RELOC_DUMP
);
4726 decompress_dumps
= TRUE
;
4732 do_debugging
= TRUE
;
4733 dwarf_select_sections_all ();
4737 do_debugging
= FALSE
;
4738 dwarf_select_sections_by_letters (optarg
);
4741 case OPTION_DEBUG_DUMP
:
4744 do_debugging
= TRUE
;
4747 do_debugging
= FALSE
;
4748 dwarf_select_sections_by_names (optarg
);
4751 case OPTION_DWARF_DEPTH
:
4755 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4758 case OPTION_DWARF_START
:
4762 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4765 case OPTION_DWARF_CHECK
:
4768 case OPTION_CTF_DUMP
:
4770 request_dump (filedata
, CTF_DUMP
);
4772 case OPTION_CTF_SYMBOLS
:
4773 dump_ctf_symtab_name
= strdup (optarg
);
4775 case OPTION_CTF_STRINGS
:
4776 dump_ctf_strtab_name
= strdup (optarg
);
4778 case OPTION_CTF_PARENT
:
4779 dump_ctf_parent_name
= strdup (optarg
);
4781 case OPTION_DYN_SYMS
:
4784 #ifdef SUPPORT_DISASSEMBLY
4786 request_dump (filedata
, DISASS_DUMP
);
4790 print_version (program_name
);
4799 /* xgettext:c-format */
4800 error (_("Invalid option '-%c'\n"), c
);
4807 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4808 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4809 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4810 && !do_section_groups
&& !do_archive_index
4816 get_elf_class (unsigned int elf_class
)
4818 static char buff
[32];
4822 case ELFCLASSNONE
: return _("none");
4823 case ELFCLASS32
: return "ELF32";
4824 case ELFCLASS64
: return "ELF64";
4826 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4832 get_data_encoding (unsigned int encoding
)
4834 static char buff
[32];
4838 case ELFDATANONE
: return _("none");
4839 case ELFDATA2LSB
: return _("2's complement, little endian");
4840 case ELFDATA2MSB
: return _("2's complement, big endian");
4842 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4847 /* Decode the data held in 'filedata->file_header'. */
4850 process_file_header (Filedata
* filedata
)
4852 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4854 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4855 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4856 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4857 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4860 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4864 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4870 printf (_("ELF Header:\n"));
4871 printf (_(" Magic: "));
4872 for (i
= 0; i
< EI_NIDENT
; i
++)
4873 printf ("%2.2x ", header
->e_ident
[i
]);
4875 printf (_(" Class: %s\n"),
4876 get_elf_class (header
->e_ident
[EI_CLASS
]));
4877 printf (_(" Data: %s\n"),
4878 get_data_encoding (header
->e_ident
[EI_DATA
]));
4879 printf (_(" Version: %d%s\n"),
4880 header
->e_ident
[EI_VERSION
],
4881 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4883 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4886 printf (_(" OS/ABI: %s\n"),
4887 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4888 printf (_(" ABI Version: %d\n"),
4889 header
->e_ident
[EI_ABIVERSION
]);
4890 printf (_(" Type: %s\n"),
4891 get_file_type (header
->e_type
));
4892 printf (_(" Machine: %s\n"),
4893 get_machine_name (header
->e_machine
));
4894 printf (_(" Version: 0x%lx\n"),
4897 printf (_(" Entry point address: "));
4898 print_vma (header
->e_entry
, PREFIX_HEX
);
4899 printf (_("\n Start of program headers: "));
4900 print_vma (header
->e_phoff
, DEC
);
4901 printf (_(" (bytes into file)\n Start of section headers: "));
4902 print_vma (header
->e_shoff
, DEC
);
4903 printf (_(" (bytes into file)\n"));
4905 printf (_(" Flags: 0x%lx%s\n"),
4907 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4908 printf (_(" Size of this header: %u (bytes)\n"),
4910 printf (_(" Size of program headers: %u (bytes)\n"),
4911 header
->e_phentsize
);
4912 printf (_(" Number of program headers: %u"),
4914 if (filedata
->section_headers
!= NULL
4915 && header
->e_phnum
== PN_XNUM
4916 && filedata
->section_headers
[0].sh_info
!= 0)
4918 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4919 printf (" (%u)", header
->e_phnum
);
4921 putc ('\n', stdout
);
4922 printf (_(" Size of section headers: %u (bytes)\n"),
4923 header
->e_shentsize
);
4924 printf (_(" Number of section headers: %u"),
4926 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4928 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4929 printf (" (%u)", header
->e_shnum
);
4931 putc ('\n', stdout
);
4932 printf (_(" Section header string table index: %u"),
4933 header
->e_shstrndx
);
4934 if (filedata
->section_headers
!= NULL
4935 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4937 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4938 printf (" (%u)", header
->e_shstrndx
);
4940 if (header
->e_shstrndx
!= SHN_UNDEF
4941 && header
->e_shstrndx
>= header
->e_shnum
)
4943 header
->e_shstrndx
= SHN_UNDEF
;
4944 printf (_(" <corrupt: out of range>"));
4946 putc ('\n', stdout
);
4949 if (filedata
->section_headers
!= NULL
)
4951 if (header
->e_phnum
== PN_XNUM
4952 && filedata
->section_headers
[0].sh_info
!= 0)
4953 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4954 if (header
->e_shnum
== SHN_UNDEF
)
4955 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4956 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4957 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4958 if (header
->e_shstrndx
>= header
->e_shnum
)
4959 header
->e_shstrndx
= SHN_UNDEF
;
4960 free (filedata
->section_headers
);
4961 filedata
->section_headers
= NULL
;
4967 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4968 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4971 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4973 Elf32_External_Phdr
* phdrs
;
4974 Elf32_External_Phdr
* external
;
4975 Elf_Internal_Phdr
* internal
;
4977 unsigned int size
= filedata
->file_header
.e_phentsize
;
4978 unsigned int num
= filedata
->file_header
.e_phnum
;
4980 /* PR binutils/17531: Cope with unexpected section header sizes. */
4981 if (size
== 0 || num
== 0)
4983 if (size
< sizeof * phdrs
)
4985 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4988 if (size
> sizeof * phdrs
)
4989 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4991 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4992 size
, num
, _("program headers"));
4996 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4997 i
< filedata
->file_header
.e_phnum
;
4998 i
++, internal
++, external
++)
5000 internal
->p_type
= BYTE_GET (external
->p_type
);
5001 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5002 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5003 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5004 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5005 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5006 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5007 internal
->p_align
= BYTE_GET (external
->p_align
);
5014 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5015 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5018 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5020 Elf64_External_Phdr
* phdrs
;
5021 Elf64_External_Phdr
* external
;
5022 Elf_Internal_Phdr
* internal
;
5024 unsigned int size
= filedata
->file_header
.e_phentsize
;
5025 unsigned int num
= filedata
->file_header
.e_phnum
;
5027 /* PR binutils/17531: Cope with unexpected section header sizes. */
5028 if (size
== 0 || num
== 0)
5030 if (size
< sizeof * phdrs
)
5032 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5035 if (size
> sizeof * phdrs
)
5036 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5038 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5039 size
, num
, _("program headers"));
5043 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5044 i
< filedata
->file_header
.e_phnum
;
5045 i
++, internal
++, external
++)
5047 internal
->p_type
= BYTE_GET (external
->p_type
);
5048 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5049 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5050 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5051 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5052 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5053 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5054 internal
->p_align
= BYTE_GET (external
->p_align
);
5061 /* Returns TRUE if the program headers were read into `program_headers'. */
5064 get_program_headers (Filedata
* filedata
)
5066 Elf_Internal_Phdr
* phdrs
;
5068 /* Check cache of prior read. */
5069 if (filedata
->program_headers
!= NULL
)
5072 /* Be kind to memory checkers by looking for
5073 e_phnum values which we know must be invalid. */
5074 if (filedata
->file_header
.e_phnum
5075 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5076 >= filedata
->file_size
)
5078 error (_("Too many program headers - %#x - the file is not that big\n"),
5079 filedata
->file_header
.e_phnum
);
5083 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5084 sizeof (Elf_Internal_Phdr
));
5087 error (_("Out of memory reading %u program headers\n"),
5088 filedata
->file_header
.e_phnum
);
5093 ? get_32bit_program_headers (filedata
, phdrs
)
5094 : get_64bit_program_headers (filedata
, phdrs
))
5096 filedata
->program_headers
= phdrs
;
5104 /* Returns TRUE if the program headers were loaded. */
5107 process_program_headers (Filedata
* filedata
)
5109 Elf_Internal_Phdr
* segment
;
5111 Elf_Internal_Phdr
* previous_load
= NULL
;
5116 if (filedata
->file_header
.e_phnum
== 0)
5118 /* PR binutils/12467. */
5119 if (filedata
->file_header
.e_phoff
!= 0)
5121 warn (_("possibly corrupt ELF header - it has a non-zero program"
5122 " header offset, but no program headers\n"));
5125 else if (do_segments
)
5126 printf (_("\nThere are no program headers in this file.\n"));
5130 if (do_segments
&& !do_header
)
5132 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5133 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5134 printf (ngettext ("There is %d program header, starting at offset %s\n",
5135 "There are %d program headers, starting at offset %s\n",
5136 filedata
->file_header
.e_phnum
),
5137 filedata
->file_header
.e_phnum
,
5138 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5141 if (! get_program_headers (filedata
))
5146 if (filedata
->file_header
.e_phnum
> 1)
5147 printf (_("\nProgram Headers:\n"));
5149 printf (_("\nProgram Headers:\n"));
5153 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5156 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5160 (_(" Type Offset VirtAddr PhysAddr\n"));
5162 (_(" FileSiz MemSiz Flags Align\n"));
5166 for (i
= 0, segment
= filedata
->program_headers
;
5167 i
< filedata
->file_header
.e_phnum
;
5172 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5176 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5177 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5178 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5179 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5180 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5182 (segment
->p_flags
& PF_R
? 'R' : ' '),
5183 (segment
->p_flags
& PF_W
? 'W' : ' '),
5184 (segment
->p_flags
& PF_X
? 'E' : ' '));
5185 printf ("%#lx", (unsigned long) segment
->p_align
);
5189 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5190 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5193 print_vma (segment
->p_offset
, FULL_HEX
);
5197 print_vma (segment
->p_vaddr
, FULL_HEX
);
5199 print_vma (segment
->p_paddr
, FULL_HEX
);
5202 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5203 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5206 print_vma (segment
->p_filesz
, FULL_HEX
);
5210 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5211 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5214 print_vma (segment
->p_memsz
, FULL_HEX
);
5218 (segment
->p_flags
& PF_R
? 'R' : ' '),
5219 (segment
->p_flags
& PF_W
? 'W' : ' '),
5220 (segment
->p_flags
& PF_X
? 'E' : ' '));
5222 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5223 printf ("%#lx", (unsigned long) segment
->p_align
);
5226 print_vma (segment
->p_align
, PREFIX_HEX
);
5231 print_vma (segment
->p_offset
, FULL_HEX
);
5233 print_vma (segment
->p_vaddr
, FULL_HEX
);
5235 print_vma (segment
->p_paddr
, FULL_HEX
);
5237 print_vma (segment
->p_filesz
, FULL_HEX
);
5239 print_vma (segment
->p_memsz
, FULL_HEX
);
5241 (segment
->p_flags
& PF_R
? 'R' : ' '),
5242 (segment
->p_flags
& PF_W
? 'W' : ' '),
5243 (segment
->p_flags
& PF_X
? 'E' : ' '));
5244 print_vma (segment
->p_align
, PREFIX_HEX
);
5247 putc ('\n', stdout
);
5250 switch (segment
->p_type
)
5253 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5254 required by the ELF standard, several programs, including the Linux
5255 kernel, make use of non-ordered segments. */
5257 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5258 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5260 if (segment
->p_memsz
< segment
->p_filesz
)
5261 error (_("the segment's file size is larger than its memory size\n"));
5262 previous_load
= segment
;
5266 /* PR 20815 - Verify that the program header is loaded into memory. */
5267 if (i
> 0 && previous_load
!= NULL
)
5268 error (_("the PHDR segment must occur before any LOAD segment\n"));
5269 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5273 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5275 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5276 if (load
->p_type
== PT_LOAD
5277 && load
->p_offset
<= segment
->p_offset
5278 && (load
->p_offset
+ load
->p_filesz
5279 >= segment
->p_offset
+ segment
->p_filesz
)
5280 && load
->p_vaddr
<= segment
->p_vaddr
5281 && (load
->p_vaddr
+ load
->p_filesz
5282 >= segment
->p_vaddr
+ segment
->p_filesz
))
5285 if (j
== filedata
->file_header
.e_phnum
)
5286 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5292 error (_("more than one dynamic segment\n"));
5294 /* By default, assume that the .dynamic section is the first
5295 section in the DYNAMIC segment. */
5296 dynamic_addr
= segment
->p_offset
;
5297 dynamic_size
= segment
->p_filesz
;
5299 /* Try to locate the .dynamic section. If there is
5300 a section header table, we can easily locate it. */
5301 if (filedata
->section_headers
!= NULL
)
5303 Elf_Internal_Shdr
* sec
;
5305 sec
= find_section (filedata
, ".dynamic");
5306 if (sec
== NULL
|| sec
->sh_size
== 0)
5308 /* A corresponding .dynamic section is expected, but on
5309 IA-64/OpenVMS it is OK for it to be missing. */
5310 if (!is_ia64_vms (filedata
))
5311 error (_("no .dynamic section in the dynamic segment\n"));
5315 if (sec
->sh_type
== SHT_NOBITS
)
5321 dynamic_addr
= sec
->sh_offset
;
5322 dynamic_size
= sec
->sh_size
;
5324 if (dynamic_addr
< segment
->p_offset
5325 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5326 warn (_("the .dynamic section is not contained"
5327 " within the dynamic segment\n"));
5328 else if (dynamic_addr
> segment
->p_offset
)
5329 warn (_("the .dynamic section is not the first section"
5330 " in the dynamic segment.\n"));
5333 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5334 segment. Check this after matching against the section headers
5335 so we don't warn on debuginfo file (which have NOBITS .dynamic
5337 if (dynamic_addr
> filedata
->file_size
5338 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5340 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5341 dynamic_addr
= dynamic_size
= 0;
5346 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5348 error (_("Unable to find program interpreter name\n"));
5352 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5354 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5355 error (_("Internal error: failed to create format string to display program interpreter\n"));
5357 program_interpreter
[0] = 0;
5358 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5359 error (_("Unable to read program interpreter name\n"));
5362 printf (_(" [Requesting program interpreter: %s]\n"),
5363 program_interpreter
);
5370 && filedata
->section_headers
!= NULL
5371 && filedata
->string_table
!= NULL
)
5373 printf (_("\n Section to Segment mapping:\n"));
5374 printf (_(" Segment Sections...\n"));
5376 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5379 Elf_Internal_Shdr
* section
;
5381 segment
= filedata
->program_headers
+ i
;
5382 section
= filedata
->section_headers
+ 1;
5384 printf (" %2.2d ", i
);
5386 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5388 if (!ELF_TBSS_SPECIAL (section
, segment
)
5389 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5390 printf ("%s ", printable_section_name (filedata
, section
));
5401 /* Find the file offset corresponding to VMA by using the program headers. */
5404 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5406 Elf_Internal_Phdr
* seg
;
5408 if (! get_program_headers (filedata
))
5410 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5414 for (seg
= filedata
->program_headers
;
5415 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5418 if (seg
->p_type
!= PT_LOAD
)
5421 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5422 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5423 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5426 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5427 (unsigned long) vma
);
5432 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5433 If PROBE is true, this is just a probe and we do not generate any error
5434 messages if the load fails. */
5437 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5439 Elf32_External_Shdr
* shdrs
;
5440 Elf_Internal_Shdr
* internal
;
5442 unsigned int size
= filedata
->file_header
.e_shentsize
;
5443 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5445 /* PR binutils/17531: Cope with unexpected section header sizes. */
5446 if (size
== 0 || num
== 0)
5448 if (size
< sizeof * shdrs
)
5451 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5454 if (!probe
&& size
> sizeof * shdrs
)
5455 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5457 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5459 probe
? NULL
: _("section headers"));
5463 free (filedata
->section_headers
);
5464 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5465 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5466 if (filedata
->section_headers
== NULL
)
5469 error (_("Out of memory reading %u section headers\n"), num
);
5474 for (i
= 0, internal
= filedata
->section_headers
;
5478 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5479 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5480 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5481 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5482 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5483 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5484 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5485 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5486 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5487 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5488 if (!probe
&& internal
->sh_link
> num
)
5489 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5490 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5491 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5498 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5501 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5503 Elf64_External_Shdr
* shdrs
;
5504 Elf_Internal_Shdr
* internal
;
5506 unsigned int size
= filedata
->file_header
.e_shentsize
;
5507 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5509 /* PR binutils/17531: Cope with unexpected section header sizes. */
5510 if (size
== 0 || num
== 0)
5513 if (size
< sizeof * shdrs
)
5516 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5520 if (! probe
&& size
> sizeof * shdrs
)
5521 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5523 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5524 filedata
->file_header
.e_shoff
,
5526 probe
? NULL
: _("section headers"));
5530 free (filedata
->section_headers
);
5531 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5532 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5533 if (filedata
->section_headers
== NULL
)
5536 error (_("Out of memory reading %u section headers\n"), num
);
5541 for (i
= 0, internal
= filedata
->section_headers
;
5545 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5546 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5547 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5548 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5549 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5550 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5551 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5552 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5553 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5554 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5555 if (!probe
&& internal
->sh_link
> num
)
5556 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5557 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5558 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5565 static Elf_Internal_Sym
*
5566 get_32bit_elf_symbols (Filedata
* filedata
,
5567 Elf_Internal_Shdr
* section
,
5568 unsigned long * num_syms_return
)
5570 unsigned long number
= 0;
5571 Elf32_External_Sym
* esyms
= NULL
;
5572 Elf_External_Sym_Shndx
* shndx
= NULL
;
5573 Elf_Internal_Sym
* isyms
= NULL
;
5574 Elf_Internal_Sym
* psym
;
5576 elf_section_list
* entry
;
5578 if (section
->sh_size
== 0)
5580 if (num_syms_return
!= NULL
)
5581 * num_syms_return
= 0;
5585 /* Run some sanity checks first. */
5586 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5588 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5589 printable_section_name (filedata
, section
),
5590 (unsigned long) section
->sh_entsize
);
5594 if (section
->sh_size
> filedata
->file_size
)
5596 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5597 printable_section_name (filedata
, section
),
5598 (unsigned long) section
->sh_size
);
5602 number
= section
->sh_size
/ section
->sh_entsize
;
5604 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5606 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5607 (unsigned long) section
->sh_size
,
5608 printable_section_name (filedata
, section
),
5609 (unsigned long) section
->sh_entsize
);
5613 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5614 section
->sh_size
, _("symbols"));
5619 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5621 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5626 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5630 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5631 entry
->hdr
->sh_offset
,
5632 1, entry
->hdr
->sh_size
,
5633 _("symbol table section indices"));
5637 /* PR17531: file: heap-buffer-overflow */
5638 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5640 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5641 printable_section_name (filedata
, entry
->hdr
),
5642 (unsigned long) entry
->hdr
->sh_size
,
5643 (unsigned long) section
->sh_size
);
5648 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5652 error (_("Out of memory reading %lu symbols\n"),
5653 (unsigned long) number
);
5657 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5659 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5660 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5661 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5662 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5663 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5665 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5666 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5667 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5668 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5669 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5676 if (num_syms_return
!= NULL
)
5677 * num_syms_return
= isyms
== NULL
? 0 : number
;
5682 static Elf_Internal_Sym
*
5683 get_64bit_elf_symbols (Filedata
* filedata
,
5684 Elf_Internal_Shdr
* section
,
5685 unsigned long * num_syms_return
)
5687 unsigned long number
= 0;
5688 Elf64_External_Sym
* esyms
= NULL
;
5689 Elf_External_Sym_Shndx
* shndx
= NULL
;
5690 Elf_Internal_Sym
* isyms
= NULL
;
5691 Elf_Internal_Sym
* psym
;
5693 elf_section_list
* entry
;
5695 if (section
->sh_size
== 0)
5697 if (num_syms_return
!= NULL
)
5698 * num_syms_return
= 0;
5702 /* Run some sanity checks first. */
5703 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5705 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5706 printable_section_name (filedata
, section
),
5707 (unsigned long) section
->sh_entsize
);
5711 if (section
->sh_size
> filedata
->file_size
)
5713 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5714 printable_section_name (filedata
, section
),
5715 (unsigned long) section
->sh_size
);
5719 number
= section
->sh_size
/ section
->sh_entsize
;
5721 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5723 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5724 (unsigned long) section
->sh_size
,
5725 printable_section_name (filedata
, section
),
5726 (unsigned long) section
->sh_entsize
);
5730 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5731 section
->sh_size
, _("symbols"));
5736 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5738 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5743 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5747 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5748 entry
->hdr
->sh_offset
,
5749 1, entry
->hdr
->sh_size
,
5750 _("symbol table section indices"));
5754 /* PR17531: file: heap-buffer-overflow */
5755 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5757 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5758 printable_section_name (filedata
, entry
->hdr
),
5759 (unsigned long) entry
->hdr
->sh_size
,
5760 (unsigned long) section
->sh_size
);
5765 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5769 error (_("Out of memory reading %lu symbols\n"),
5770 (unsigned long) number
);
5774 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5776 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5777 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5778 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5779 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5781 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5783 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5784 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5785 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5787 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5788 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5795 if (num_syms_return
!= NULL
)
5796 * num_syms_return
= isyms
== NULL
? 0 : number
;
5802 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5804 static char buff
[1024];
5806 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5808 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5809 bfd_vma os_flags
= 0;
5810 bfd_vma proc_flags
= 0;
5811 bfd_vma unknown_flags
= 0;
5819 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5820 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5821 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5822 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5823 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5824 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5825 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5826 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5827 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5828 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5829 /* IA-64 specific. */
5830 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5831 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5832 /* IA-64 OpenVMS specific. */
5833 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5834 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5835 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5836 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5837 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5838 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5840 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5841 /* SPARC specific. */
5842 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5843 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5845 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5846 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5847 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5849 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5851 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5854 if (do_section_details
)
5856 sprintf (buff
, "[%*.*lx]: ",
5857 field_size
, field_size
, (unsigned long) sh_flags
);
5858 p
+= field_size
+ 4;
5865 flag
= sh_flags
& - sh_flags
;
5868 if (do_section_details
)
5872 case SHF_WRITE
: sindex
= 0; break;
5873 case SHF_ALLOC
: sindex
= 1; break;
5874 case SHF_EXECINSTR
: sindex
= 2; break;
5875 case SHF_MERGE
: sindex
= 3; break;
5876 case SHF_STRINGS
: sindex
= 4; break;
5877 case SHF_INFO_LINK
: sindex
= 5; break;
5878 case SHF_LINK_ORDER
: sindex
= 6; break;
5879 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5880 case SHF_GROUP
: sindex
= 8; break;
5881 case SHF_TLS
: sindex
= 9; break;
5882 case SHF_EXCLUDE
: sindex
= 18; break;
5883 case SHF_COMPRESSED
: sindex
= 20; break;
5884 case SHF_GNU_MBIND
: sindex
= 24; break;
5888 switch (filedata
->file_header
.e_machine
)
5891 if (flag
== SHF_IA_64_SHORT
)
5893 else if (flag
== SHF_IA_64_NORECOV
)
5896 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5899 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5900 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5901 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5902 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5903 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5904 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5915 case EM_OLD_SPARCV9
:
5916 case EM_SPARC32PLUS
:
5919 if (flag
== SHF_ORDERED
)
5926 case SHF_ENTRYSECT
: sindex
= 21; break;
5927 case SHF_ARM_PURECODE
: sindex
= 22; break;
5928 case SHF_COMDEF
: sindex
= 23; break;
5933 if (flag
== SHF_PPC_VLE
)
5944 if (p
!= buff
+ field_size
+ 4)
5946 if (size
< (10 + 2))
5948 warn (_("Internal error: not enough buffer room for section flag info"));
5949 return _("<unknown>");
5956 size
-= flags
[sindex
].len
;
5957 p
= stpcpy (p
, flags
[sindex
].str
);
5959 else if (flag
& SHF_MASKOS
)
5961 else if (flag
& SHF_MASKPROC
)
5964 unknown_flags
|= flag
;
5970 case SHF_WRITE
: *p
= 'W'; break;
5971 case SHF_ALLOC
: *p
= 'A'; break;
5972 case SHF_EXECINSTR
: *p
= 'X'; break;
5973 case SHF_MERGE
: *p
= 'M'; break;
5974 case SHF_STRINGS
: *p
= 'S'; break;
5975 case SHF_INFO_LINK
: *p
= 'I'; break;
5976 case SHF_LINK_ORDER
: *p
= 'L'; break;
5977 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5978 case SHF_GROUP
: *p
= 'G'; break;
5979 case SHF_TLS
: *p
= 'T'; break;
5980 case SHF_EXCLUDE
: *p
= 'E'; break;
5981 case SHF_COMPRESSED
: *p
= 'C'; break;
5982 case SHF_GNU_MBIND
: *p
= 'D'; break;
5985 if ((filedata
->file_header
.e_machine
== EM_X86_64
5986 || filedata
->file_header
.e_machine
== EM_L1OM
5987 || filedata
->file_header
.e_machine
== EM_K1OM
)
5988 && flag
== SHF_X86_64_LARGE
)
5990 else if (filedata
->file_header
.e_machine
== EM_ARM
5991 && flag
== SHF_ARM_PURECODE
)
5993 else if (filedata
->file_header
.e_machine
== EM_PPC
5994 && flag
== SHF_PPC_VLE
)
5996 else if (flag
& SHF_MASKOS
)
5999 sh_flags
&= ~ SHF_MASKOS
;
6001 else if (flag
& SHF_MASKPROC
)
6004 sh_flags
&= ~ SHF_MASKPROC
;
6014 if (do_section_details
)
6018 size
-= 5 + field_size
;
6019 if (p
!= buff
+ field_size
+ 4)
6023 warn (_("Internal error: not enough buffer room for section flag info"));
6024 return _("<unknown>");
6030 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6031 (unsigned long) os_flags
);
6032 p
+= 5 + field_size
;
6036 size
-= 7 + field_size
;
6037 if (p
!= buff
+ field_size
+ 4)
6041 warn (_("Internal error: not enough buffer room for section flag info"));
6042 return _("<unknown>");
6048 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6049 (unsigned long) proc_flags
);
6050 p
+= 7 + field_size
;
6054 size
-= 10 + field_size
;
6055 if (p
!= buff
+ field_size
+ 4)
6059 warn (_("Internal error: not enough buffer room for section flag info"));
6060 return _("<unknown>");
6066 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6067 (unsigned long) unknown_flags
);
6068 p
+= 10 + field_size
;
6077 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6081 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6083 if (size
< sizeof (* echdr
))
6085 error (_("Compressed section is too small even for a compression header\n"));
6089 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6090 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6091 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6092 return sizeof (*echdr
);
6096 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6098 if (size
< sizeof (* echdr
))
6100 error (_("Compressed section is too small even for a compression header\n"));
6104 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6105 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6106 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6107 return sizeof (*echdr
);
6112 process_section_headers (Filedata
* filedata
)
6114 Elf_Internal_Shdr
* section
;
6117 filedata
->section_headers
= NULL
;
6119 if (filedata
->file_header
.e_shnum
== 0)
6121 /* PR binutils/12467. */
6122 if (filedata
->file_header
.e_shoff
!= 0)
6124 warn (_("possibly corrupt ELF file header - it has a non-zero"
6125 " section header offset, but no section headers\n"));
6128 else if (do_sections
)
6129 printf (_("\nThere are no sections in this file.\n"));
6134 if (do_sections
&& !do_header
)
6135 printf (ngettext ("There is %d section header, "
6136 "starting at offset 0x%lx:\n",
6137 "There are %d section headers, "
6138 "starting at offset 0x%lx:\n",
6139 filedata
->file_header
.e_shnum
),
6140 filedata
->file_header
.e_shnum
,
6141 (unsigned long) filedata
->file_header
.e_shoff
);
6145 if (! get_32bit_section_headers (filedata
, FALSE
))
6150 if (! get_64bit_section_headers (filedata
, FALSE
))
6154 /* Read in the string table, so that we have names to display. */
6155 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6156 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6158 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6160 if (section
->sh_size
!= 0)
6162 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6163 1, section
->sh_size
,
6166 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6170 /* Scan the sections for the dynamic symbol table
6171 and dynamic string table and debug sections. */
6172 dynamic_symbols
= NULL
;
6173 dynamic_strings
= NULL
;
6174 dynamic_syminfo
= NULL
;
6175 symtab_shndx_list
= NULL
;
6177 eh_addr_size
= is_32bit_elf
? 4 : 8;
6178 switch (filedata
->file_header
.e_machine
)
6181 case EM_MIPS_RS3_LE
:
6182 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6183 FDE addresses. However, the ABI also has a semi-official ILP32
6184 variant for which the normal FDE address size rules apply.
6186 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6187 section, where XX is the size of longs in bits. Unfortunately,
6188 earlier compilers provided no way of distinguishing ILP32 objects
6189 from LP64 objects, so if there's any doubt, we should assume that
6190 the official LP64 form is being used. */
6191 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6192 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6198 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6200 case E_H8_MACH_H8300
:
6201 case E_H8_MACH_H8300HN
:
6202 case E_H8_MACH_H8300SN
:
6203 case E_H8_MACH_H8300SXN
:
6206 case E_H8_MACH_H8300H
:
6207 case E_H8_MACH_H8300S
:
6208 case E_H8_MACH_H8300SX
:
6216 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6218 case EF_M32C_CPU_M16C
:
6225 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6228 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6229 if (section->sh_entsize != expected_entsize) \
6232 sprintf_vma (buf, section->sh_entsize); \
6233 /* Note: coded this way so that there is a single string for \
6235 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6236 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6237 (unsigned) expected_entsize); \
6238 section->sh_entsize = expected_entsize; \
6243 #define CHECK_ENTSIZE(section, i, type) \
6244 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6245 sizeof (Elf64_External_##type))
6247 for (i
= 0, section
= filedata
->section_headers
;
6248 i
< filedata
->file_header
.e_shnum
;
6251 char * name
= SECTION_NAME (section
);
6253 if (section
->sh_type
== SHT_DYNSYM
)
6255 if (dynamic_symbols
!= NULL
)
6257 error (_("File contains multiple dynamic symbol tables\n"));
6261 CHECK_ENTSIZE (section
, i
, Sym
);
6262 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6264 else if (section
->sh_type
== SHT_STRTAB
6265 && streq (name
, ".dynstr"))
6267 if (dynamic_strings
!= NULL
)
6269 error (_("File contains multiple dynamic string tables\n"));
6273 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6274 1, section
->sh_size
,
6275 _("dynamic strings"));
6276 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6278 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6280 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6282 entry
->hdr
= section
;
6283 entry
->next
= symtab_shndx_list
;
6284 symtab_shndx_list
= entry
;
6286 else if (section
->sh_type
== SHT_SYMTAB
)
6287 CHECK_ENTSIZE (section
, i
, Sym
);
6288 else if (section
->sh_type
== SHT_GROUP
)
6289 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6290 else if (section
->sh_type
== SHT_REL
)
6291 CHECK_ENTSIZE (section
, i
, Rel
);
6292 else if (section
->sh_type
== SHT_RELA
)
6293 CHECK_ENTSIZE (section
, i
, Rela
);
6294 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6295 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6296 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6297 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6298 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6299 && (const_strneq (name
, ".debug_")
6300 || const_strneq (name
, ".zdebug_")))
6303 name
+= sizeof (".zdebug_") - 1;
6305 name
+= sizeof (".debug_") - 1;
6308 || (do_debug_info
&& const_strneq (name
, "info"))
6309 || (do_debug_info
&& const_strneq (name
, "types"))
6310 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6311 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6312 || (do_debug_lines
&& const_strneq (name
, "line."))
6313 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6314 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6315 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6316 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6317 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6318 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6319 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6320 || (do_debug_frames
&& const_strneq (name
, "frame"))
6321 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6322 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6323 || (do_debug_str
&& const_strneq (name
, "str"))
6324 || (do_debug_loc
&& const_strneq (name
, "loc"))
6325 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6326 || (do_debug_addr
&& const_strneq (name
, "addr"))
6327 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6328 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6330 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6332 /* Linkonce section to be combined with .debug_info at link time. */
6333 else if ((do_debugging
|| do_debug_info
)
6334 && const_strneq (name
, ".gnu.linkonce.wi."))
6335 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6336 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6337 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6338 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6339 || streq (name
, ".debug_names")))
6340 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6341 /* Trace sections for Itanium VMS. */
6342 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6343 || do_trace_aranges
)
6344 && const_strneq (name
, ".trace_"))
6346 name
+= sizeof (".trace_") - 1;
6349 || (do_trace_info
&& streq (name
, "info"))
6350 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6351 || (do_trace_aranges
&& streq (name
, "aranges"))
6353 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6355 else if ((do_debugging
|| do_debug_links
)
6356 && (const_strneq (name
, ".gnu_debuglink")
6357 || const_strneq (name
, ".gnu_debugaltlink")))
6358 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6364 if (filedata
->file_header
.e_shnum
> 1)
6365 printf (_("\nSection Headers:\n"));
6367 printf (_("\nSection Header:\n"));
6371 if (do_section_details
)
6373 printf (_(" [Nr] Name\n"));
6374 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6378 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6382 if (do_section_details
)
6384 printf (_(" [Nr] Name\n"));
6385 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6389 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6393 if (do_section_details
)
6395 printf (_(" [Nr] Name\n"));
6396 printf (_(" Type Address Offset Link\n"));
6397 printf (_(" Size EntSize Info Align\n"));
6401 printf (_(" [Nr] Name Type Address Offset\n"));
6402 printf (_(" Size EntSize Flags Link Info Align\n"));
6406 if (do_section_details
)
6407 printf (_(" Flags\n"));
6409 for (i
= 0, section
= filedata
->section_headers
;
6410 i
< filedata
->file_header
.e_shnum
;
6413 /* Run some sanity checks on the section header. */
6415 /* Check the sh_link field. */
6416 switch (section
->sh_type
)
6420 if (section
->sh_link
== 0
6421 && (filedata
->file_header
.e_type
== ET_EXEC
6422 || filedata
->file_header
.e_type
== ET_DYN
))
6423 /* A dynamic relocation section where all entries use a
6424 zero symbol index need not specify a symtab section. */
6427 case SHT_SYMTAB_SHNDX
:
6431 case SHT_GNU_versym
:
6432 if (section
->sh_link
== 0
6433 || section
->sh_link
>= filedata
->file_header
.e_shnum
6434 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6435 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6436 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6437 i
, section
->sh_link
);
6443 case SHT_GNU_verneed
:
6444 case SHT_GNU_verdef
:
6445 case SHT_GNU_LIBLIST
:
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_STRTAB
)
6449 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6450 i
, section
->sh_link
);
6453 case SHT_INIT_ARRAY
:
6454 case SHT_FINI_ARRAY
:
6455 case SHT_PREINIT_ARRAY
:
6456 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6457 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6458 i
, section
->sh_link
);
6462 /* FIXME: Add support for target specific section types. */
6463 #if 0 /* Currently we do not check other section types as there are too
6464 many special cases. Stab sections for example have a type
6465 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6467 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6468 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6469 i
, section
->sh_link
);
6474 /* Check the sh_info field. */
6475 switch (section
->sh_type
)
6479 if (section
->sh_info
== 0
6480 && (filedata
->file_header
.e_type
== ET_EXEC
6481 || filedata
->file_header
.e_type
== ET_DYN
))
6482 /* Dynamic relocations apply to segments, so they do not
6483 need to specify the section they relocate. */
6485 if (section
->sh_info
== 0
6486 || section
->sh_info
>= filedata
->file_header
.e_shnum
6487 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6488 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6489 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6490 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6491 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6492 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6493 /* FIXME: Are other section types valid ? */
6494 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6495 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6496 i
, section
->sh_info
);
6501 case SHT_SYMTAB_SHNDX
:
6502 case SHT_INIT_ARRAY
:
6503 case SHT_FINI_ARRAY
:
6504 case SHT_PREINIT_ARRAY
:
6505 if (section
->sh_info
!= 0)
6506 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6507 i
, section
->sh_info
);
6513 /* A symbol index - we assume that it is valid. */
6517 /* FIXME: Add support for target specific section types. */
6518 if (section
->sh_type
== SHT_NOBITS
)
6519 /* NOBITS section headers with non-zero sh_info fields can be
6520 created when a binary is stripped of everything but its debug
6521 information. The stripped sections have their headers
6522 preserved but their types set to SHT_NOBITS. So do not check
6523 this type of section. */
6525 else if (section
->sh_flags
& SHF_INFO_LINK
)
6527 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6528 warn (_("[%2u]: Expected link to another section in info field"), i
);
6530 else if (section
->sh_type
< SHT_LOOS
6531 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6532 && section
->sh_info
!= 0)
6533 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6534 i
, section
->sh_info
);
6538 /* Check the sh_size field. */
6539 if (section
->sh_size
> filedata
->file_size
6540 && section
->sh_type
!= SHT_NOBITS
6541 && section
->sh_type
!= SHT_NULL
6542 && section
->sh_type
< SHT_LOOS
)
6543 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6545 printf (" [%2u] ", i
);
6546 if (do_section_details
)
6547 printf ("%s\n ", printable_section_name (filedata
, section
));
6549 print_symbol (-17, SECTION_NAME (section
));
6551 printf (do_wide
? " %-15s " : " %-15.15s ",
6552 get_section_type_name (filedata
, section
->sh_type
));
6556 const char * link_too_big
= NULL
;
6558 print_vma (section
->sh_addr
, LONG_HEX
);
6560 printf ( " %6.6lx %6.6lx %2.2lx",
6561 (unsigned long) section
->sh_offset
,
6562 (unsigned long) section
->sh_size
,
6563 (unsigned long) section
->sh_entsize
);
6565 if (do_section_details
)
6566 fputs (" ", stdout
);
6568 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6570 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6573 /* The sh_link value is out of range. Normally this indicates
6574 an error but it can have special values in Solaris binaries. */
6575 switch (filedata
->file_header
.e_machine
)
6582 case EM_OLD_SPARCV9
:
6583 case EM_SPARC32PLUS
:
6586 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6587 link_too_big
= "BEFORE";
6588 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6589 link_too_big
= "AFTER";
6596 if (do_section_details
)
6598 if (link_too_big
!= NULL
&& * link_too_big
)
6599 printf ("<%s> ", link_too_big
);
6601 printf ("%2u ", section
->sh_link
);
6602 printf ("%3u %2lu\n", section
->sh_info
,
6603 (unsigned long) section
->sh_addralign
);
6606 printf ("%2u %3u %2lu\n",
6609 (unsigned long) section
->sh_addralign
);
6611 if (link_too_big
&& ! * link_too_big
)
6612 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6613 i
, section
->sh_link
);
6617 print_vma (section
->sh_addr
, LONG_HEX
);
6619 if ((long) section
->sh_offset
== section
->sh_offset
)
6620 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6624 print_vma (section
->sh_offset
, LONG_HEX
);
6627 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6628 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6632 print_vma (section
->sh_size
, LONG_HEX
);
6635 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6636 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6640 print_vma (section
->sh_entsize
, LONG_HEX
);
6643 if (do_section_details
)
6644 fputs (" ", stdout
);
6646 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6648 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6650 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6651 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6654 print_vma (section
->sh_addralign
, DEC
);
6658 else if (do_section_details
)
6661 print_vma (section
->sh_addr
, LONG_HEX
);
6662 if ((long) section
->sh_offset
== section
->sh_offset
)
6663 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6667 print_vma (section
->sh_offset
, LONG_HEX
);
6669 printf (" %u\n ", section
->sh_link
);
6670 print_vma (section
->sh_size
, LONG_HEX
);
6672 print_vma (section
->sh_entsize
, LONG_HEX
);
6674 printf (" %-16u %lu\n",
6676 (unsigned long) section
->sh_addralign
);
6681 print_vma (section
->sh_addr
, LONG_HEX
);
6682 if ((long) section
->sh_offset
== section
->sh_offset
)
6683 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6687 print_vma (section
->sh_offset
, LONG_HEX
);
6690 print_vma (section
->sh_size
, LONG_HEX
);
6692 print_vma (section
->sh_entsize
, LONG_HEX
);
6694 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6696 printf (" %2u %3u %lu\n",
6699 (unsigned long) section
->sh_addralign
);
6702 if (do_section_details
)
6704 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6705 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6707 /* Minimum section size is 12 bytes for 32-bit compression
6708 header + 12 bytes for compressed data header. */
6709 unsigned char buf
[24];
6711 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6712 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6713 sizeof (buf
), _("compression header")))
6715 Elf_Internal_Chdr chdr
;
6717 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6719 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6722 printf (_(" [<unknown>: 0x%x], "),
6724 print_vma (chdr
.ch_size
, LONG_HEX
);
6725 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6731 if (!do_section_details
)
6733 /* The ordering of the letters shown here matches the ordering of the
6734 corresponding SHF_xxx values, and hence the order in which these
6735 letters will be displayed to the user. */
6736 printf (_("Key to Flags:\n\
6737 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6738 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6739 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6740 if (filedata
->file_header
.e_machine
== EM_X86_64
6741 || filedata
->file_header
.e_machine
== EM_L1OM
6742 || filedata
->file_header
.e_machine
== EM_K1OM
)
6743 printf (_("l (large), "));
6744 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6745 printf (_("y (purecode), "));
6746 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6747 printf (_("v (VLE), "));
6748 printf ("p (processor specific)\n");
6755 get_group_flags (unsigned int flags
)
6757 static char buff
[128];
6761 else if (flags
== GRP_COMDAT
)
6764 snprintf (buff
, 14, _("[0x%x: "), flags
);
6766 flags
&= ~ GRP_COMDAT
;
6767 if (flags
& GRP_MASKOS
)
6769 strcat (buff
, "<OS specific>");
6770 flags
&= ~ GRP_MASKOS
;
6773 if (flags
& GRP_MASKPROC
)
6775 strcat (buff
, "<PROC specific>");
6776 flags
&= ~ GRP_MASKPROC
;
6780 strcat (buff
, "<unknown>");
6787 process_section_groups (Filedata
* filedata
)
6789 Elf_Internal_Shdr
* section
;
6791 struct group
* group
;
6792 Elf_Internal_Shdr
* symtab_sec
;
6793 Elf_Internal_Shdr
* strtab_sec
;
6794 Elf_Internal_Sym
* symtab
;
6795 unsigned long num_syms
;
6799 /* Don't process section groups unless needed. */
6800 if (!do_unwind
&& !do_section_groups
)
6803 if (filedata
->file_header
.e_shnum
== 0)
6805 if (do_section_groups
)
6806 printf (_("\nThere are no sections to group in this file.\n"));
6811 if (filedata
->section_headers
== NULL
)
6813 error (_("Section headers are not available!\n"));
6814 /* PR 13622: This can happen with a corrupt ELF header. */
6818 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6819 sizeof (struct group
*));
6821 if (section_headers_groups
== NULL
)
6823 error (_("Out of memory reading %u section group headers\n"),
6824 filedata
->file_header
.e_shnum
);
6828 /* Scan the sections for the group section. */
6830 for (i
= 0, section
= filedata
->section_headers
;
6831 i
< filedata
->file_header
.e_shnum
;
6833 if (section
->sh_type
== SHT_GROUP
)
6836 if (group_count
== 0)
6838 if (do_section_groups
)
6839 printf (_("\nThere are no section groups in this file.\n"));
6844 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6846 if (section_groups
== NULL
)
6848 error (_("Out of memory reading %lu groups\n"),
6849 (unsigned long) group_count
);
6859 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6860 i
< filedata
->file_header
.e_shnum
;
6863 if (section
->sh_type
== SHT_GROUP
)
6865 const char * name
= printable_section_name (filedata
, section
);
6866 const char * group_name
;
6867 unsigned char * start
;
6868 unsigned char * indices
;
6869 unsigned int entry
, j
, size
;
6870 Elf_Internal_Shdr
* sec
;
6871 Elf_Internal_Sym
* sym
;
6873 /* Get the symbol table. */
6874 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6875 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6878 error (_("Bad sh_link in group section `%s'\n"), name
);
6882 if (symtab_sec
!= sec
)
6887 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6892 error (_("Corrupt header in group section `%s'\n"), name
);
6896 if (section
->sh_info
>= num_syms
)
6898 error (_("Bad sh_info in group section `%s'\n"), name
);
6902 sym
= symtab
+ section
->sh_info
;
6904 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6906 if (sym
->st_shndx
== 0
6907 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6909 error (_("Bad sh_info in group section `%s'\n"), name
);
6913 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6922 /* Get the string table. */
6923 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6932 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6938 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6939 1, strtab_sec
->sh_size
,
6941 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6943 group_name
= sym
->st_name
< strtab_size
6944 ? strtab
+ sym
->st_name
: _("<corrupt>");
6947 /* PR 17531: file: loop. */
6948 if (section
->sh_entsize
> section
->sh_size
)
6950 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6951 printable_section_name (filedata
, section
),
6952 (unsigned long) section
->sh_entsize
,
6953 (unsigned long) section
->sh_size
);
6957 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6958 1, section
->sh_size
,
6964 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6965 entry
= byte_get (indices
, 4);
6968 if (do_section_groups
)
6970 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6971 get_group_flags (entry
), i
, name
, group_name
, size
);
6973 printf (_(" [Index] Name\n"));
6976 group
->group_index
= i
;
6978 for (j
= 0; j
< size
; j
++)
6980 struct group_list
* g
;
6982 entry
= byte_get (indices
, 4);
6985 if (entry
>= filedata
->file_header
.e_shnum
)
6987 static unsigned num_group_errors
= 0;
6989 if (num_group_errors
++ < 10)
6991 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6992 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6993 if (num_group_errors
== 10)
6994 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6999 if (section_headers_groups
[entry
] != NULL
)
7003 static unsigned num_errs
= 0;
7005 if (num_errs
++ < 10)
7007 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7009 section_headers_groups
[entry
]->group_index
);
7011 warn (_("Further error messages about already contained group sections suppressed\n"));
7017 /* Intel C/C++ compiler may put section 0 in a
7018 section group. We just warn it the first time
7019 and ignore it afterwards. */
7020 static bfd_boolean warned
= FALSE
;
7023 error (_("section 0 in group section [%5u]\n"),
7024 section_headers_groups
[entry
]->group_index
);
7030 section_headers_groups
[entry
] = group
;
7032 if (do_section_groups
)
7034 sec
= filedata
->section_headers
+ entry
;
7035 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7038 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7039 g
->section_index
= entry
;
7040 g
->next
= group
->root
;
7058 /* Data used to display dynamic fixups. */
7060 struct ia64_vms_dynfixup
7062 bfd_vma needed_ident
; /* Library ident number. */
7063 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7064 bfd_vma fixup_needed
; /* Index of the library. */
7065 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7066 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7069 /* Data used to display dynamic relocations. */
7071 struct ia64_vms_dynimgrela
7073 bfd_vma img_rela_cnt
; /* Number of relocations. */
7074 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7077 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7081 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7082 struct ia64_vms_dynfixup
* fixup
,
7083 const char * strtab
,
7084 unsigned int strtab_sz
)
7086 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7088 const char * lib_name
;
7090 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7091 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
7092 _("dynamic section image fixups"));
7096 if (fixup
->needed
< strtab_sz
)
7097 lib_name
= strtab
+ fixup
->needed
;
7100 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7101 (unsigned long) fixup
->needed
);
7104 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7105 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7107 (_("Seg Offset Type SymVec DataType\n"));
7109 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7114 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7115 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7116 type
= BYTE_GET (imfs
[i
].type
);
7117 rtype
= elf_ia64_reloc_type (type
);
7119 printf (" 0x%08x ", type
);
7121 printf (" %-32s ", rtype
);
7122 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7123 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7130 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7133 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7135 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7138 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7139 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7140 _("dynamic section image relocations"));
7144 printf (_("\nImage relocs\n"));
7146 (_("Seg Offset Type Addend Seg Sym Off\n"));
7148 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7153 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7154 printf ("%08" BFD_VMA_FMT
"x ",
7155 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7156 type
= BYTE_GET (imrs
[i
].type
);
7157 rtype
= elf_ia64_reloc_type (type
);
7159 printf ("0x%08x ", type
);
7161 printf ("%-31s ", rtype
);
7162 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7163 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7164 printf ("%08" BFD_VMA_FMT
"x\n",
7165 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7172 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7175 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7177 struct ia64_vms_dynfixup fixup
;
7178 struct ia64_vms_dynimgrela imgrela
;
7179 Elf_Internal_Dyn
*entry
;
7180 bfd_vma strtab_off
= 0;
7181 bfd_vma strtab_sz
= 0;
7182 char *strtab
= NULL
;
7183 bfd_boolean res
= TRUE
;
7185 memset (&fixup
, 0, sizeof (fixup
));
7186 memset (&imgrela
, 0, sizeof (imgrela
));
7188 /* Note: the order of the entries is specified by the OpenVMS specs. */
7189 for (entry
= dynamic_section
;
7190 entry
< dynamic_section
+ dynamic_nent
;
7193 switch (entry
->d_tag
)
7195 case DT_IA_64_VMS_STRTAB_OFFSET
:
7196 strtab_off
= entry
->d_un
.d_val
;
7199 strtab_sz
= entry
->d_un
.d_val
;
7201 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7202 1, strtab_sz
, _("dynamic string section"));
7205 case DT_IA_64_VMS_NEEDED_IDENT
:
7206 fixup
.needed_ident
= entry
->d_un
.d_val
;
7209 fixup
.needed
= entry
->d_un
.d_val
;
7211 case DT_IA_64_VMS_FIXUP_NEEDED
:
7212 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7214 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7215 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7217 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7218 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7219 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7222 case DT_IA_64_VMS_IMG_RELA_CNT
:
7223 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7225 case DT_IA_64_VMS_IMG_RELA_OFF
:
7226 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7227 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7249 dynamic_relocations
[] =
7251 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7252 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7253 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7256 /* Process the reloc section. */
7259 process_relocs (Filedata
* filedata
)
7261 unsigned long rel_size
;
7262 unsigned long rel_offset
;
7267 if (do_using_dynamic
)
7271 bfd_boolean has_dynamic_reloc
;
7274 has_dynamic_reloc
= FALSE
;
7276 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7278 is_rela
= dynamic_relocations
[i
].rela
;
7279 name
= dynamic_relocations
[i
].name
;
7280 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7281 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7284 has_dynamic_reloc
= TRUE
;
7286 if (is_rela
== UNKNOWN
)
7288 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7289 switch (dynamic_info
[DT_PLTREL
])
7303 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7304 name
, rel_offset
, rel_size
);
7306 dump_relocations (filedata
,
7307 offset_from_vma (filedata
, rel_offset
, rel_size
),
7309 dynamic_symbols
, num_dynamic_syms
,
7310 dynamic_strings
, dynamic_strings_length
,
7311 is_rela
, TRUE
/* is_dynamic */);
7315 if (is_ia64_vms (filedata
))
7316 if (process_ia64_vms_dynamic_relocs (filedata
))
7317 has_dynamic_reloc
= TRUE
;
7319 if (! has_dynamic_reloc
)
7320 printf (_("\nThere are no dynamic relocations in this file.\n"));
7324 Elf_Internal_Shdr
* section
;
7326 bfd_boolean found
= FALSE
;
7328 for (i
= 0, section
= filedata
->section_headers
;
7329 i
< filedata
->file_header
.e_shnum
;
7332 if ( section
->sh_type
!= SHT_RELA
7333 && section
->sh_type
!= SHT_REL
)
7336 rel_offset
= section
->sh_offset
;
7337 rel_size
= section
->sh_size
;
7341 Elf_Internal_Shdr
* strsec
;
7343 unsigned long num_rela
;
7345 printf (_("\nRelocation section "));
7347 if (filedata
->string_table
== NULL
)
7348 printf ("%d", section
->sh_name
);
7350 printf ("'%s'", printable_section_name (filedata
, section
));
7352 num_rela
= rel_size
/ section
->sh_entsize
;
7353 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7354 " at offset 0x%lx contains %lu entries:\n",
7356 rel_offset
, num_rela
);
7358 is_rela
= section
->sh_type
== SHT_RELA
;
7360 if (section
->sh_link
!= 0
7361 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7363 Elf_Internal_Shdr
* symsec
;
7364 Elf_Internal_Sym
* symtab
;
7365 unsigned long nsyms
;
7366 unsigned long strtablen
= 0;
7367 char * strtab
= NULL
;
7369 symsec
= filedata
->section_headers
+ section
->sh_link
;
7370 if (symsec
->sh_type
!= SHT_SYMTAB
7371 && symsec
->sh_type
!= SHT_DYNSYM
)
7374 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7379 if (symsec
->sh_link
!= 0
7380 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7382 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7384 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7387 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7390 dump_relocations (filedata
, rel_offset
, rel_size
,
7391 symtab
, nsyms
, strtab
, strtablen
,
7393 symsec
->sh_type
== SHT_DYNSYM
);
7399 dump_relocations (filedata
, rel_offset
, rel_size
,
7400 NULL
, 0, NULL
, 0, is_rela
,
7401 FALSE
/* is_dynamic */);
7409 /* Users sometimes forget the -D option, so try to be helpful. */
7410 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7412 if (dynamic_info
[dynamic_relocations
[i
].size
])
7414 printf (_("\nThere are no static relocations in this file."));
7415 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7420 if (i
== ARRAY_SIZE (dynamic_relocations
))
7421 printf (_("\nThere are no relocations in this file.\n"));
7428 /* An absolute address consists of a section and an offset. If the
7429 section is NULL, the offset itself is the address, otherwise, the
7430 address equals to LOAD_ADDRESS(section) + offset. */
7434 unsigned short section
;
7438 /* Find the nearest symbol at or below ADDR. Returns the symbol
7439 name, if found, and the offset from the symbol to ADDR. */
7442 find_symbol_for_address (Filedata
* filedata
,
7443 Elf_Internal_Sym
* symtab
,
7444 unsigned long nsyms
,
7445 const char * strtab
,
7446 unsigned long strtab_size
,
7447 struct absaddr addr
,
7448 const char ** symname
,
7451 bfd_vma dist
= 0x100000;
7452 Elf_Internal_Sym
* sym
;
7453 Elf_Internal_Sym
* beg
;
7454 Elf_Internal_Sym
* end
;
7455 Elf_Internal_Sym
* best
= NULL
;
7457 REMOVE_ARCH_BITS (addr
.offset
);
7459 end
= symtab
+ nsyms
;
7465 sym
= beg
+ (end
- beg
) / 2;
7467 value
= sym
->st_value
;
7468 REMOVE_ARCH_BITS (value
);
7470 if (sym
->st_name
!= 0
7471 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7472 && addr
.offset
>= value
7473 && addr
.offset
- value
< dist
)
7476 dist
= addr
.offset
- value
;
7481 if (addr
.offset
< value
)
7489 *symname
= (best
->st_name
>= strtab_size
7490 ? _("<corrupt>") : strtab
+ best
->st_name
);
7496 *offset
= addr
.offset
;
7499 static /* signed */ int
7500 symcmp (const void *p
, const void *q
)
7502 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7503 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7505 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7508 /* Process the unwind section. */
7510 #include "unwind-ia64.h"
7512 struct ia64_unw_table_entry
7514 struct absaddr start
;
7516 struct absaddr info
;
7519 struct ia64_unw_aux_info
7521 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7522 unsigned long table_len
; /* Length of unwind table. */
7523 unsigned char * info
; /* Unwind info. */
7524 unsigned long info_size
; /* Size of unwind info. */
7525 bfd_vma info_addr
; /* Starting address of unwind info. */
7526 bfd_vma seg_base
; /* Starting address of segment. */
7527 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7528 unsigned long nsyms
; /* Number of symbols. */
7529 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7530 unsigned long nfuns
; /* Number of entries in funtab. */
7531 char * strtab
; /* The string table. */
7532 unsigned long strtab_size
; /* Size of string table. */
7536 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7538 struct ia64_unw_table_entry
* tp
;
7539 unsigned long j
, nfuns
;
7541 bfd_boolean res
= TRUE
;
7543 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7544 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7545 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7546 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7548 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7550 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7554 const unsigned char * dp
;
7555 const unsigned char * head
;
7556 const unsigned char * end
;
7557 const char * procname
;
7559 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7560 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7562 fputs ("\n<", stdout
);
7566 fputs (procname
, stdout
);
7569 printf ("+%lx", (unsigned long) offset
);
7572 fputs (">: [", stdout
);
7573 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7574 fputc ('-', stdout
);
7575 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7576 printf ("], info at +0x%lx\n",
7577 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7579 /* PR 17531: file: 86232b32. */
7580 if (aux
->info
== NULL
)
7583 offset
= tp
->info
.offset
;
7584 if (tp
->info
.section
)
7586 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7588 warn (_("Invalid section %u in table entry %ld\n"),
7589 tp
->info
.section
, (long) (tp
- aux
->table
));
7593 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7595 offset
-= aux
->info_addr
;
7596 /* PR 17531: file: 0997b4d1. */
7597 if (offset
>= aux
->info_size
7598 || aux
->info_size
- offset
< 8)
7600 warn (_("Invalid offset %lx in table entry %ld\n"),
7601 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7606 head
= aux
->info
+ offset
;
7607 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7609 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7610 (unsigned) UNW_VER (stamp
),
7611 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7612 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7613 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7614 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7616 if (UNW_VER (stamp
) != 1)
7618 printf (_("\tUnknown version.\n"));
7623 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7624 /* PR 17531: file: 16ceda89. */
7625 if (end
> aux
->info
+ aux
->info_size
)
7626 end
= aux
->info
+ aux
->info_size
;
7627 for (dp
= head
+ 8; dp
< end
;)
7628 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7637 slurp_ia64_unwind_table (Filedata
* filedata
,
7638 struct ia64_unw_aux_info
* aux
,
7639 Elf_Internal_Shdr
* sec
)
7641 unsigned long size
, nrelas
, i
;
7642 Elf_Internal_Phdr
* seg
;
7643 struct ia64_unw_table_entry
* tep
;
7644 Elf_Internal_Shdr
* relsec
;
7645 Elf_Internal_Rela
* rela
;
7646 Elf_Internal_Rela
* rp
;
7647 unsigned char * table
;
7649 Elf_Internal_Sym
* sym
;
7650 const char * relname
;
7654 /* First, find the starting address of the segment that includes
7657 if (filedata
->file_header
.e_phnum
)
7659 if (! get_program_headers (filedata
))
7662 for (seg
= filedata
->program_headers
;
7663 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7666 if (seg
->p_type
!= PT_LOAD
)
7669 if (sec
->sh_addr
>= seg
->p_vaddr
7670 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7672 aux
->seg_base
= seg
->p_vaddr
;
7678 /* Second, build the unwind table from the contents of the unwind section: */
7679 size
= sec
->sh_size
;
7680 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7685 aux
->table_len
= size
/ (3 * eh_addr_size
);
7686 aux
->table
= (struct ia64_unw_table_entry
*)
7687 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7690 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7692 tep
->start
.section
= SHN_UNDEF
;
7693 tep
->end
.section
= SHN_UNDEF
;
7694 tep
->info
.section
= SHN_UNDEF
;
7695 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7696 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7697 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7698 tep
->start
.offset
+= aux
->seg_base
;
7699 tep
->end
.offset
+= aux
->seg_base
;
7700 tep
->info
.offset
+= aux
->seg_base
;
7704 /* Third, apply any relocations to the unwind table: */
7705 for (relsec
= filedata
->section_headers
;
7706 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7709 if (relsec
->sh_type
!= SHT_RELA
7710 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7711 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7714 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7723 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7725 unsigned int sym_ndx
;
7726 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7727 relname
= elf_ia64_reloc_type (r_type
);
7729 /* PR 17531: file: 9fa67536. */
7730 if (relname
== NULL
)
7732 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7736 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7738 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7742 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7744 /* PR 17531: file: 5bc8d9bf. */
7745 if (i
>= aux
->table_len
)
7747 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7751 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7752 if (sym_ndx
>= aux
->nsyms
)
7754 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7758 sym
= aux
->symtab
+ sym_ndx
;
7760 switch (rp
->r_offset
/ eh_addr_size
% 3)
7763 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7764 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7767 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7768 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7771 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7772 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7786 ia64_process_unwind (Filedata
* filedata
)
7788 Elf_Internal_Shdr
* sec
;
7789 Elf_Internal_Shdr
* unwsec
= NULL
;
7790 Elf_Internal_Shdr
* strsec
;
7791 unsigned long i
, unwcount
= 0, unwstart
= 0;
7792 struct ia64_unw_aux_info aux
;
7793 bfd_boolean res
= TRUE
;
7795 memset (& aux
, 0, sizeof (aux
));
7797 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7799 if (sec
->sh_type
== SHT_SYMTAB
7800 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7802 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7804 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7805 if (aux
.strtab
!= NULL
)
7807 error (_("Multiple auxillary string tables encountered\n"));
7811 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7814 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7816 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7821 printf (_("\nThere are no unwind sections in this file.\n"));
7823 while (unwcount
-- > 0)
7828 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7829 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7830 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7835 /* We have already counted the number of SHT_IA64_UNWIND
7836 sections so the loop above should never fail. */
7837 assert (unwsec
!= NULL
);
7840 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7842 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7844 /* We need to find which section group it is in. */
7845 struct group_list
* g
;
7847 if (section_headers_groups
== NULL
7848 || section_headers_groups
[i
] == NULL
)
7849 i
= filedata
->file_header
.e_shnum
;
7852 g
= section_headers_groups
[i
]->root
;
7854 for (; g
!= NULL
; g
= g
->next
)
7856 sec
= filedata
->section_headers
+ g
->section_index
;
7858 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7863 i
= filedata
->file_header
.e_shnum
;
7866 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7868 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7869 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7870 suffix
= SECTION_NAME (unwsec
) + len
;
7871 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7873 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7874 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7879 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7880 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7881 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7882 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7884 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7885 suffix
= SECTION_NAME (unwsec
) + len
;
7886 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7888 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7889 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7893 if (i
== filedata
->file_header
.e_shnum
)
7895 printf (_("\nCould not find unwind info section for "));
7897 if (filedata
->string_table
== NULL
)
7898 printf ("%d", unwsec
->sh_name
);
7900 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7904 aux
.info_addr
= sec
->sh_addr
;
7905 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7908 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7910 printf (_("\nUnwind section "));
7912 if (filedata
->string_table
== NULL
)
7913 printf ("%d", unwsec
->sh_name
);
7915 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7917 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7918 (unsigned long) unwsec
->sh_offset
,
7919 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7921 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7922 && aux
.table_len
> 0)
7923 dump_ia64_unwind (filedata
, & aux
);
7926 free ((char *) aux
.table
);
7928 free ((char *) aux
.info
);
7937 free ((char *) aux
.strtab
);
7942 struct hppa_unw_table_entry
7944 struct absaddr start
;
7946 unsigned int Cannot_unwind
:1; /* 0 */
7947 unsigned int Millicode
:1; /* 1 */
7948 unsigned int Millicode_save_sr0
:1; /* 2 */
7949 unsigned int Region_description
:2; /* 3..4 */
7950 unsigned int reserved1
:1; /* 5 */
7951 unsigned int Entry_SR
:1; /* 6 */
7952 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7953 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7954 unsigned int Args_stored
:1; /* 16 */
7955 unsigned int Variable_Frame
:1; /* 17 */
7956 unsigned int Separate_Package_Body
:1; /* 18 */
7957 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7958 unsigned int Stack_Overflow_Check
:1; /* 20 */
7959 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7960 unsigned int Ada_Region
:1; /* 22 */
7961 unsigned int cxx_info
:1; /* 23 */
7962 unsigned int cxx_try_catch
:1; /* 24 */
7963 unsigned int sched_entry_seq
:1; /* 25 */
7964 unsigned int reserved2
:1; /* 26 */
7965 unsigned int Save_SP
:1; /* 27 */
7966 unsigned int Save_RP
:1; /* 28 */
7967 unsigned int Save_MRP_in_frame
:1; /* 29 */
7968 unsigned int extn_ptr_defined
:1; /* 30 */
7969 unsigned int Cleanup_defined
:1; /* 31 */
7971 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7972 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7973 unsigned int Large_frame
:1; /* 2 */
7974 unsigned int Pseudo_SP_Set
:1; /* 3 */
7975 unsigned int reserved4
:1; /* 4 */
7976 unsigned int Total_frame_size
:27; /* 5..31 */
7979 struct hppa_unw_aux_info
7981 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7982 unsigned long table_len
; /* Length of unwind table. */
7983 bfd_vma seg_base
; /* Starting address of segment. */
7984 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7985 unsigned long nsyms
; /* Number of symbols. */
7986 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7987 unsigned long nfuns
; /* Number of entries in funtab. */
7988 char * strtab
; /* The string table. */
7989 unsigned long strtab_size
; /* Size of string table. */
7993 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7995 struct hppa_unw_table_entry
* tp
;
7996 unsigned long j
, nfuns
;
7997 bfd_boolean res
= TRUE
;
7999 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8000 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8001 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8002 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8004 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8006 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8009 const char * procname
;
8011 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8012 aux
->strtab_size
, tp
->start
, &procname
,
8015 fputs ("\n<", stdout
);
8019 fputs (procname
, stdout
);
8022 printf ("+%lx", (unsigned long) offset
);
8025 fputs (">: [", stdout
);
8026 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8027 fputc ('-', stdout
);
8028 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8031 #define PF(_m) if (tp->_m) printf (#_m " ");
8032 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8035 PF(Millicode_save_sr0
);
8036 /* PV(Region_description); */
8042 PF(Separate_Package_Body
);
8043 PF(Frame_Extension_Millicode
);
8044 PF(Stack_Overflow_Check
);
8045 PF(Two_Instruction_SP_Increment
);
8049 PF(sched_entry_seq
);
8052 PF(Save_MRP_in_frame
);
8053 PF(extn_ptr_defined
);
8054 PF(Cleanup_defined
);
8055 PF(MPE_XL_interrupt_marker
);
8056 PF(HP_UX_interrupt_marker
);
8059 PV(Total_frame_size
);
8072 slurp_hppa_unwind_table (Filedata
* filedata
,
8073 struct hppa_unw_aux_info
* aux
,
8074 Elf_Internal_Shdr
* sec
)
8076 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8077 Elf_Internal_Phdr
* seg
;
8078 struct hppa_unw_table_entry
* tep
;
8079 Elf_Internal_Shdr
* relsec
;
8080 Elf_Internal_Rela
* rela
;
8081 Elf_Internal_Rela
* rp
;
8082 unsigned char * table
;
8084 Elf_Internal_Sym
* sym
;
8085 const char * relname
;
8087 /* First, find the starting address of the segment that includes
8089 if (filedata
->file_header
.e_phnum
)
8091 if (! get_program_headers (filedata
))
8094 for (seg
= filedata
->program_headers
;
8095 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8098 if (seg
->p_type
!= PT_LOAD
)
8101 if (sec
->sh_addr
>= seg
->p_vaddr
8102 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8104 aux
->seg_base
= seg
->p_vaddr
;
8110 /* Second, build the unwind table from the contents of the unwind
8112 size
= sec
->sh_size
;
8113 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8119 nentries
= size
/ unw_ent_size
;
8120 size
= unw_ent_size
* nentries
;
8122 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8123 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8125 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8127 unsigned int tmp1
, tmp2
;
8129 tep
->start
.section
= SHN_UNDEF
;
8130 tep
->end
.section
= SHN_UNDEF
;
8132 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8133 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8134 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8135 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8137 tep
->start
.offset
+= aux
->seg_base
;
8138 tep
->end
.offset
+= aux
->seg_base
;
8140 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8141 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8142 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8143 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8144 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8145 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8146 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8147 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8148 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8149 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8150 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8151 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8152 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8153 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8154 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8155 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8156 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8157 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8158 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8159 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8160 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8161 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8162 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8163 tep
->Cleanup_defined
= tmp1
& 0x1;
8165 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8166 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8167 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8168 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8169 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8170 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8174 /* Third, apply any relocations to the unwind table. */
8175 for (relsec
= filedata
->section_headers
;
8176 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8179 if (relsec
->sh_type
!= SHT_RELA
8180 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8181 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8184 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8188 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8190 unsigned int sym_ndx
;
8191 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8192 relname
= elf_hppa_reloc_type (r_type
);
8194 if (relname
== NULL
)
8196 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8200 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8201 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8203 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8207 i
= rp
->r_offset
/ unw_ent_size
;
8208 if (i
>= aux
->table_len
)
8210 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8214 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8215 if (sym_ndx
>= aux
->nsyms
)
8217 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8221 sym
= aux
->symtab
+ sym_ndx
;
8223 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8226 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8227 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8230 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8231 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8241 aux
->table_len
= nentries
;
8247 hppa_process_unwind (Filedata
* filedata
)
8249 struct hppa_unw_aux_info aux
;
8250 Elf_Internal_Shdr
* unwsec
= NULL
;
8251 Elf_Internal_Shdr
* strsec
;
8252 Elf_Internal_Shdr
* sec
;
8254 bfd_boolean res
= TRUE
;
8256 if (filedata
->string_table
== NULL
)
8259 memset (& aux
, 0, sizeof (aux
));
8261 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8263 if (sec
->sh_type
== SHT_SYMTAB
8264 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8266 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8268 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8269 if (aux
.strtab
!= NULL
)
8271 error (_("Multiple auxillary string tables encountered\n"));
8275 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8278 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8280 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8285 printf (_("\nThere are no unwind sections in this file.\n"));
8287 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8289 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8291 unsigned long num_unwind
= sec
->sh_size
/ 16;
8293 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8294 "contains %lu entry:\n",
8295 "\nUnwind section '%s' at offset 0x%lx "
8296 "contains %lu entries:\n",
8298 printable_section_name (filedata
, sec
),
8299 (unsigned long) sec
->sh_offset
,
8302 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8305 if (res
&& aux
.table_len
> 0)
8307 if (! dump_hppa_unwind (filedata
, &aux
))
8312 free ((char *) aux
.table
);
8320 free ((char *) aux
.strtab
);
8327 unsigned char * data
; /* The unwind data. */
8328 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8329 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8330 unsigned long nrelas
; /* The number of relocations. */
8331 unsigned int rel_type
; /* REL or RELA ? */
8332 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8335 struct arm_unw_aux_info
8337 Filedata
* filedata
; /* The file containing the unwind sections. */
8338 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8339 unsigned long nsyms
; /* Number of symbols. */
8340 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8341 unsigned long nfuns
; /* Number of these symbols. */
8342 char * strtab
; /* The file's string table. */
8343 unsigned long strtab_size
; /* Size of string table. */
8347 arm_print_vma_and_name (Filedata
* filedata
,
8348 struct arm_unw_aux_info
* aux
,
8350 struct absaddr addr
)
8352 const char *procname
;
8355 if (addr
.section
== SHN_UNDEF
)
8358 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8359 aux
->strtab_size
, addr
, &procname
,
8362 print_vma (fn
, PREFIX_HEX
);
8366 fputs (" <", stdout
);
8367 fputs (procname
, stdout
);
8370 printf ("+0x%lx", (unsigned long) sym_offset
);
8371 fputc ('>', stdout
);
8378 arm_free_section (struct arm_section
*arm_sec
)
8380 if (arm_sec
->data
!= NULL
)
8381 free (arm_sec
->data
);
8383 if (arm_sec
->rela
!= NULL
)
8384 free (arm_sec
->rela
);
8387 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8388 cached section and install SEC instead.
8389 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8390 and return its valued in * WORDP, relocating if necessary.
8391 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8392 relocation's offset in ADDR.
8393 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8394 into the string table of the symbol associated with the reloc. If no
8395 reloc was applied store -1 there.
8396 5) Return TRUE upon success, FALSE otherwise. */
8399 get_unwind_section_word (Filedata
* filedata
,
8400 struct arm_unw_aux_info
* aux
,
8401 struct arm_section
* arm_sec
,
8402 Elf_Internal_Shdr
* sec
,
8403 bfd_vma word_offset
,
8404 unsigned int * wordp
,
8405 struct absaddr
* addr
,
8408 Elf_Internal_Rela
*rp
;
8409 Elf_Internal_Sym
*sym
;
8410 const char * relname
;
8412 bfd_boolean wrapped
;
8414 if (sec
== NULL
|| arm_sec
== NULL
)
8417 addr
->section
= SHN_UNDEF
;
8420 if (sym_name
!= NULL
)
8421 *sym_name
= (bfd_vma
) -1;
8423 /* If necessary, update the section cache. */
8424 if (sec
!= arm_sec
->sec
)
8426 Elf_Internal_Shdr
*relsec
;
8428 arm_free_section (arm_sec
);
8431 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8432 sec
->sh_size
, _("unwind data"));
8433 arm_sec
->rela
= NULL
;
8434 arm_sec
->nrelas
= 0;
8436 for (relsec
= filedata
->section_headers
;
8437 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8440 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8441 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8442 /* PR 15745: Check the section type as well. */
8443 || (relsec
->sh_type
!= SHT_REL
8444 && relsec
->sh_type
!= SHT_RELA
))
8447 arm_sec
->rel_type
= relsec
->sh_type
;
8448 if (relsec
->sh_type
== SHT_REL
)
8450 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8452 & arm_sec
->rela
, & arm_sec
->nrelas
))
8455 else /* relsec->sh_type == SHT_RELA */
8457 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8459 & arm_sec
->rela
, & arm_sec
->nrelas
))
8465 arm_sec
->next_rela
= arm_sec
->rela
;
8468 /* If there is no unwind data we can do nothing. */
8469 if (arm_sec
->data
== NULL
)
8472 /* If the offset is invalid then fail. */
8473 if (/* PR 21343 *//* PR 18879 */
8475 || word_offset
> (sec
->sh_size
- 4)
8476 || ((bfd_signed_vma
) word_offset
) < 0)
8479 /* Get the word at the required offset. */
8480 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8482 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8483 if (arm_sec
->rela
== NULL
)
8489 /* Look through the relocs to find the one that applies to the provided offset. */
8491 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8493 bfd_vma prelval
, offset
;
8495 if (rp
->r_offset
> word_offset
&& !wrapped
)
8500 if (rp
->r_offset
> word_offset
)
8503 if (rp
->r_offset
& 3)
8505 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8506 (unsigned long) rp
->r_offset
);
8510 if (rp
->r_offset
< word_offset
)
8513 /* PR 17531: file: 027-161405-0.004 */
8514 if (aux
->symtab
== NULL
)
8517 if (arm_sec
->rel_type
== SHT_REL
)
8519 offset
= word
& 0x7fffffff;
8520 if (offset
& 0x40000000)
8521 offset
|= ~ (bfd_vma
) 0x7fffffff;
8523 else if (arm_sec
->rel_type
== SHT_RELA
)
8524 offset
= rp
->r_addend
;
8527 error (_("Unknown section relocation type %d encountered\n"),
8532 /* PR 17531 file: 027-1241568-0.004. */
8533 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8535 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8536 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8540 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8541 offset
+= sym
->st_value
;
8542 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8544 /* Check that we are processing the expected reloc type. */
8545 if (filedata
->file_header
.e_machine
== EM_ARM
)
8547 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8548 if (relname
== NULL
)
8550 warn (_("Skipping unknown ARM relocation type: %d\n"),
8551 (int) ELF32_R_TYPE (rp
->r_info
));
8555 if (streq (relname
, "R_ARM_NONE"))
8558 if (! streq (relname
, "R_ARM_PREL31"))
8560 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8564 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8566 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8567 if (relname
== NULL
)
8569 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8570 (int) ELF32_R_TYPE (rp
->r_info
));
8574 if (streq (relname
, "R_C6000_NONE"))
8577 if (! streq (relname
, "R_C6000_PREL31"))
8579 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8587 /* This function currently only supports ARM and TI unwinders. */
8588 warn (_("Only TI and ARM unwinders are currently supported\n"));
8592 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8593 addr
->section
= sym
->st_shndx
;
8594 addr
->offset
= offset
;
8597 * sym_name
= sym
->st_name
;
8602 arm_sec
->next_rela
= rp
;
8607 static const char *tic6x_unwind_regnames
[16] =
8609 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8610 "A14", "A13", "A12", "A11", "A10",
8611 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8615 decode_tic6x_unwind_regmask (unsigned int mask
)
8619 for (i
= 12; mask
; mask
>>= 1, i
--)
8623 fputs (tic6x_unwind_regnames
[i
], stdout
);
8625 fputs (", ", stdout
);
8631 if (remaining == 0 && more_words) \
8634 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8635 data_offset, & word, & addr, NULL)) \
8641 #define GET_OP(OP) \
8646 (OP) = word >> 24; \
8651 printf (_("[Truncated opcode]\n")); \
8654 printf ("0x%02x ", OP)
8657 decode_arm_unwind_bytecode (Filedata
* filedata
,
8658 struct arm_unw_aux_info
* aux
,
8660 unsigned int remaining
,
8661 unsigned int more_words
,
8662 bfd_vma data_offset
,
8663 Elf_Internal_Shdr
* data_sec
,
8664 struct arm_section
* data_arm_sec
)
8666 struct absaddr addr
;
8667 bfd_boolean res
= TRUE
;
8669 /* Decode the unwinding instructions. */
8672 unsigned int op
, op2
;
8681 printf (" 0x%02x ", op
);
8683 if ((op
& 0xc0) == 0x00)
8685 int offset
= ((op
& 0x3f) << 2) + 4;
8687 printf (" vsp = vsp + %d", offset
);
8689 else if ((op
& 0xc0) == 0x40)
8691 int offset
= ((op
& 0x3f) << 2) + 4;
8693 printf (" vsp = vsp - %d", offset
);
8695 else if ((op
& 0xf0) == 0x80)
8698 if (op
== 0x80 && op2
== 0)
8699 printf (_("Refuse to unwind"));
8702 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8703 bfd_boolean first
= TRUE
;
8707 for (i
= 0; i
< 12; i
++)
8708 if (mask
& (1 << i
))
8714 printf ("r%d", 4 + i
);
8719 else if ((op
& 0xf0) == 0x90)
8721 if (op
== 0x9d || op
== 0x9f)
8722 printf (_(" [Reserved]"));
8724 printf (" vsp = r%d", op
& 0x0f);
8726 else if ((op
& 0xf0) == 0xa0)
8728 int end
= 4 + (op
& 0x07);
8729 bfd_boolean first
= TRUE
;
8733 for (i
= 4; i
<= end
; i
++)
8749 else if (op
== 0xb0)
8750 printf (_(" finish"));
8751 else if (op
== 0xb1)
8754 if (op2
== 0 || (op2
& 0xf0) != 0)
8755 printf (_("[Spare]"));
8758 unsigned int mask
= op2
& 0x0f;
8759 bfd_boolean first
= TRUE
;
8763 for (i
= 0; i
< 12; i
++)
8764 if (mask
& (1 << i
))
8775 else if (op
== 0xb2)
8777 unsigned char buf
[9];
8778 unsigned int i
, len
;
8779 unsigned long offset
;
8781 for (i
= 0; i
< sizeof (buf
); i
++)
8784 if ((buf
[i
] & 0x80) == 0)
8787 if (i
== sizeof (buf
))
8789 error (_("corrupt change to vsp"));
8794 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8795 assert (len
== i
+ 1);
8796 offset
= offset
* 4 + 0x204;
8797 printf ("vsp = vsp + %ld", offset
);
8800 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8802 unsigned int first
, last
;
8809 printf ("pop {D%d", first
);
8811 printf ("-D%d", first
+ last
);
8814 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8816 unsigned int count
= op
& 0x07;
8820 printf ("-D%d", 8 + count
);
8823 else if (op
>= 0xc0 && op
<= 0xc5)
8825 unsigned int count
= op
& 0x07;
8827 printf (" pop {wR10");
8829 printf ("-wR%d", 10 + count
);
8832 else if (op
== 0xc6)
8834 unsigned int first
, last
;
8839 printf ("pop {wR%d", first
);
8841 printf ("-wR%d", first
+ last
);
8844 else if (op
== 0xc7)
8847 if (op2
== 0 || (op2
& 0xf0) != 0)
8848 printf (_("[Spare]"));
8851 unsigned int mask
= op2
& 0x0f;
8852 bfd_boolean first
= TRUE
;
8856 for (i
= 0; i
< 4; i
++)
8857 if (mask
& (1 << i
))
8863 printf ("wCGR%d", i
);
8870 printf (_(" [unsupported opcode]"));
8881 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8882 struct arm_unw_aux_info
* aux
,
8884 unsigned int remaining
,
8885 unsigned int more_words
,
8886 bfd_vma data_offset
,
8887 Elf_Internal_Shdr
* data_sec
,
8888 struct arm_section
* data_arm_sec
)
8890 struct absaddr addr
;
8892 /* Decode the unwinding instructions. */
8895 unsigned int op
, op2
;
8904 printf (" 0x%02x ", op
);
8906 if ((op
& 0xc0) == 0x00)
8908 int offset
= ((op
& 0x3f) << 3) + 8;
8909 printf (" sp = sp + %d", offset
);
8911 else if ((op
& 0xc0) == 0x80)
8914 if (op
== 0x80 && op2
== 0)
8915 printf (_("Refuse to unwind"));
8918 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8920 printf ("pop compact {");
8924 decode_tic6x_unwind_regmask (mask
);
8928 else if ((op
& 0xf0) == 0xc0)
8936 unsigned int offset
;
8940 /* Scan entire instruction first so that GET_OP output is not
8941 interleaved with disassembly. */
8943 for (i
= 0; nregs
< (op
& 0xf); i
++)
8949 regpos
[nregs
].offset
= i
* 2;
8950 regpos
[nregs
].reg
= reg
;
8957 regpos
[nregs
].offset
= i
* 2 + 1;
8958 regpos
[nregs
].reg
= reg
;
8963 printf (_("pop frame {"));
8966 printf (_("*corrupt* - no registers specified"));
8971 for (i
= i
* 2; i
> 0; i
--)
8973 if (regpos
[reg
].offset
== i
- 1)
8975 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8982 fputs (name
, stdout
);
8990 else if (op
== 0xd0)
8991 printf (" MOV FP, SP");
8992 else if (op
== 0xd1)
8993 printf (" __c6xabi_pop_rts");
8994 else if (op
== 0xd2)
8996 unsigned char buf
[9];
8997 unsigned int i
, len
;
8998 unsigned long offset
;
9000 for (i
= 0; i
< sizeof (buf
); i
++)
9003 if ((buf
[i
] & 0x80) == 0)
9006 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9007 if (i
== sizeof (buf
))
9009 warn (_("Corrupt stack pointer adjustment detected\n"));
9013 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9014 assert (len
== i
+ 1);
9015 offset
= offset
* 8 + 0x408;
9016 printf (_("sp = sp + %ld"), offset
);
9018 else if ((op
& 0xf0) == 0xe0)
9020 if ((op
& 0x0f) == 7)
9023 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9027 printf (_(" [unsupported opcode]"));
9036 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9040 offset
= word
& 0x7fffffff;
9041 if (offset
& 0x40000000)
9042 offset
|= ~ (bfd_vma
) 0x7fffffff;
9044 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9047 return offset
+ where
;
9051 decode_arm_unwind (Filedata
* filedata
,
9052 struct arm_unw_aux_info
* aux
,
9054 unsigned int remaining
,
9055 bfd_vma data_offset
,
9056 Elf_Internal_Shdr
* data_sec
,
9057 struct arm_section
* data_arm_sec
)
9060 unsigned int more_words
= 0;
9061 struct absaddr addr
;
9062 bfd_vma sym_name
= (bfd_vma
) -1;
9063 bfd_boolean res
= TRUE
;
9067 /* Fetch the first word.
9068 Note - when decoding an object file the address extracted
9069 here will always be 0. So we also pass in the sym_name
9070 parameter so that we can find the symbol associated with
9071 the personality routine. */
9072 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9073 & word
, & addr
, & sym_name
))
9080 addr
.section
= SHN_UNDEF
;
9084 if ((word
& 0x80000000) == 0)
9086 /* Expand prel31 for personality routine. */
9088 const char *procname
;
9090 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9091 printf (_(" Personality routine: "));
9093 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9094 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9096 procname
= aux
->strtab
+ sym_name
;
9097 print_vma (fn
, PREFIX_HEX
);
9100 fputs (" <", stdout
);
9101 fputs (procname
, stdout
);
9102 fputc ('>', stdout
);
9106 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9107 fputc ('\n', stdout
);
9109 /* The GCC personality routines use the standard compact
9110 encoding, starting with one byte giving the number of
9112 if (procname
!= NULL
9113 && (const_strneq (procname
, "__gcc_personality_v0")
9114 || const_strneq (procname
, "__gxx_personality_v0")
9115 || const_strneq (procname
, "__gcj_personality_v0")
9116 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9123 printf (_(" [Truncated data]\n"));
9126 more_words
= word
>> 24;
9136 /* ARM EHABI Section 6.3:
9138 An exception-handling table entry for the compact model looks like:
9142 1 0 index Data for personalityRoutine[index] */
9144 if (filedata
->file_header
.e_machine
== EM_ARM
9145 && (word
& 0x70000000))
9147 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9151 per_index
= (word
>> 24) & 0x7f;
9152 printf (_(" Compact model index: %d\n"), per_index
);
9159 else if (per_index
< 3)
9161 more_words
= (word
>> 16) & 0xff;
9167 switch (filedata
->file_header
.e_machine
)
9172 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9173 data_offset
, data_sec
, data_arm_sec
))
9178 warn (_("Unknown ARM compact model index encountered\n"));
9179 printf (_(" [reserved]\n"));
9187 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9188 data_offset
, data_sec
, data_arm_sec
))
9191 else if (per_index
< 5)
9193 if (((word
>> 17) & 0x7f) == 0x7f)
9194 printf (_(" Restore stack from frame pointer\n"));
9196 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9197 printf (_(" Registers restored: "));
9199 printf (" (compact) ");
9200 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9202 printf (_(" Return register: %s\n"),
9203 tic6x_unwind_regnames
[word
& 0xf]);
9206 printf (_(" [reserved (%d)]\n"), per_index
);
9210 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9211 filedata
->file_header
.e_machine
);
9215 /* Decode the descriptors. Not implemented. */
9221 dump_arm_unwind (Filedata
* filedata
,
9222 struct arm_unw_aux_info
* aux
,
9223 Elf_Internal_Shdr
* exidx_sec
)
9225 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9226 unsigned int i
, exidx_len
;
9227 unsigned long j
, nfuns
;
9228 bfd_boolean res
= TRUE
;
9230 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9231 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9232 exidx_len
= exidx_sec
->sh_size
/ 8;
9234 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9235 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9236 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9237 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9239 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9241 for (i
= 0; i
< exidx_len
; i
++)
9243 unsigned int exidx_fn
, exidx_entry
;
9244 struct absaddr fn_addr
, entry_addr
;
9247 fputc ('\n', stdout
);
9249 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9250 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9251 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9252 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9255 arm_free_section (& exidx_arm_sec
);
9256 arm_free_section (& extab_arm_sec
);
9260 /* ARM EHABI, Section 5:
9261 An index table entry consists of 2 words.
9262 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9263 if (exidx_fn
& 0x80000000)
9265 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9269 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9271 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9272 fputs (": ", stdout
);
9274 if (exidx_entry
== 1)
9276 print_vma (exidx_entry
, PREFIX_HEX
);
9277 fputs (" [cantunwind]\n", stdout
);
9279 else if (exidx_entry
& 0x80000000)
9281 print_vma (exidx_entry
, PREFIX_HEX
);
9282 fputc ('\n', stdout
);
9283 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9287 bfd_vma table
, table_offset
= 0;
9288 Elf_Internal_Shdr
*table_sec
;
9290 fputs ("@", stdout
);
9291 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9292 print_vma (table
, PREFIX_HEX
);
9295 /* Locate the matching .ARM.extab. */
9296 if (entry_addr
.section
!= SHN_UNDEF
9297 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9299 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9300 table_offset
= entry_addr
.offset
;
9302 if (table_offset
> table_sec
->sh_size
9303 || ((bfd_signed_vma
) table_offset
) < 0)
9305 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9306 (unsigned long) table_offset
,
9307 printable_section_name (filedata
, table_sec
));
9314 table_sec
= find_section_by_address (filedata
, table
);
9315 if (table_sec
!= NULL
)
9316 table_offset
= table
- table_sec
->sh_addr
;
9319 if (table_sec
== NULL
)
9321 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9322 (unsigned long) table
);
9327 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9336 arm_free_section (&exidx_arm_sec
);
9337 arm_free_section (&extab_arm_sec
);
9342 /* Used for both ARM and C6X unwinding tables. */
9345 arm_process_unwind (Filedata
* filedata
)
9347 struct arm_unw_aux_info aux
;
9348 Elf_Internal_Shdr
*unwsec
= NULL
;
9349 Elf_Internal_Shdr
*strsec
;
9350 Elf_Internal_Shdr
*sec
;
9352 unsigned int sec_type
;
9353 bfd_boolean res
= TRUE
;
9355 switch (filedata
->file_header
.e_machine
)
9358 sec_type
= SHT_ARM_EXIDX
;
9362 sec_type
= SHT_C6000_UNWIND
;
9366 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9367 filedata
->file_header
.e_machine
);
9371 if (filedata
->string_table
== NULL
)
9374 memset (& aux
, 0, sizeof (aux
));
9375 aux
.filedata
= filedata
;
9377 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9379 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9381 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9383 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9385 /* PR binutils/17531 file: 011-12666-0.004. */
9386 if (aux
.strtab
!= NULL
)
9388 error (_("Multiple string tables found in file.\n"));
9392 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9393 1, strsec
->sh_size
, _("string table"));
9394 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9396 else if (sec
->sh_type
== sec_type
)
9401 printf (_("\nThere are no unwind sections in this file.\n"));
9403 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9405 if (sec
->sh_type
== sec_type
)
9407 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9408 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9409 "contains %lu entry:\n",
9410 "\nUnwind section '%s' at offset 0x%lx "
9411 "contains %lu entries:\n",
9413 printable_section_name (filedata
, sec
),
9414 (unsigned long) sec
->sh_offset
,
9417 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9425 free ((char *) aux
.strtab
);
9431 process_unwind (Filedata
* filedata
)
9433 struct unwind_handler
9435 unsigned int machtype
;
9436 bfd_boolean (* handler
)(Filedata
*);
9439 { EM_ARM
, arm_process_unwind
},
9440 { EM_IA_64
, ia64_process_unwind
},
9441 { EM_PARISC
, hppa_process_unwind
},
9442 { EM_TI_C6000
, arm_process_unwind
},
9450 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9451 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9452 return handlers
[i
].handler (filedata
);
9454 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9455 get_machine_name (filedata
->file_header
.e_machine
));
9460 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9462 switch (entry
->d_tag
)
9464 case DT_AARCH64_BTI_PLT
:
9465 case DT_AARCH64_PAC_PLT
:
9468 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9475 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9477 switch (entry
->d_tag
)
9480 if (entry
->d_un
.d_val
== 0)
9484 static const char * opts
[] =
9486 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9487 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9488 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9489 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9493 bfd_boolean first
= TRUE
;
9495 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9496 if (entry
->d_un
.d_val
& (1 << cnt
))
9498 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9504 case DT_MIPS_IVERSION
:
9505 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9506 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9510 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9511 /* Note: coded this way so that there is a single string for translation. */
9512 printf (_("<corrupt: %s>"), buf
);
9516 case DT_MIPS_TIME_STAMP
:
9520 time_t atime
= entry
->d_un
.d_val
;
9522 tmp
= gmtime (&atime
);
9523 /* PR 17531: file: 6accc532. */
9525 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9527 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9528 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9529 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9530 printf (_("Time Stamp: %s"), timebuf
);
9534 case DT_MIPS_RLD_VERSION
:
9535 case DT_MIPS_LOCAL_GOTNO
:
9536 case DT_MIPS_CONFLICTNO
:
9537 case DT_MIPS_LIBLISTNO
:
9538 case DT_MIPS_SYMTABNO
:
9539 case DT_MIPS_UNREFEXTNO
:
9540 case DT_MIPS_HIPAGENO
:
9541 case DT_MIPS_DELTA_CLASS_NO
:
9542 case DT_MIPS_DELTA_INSTANCE_NO
:
9543 case DT_MIPS_DELTA_RELOC_NO
:
9544 case DT_MIPS_DELTA_SYM_NO
:
9545 case DT_MIPS_DELTA_CLASSSYM_NO
:
9546 case DT_MIPS_COMPACT_SIZE
:
9547 print_vma (entry
->d_un
.d_val
, DEC
);
9551 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9552 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9553 /* Falls through. */
9556 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9562 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9564 switch (entry
->d_tag
)
9566 case DT_HP_DLD_FLAGS
:
9575 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9576 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9577 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9578 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9579 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9580 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9581 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9582 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9583 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9584 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9585 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9586 { DT_HP_GST
, "HP_GST" },
9587 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9588 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9589 { DT_HP_NODELETE
, "HP_NODELETE" },
9590 { DT_HP_GROUP
, "HP_GROUP" },
9591 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9593 bfd_boolean first
= TRUE
;
9595 bfd_vma val
= entry
->d_un
.d_val
;
9597 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9598 if (val
& flags
[cnt
].bit
)
9602 fputs (flags
[cnt
].str
, stdout
);
9604 val
^= flags
[cnt
].bit
;
9607 if (val
!= 0 || first
)
9611 print_vma (val
, HEX
);
9617 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9625 /* VMS vs Unix time offset and factor. */
9627 #define VMS_EPOCH_OFFSET 35067168000000000LL
9628 #define VMS_GRANULARITY_FACTOR 10000000
9630 /* Display a VMS time in a human readable format. */
9633 print_vms_time (bfd_int64_t vmstime
)
9638 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9639 tm
= gmtime (&unxtime
);
9640 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9641 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9642 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9647 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9649 switch (entry
->d_tag
)
9651 case DT_IA_64_PLT_RESERVE
:
9652 /* First 3 slots reserved. */
9653 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9655 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9658 case DT_IA_64_VMS_LINKTIME
:
9660 print_vms_time (entry
->d_un
.d_val
);
9664 case DT_IA_64_VMS_LNKFLAGS
:
9665 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9666 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9667 printf (" CALL_DEBUG");
9668 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9669 printf (" NOP0BUFS");
9670 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9671 printf (" P0IMAGE");
9672 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9673 printf (" MKTHREADS");
9674 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9675 printf (" UPCALLS");
9676 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9678 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9679 printf (" INITIALIZE");
9680 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9682 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9683 printf (" EXE_INIT");
9684 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9685 printf (" TBK_IN_IMG");
9686 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9687 printf (" DBG_IN_IMG");
9688 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9689 printf (" TBK_IN_DSF");
9690 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9691 printf (" DBG_IN_DSF");
9692 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9693 printf (" SIGNATURES");
9694 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9695 printf (" REL_SEG_OFF");
9699 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9706 get_32bit_dynamic_section (Filedata
* filedata
)
9708 Elf32_External_Dyn
* edyn
;
9709 Elf32_External_Dyn
* ext
;
9710 Elf_Internal_Dyn
* entry
;
9712 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9713 dynamic_size
, _("dynamic section"));
9717 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9718 might not have the luxury of section headers. Look for the DT_NULL
9719 terminator to determine the number of entries. */
9720 for (ext
= edyn
, dynamic_nent
= 0;
9721 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9725 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9729 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9731 if (dynamic_section
== NULL
)
9733 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9734 (unsigned long) dynamic_nent
);
9739 for (ext
= edyn
, entry
= dynamic_section
;
9740 entry
< dynamic_section
+ dynamic_nent
;
9743 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9744 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9753 get_64bit_dynamic_section (Filedata
* filedata
)
9755 Elf64_External_Dyn
* edyn
;
9756 Elf64_External_Dyn
* ext
;
9757 Elf_Internal_Dyn
* entry
;
9759 /* Read in the data. */
9760 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9761 dynamic_size
, _("dynamic section"));
9765 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9766 might not have the luxury of section headers. Look for the DT_NULL
9767 terminator to determine the number of entries. */
9768 for (ext
= edyn
, dynamic_nent
= 0;
9769 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9770 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9774 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9778 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9780 if (dynamic_section
== NULL
)
9782 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9783 (unsigned long) dynamic_nent
);
9788 /* Convert from external to internal formats. */
9789 for (ext
= edyn
, entry
= dynamic_section
;
9790 entry
< dynamic_section
+ dynamic_nent
;
9793 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9794 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9803 print_dynamic_flags (bfd_vma flags
)
9805 bfd_boolean first
= TRUE
;
9811 flag
= flags
& - flags
;
9821 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9822 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9823 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9824 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9825 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9826 default: fputs (_("unknown"), stdout
); break;
9832 /* Parse and display the contents of the dynamic section. */
9835 process_dynamic_section (Filedata
* filedata
)
9837 Elf_Internal_Dyn
* entry
;
9839 if (dynamic_size
== 0)
9842 printf (_("\nThere is no dynamic section in this file.\n"));
9849 if (! get_32bit_dynamic_section (filedata
))
9854 if (! get_64bit_dynamic_section (filedata
))
9858 /* Find the appropriate symbol table. */
9859 if (dynamic_symbols
== NULL
)
9861 for (entry
= dynamic_section
;
9862 entry
< dynamic_section
+ dynamic_nent
;
9865 Elf_Internal_Shdr section
;
9867 if (entry
->d_tag
!= DT_SYMTAB
)
9870 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9872 /* Since we do not know how big the symbol table is,
9873 we default to reading in the entire file (!) and
9874 processing that. This is overkill, I know, but it
9876 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9877 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9879 /* See PR 21379 for a reproducer. */
9880 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9884 if (archive_file_offset
!= 0)
9885 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9887 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9890 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9892 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9893 section
.sh_name
= filedata
->string_table_length
;
9895 if (dynamic_symbols
!= NULL
)
9897 error (_("Multiple dynamic symbol table sections found\n"));
9898 free (dynamic_symbols
);
9900 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9901 if (num_dynamic_syms
< 1)
9903 error (_("Unable to determine the number of symbols to load\n"));
9909 /* Similarly find a string table. */
9910 if (dynamic_strings
== NULL
)
9912 for (entry
= dynamic_section
;
9913 entry
< dynamic_section
+ dynamic_nent
;
9916 unsigned long offset
;
9919 if (entry
->d_tag
!= DT_STRTAB
)
9922 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9924 /* Since we do not know how big the string table is,
9925 we default to reading in the entire file (!) and
9926 processing that. This is overkill, I know, but it
9929 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9931 if (archive_file_offset
!= 0)
9932 str_tab_len
= archive_file_size
- offset
;
9934 str_tab_len
= filedata
->file_size
- offset
;
9936 if (str_tab_len
< 1)
9939 (_("Unable to determine the length of the dynamic string table\n"));
9943 if (dynamic_strings
!= NULL
)
9945 error (_("Multiple dynamic string tables found\n"));
9946 free (dynamic_strings
);
9949 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9951 _("dynamic string table"));
9952 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9956 /* And find the syminfo section if available. */
9957 if (dynamic_syminfo
== NULL
)
9959 unsigned long syminsz
= 0;
9961 for (entry
= dynamic_section
;
9962 entry
< dynamic_section
+ dynamic_nent
;
9965 if (entry
->d_tag
== DT_SYMINENT
)
9967 /* Note: these braces are necessary to avoid a syntax
9968 error from the SunOS4 C compiler. */
9969 /* PR binutils/17531: A corrupt file can trigger this test.
9970 So do not use an assert, instead generate an error message. */
9971 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9972 error (_("Bad value (%d) for SYMINENT entry\n"),
9973 (int) entry
->d_un
.d_val
);
9975 else if (entry
->d_tag
== DT_SYMINSZ
)
9976 syminsz
= entry
->d_un
.d_val
;
9977 else if (entry
->d_tag
== DT_SYMINFO
)
9978 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9982 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9984 Elf_External_Syminfo
* extsyminfo
;
9985 Elf_External_Syminfo
* extsym
;
9986 Elf_Internal_Syminfo
* syminfo
;
9988 /* There is a syminfo section. Read the data. */
9989 extsyminfo
= (Elf_External_Syminfo
*)
9990 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9991 _("symbol information"));
9995 if (dynamic_syminfo
!= NULL
)
9997 error (_("Multiple dynamic symbol information sections found\n"));
9998 free (dynamic_syminfo
);
10000 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10001 if (dynamic_syminfo
== NULL
)
10003 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10004 (unsigned long) syminsz
);
10008 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10009 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10010 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10011 ++syminfo
, ++extsym
)
10013 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10014 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10021 if (do_dynamic
&& dynamic_addr
)
10022 printf (ngettext ("\nDynamic section at offset 0x%lx "
10023 "contains %lu entry:\n",
10024 "\nDynamic section at offset 0x%lx "
10025 "contains %lu entries:\n",
10027 dynamic_addr
, (unsigned long) dynamic_nent
);
10029 printf (_(" Tag Type Name/Value\n"));
10031 for (entry
= dynamic_section
;
10032 entry
< dynamic_section
+ dynamic_nent
;
10037 const char * dtype
;
10040 print_vma (entry
->d_tag
, FULL_HEX
);
10041 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10042 printf (" (%s)%*s", dtype
,
10043 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10046 switch (entry
->d_tag
)
10050 print_dynamic_flags (entry
->d_un
.d_val
);
10060 switch (entry
->d_tag
)
10063 printf (_("Auxiliary library"));
10067 printf (_("Filter library"));
10071 printf (_("Configuration file"));
10075 printf (_("Dependency audit library"));
10079 printf (_("Audit library"));
10083 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10084 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10088 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10097 printf (_("Flags:"));
10099 if (entry
->d_un
.d_val
== 0)
10100 printf (_(" None\n"));
10103 unsigned long int val
= entry
->d_un
.d_val
;
10105 if (val
& DTF_1_PARINIT
)
10107 printf (" PARINIT");
10108 val
^= DTF_1_PARINIT
;
10110 if (val
& DTF_1_CONFEXP
)
10112 printf (" CONFEXP");
10113 val
^= DTF_1_CONFEXP
;
10116 printf (" %lx", val
);
10125 printf (_("Flags:"));
10127 if (entry
->d_un
.d_val
== 0)
10128 printf (_(" None\n"));
10131 unsigned long int val
= entry
->d_un
.d_val
;
10133 if (val
& DF_P1_LAZYLOAD
)
10135 printf (" LAZYLOAD");
10136 val
^= DF_P1_LAZYLOAD
;
10138 if (val
& DF_P1_GROUPPERM
)
10140 printf (" GROUPPERM");
10141 val
^= DF_P1_GROUPPERM
;
10144 printf (" %lx", val
);
10153 printf (_("Flags:"));
10154 if (entry
->d_un
.d_val
== 0)
10155 printf (_(" None\n"));
10158 unsigned long int val
= entry
->d_un
.d_val
;
10160 if (val
& DF_1_NOW
)
10165 if (val
& DF_1_GLOBAL
)
10167 printf (" GLOBAL");
10168 val
^= DF_1_GLOBAL
;
10170 if (val
& DF_1_GROUP
)
10175 if (val
& DF_1_NODELETE
)
10177 printf (" NODELETE");
10178 val
^= DF_1_NODELETE
;
10180 if (val
& DF_1_LOADFLTR
)
10182 printf (" LOADFLTR");
10183 val
^= DF_1_LOADFLTR
;
10185 if (val
& DF_1_INITFIRST
)
10187 printf (" INITFIRST");
10188 val
^= DF_1_INITFIRST
;
10190 if (val
& DF_1_NOOPEN
)
10192 printf (" NOOPEN");
10193 val
^= DF_1_NOOPEN
;
10195 if (val
& DF_1_ORIGIN
)
10197 printf (" ORIGIN");
10198 val
^= DF_1_ORIGIN
;
10200 if (val
& DF_1_DIRECT
)
10202 printf (" DIRECT");
10203 val
^= DF_1_DIRECT
;
10205 if (val
& DF_1_TRANS
)
10210 if (val
& DF_1_INTERPOSE
)
10212 printf (" INTERPOSE");
10213 val
^= DF_1_INTERPOSE
;
10215 if (val
& DF_1_NODEFLIB
)
10217 printf (" NODEFLIB");
10218 val
^= DF_1_NODEFLIB
;
10220 if (val
& DF_1_NODUMP
)
10222 printf (" NODUMP");
10223 val
^= DF_1_NODUMP
;
10225 if (val
& DF_1_CONFALT
)
10227 printf (" CONFALT");
10228 val
^= DF_1_CONFALT
;
10230 if (val
& DF_1_ENDFILTEE
)
10232 printf (" ENDFILTEE");
10233 val
^= DF_1_ENDFILTEE
;
10235 if (val
& DF_1_DISPRELDNE
)
10237 printf (" DISPRELDNE");
10238 val
^= DF_1_DISPRELDNE
;
10240 if (val
& DF_1_DISPRELPND
)
10242 printf (" DISPRELPND");
10243 val
^= DF_1_DISPRELPND
;
10245 if (val
& DF_1_NODIRECT
)
10247 printf (" NODIRECT");
10248 val
^= DF_1_NODIRECT
;
10250 if (val
& DF_1_IGNMULDEF
)
10252 printf (" IGNMULDEF");
10253 val
^= DF_1_IGNMULDEF
;
10255 if (val
& DF_1_NOKSYMS
)
10257 printf (" NOKSYMS");
10258 val
^= DF_1_NOKSYMS
;
10260 if (val
& DF_1_NOHDR
)
10265 if (val
& DF_1_EDITED
)
10267 printf (" EDITED");
10268 val
^= DF_1_EDITED
;
10270 if (val
& DF_1_NORELOC
)
10272 printf (" NORELOC");
10273 val
^= DF_1_NORELOC
;
10275 if (val
& DF_1_SYMINTPOSE
)
10277 printf (" SYMINTPOSE");
10278 val
^= DF_1_SYMINTPOSE
;
10280 if (val
& DF_1_GLOBAUDIT
)
10282 printf (" GLOBAUDIT");
10283 val
^= DF_1_GLOBAUDIT
;
10285 if (val
& DF_1_SINGLETON
)
10287 printf (" SINGLETON");
10288 val
^= DF_1_SINGLETON
;
10290 if (val
& DF_1_STUB
)
10295 if (val
& DF_1_PIE
)
10300 if (val
& DF_1_KMOD
)
10305 if (val
& DF_1_WEAKFILTER
)
10307 printf (" WEAKFILTER");
10308 val
^= DF_1_WEAKFILTER
;
10310 if (val
& DF_1_NOCOMMON
)
10312 printf (" NOCOMMON");
10313 val
^= DF_1_NOCOMMON
;
10316 printf (" %lx", val
);
10323 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10325 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10345 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10351 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10352 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10358 switch (entry
->d_tag
)
10361 printf (_("Shared library: [%s]"), name
);
10363 if (streq (name
, program_interpreter
))
10364 printf (_(" program interpreter"));
10368 printf (_("Library soname: [%s]"), name
);
10372 printf (_("Library rpath: [%s]"), name
);
10376 printf (_("Library runpath: [%s]"), name
);
10380 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10385 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10398 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10399 /* Fall through. */
10403 case DT_INIT_ARRAYSZ
:
10404 case DT_FINI_ARRAYSZ
:
10405 case DT_GNU_CONFLICTSZ
:
10406 case DT_GNU_LIBLISTSZ
:
10409 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10410 printf (_(" (bytes)\n"));
10415 case DT_VERNEEDNUM
:
10420 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10429 case DT_INIT_ARRAY
:
10430 case DT_FINI_ARRAY
:
10433 if (entry
->d_tag
== DT_USED
10434 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10436 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10440 printf (_("Not needed object: [%s]\n"), name
);
10445 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10451 /* The value of this entry is ignored. */
10456 case DT_GNU_PRELINKED
:
10460 time_t atime
= entry
->d_un
.d_val
;
10462 tmp
= gmtime (&atime
);
10463 /* PR 17533 file: 041-1244816-0.004. */
10465 printf (_("<corrupt time val: %lx"),
10466 (unsigned long) atime
);
10468 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10469 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10470 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10476 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10479 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10485 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10486 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10491 switch (filedata
->file_header
.e_machine
)
10494 dynamic_section_aarch64_val (entry
);
10497 case EM_MIPS_RS3_LE
:
10498 dynamic_section_mips_val (entry
);
10501 dynamic_section_parisc_val (entry
);
10504 dynamic_section_ia64_val (entry
);
10507 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10519 get_ver_flags (unsigned int flags
)
10521 static char buff
[128];
10528 if (flags
& VER_FLG_BASE
)
10529 strcat (buff
, "BASE");
10531 if (flags
& VER_FLG_WEAK
)
10533 if (flags
& VER_FLG_BASE
)
10534 strcat (buff
, " | ");
10536 strcat (buff
, "WEAK");
10539 if (flags
& VER_FLG_INFO
)
10541 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10542 strcat (buff
, " | ");
10544 strcat (buff
, "INFO");
10547 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10549 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10550 strcat (buff
, " | ");
10552 strcat (buff
, _("<unknown>"));
10558 /* Display the contents of the version sections. */
10561 process_version_sections (Filedata
* filedata
)
10563 Elf_Internal_Shdr
* section
;
10565 bfd_boolean found
= FALSE
;
10570 for (i
= 0, section
= filedata
->section_headers
;
10571 i
< filedata
->file_header
.e_shnum
;
10574 switch (section
->sh_type
)
10576 case SHT_GNU_verdef
:
10578 Elf_External_Verdef
* edefs
;
10585 printf (ngettext ("\nVersion definition section '%s' "
10586 "contains %u entry:\n",
10587 "\nVersion definition section '%s' "
10588 "contains %u entries:\n",
10590 printable_section_name (filedata
, section
),
10593 printf (_(" Addr: 0x"));
10594 printf_vma (section
->sh_addr
);
10595 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10596 (unsigned long) section
->sh_offset
, section
->sh_link
,
10597 printable_section_name_from_index (filedata
, section
->sh_link
));
10599 edefs
= (Elf_External_Verdef
*)
10600 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10601 _("version definition section"));
10604 endbuf
= (char *) edefs
+ section
->sh_size
;
10606 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10609 Elf_External_Verdef
* edef
;
10610 Elf_Internal_Verdef ent
;
10611 Elf_External_Verdaux
* eaux
;
10612 Elf_Internal_Verdaux aux
;
10613 unsigned long isum
;
10616 vstart
= ((char *) edefs
) + idx
;
10617 if (vstart
+ sizeof (*edef
) > endbuf
)
10620 edef
= (Elf_External_Verdef
*) vstart
;
10622 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10623 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10624 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10625 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10626 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10627 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10628 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10630 printf (_(" %#06lx: Rev: %d Flags: %s"),
10631 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10633 printf (_(" Index: %d Cnt: %d "),
10634 ent
.vd_ndx
, ent
.vd_cnt
);
10636 /* Check for overflow. */
10637 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10640 vstart
+= ent
.vd_aux
;
10642 if (vstart
+ sizeof (*eaux
) > endbuf
)
10644 eaux
= (Elf_External_Verdaux
*) vstart
;
10646 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10647 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10649 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10650 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10652 printf (_("Name index: %ld\n"), aux
.vda_name
);
10654 isum
= idx
+ ent
.vd_aux
;
10656 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10658 if (aux
.vda_next
< sizeof (*eaux
)
10659 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10661 warn (_("Invalid vda_next field of %lx\n"),
10666 /* Check for overflow. */
10667 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10670 isum
+= aux
.vda_next
;
10671 vstart
+= aux
.vda_next
;
10673 if (vstart
+ sizeof (*eaux
) > endbuf
)
10675 eaux
= (Elf_External_Verdaux
*) vstart
;
10677 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10678 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10680 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10681 printf (_(" %#06lx: Parent %d: %s\n"),
10682 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10684 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10685 isum
, j
, aux
.vda_name
);
10688 if (j
< ent
.vd_cnt
)
10689 printf (_(" Version def aux past end of section\n"));
10692 file: id:000001,src:000172+005151,op:splice,rep:2. */
10693 if (ent
.vd_next
< sizeof (*edef
)
10694 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10696 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10697 cnt
= section
->sh_info
;
10700 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10703 idx
+= ent
.vd_next
;
10706 if (cnt
< section
->sh_info
)
10707 printf (_(" Version definition past end of section\n"));
10713 case SHT_GNU_verneed
:
10715 Elf_External_Verneed
* eneed
;
10722 printf (ngettext ("\nVersion needs section '%s' "
10723 "contains %u entry:\n",
10724 "\nVersion needs section '%s' "
10725 "contains %u entries:\n",
10727 printable_section_name (filedata
, section
), section
->sh_info
);
10729 printf (_(" Addr: 0x"));
10730 printf_vma (section
->sh_addr
);
10731 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10732 (unsigned long) section
->sh_offset
, section
->sh_link
,
10733 printable_section_name_from_index (filedata
, section
->sh_link
));
10735 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10736 section
->sh_offset
, 1,
10738 _("Version Needs section"));
10741 endbuf
= (char *) eneed
+ section
->sh_size
;
10743 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10745 Elf_External_Verneed
* entry
;
10746 Elf_Internal_Verneed ent
;
10747 unsigned long isum
;
10751 vstart
= ((char *) eneed
) + idx
;
10752 if (vstart
+ sizeof (*entry
) > endbuf
)
10755 entry
= (Elf_External_Verneed
*) vstart
;
10757 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10758 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10759 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10760 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10761 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10763 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10765 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10766 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10768 printf (_(" File: %lx"), ent
.vn_file
);
10770 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10772 /* Check for overflow. */
10773 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10775 vstart
+= ent
.vn_aux
;
10777 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10779 Elf_External_Vernaux
* eaux
;
10780 Elf_Internal_Vernaux aux
;
10782 if (vstart
+ sizeof (*eaux
) > endbuf
)
10784 eaux
= (Elf_External_Vernaux
*) vstart
;
10786 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10787 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10788 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10789 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10790 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10792 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10793 printf (_(" %#06lx: Name: %s"),
10794 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10796 printf (_(" %#06lx: Name index: %lx"),
10797 isum
, aux
.vna_name
);
10799 printf (_(" Flags: %s Version: %d\n"),
10800 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10802 if (aux
.vna_next
< sizeof (*eaux
)
10803 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10805 warn (_("Invalid vna_next field of %lx\n"),
10810 /* Check for overflow. */
10811 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10813 isum
+= aux
.vna_next
;
10814 vstart
+= aux
.vna_next
;
10817 if (j
< ent
.vn_cnt
)
10818 warn (_("Missing Version Needs auxillary information\n"));
10820 if (ent
.vn_next
< sizeof (*entry
)
10821 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10823 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10824 cnt
= section
->sh_info
;
10827 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10829 idx
+= ent
.vn_next
;
10832 if (cnt
< section
->sh_info
)
10833 warn (_("Missing Version Needs information\n"));
10839 case SHT_GNU_versym
:
10841 Elf_Internal_Shdr
* link_section
;
10844 unsigned char * edata
;
10845 unsigned short * data
;
10847 Elf_Internal_Sym
* symbols
;
10848 Elf_Internal_Shdr
* string_sec
;
10849 unsigned long num_syms
;
10852 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10855 link_section
= filedata
->section_headers
+ section
->sh_link
;
10856 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10858 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10863 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10864 if (symbols
== NULL
)
10867 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10869 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10870 string_sec
->sh_size
,
10871 _("version string table"));
10878 printf (ngettext ("\nVersion symbols section '%s' "
10879 "contains %lu entry:\n",
10880 "\nVersion symbols section '%s' "
10881 "contains %lu entries:\n",
10883 printable_section_name (filedata
, section
), (unsigned long) total
);
10885 printf (_(" Addr: 0x"));
10886 printf_vma (section
->sh_addr
);
10887 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10888 (unsigned long) section
->sh_offset
, section
->sh_link
,
10889 printable_section_name (filedata
, link_section
));
10891 off
= offset_from_vma (filedata
,
10892 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10893 total
* sizeof (short));
10894 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10896 _("version symbol data"));
10904 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10906 for (cnt
= total
; cnt
--;)
10907 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10912 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10916 char *invalid
= _("*invalid*");
10918 printf (" %03x:", cnt
);
10920 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10921 switch (data
[cnt
+ j
])
10924 fputs (_(" 0 (*local*) "), stdout
);
10928 fputs (_(" 1 (*global*) "), stdout
);
10932 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10933 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10935 /* If this index value is greater than the size of the symbols
10936 array, break to avoid an out-of-bounds read. */
10937 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10939 warn (_("invalid index into symbol array\n"));
10944 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10946 Elf_Internal_Verneed ivn
;
10947 unsigned long offset
;
10949 offset
= offset_from_vma
10950 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10951 sizeof (Elf_External_Verneed
));
10955 Elf_Internal_Vernaux ivna
;
10956 Elf_External_Verneed evn
;
10957 Elf_External_Vernaux evna
;
10958 unsigned long a_off
;
10960 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10961 _("version need")) == NULL
)
10964 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10965 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10967 a_off
= offset
+ ivn
.vn_aux
;
10971 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10972 1, _("version need aux (2)")) == NULL
)
10975 ivna
.vna_other
= 0;
10979 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10980 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10983 a_off
+= ivna
.vna_next
;
10985 while (ivna
.vna_other
!= data
[cnt
+ j
]
10986 && ivna
.vna_next
!= 0);
10988 if (ivna
.vna_other
== data
[cnt
+ j
])
10990 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10992 if (ivna
.vna_name
>= string_sec
->sh_size
)
10995 name
= strtab
+ ivna
.vna_name
;
10999 offset
+= ivn
.vn_next
;
11001 while (ivn
.vn_next
);
11004 if (data
[cnt
+ j
] != 0x8001
11005 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11007 Elf_Internal_Verdef ivd
;
11008 Elf_External_Verdef evd
;
11009 unsigned long offset
;
11011 offset
= offset_from_vma
11012 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11017 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11018 _("version def")) == NULL
)
11021 /* PR 17531: file: 046-1082287-0.004. */
11022 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11027 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11028 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11031 offset
+= ivd
.vd_next
;
11033 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11034 && ivd
.vd_next
!= 0);
11036 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11038 Elf_External_Verdaux evda
;
11039 Elf_Internal_Verdaux ivda
;
11041 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11043 if (get_data (&evda
, filedata
,
11044 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11046 _("version def aux")) == NULL
)
11049 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11051 if (ivda
.vda_name
>= string_sec
->sh_size
)
11053 else if (name
!= NULL
&& name
!= invalid
)
11054 name
= _("*both*");
11056 name
= strtab
+ ivda
.vda_name
;
11060 nn
+= printf ("(%s%-*s",
11062 12 - (int) strlen (name
),
11066 printf ("%*c", 18 - nn
, ' ');
11084 printf (_("\nNo version information found in this file.\n"));
11089 static const char *
11090 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11092 static char buff
[32];
11096 case STB_LOCAL
: return "LOCAL";
11097 case STB_GLOBAL
: return "GLOBAL";
11098 case STB_WEAK
: return "WEAK";
11100 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11101 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11103 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11105 if (binding
== STB_GNU_UNIQUE
11106 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11108 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11111 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11116 static const char *
11117 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11119 static char buff
[32];
11123 case STT_NOTYPE
: return "NOTYPE";
11124 case STT_OBJECT
: return "OBJECT";
11125 case STT_FUNC
: return "FUNC";
11126 case STT_SECTION
: return "SECTION";
11127 case STT_FILE
: return "FILE";
11128 case STT_COMMON
: return "COMMON";
11129 case STT_TLS
: return "TLS";
11130 case STT_RELC
: return "RELC";
11131 case STT_SRELC
: return "SRELC";
11133 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11135 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11136 return "THUMB_FUNC";
11138 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11141 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11142 return "PARISC_MILLI";
11144 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11146 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11148 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11150 if (type
== STT_HP_OPAQUE
)
11151 return "HP_OPAQUE";
11152 if (type
== STT_HP_STUB
)
11156 if (type
== STT_GNU_IFUNC
11157 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11158 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11161 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11164 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11169 static const char *
11170 get_symbol_visibility (unsigned int visibility
)
11172 switch (visibility
)
11174 case STV_DEFAULT
: return "DEFAULT";
11175 case STV_INTERNAL
: return "INTERNAL";
11176 case STV_HIDDEN
: return "HIDDEN";
11177 case STV_PROTECTED
: return "PROTECTED";
11179 error (_("Unrecognized visibility value: %u"), visibility
);
11180 return _("<unknown>");
11184 static const char *
11185 get_alpha_symbol_other (unsigned int other
)
11189 case STO_ALPHA_NOPV
: return "NOPV";
11190 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11192 error (_("Unrecognized alpha specific other value: %u"), other
);
11193 return _("<unknown>");
11197 static const char *
11198 get_solaris_symbol_visibility (unsigned int visibility
)
11200 switch (visibility
)
11202 case 4: return "EXPORTED";
11203 case 5: return "SINGLETON";
11204 case 6: return "ELIMINATE";
11205 default: return get_symbol_visibility (visibility
);
11209 static const char *
11210 get_aarch64_symbol_other (unsigned int other
)
11212 static char buf
[32];
11214 if (other
& STO_AARCH64_VARIANT_PCS
)
11216 other
&= ~STO_AARCH64_VARIANT_PCS
;
11218 return "VARIANT_PCS";
11219 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11225 static const char *
11226 get_mips_symbol_other (unsigned int other
)
11230 case STO_OPTIONAL
: return "OPTIONAL";
11231 case STO_MIPS_PLT
: return "MIPS PLT";
11232 case STO_MIPS_PIC
: return "MIPS PIC";
11233 case STO_MICROMIPS
: return "MICROMIPS";
11234 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11235 case STO_MIPS16
: return "MIPS16";
11236 default: return NULL
;
11240 static const char *
11241 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11243 if (is_ia64_vms (filedata
))
11245 static char res
[32];
11249 /* Function types is for images and .STB files only. */
11250 switch (filedata
->file_header
.e_type
)
11254 switch (VMS_ST_FUNC_TYPE (other
))
11256 case VMS_SFT_CODE_ADDR
:
11257 strcat (res
, " CA");
11259 case VMS_SFT_SYMV_IDX
:
11260 strcat (res
, " VEC");
11263 strcat (res
, " FD");
11265 case VMS_SFT_RESERVE
:
11266 strcat (res
, " RSV");
11269 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11270 VMS_ST_FUNC_TYPE (other
));
11271 strcat (res
, " <unknown>");
11278 switch (VMS_ST_LINKAGE (other
))
11280 case VMS_STL_IGNORE
:
11281 strcat (res
, " IGN");
11283 case VMS_STL_RESERVE
:
11284 strcat (res
, " RSV");
11287 strcat (res
, " STD");
11290 strcat (res
, " LNK");
11293 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11294 VMS_ST_LINKAGE (other
));
11295 strcat (res
, " <unknown>");
11307 static const char *
11308 get_ppc64_symbol_other (unsigned int other
)
11310 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11313 other
>>= STO_PPC64_LOCAL_BIT
;
11316 static char buf
[32];
11318 other
= ppc64_decode_local_entry (other
);
11319 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11325 static const char *
11326 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11328 const char * result
= NULL
;
11329 static char buff
[32];
11334 switch (filedata
->file_header
.e_machine
)
11337 result
= get_alpha_symbol_other (other
);
11340 result
= get_aarch64_symbol_other (other
);
11343 result
= get_mips_symbol_other (other
);
11346 result
= get_ia64_symbol_other (filedata
, other
);
11349 result
= get_ppc64_symbol_other (other
);
11359 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11363 static const char *
11364 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11366 static char buff
[32];
11370 case SHN_UNDEF
: return "UND";
11371 case SHN_ABS
: return "ABS";
11372 case SHN_COMMON
: return "COM";
11374 if (type
== SHN_IA_64_ANSI_COMMON
11375 && filedata
->file_header
.e_machine
== EM_IA_64
11376 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11378 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11379 || filedata
->file_header
.e_machine
== EM_L1OM
11380 || filedata
->file_header
.e_machine
== EM_K1OM
)
11381 && type
== SHN_X86_64_LCOMMON
)
11382 return "LARGE_COM";
11383 else if ((type
== SHN_MIPS_SCOMMON
11384 && filedata
->file_header
.e_machine
== EM_MIPS
)
11385 || (type
== SHN_TIC6X_SCOMMON
11386 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11388 else if (type
== SHN_MIPS_SUNDEFINED
11389 && filedata
->file_header
.e_machine
== EM_MIPS
)
11391 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11392 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11393 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11394 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11395 else if (type
>= SHN_LORESERVE
)
11396 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11397 else if (type
>= filedata
->file_header
.e_shnum
)
11398 sprintf (buff
, _("bad section index[%3d]"), type
);
11400 sprintf (buff
, "%3d", type
);
11408 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11410 unsigned char * e_data
;
11413 /* If the size_t type is smaller than the bfd_size_type, eg because
11414 you are building a 32-bit tool on a 64-bit host, then make sure
11415 that when (number) is cast to (size_t) no information is lost. */
11416 if (sizeof (size_t) < sizeof (bfd_size_type
)
11417 && (bfd_size_type
) ((size_t) number
) != number
)
11419 error (_("Size truncation prevents reading %s elements of size %u\n"),
11420 bfd_vmatoa ("u", number
), ent_size
);
11424 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11425 attempting to allocate memory when the read is bound to fail. */
11426 if (ent_size
* number
> filedata
->file_size
)
11428 error (_("Invalid number of dynamic entries: %s\n"),
11429 bfd_vmatoa ("u", number
));
11433 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11434 if (e_data
== NULL
)
11436 error (_("Out of memory reading %s dynamic entries\n"),
11437 bfd_vmatoa ("u", number
));
11441 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11443 error (_("Unable to read in %s bytes of dynamic data\n"),
11444 bfd_vmatoa ("u", number
* ent_size
));
11449 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11450 if (i_data
== NULL
)
11452 error (_("Out of memory allocating space for %s dynamic entries\n"),
11453 bfd_vmatoa ("u", number
));
11459 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11467 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11469 Elf_Internal_Sym
* psym
;
11472 n
= print_vma (si
, DEC_5
);
11474 fputs (&" "[n
], stdout
);
11475 printf (" %3lu: ", hn
);
11477 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11479 printf (_("<No info available for dynamic symbol number %lu>\n"),
11480 (unsigned long) si
);
11484 psym
= dynamic_symbols
+ si
;
11485 print_vma (psym
->st_value
, LONG_HEX
);
11487 print_vma (psym
->st_size
, DEC_5
);
11489 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11490 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11492 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11493 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11496 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11498 printf (" %-7s", get_symbol_visibility (vis
));
11499 /* Check to see if any other bits in the st_other field are set.
11500 Note - displaying this information disrupts the layout of the
11501 table being generated, but for the moment this case is very
11503 if (psym
->st_other
^ vis
)
11504 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11507 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11508 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11509 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11511 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11515 static const char *
11516 get_symbol_version_string (Filedata
* filedata
,
11517 bfd_boolean is_dynsym
,
11518 const char * strtab
,
11519 unsigned long int strtab_size
,
11521 Elf_Internal_Sym
* psym
,
11522 enum versioned_symbol_info
* sym_info
,
11523 unsigned short * vna_other
)
11525 unsigned char data
[2];
11526 unsigned short vers_data
;
11527 unsigned long offset
;
11528 unsigned short max_vd_ndx
;
11531 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11534 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11535 sizeof data
+ si
* sizeof (vers_data
));
11537 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11538 sizeof (data
), 1, _("version data")) == NULL
)
11541 vers_data
= byte_get (data
, 2);
11543 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11546 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11549 /* Usually we'd only see verdef for defined symbols, and verneed for
11550 undefined symbols. However, symbols defined by the linker in
11551 .dynbss for variables copied from a shared library in order to
11552 avoid text relocations are defined yet have verneed. We could
11553 use a heuristic to detect the special case, for example, check
11554 for verneed first on symbols defined in SHT_NOBITS sections, but
11555 it is simpler and more reliable to just look for both verdef and
11556 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11558 if (psym
->st_shndx
!= SHN_UNDEF
11559 && vers_data
!= 0x8001
11560 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11562 Elf_Internal_Verdef ivd
;
11563 Elf_Internal_Verdaux ivda
;
11564 Elf_External_Verdaux evda
;
11567 off
= offset_from_vma (filedata
,
11568 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11569 sizeof (Elf_External_Verdef
));
11573 Elf_External_Verdef evd
;
11575 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11576 _("version def")) == NULL
)
11585 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11586 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11587 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11588 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11591 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11592 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11594 off
+= ivd
.vd_next
;
11596 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11598 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11600 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11603 off
-= ivd
.vd_next
;
11606 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11607 _("version def aux")) != NULL
)
11609 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11611 if (psym
->st_name
!= ivda
.vda_name
)
11612 return (ivda
.vda_name
< strtab_size
11613 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11618 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11620 Elf_External_Verneed evn
;
11621 Elf_Internal_Verneed ivn
;
11622 Elf_Internal_Vernaux ivna
;
11624 offset
= offset_from_vma (filedata
,
11625 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11629 unsigned long vna_off
;
11631 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11632 _("version need")) == NULL
)
11635 ivna
.vna_other
= 0;
11640 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11641 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11643 vna_off
= offset
+ ivn
.vn_aux
;
11647 Elf_External_Vernaux evna
;
11649 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11650 _("version need aux (3)")) == NULL
)
11653 ivna
.vna_other
= 0;
11658 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11659 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11660 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11663 vna_off
+= ivna
.vna_next
;
11665 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11667 if (ivna
.vna_other
== vers_data
)
11670 offset
+= ivn
.vn_next
;
11672 while (ivn
.vn_next
!= 0);
11674 if (ivna
.vna_other
== vers_data
)
11676 *sym_info
= symbol_undefined
;
11677 *vna_other
= ivna
.vna_other
;
11678 return (ivna
.vna_name
< strtab_size
11679 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11681 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11682 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11683 return _("<corrupt>");
11688 /* Dump the symbol table. */
11690 process_symbol_table (Filedata
* filedata
)
11692 Elf_Internal_Shdr
* section
;
11693 bfd_size_type nbuckets
= 0;
11694 bfd_size_type nchains
= 0;
11695 bfd_vma
* buckets
= NULL
;
11696 bfd_vma
* chains
= NULL
;
11697 bfd_vma ngnubuckets
= 0;
11698 bfd_vma
* gnubuckets
= NULL
;
11699 bfd_vma
* gnuchains
= NULL
;
11700 bfd_vma
* mipsxlat
= NULL
;
11701 bfd_vma gnusymidx
= 0;
11702 bfd_size_type ngnuchains
= 0;
11704 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11707 if (dynamic_info
[DT_HASH
]
11709 || (do_using_dynamic
11711 && dynamic_strings
!= NULL
)))
11713 unsigned char nb
[8];
11714 unsigned char nc
[8];
11715 unsigned int hash_ent_size
= 4;
11717 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11718 || filedata
->file_header
.e_machine
== EM_S390
11719 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11720 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11723 if (fseek (filedata
->handle
,
11724 (archive_file_offset
11725 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11726 sizeof nb
+ sizeof nc
)),
11729 error (_("Unable to seek to start of dynamic information\n"));
11733 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11735 error (_("Failed to read in number of buckets\n"));
11739 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11741 error (_("Failed to read in number of chains\n"));
11745 nbuckets
= byte_get (nb
, hash_ent_size
);
11746 nchains
= byte_get (nc
, hash_ent_size
);
11748 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11749 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11752 if (buckets
== NULL
|| chains
== NULL
)
11754 if (do_using_dynamic
)
11765 if (dynamic_info_DT_GNU_HASH
11767 || (do_using_dynamic
11769 && dynamic_strings
!= NULL
)))
11771 unsigned char nb
[16];
11772 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11773 bfd_vma buckets_vma
;
11775 if (fseek (filedata
->handle
,
11776 (archive_file_offset
11777 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11781 error (_("Unable to seek to start of dynamic information\n"));
11785 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11787 error (_("Failed to read in number of buckets\n"));
11791 ngnubuckets
= byte_get (nb
, 4);
11792 gnusymidx
= byte_get (nb
+ 4, 4);
11793 bitmaskwords
= byte_get (nb
+ 8, 4);
11794 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11796 buckets_vma
+= bitmaskwords
* 4;
11798 buckets_vma
+= bitmaskwords
* 8;
11800 if (fseek (filedata
->handle
,
11801 (archive_file_offset
11802 + offset_from_vma (filedata
, buckets_vma
, 4)),
11805 error (_("Unable to seek to start of dynamic information\n"));
11809 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11811 if (gnubuckets
== NULL
)
11814 for (i
= 0; i
< ngnubuckets
; i
++)
11815 if (gnubuckets
[i
] != 0)
11817 if (gnubuckets
[i
] < gnusymidx
)
11820 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11821 maxchain
= gnubuckets
[i
];
11824 if (maxchain
== 0xffffffff)
11827 maxchain
-= gnusymidx
;
11829 if (fseek (filedata
->handle
,
11830 (archive_file_offset
11831 + offset_from_vma (filedata
, buckets_vma
11832 + 4 * (ngnubuckets
+ maxchain
), 4)),
11835 error (_("Unable to seek to start of dynamic information\n"));
11841 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11843 error (_("Failed to determine last chain length\n"));
11847 if (maxchain
+ 1 == 0)
11852 while ((byte_get (nb
, 4) & 1) == 0);
11854 if (fseek (filedata
->handle
,
11855 (archive_file_offset
11856 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11859 error (_("Unable to seek to start of dynamic information\n"));
11863 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11864 ngnuchains
= maxchain
;
11866 if (gnuchains
== NULL
)
11869 if (dynamic_info_DT_MIPS_XHASH
)
11871 if (fseek (filedata
->handle
,
11872 (archive_file_offset
11873 + offset_from_vma (filedata
, (buckets_vma
11878 error (_("Unable to seek to start of dynamic information\n"));
11882 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11886 if (dynamic_info_DT_MIPS_XHASH
&& mipsxlat
== NULL
)
11891 if (gnuchains
== NULL
)
11896 if (do_using_dynamic
)
11901 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11903 && do_using_dynamic
11904 && dynamic_strings
!= NULL
11905 && dynamic_symbols
!= NULL
)
11909 if (dynamic_info
[DT_HASH
])
11914 printf (_("\nSymbol table for image:\n"));
11916 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11918 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11920 visited
= xcmalloc (nchains
, 1);
11921 memset (visited
, 0, nchains
);
11922 for (hn
= 0; hn
< nbuckets
; hn
++)
11924 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11926 print_dynamic_symbol (filedata
, si
, hn
);
11927 if (si
>= nchains
|| visited
[si
])
11929 error (_("histogram chain is corrupt\n"));
11938 if (dynamic_info_DT_GNU_HASH
)
11940 printf (_("\nSymbol table of `%s' for image:\n"),
11941 GNU_HASH_SECTION_NAME
);
11943 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11945 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11947 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11948 if (gnubuckets
[hn
] != 0)
11950 bfd_vma si
= gnubuckets
[hn
];
11951 bfd_vma off
= si
- gnusymidx
;
11955 if (dynamic_info_DT_MIPS_XHASH
)
11956 print_dynamic_symbol (filedata
, mipsxlat
[off
], hn
);
11958 print_dynamic_symbol (filedata
, si
, hn
);
11961 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11965 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11966 && filedata
->section_headers
!= NULL
)
11970 for (i
= 0, section
= filedata
->section_headers
;
11971 i
< filedata
->file_header
.e_shnum
;
11975 char * strtab
= NULL
;
11976 unsigned long int strtab_size
= 0;
11977 Elf_Internal_Sym
* symtab
;
11978 Elf_Internal_Sym
* psym
;
11979 unsigned long num_syms
;
11981 if ((section
->sh_type
!= SHT_SYMTAB
11982 && section
->sh_type
!= SHT_DYNSYM
)
11984 && section
->sh_type
== SHT_SYMTAB
))
11987 if (section
->sh_entsize
== 0)
11989 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11990 printable_section_name (filedata
, section
));
11994 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11995 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11996 "\nSymbol table '%s' contains %lu entries:\n",
11998 printable_section_name (filedata
, section
),
12002 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12004 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12006 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12007 if (symtab
== NULL
)
12010 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12012 strtab
= filedata
->string_table
;
12013 strtab_size
= filedata
->string_table_length
;
12015 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12017 Elf_Internal_Shdr
* string_sec
;
12019 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12021 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12022 1, string_sec
->sh_size
,
12023 _("string table"));
12024 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12027 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
12029 const char *version_string
;
12030 enum versioned_symbol_info sym_info
;
12031 unsigned short vna_other
;
12033 printf ("%6d: ", si
);
12034 print_vma (psym
->st_value
, LONG_HEX
);
12036 print_vma (psym
->st_size
, DEC_5
);
12037 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12038 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12039 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12040 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12043 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12045 printf (" %-7s", get_symbol_visibility (vis
));
12046 /* Check to see if any other bits in the st_other field are set.
12047 Note - displaying this information disrupts the layout of the
12048 table being generated, but for the moment this case is very rare. */
12049 if (psym
->st_other
^ vis
)
12050 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12052 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12053 print_symbol (25, psym
->st_name
< strtab_size
12054 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12057 = get_symbol_version_string (filedata
,
12058 section
->sh_type
== SHT_DYNSYM
,
12059 strtab
, strtab_size
, si
,
12060 psym
, &sym_info
, &vna_other
);
12061 if (version_string
)
12063 if (sym_info
== symbol_undefined
)
12064 printf ("@%s (%d)", version_string
, vna_other
);
12066 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12072 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12073 && si
>= section
->sh_info
12074 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12075 && filedata
->file_header
.e_machine
!= EM_MIPS
12076 /* Solaris binaries have been found to violate this requirement as
12077 well. Not sure if this is a bug or an ABI requirement. */
12078 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12079 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12080 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12084 if (strtab
!= filedata
->string_table
)
12090 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12092 if (do_histogram
&& buckets
!= NULL
)
12094 unsigned long * lengths
;
12095 unsigned long * counts
;
12098 unsigned long maxlength
= 0;
12099 unsigned long nzero_counts
= 0;
12100 unsigned long nsyms
= 0;
12103 printf (ngettext ("\nHistogram for bucket list length "
12104 "(total of %lu bucket):\n",
12105 "\nHistogram for bucket list length "
12106 "(total of %lu buckets):\n",
12107 (unsigned long) nbuckets
),
12108 (unsigned long) nbuckets
);
12110 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12111 if (lengths
== NULL
)
12113 error (_("Out of memory allocating space for histogram buckets\n"));
12116 visited
= xcmalloc (nchains
, 1);
12117 memset (visited
, 0, nchains
);
12119 printf (_(" Length Number %% of total Coverage\n"));
12120 for (hn
= 0; hn
< nbuckets
; ++hn
)
12122 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12125 if (maxlength
< ++lengths
[hn
])
12127 if (si
>= nchains
|| visited
[si
])
12129 error (_("histogram chain is corrupt\n"));
12137 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12138 if (counts
== NULL
)
12141 error (_("Out of memory allocating space for histogram counts\n"));
12145 for (hn
= 0; hn
< nbuckets
; ++hn
)
12146 ++counts
[lengths
[hn
]];
12151 printf (" 0 %-10lu (%5.1f%%)\n",
12152 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12153 for (i
= 1; i
<= maxlength
; ++i
)
12155 nzero_counts
+= counts
[i
] * i
;
12156 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12157 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12158 (nzero_counts
* 100.0) / nsyms
);
12166 if (buckets
!= NULL
)
12172 if (do_histogram
&& gnubuckets
!= NULL
)
12174 unsigned long * lengths
;
12175 unsigned long * counts
;
12177 unsigned long maxlength
= 0;
12178 unsigned long nzero_counts
= 0;
12179 unsigned long nsyms
= 0;
12181 printf (ngettext ("\nHistogram for `%s' bucket list length "
12182 "(total of %lu bucket):\n",
12183 "\nHistogram for `%s' bucket list length "
12184 "(total of %lu buckets):\n",
12185 (unsigned long) ngnubuckets
),
12186 GNU_HASH_SECTION_NAME
,
12187 (unsigned long) ngnubuckets
);
12189 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12190 if (lengths
== NULL
)
12192 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12196 printf (_(" Length Number %% of total Coverage\n"));
12198 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12199 if (gnubuckets
[hn
] != 0)
12201 bfd_vma off
, length
= 1;
12203 for (off
= gnubuckets
[hn
] - gnusymidx
;
12204 /* PR 17531 file: 010-77222-0.004. */
12205 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12208 lengths
[hn
] = length
;
12209 if (length
> maxlength
)
12210 maxlength
= length
;
12214 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12215 if (counts
== NULL
)
12218 error (_("Out of memory allocating space for gnu histogram counts\n"));
12222 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12223 ++counts
[lengths
[hn
]];
12225 if (ngnubuckets
> 0)
12228 printf (" 0 %-10lu (%5.1f%%)\n",
12229 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12230 for (j
= 1; j
<= maxlength
; ++j
)
12232 nzero_counts
+= counts
[j
] * j
;
12233 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12234 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12235 (nzero_counts
* 100.0) / nsyms
);
12250 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12254 if (dynamic_syminfo
== NULL
12256 /* No syminfo, this is ok. */
12259 /* There better should be a dynamic symbol section. */
12260 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12264 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12265 "contains %d entry:\n",
12266 "\nDynamic info segment at offset 0x%lx "
12267 "contains %d entries:\n",
12268 dynamic_syminfo_nent
),
12269 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12271 printf (_(" Num: Name BoundTo Flags\n"));
12272 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12274 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12276 printf ("%4d: ", i
);
12277 if (i
>= num_dynamic_syms
)
12278 printf (_("<corrupt index>"));
12279 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12280 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12282 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12285 switch (dynamic_syminfo
[i
].si_boundto
)
12287 case SYMINFO_BT_SELF
:
12288 fputs ("SELF ", stdout
);
12290 case SYMINFO_BT_PARENT
:
12291 fputs ("PARENT ", stdout
);
12294 if (dynamic_syminfo
[i
].si_boundto
> 0
12295 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12296 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12298 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12302 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12306 if (flags
& SYMINFO_FLG_DIRECT
)
12307 printf (" DIRECT");
12308 if (flags
& SYMINFO_FLG_PASSTHRU
)
12309 printf (" PASSTHRU");
12310 if (flags
& SYMINFO_FLG_COPY
)
12312 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12313 printf (" LAZYLOAD");
12321 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12322 is contained by the region START .. END. The types of ADDR, START
12323 and END should all be the same. Note both ADDR + NELEM and END
12324 point to just beyond the end of the regions that are being tested. */
12325 #define IN_RANGE(START,END,ADDR,NELEM) \
12326 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12328 /* Check to see if the given reloc needs to be handled in a target specific
12329 manner. If so then process the reloc and return TRUE otherwise return
12332 If called with reloc == NULL, then this is a signal that reloc processing
12333 for the current section has finished, and any saved state should be
12337 target_specific_reloc_handling (Filedata
* filedata
,
12338 Elf_Internal_Rela
* reloc
,
12339 unsigned char * start
,
12340 unsigned char * end
,
12341 Elf_Internal_Sym
* symtab
,
12342 unsigned long num_syms
)
12344 unsigned int reloc_type
= 0;
12345 unsigned long sym_index
= 0;
12349 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12350 sym_index
= get_reloc_symindex (reloc
->r_info
);
12353 switch (filedata
->file_header
.e_machine
)
12356 case EM_MSP430_OLD
:
12358 static Elf_Internal_Sym
* saved_sym
= NULL
;
12366 switch (reloc_type
)
12368 case 10: /* R_MSP430_SYM_DIFF */
12369 if (uses_msp430x_relocs (filedata
))
12371 /* Fall through. */
12372 case 21: /* R_MSP430X_SYM_DIFF */
12374 if (sym_index
>= num_syms
)
12375 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12378 saved_sym
= symtab
+ sym_index
;
12381 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12382 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12383 goto handle_sym_diff
;
12385 case 5: /* R_MSP430_16_BYTE */
12386 case 9: /* R_MSP430_8 */
12387 if (uses_msp430x_relocs (filedata
))
12389 goto handle_sym_diff
;
12391 case 2: /* R_MSP430_ABS16 */
12392 case 15: /* R_MSP430X_ABS16 */
12393 if (! uses_msp430x_relocs (filedata
))
12395 goto handle_sym_diff
;
12398 if (saved_sym
!= NULL
)
12400 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12403 if (sym_index
>= num_syms
)
12404 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12408 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12409 - saved_sym
->st_value
);
12411 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12412 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12415 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12416 (long) reloc
->r_offset
);
12425 if (saved_sym
!= NULL
)
12426 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12433 case EM_CYGNUS_MN10300
:
12435 static Elf_Internal_Sym
* saved_sym
= NULL
;
12443 switch (reloc_type
)
12445 case 34: /* R_MN10300_ALIGN */
12447 case 33: /* R_MN10300_SYM_DIFF */
12448 if (sym_index
>= num_syms
)
12449 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12452 saved_sym
= symtab
+ sym_index
;
12455 case 1: /* R_MN10300_32 */
12456 case 2: /* R_MN10300_16 */
12457 if (saved_sym
!= NULL
)
12459 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12462 if (sym_index
>= num_syms
)
12463 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12467 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12468 - saved_sym
->st_value
);
12470 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12471 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12473 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12474 (long) reloc
->r_offset
);
12482 if (saved_sym
!= NULL
)
12483 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12491 static bfd_vma saved_sym1
= 0;
12492 static bfd_vma saved_sym2
= 0;
12493 static bfd_vma value
;
12497 saved_sym1
= saved_sym2
= 0;
12501 switch (reloc_type
)
12503 case 0x80: /* R_RL78_SYM. */
12504 saved_sym1
= saved_sym2
;
12505 if (sym_index
>= num_syms
)
12506 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12510 saved_sym2
= symtab
[sym_index
].st_value
;
12511 saved_sym2
+= reloc
->r_addend
;
12515 case 0x83: /* R_RL78_OPsub. */
12516 value
= saved_sym1
- saved_sym2
;
12517 saved_sym2
= saved_sym1
= 0;
12521 case 0x41: /* R_RL78_ABS32. */
12522 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12523 byte_put (start
+ reloc
->r_offset
, value
, 4);
12525 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12526 (long) reloc
->r_offset
);
12530 case 0x43: /* R_RL78_ABS16. */
12531 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12532 byte_put (start
+ reloc
->r_offset
, value
, 2);
12534 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12535 (long) reloc
->r_offset
);
12549 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12550 DWARF debug sections. This is a target specific test. Note - we do not
12551 go through the whole including-target-headers-multiple-times route, (as
12552 we have already done with <elf/h8.h>) because this would become very
12553 messy and even then this function would have to contain target specific
12554 information (the names of the relocs instead of their numeric values).
12555 FIXME: This is not the correct way to solve this problem. The proper way
12556 is to have target specific reloc sizing and typing functions created by
12557 the reloc-macros.h header, in the same way that it already creates the
12558 reloc naming functions. */
12561 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12563 /* Please keep this table alpha-sorted for ease of visual lookup. */
12564 switch (filedata
->file_header
.e_machine
)
12568 return reloc_type
== 1; /* R_386_32. */
12570 return reloc_type
== 1; /* R_68K_32. */
12572 return reloc_type
== 1; /* R_860_32. */
12574 return reloc_type
== 2; /* R_960_32. */
12576 return (reloc_type
== 258
12577 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12579 return reloc_type
== 11; /* R_BPF_DATA_32 */
12580 case EM_ADAPTEVA_EPIPHANY
:
12581 return reloc_type
== 3;
12583 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12585 return reloc_type
== 1; /* R_ARC_32. */
12586 case EM_ARC_COMPACT
:
12587 case EM_ARC_COMPACT2
:
12588 return reloc_type
== 4; /* R_ARC_32. */
12590 return reloc_type
== 2; /* R_ARM_ABS32 */
12593 return reloc_type
== 1;
12595 return reloc_type
== 0x12; /* R_byte4_data. */
12597 return reloc_type
== 3; /* R_CRIS_32. */
12599 return reloc_type
== 3; /* R_CR16_NUM32. */
12601 return reloc_type
== 15; /* R_CRX_NUM32. */
12603 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12604 case EM_CYGNUS_FRV
:
12605 return reloc_type
== 1;
12606 case EM_CYGNUS_D10V
:
12608 return reloc_type
== 6; /* R_D10V_32. */
12609 case EM_CYGNUS_D30V
:
12611 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12613 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12614 case EM_CYGNUS_FR30
:
12616 return reloc_type
== 3; /* R_FR30_32. */
12618 return reloc_type
== 1; /* R_FT32_32. */
12622 return reloc_type
== 1; /* R_H8_DIR32. */
12624 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12625 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12626 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12627 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12630 return reloc_type
== 2; /* R_IP2K_32. */
12632 return reloc_type
== 2; /* R_IQ2000_32. */
12633 case EM_LATTICEMICO32
:
12634 return reloc_type
== 3; /* R_LM32_32. */
12637 return reloc_type
== 3; /* R_M32C_32. */
12639 return reloc_type
== 34; /* R_M32R_32_RELA. */
12642 return reloc_type
== 6; /* R_M68HC11_32. */
12644 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12645 reloc_type
== 6; /* R_S12Z_CW32. */
12647 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12648 case EM_CYGNUS_MEP
:
12649 return reloc_type
== 4; /* R_MEP_32. */
12651 return reloc_type
== 2; /* R_METAG_ADDR32. */
12652 case EM_MICROBLAZE
:
12653 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12655 return reloc_type
== 2; /* R_MIPS_32. */
12657 return reloc_type
== 4; /* R_MMIX_32. */
12658 case EM_CYGNUS_MN10200
:
12660 return reloc_type
== 1; /* R_MN10200_32. */
12661 case EM_CYGNUS_MN10300
:
12663 return reloc_type
== 1; /* R_MN10300_32. */
12665 return reloc_type
== 1; /* R_MOXIE_32. */
12666 case EM_MSP430_OLD
:
12668 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12670 return reloc_type
== 2; /* R_MT_32. */
12672 return reloc_type
== 20; /* R_NDS32_RELA. */
12673 case EM_ALTERA_NIOS2
:
12674 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12676 return reloc_type
== 1; /* R_NIOS_32. */
12678 return reloc_type
== 1; /* R_OR1K_32. */
12680 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12681 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12682 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12685 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12687 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12689 return reloc_type
== 1; /* R_PPC_ADDR32. */
12691 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12693 return reloc_type
== 1; /* R_RISCV_32. */
12695 return reloc_type
== 1; /* R_RL78_DIR32. */
12697 return reloc_type
== 1; /* R_RX_DIR32. */
12699 return reloc_type
== 1; /* R_I370_ADDR31. */
12702 return reloc_type
== 4; /* R_S390_32. */
12704 return reloc_type
== 8; /* R_SCORE_ABS32. */
12706 return reloc_type
== 1; /* R_SH_DIR32. */
12707 case EM_SPARC32PLUS
:
12710 return reloc_type
== 3 /* R_SPARC_32. */
12711 || reloc_type
== 23; /* R_SPARC_UA32. */
12713 return reloc_type
== 6; /* R_SPU_ADDR32 */
12715 return reloc_type
== 1; /* R_C6000_ABS32. */
12717 return reloc_type
== 2; /* R_TILEGX_32. */
12719 return reloc_type
== 1; /* R_TILEPRO_32. */
12720 case EM_CYGNUS_V850
:
12722 return reloc_type
== 6; /* R_V850_ABS32. */
12724 return reloc_type
== 0x33; /* R_V810_WORD. */
12726 return reloc_type
== 1; /* R_VAX_32. */
12728 return reloc_type
== 3; /* R_VISIUM_32. */
12729 case EM_WEBASSEMBLY
:
12730 return reloc_type
== 1; /* R_WASM32_32. */
12734 return reloc_type
== 10; /* R_X86_64_32. */
12737 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12739 return reloc_type
== 4; /* R_XGATE_32. */
12741 return reloc_type
== 1; /* R_XSTROMY16_32. */
12742 case EM_XTENSA_OLD
:
12744 return reloc_type
== 1; /* R_XTENSA_32. */
12746 return reloc_type
== 6; /* R_Z80_32. */
12749 static unsigned int prev_warn
= 0;
12751 /* Avoid repeating the same warning multiple times. */
12752 if (prev_warn
!= filedata
->file_header
.e_machine
)
12753 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12754 filedata
->file_header
.e_machine
);
12755 prev_warn
= filedata
->file_header
.e_machine
;
12761 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12762 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12765 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12767 switch (filedata
->file_header
.e_machine
)
12768 /* Please keep this table alpha-sorted for ease of visual lookup. */
12772 return reloc_type
== 2; /* R_386_PC32. */
12774 return reloc_type
== 4; /* R_68K_PC32. */
12776 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12777 case EM_ADAPTEVA_EPIPHANY
:
12778 return reloc_type
== 6;
12780 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12781 case EM_ARC_COMPACT
:
12782 case EM_ARC_COMPACT2
:
12783 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12785 return reloc_type
== 3; /* R_ARM_REL32 */
12788 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12789 case EM_MICROBLAZE
:
12790 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12792 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12794 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12796 return reloc_type
== 26; /* R_PPC_REL32. */
12798 return reloc_type
== 26; /* R_PPC64_REL32. */
12800 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12803 return reloc_type
== 5; /* R_390_PC32. */
12805 return reloc_type
== 2; /* R_SH_REL32. */
12806 case EM_SPARC32PLUS
:
12809 return reloc_type
== 6; /* R_SPARC_DISP32. */
12811 return reloc_type
== 13; /* R_SPU_REL32. */
12813 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12815 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12817 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12821 return reloc_type
== 2; /* R_X86_64_PC32. */
12823 return reloc_type
== 4; /* R_VAX_PCREL32. */
12824 case EM_XTENSA_OLD
:
12826 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12828 /* Do not abort or issue an error message here. Not all targets use
12829 pc-relative 32-bit relocs in their DWARF debug information and we
12830 have already tested for target coverage in is_32bit_abs_reloc. A
12831 more helpful warning message will be generated by apply_relocations
12832 anyway, so just return. */
12837 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12838 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12841 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12843 switch (filedata
->file_header
.e_machine
)
12846 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12848 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12850 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12851 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12853 return reloc_type
== 80; /* R_PARISC_DIR64. */
12855 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12857 return reloc_type
== 2; /* R_RISCV_64. */
12858 case EM_SPARC32PLUS
:
12861 return reloc_type
== 32 /* R_SPARC_64. */
12862 || reloc_type
== 54; /* R_SPARC_UA64. */
12866 return reloc_type
== 1; /* R_X86_64_64. */
12869 return reloc_type
== 22; /* R_S390_64. */
12871 return reloc_type
== 1; /* R_TILEGX_64. */
12873 return reloc_type
== 18; /* R_MIPS_64. */
12879 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12880 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12883 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12885 switch (filedata
->file_header
.e_machine
)
12888 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12890 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12892 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12893 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12895 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12897 return reloc_type
== 44; /* R_PPC64_REL64. */
12898 case EM_SPARC32PLUS
:
12901 return reloc_type
== 46; /* R_SPARC_DISP64. */
12905 return reloc_type
== 24; /* R_X86_64_PC64. */
12908 return reloc_type
== 23; /* R_S390_PC64. */
12910 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12916 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12917 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12920 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12922 switch (filedata
->file_header
.e_machine
)
12924 case EM_CYGNUS_MN10200
:
12926 return reloc_type
== 4; /* R_MN10200_24. */
12928 return reloc_type
== 5; /* R_FT32_20. */
12930 return reloc_type
== 5; /* R_Z80_24. */
12936 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12937 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12940 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12942 /* Please keep this table alpha-sorted for ease of visual lookup. */
12943 switch (filedata
->file_header
.e_machine
)
12946 case EM_ARC_COMPACT
:
12947 case EM_ARC_COMPACT2
:
12948 return reloc_type
== 2; /* R_ARC_16. */
12949 case EM_ADAPTEVA_EPIPHANY
:
12950 return reloc_type
== 5;
12953 return reloc_type
== 4; /* R_AVR_16. */
12954 case EM_CYGNUS_D10V
:
12956 return reloc_type
== 3; /* R_D10V_16. */
12958 return reloc_type
== 2; /* R_FT32_16. */
12962 return reloc_type
== R_H8_DIR16
;
12965 return reloc_type
== 1; /* R_IP2K_16. */
12968 return reloc_type
== 1; /* R_M32C_16 */
12969 case EM_CYGNUS_MN10200
:
12971 return reloc_type
== 2; /* R_MN10200_16. */
12972 case EM_CYGNUS_MN10300
:
12974 return reloc_type
== 2; /* R_MN10300_16. */
12976 if (uses_msp430x_relocs (filedata
))
12977 return reloc_type
== 2; /* R_MSP430_ABS16. */
12978 /* Fall through. */
12979 case EM_MSP430_OLD
:
12980 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12982 return reloc_type
== 19; /* R_NDS32_RELA. */
12983 case EM_ALTERA_NIOS2
:
12984 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12986 return reloc_type
== 9; /* R_NIOS_16. */
12988 return reloc_type
== 2; /* R_OR1K_16. */
12990 return reloc_type
== 55; /* R_RISCV_SET16. */
12992 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12994 return reloc_type
== 2; /* R_C6000_ABS16. */
12996 return reloc_type
== 2; /* R_VISIUM_16. */
12999 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13001 return reloc_type
== 3; /* R_XGATE_16. */
13003 return reloc_type
== 4; /* R_Z80_16. */
13009 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13010 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13013 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13015 switch (filedata
->file_header
.e_machine
)
13018 return reloc_type
== 54; /* R_RISCV_SET8. */
13020 return reloc_type
== 1; /* R_Z80_8. */
13026 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13027 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13030 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13032 switch (filedata
->file_header
.e_machine
)
13035 return reloc_type
== 53; /* R_RISCV_SET6. */
13041 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13042 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13045 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13047 /* Please keep this table alpha-sorted for ease of visual lookup. */
13048 switch (filedata
->file_header
.e_machine
)
13051 return reloc_type
== 35; /* R_RISCV_ADD32. */
13057 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13058 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13061 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13063 /* Please keep this table alpha-sorted for ease of visual lookup. */
13064 switch (filedata
->file_header
.e_machine
)
13067 return reloc_type
== 39; /* R_RISCV_SUB32. */
13073 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13074 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13077 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13079 /* Please keep this table alpha-sorted for ease of visual lookup. */
13080 switch (filedata
->file_header
.e_machine
)
13083 return reloc_type
== 36; /* R_RISCV_ADD64. */
13089 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13090 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13093 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13095 /* Please keep this table alpha-sorted for ease of visual lookup. */
13096 switch (filedata
->file_header
.e_machine
)
13099 return reloc_type
== 40; /* R_RISCV_SUB64. */
13105 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13106 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13109 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13111 /* Please keep this table alpha-sorted for ease of visual lookup. */
13112 switch (filedata
->file_header
.e_machine
)
13115 return reloc_type
== 34; /* R_RISCV_ADD16. */
13121 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13122 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13125 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13127 /* Please keep this table alpha-sorted for ease of visual lookup. */
13128 switch (filedata
->file_header
.e_machine
)
13131 return reloc_type
== 38; /* R_RISCV_SUB16. */
13137 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13138 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13141 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13143 /* Please keep this table alpha-sorted for ease of visual lookup. */
13144 switch (filedata
->file_header
.e_machine
)
13147 return reloc_type
== 33; /* R_RISCV_ADD8. */
13153 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13154 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13157 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13159 /* Please keep this table alpha-sorted for ease of visual lookup. */
13160 switch (filedata
->file_header
.e_machine
)
13163 return reloc_type
== 37; /* R_RISCV_SUB8. */
13169 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13170 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13173 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13175 switch (filedata
->file_header
.e_machine
)
13178 return reloc_type
== 52; /* R_RISCV_SUB6. */
13184 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13185 relocation entries (possibly formerly used for SHT_GROUP sections). */
13188 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13190 switch (filedata
->file_header
.e_machine
)
13192 case EM_386
: /* R_386_NONE. */
13193 case EM_68K
: /* R_68K_NONE. */
13194 case EM_ADAPTEVA_EPIPHANY
:
13195 case EM_ALPHA
: /* R_ALPHA_NONE. */
13196 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13197 case EM_ARC
: /* R_ARC_NONE. */
13198 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13199 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13200 case EM_ARM
: /* R_ARM_NONE. */
13201 case EM_C166
: /* R_XC16X_NONE. */
13202 case EM_CRIS
: /* R_CRIS_NONE. */
13203 case EM_FT32
: /* R_FT32_NONE. */
13204 case EM_IA_64
: /* R_IA64_NONE. */
13205 case EM_K1OM
: /* R_X86_64_NONE. */
13206 case EM_L1OM
: /* R_X86_64_NONE. */
13207 case EM_M32R
: /* R_M32R_NONE. */
13208 case EM_MIPS
: /* R_MIPS_NONE. */
13209 case EM_MN10300
: /* R_MN10300_NONE. */
13210 case EM_MOXIE
: /* R_MOXIE_NONE. */
13211 case EM_NIOS32
: /* R_NIOS_NONE. */
13212 case EM_OR1K
: /* R_OR1K_NONE. */
13213 case EM_PARISC
: /* R_PARISC_NONE. */
13214 case EM_PPC64
: /* R_PPC64_NONE. */
13215 case EM_PPC
: /* R_PPC_NONE. */
13216 case EM_RISCV
: /* R_RISCV_NONE. */
13217 case EM_S390
: /* R_390_NONE. */
13219 case EM_SH
: /* R_SH_NONE. */
13220 case EM_SPARC32PLUS
:
13221 case EM_SPARC
: /* R_SPARC_NONE. */
13223 case EM_TILEGX
: /* R_TILEGX_NONE. */
13224 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13225 case EM_TI_C6000
:/* R_C6000_NONE. */
13226 case EM_X86_64
: /* R_X86_64_NONE. */
13228 case EM_Z80
: /* R_Z80_NONE. */
13229 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13230 return reloc_type
== 0;
13233 return reloc_type
== 0 || reloc_type
== 256;
13236 return (reloc_type
== 0 /* R_AVR_NONE. */
13237 || reloc_type
== 30 /* R_AVR_DIFF8. */
13238 || reloc_type
== 31 /* R_AVR_DIFF16. */
13239 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13241 return reloc_type
== 3; /* R_METAG_NONE. */
13243 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13244 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13245 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13246 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13247 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13249 return (reloc_type
== 0 /* R_PRU_NONE. */
13250 || reloc_type
== 65 /* R_PRU_DIFF8. */
13251 || reloc_type
== 66 /* R_PRU_DIFF16. */
13252 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13253 case EM_XTENSA_OLD
:
13255 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13256 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13257 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13258 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13263 /* Returns TRUE if there is a relocation against
13264 section NAME at OFFSET bytes. */
13267 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13269 Elf_Internal_Rela
* relocs
;
13270 Elf_Internal_Rela
* rp
;
13272 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13275 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13277 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13278 if (rp
->r_offset
== offset
)
13284 /* Apply relocations to a section.
13285 Returns TRUE upon success, FALSE otherwise.
13286 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13287 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13288 will be set to the number of relocs loaded.
13290 Note: So far support has been added only for those relocations
13291 which can be found in debug sections. FIXME: Add support for
13292 more relocations ? */
13295 apply_relocations (Filedata
* filedata
,
13296 const Elf_Internal_Shdr
* section
,
13297 unsigned char * start
,
13298 bfd_size_type size
,
13299 void ** relocs_return
,
13300 unsigned long * num_relocs_return
)
13302 Elf_Internal_Shdr
* relsec
;
13303 unsigned char * end
= start
+ size
;
13305 if (relocs_return
!= NULL
)
13307 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13308 * num_relocs_return
= 0;
13311 if (filedata
->file_header
.e_type
!= ET_REL
)
13312 /* No relocs to apply. */
13315 /* Find the reloc section associated with the section. */
13316 for (relsec
= filedata
->section_headers
;
13317 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13320 bfd_boolean is_rela
;
13321 unsigned long num_relocs
;
13322 Elf_Internal_Rela
* relocs
;
13323 Elf_Internal_Rela
* rp
;
13324 Elf_Internal_Shdr
* symsec
;
13325 Elf_Internal_Sym
* symtab
;
13326 unsigned long num_syms
;
13327 Elf_Internal_Sym
* sym
;
13329 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13330 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13331 || filedata
->section_headers
+ relsec
->sh_info
!= section
13332 || relsec
->sh_size
== 0
13333 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13336 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13337 if (symsec
->sh_type
!= SHT_SYMTAB
13338 && symsec
->sh_type
!= SHT_DYNSYM
)
13341 is_rela
= relsec
->sh_type
== SHT_RELA
;
13345 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13346 relsec
->sh_size
, & relocs
, & num_relocs
))
13351 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13352 relsec
->sh_size
, & relocs
, & num_relocs
))
13356 /* SH uses RELA but uses in place value instead of the addend field. */
13357 if (filedata
->file_header
.e_machine
== EM_SH
)
13360 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13362 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13365 unsigned int reloc_type
;
13366 unsigned int reloc_size
;
13367 bfd_boolean reloc_inplace
= FALSE
;
13368 bfd_boolean reloc_subtract
= FALSE
;
13369 unsigned char * rloc
;
13370 unsigned long sym_index
;
13372 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13374 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13376 else if (is_none_reloc (filedata
, reloc_type
))
13378 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13379 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13381 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13382 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13384 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13386 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13388 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13389 || is_6bit_abs_reloc (filedata
, reloc_type
))
13391 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13393 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13396 reloc_inplace
= TRUE
;
13398 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13400 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13403 reloc_inplace
= TRUE
;
13405 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13407 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13410 reloc_inplace
= TRUE
;
13412 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13414 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13417 reloc_inplace
= TRUE
;
13419 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13423 reloc_inplace
= TRUE
;
13427 static unsigned int prev_reloc
= 0;
13429 if (reloc_type
!= prev_reloc
)
13430 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13431 reloc_type
, printable_section_name (filedata
, section
));
13432 prev_reloc
= reloc_type
;
13436 rloc
= start
+ rp
->r_offset
;
13437 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13439 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13440 (unsigned long) rp
->r_offset
,
13441 printable_section_name (filedata
, section
));
13445 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13446 if (sym_index
>= num_syms
)
13448 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13449 sym_index
, printable_section_name (filedata
, section
));
13452 sym
= symtab
+ sym_index
;
13454 /* If the reloc has a symbol associated with it,
13455 make sure that it is of an appropriate type.
13457 Relocations against symbols without type can happen.
13458 Gcc -feliminate-dwarf2-dups may generate symbols
13459 without type for debug info.
13461 Icc generates relocations against function symbols
13462 instead of local labels.
13464 Relocations against object symbols can happen, eg when
13465 referencing a global array. For an example of this see
13466 the _clz.o binary in libgcc.a. */
13468 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13469 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13471 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13472 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13473 printable_section_name (filedata
, relsec
),
13474 (long int)(rp
- relocs
));
13480 addend
+= rp
->r_addend
;
13481 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13482 partial_inplace. */
13484 || (filedata
->file_header
.e_machine
== EM_XTENSA
13485 && reloc_type
== 1)
13486 || ((filedata
->file_header
.e_machine
== EM_PJ
13487 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13488 && reloc_type
== 1)
13489 || ((filedata
->file_header
.e_machine
== EM_D30V
13490 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13491 && reloc_type
== 12)
13494 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13495 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13497 addend
+= byte_get (rloc
, reloc_size
);
13500 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13501 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13503 /* On HPPA, all pc-relative relocations are biased by 8. */
13504 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13506 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13509 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13510 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13512 if (reloc_subtract
)
13513 addend
-= sym
->st_value
;
13515 addend
+= sym
->st_value
;
13516 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13517 byte_put (rloc
, addend
, reloc_size
);
13519 else if (reloc_subtract
)
13520 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13522 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13526 /* Let the target specific reloc processing code know that
13527 we have finished with these relocs. */
13528 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13532 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13533 * num_relocs_return
= num_relocs
;
13544 #ifdef SUPPORT_DISASSEMBLY
13546 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13548 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13550 /* FIXME: XXX -- to be done --- XXX */
13556 /* Reads in the contents of SECTION from FILE, returning a pointer
13557 to a malloc'ed buffer or NULL if something went wrong. */
13560 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13562 bfd_size_type num_bytes
= section
->sh_size
;
13564 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13566 printf (_("Section '%s' has no data to dump.\n"),
13567 printable_section_name (filedata
, section
));
13571 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13572 _("section contents"));
13575 /* Uncompresses a section that was compressed using zlib, in place. */
13578 uncompress_section_contents (unsigned char ** buffer
,
13579 dwarf_size_type uncompressed_size
,
13580 dwarf_size_type
* size
)
13582 dwarf_size_type compressed_size
= *size
;
13583 unsigned char * compressed_buffer
= *buffer
;
13584 unsigned char * uncompressed_buffer
;
13588 /* It is possible the section consists of several compressed
13589 buffers concatenated together, so we uncompress in a loop. */
13590 /* PR 18313: The state field in the z_stream structure is supposed
13591 to be invisible to the user (ie us), but some compilers will
13592 still complain about it being used without initialisation. So
13593 we first zero the entire z_stream structure and then set the fields
13595 memset (& strm
, 0, sizeof strm
);
13596 strm
.avail_in
= compressed_size
;
13597 strm
.next_in
= (Bytef
*) compressed_buffer
;
13598 strm
.avail_out
= uncompressed_size
;
13599 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13601 rc
= inflateInit (& strm
);
13602 while (strm
.avail_in
> 0)
13606 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13607 + (uncompressed_size
- strm
.avail_out
));
13608 rc
= inflate (&strm
, Z_FINISH
);
13609 if (rc
!= Z_STREAM_END
)
13611 rc
= inflateReset (& strm
);
13613 rc
= inflateEnd (& strm
);
13615 || strm
.avail_out
!= 0)
13618 *buffer
= uncompressed_buffer
;
13619 *size
= uncompressed_size
;
13623 free (uncompressed_buffer
);
13624 /* Indicate decompression failure. */
13630 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13632 Elf_Internal_Shdr
* relsec
;
13633 bfd_size_type num_bytes
;
13634 unsigned char * data
;
13635 unsigned char * end
;
13636 unsigned char * real_start
;
13637 unsigned char * start
;
13638 bfd_boolean some_strings_shown
;
13640 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13642 /* PR 21820: Do not fail if the section was empty. */
13643 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13645 num_bytes
= section
->sh_size
;
13647 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13649 if (decompress_dumps
)
13651 dwarf_size_type new_size
= num_bytes
;
13652 dwarf_size_type uncompressed_size
= 0;
13654 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13656 Elf_Internal_Chdr chdr
;
13657 unsigned int compression_header_size
13658 = get_compression_header (& chdr
, (unsigned char *) start
,
13661 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13663 warn (_("section '%s' has unsupported compress type: %d\n"),
13664 printable_section_name (filedata
, section
), chdr
.ch_type
);
13667 uncompressed_size
= chdr
.ch_size
;
13668 start
+= compression_header_size
;
13669 new_size
-= compression_header_size
;
13671 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13673 /* Read the zlib header. In this case, it should be "ZLIB"
13674 followed by the uncompressed section size, 8 bytes in
13675 big-endian order. */
13676 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13677 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13678 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13679 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13680 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13681 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13682 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13683 uncompressed_size
+= start
[11];
13688 if (uncompressed_size
)
13690 if (uncompress_section_contents (& start
,
13691 uncompressed_size
, & new_size
))
13692 num_bytes
= new_size
;
13695 error (_("Unable to decompress section %s\n"),
13696 printable_section_name (filedata
, section
));
13701 start
= real_start
;
13704 /* If the section being dumped has relocations against it the user might
13705 be expecting these relocations to have been applied. Check for this
13706 case and issue a warning message in order to avoid confusion.
13707 FIXME: Maybe we ought to have an option that dumps a section with
13708 relocs applied ? */
13709 for (relsec
= filedata
->section_headers
;
13710 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13713 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13714 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13715 || filedata
->section_headers
+ relsec
->sh_info
!= section
13716 || relsec
->sh_size
== 0
13717 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13720 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13725 end
= start
+ num_bytes
;
13726 some_strings_shown
= FALSE
;
13730 while (!ISPRINT (* data
))
13731 if (++ data
>= end
)
13736 size_t maxlen
= end
- data
;
13739 /* PR 11128: Use two separate invocations in order to work
13740 around bugs in the Solaris 8 implementation of printf. */
13741 printf (" [%6tx] ", data
- start
);
13743 printf (" [%6Ix] ", (size_t) (data
- start
));
13747 print_symbol ((int) maxlen
, (const char *) data
);
13749 data
+= strnlen ((const char *) data
, maxlen
);
13753 printf (_("<corrupt>\n"));
13756 some_strings_shown
= TRUE
;
13760 if (! some_strings_shown
)
13761 printf (_(" No strings found in this section."));
13770 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13771 Filedata
* filedata
,
13772 bfd_boolean relocate
)
13774 Elf_Internal_Shdr
* relsec
;
13775 bfd_size_type bytes
;
13776 bfd_size_type section_size
;
13778 unsigned char * data
;
13779 unsigned char * real_start
;
13780 unsigned char * start
;
13782 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13784 /* PR 21820: Do not fail if the section was empty. */
13785 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13787 section_size
= section
->sh_size
;
13789 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13791 if (decompress_dumps
)
13793 dwarf_size_type new_size
= section_size
;
13794 dwarf_size_type uncompressed_size
= 0;
13796 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13798 Elf_Internal_Chdr chdr
;
13799 unsigned int compression_header_size
13800 = get_compression_header (& chdr
, start
, section_size
);
13802 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13804 warn (_("section '%s' has unsupported compress type: %d\n"),
13805 printable_section_name (filedata
, section
), chdr
.ch_type
);
13808 uncompressed_size
= chdr
.ch_size
;
13809 start
+= compression_header_size
;
13810 new_size
-= compression_header_size
;
13812 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13814 /* Read the zlib header. In this case, it should be "ZLIB"
13815 followed by the uncompressed section size, 8 bytes in
13816 big-endian order. */
13817 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13818 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13819 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13820 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13821 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13822 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13823 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13824 uncompressed_size
+= start
[11];
13829 if (uncompressed_size
)
13831 if (uncompress_section_contents (& start
, uncompressed_size
,
13834 section_size
= new_size
;
13838 error (_("Unable to decompress section %s\n"),
13839 printable_section_name (filedata
, section
));
13840 /* FIXME: Print the section anyway ? */
13845 start
= real_start
;
13850 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13855 /* If the section being dumped has relocations against it the user might
13856 be expecting these relocations to have been applied. Check for this
13857 case and issue a warning message in order to avoid confusion.
13858 FIXME: Maybe we ought to have an option that dumps a section with
13859 relocs applied ? */
13860 for (relsec
= filedata
->section_headers
;
13861 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13864 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13865 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13866 || filedata
->section_headers
+ relsec
->sh_info
!= section
13867 || relsec
->sh_size
== 0
13868 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13871 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13876 addr
= section
->sh_addr
;
13877 bytes
= section_size
;
13886 lbytes
= (bytes
> 16 ? 16 : bytes
);
13888 printf (" 0x%8.8lx ", (unsigned long) addr
);
13890 for (j
= 0; j
< 16; j
++)
13893 printf ("%2.2x", data
[j
]);
13901 for (j
= 0; j
< lbytes
; j
++)
13904 if (k
>= ' ' && k
< 0x7f)
13923 static ctf_sect_t
*
13924 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
13926 buf
->cts_name
= SECTION_NAME (shdr
);
13927 buf
->cts_size
= shdr
->sh_size
;
13928 buf
->cts_entsize
= shdr
->sh_entsize
;
13933 /* Formatting callback function passed to ctf_dump. Returns either the pointer
13934 it is passed, or a pointer to newly-allocated storage, in which case
13935 dump_ctf() will free it when it no longer needs it. */
13937 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
13938 char *s
, void *arg
)
13940 const char *blanks
= arg
;
13943 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
13949 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13951 Elf_Internal_Shdr
* parent_sec
= NULL
;
13952 Elf_Internal_Shdr
* symtab_sec
= NULL
;
13953 Elf_Internal_Shdr
* strtab_sec
= NULL
;
13954 void * data
= NULL
;
13955 void * symdata
= NULL
;
13956 void * strdata
= NULL
;
13957 void * parentdata
= NULL
;
13958 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
13959 ctf_sect_t
* symsectp
= NULL
;
13960 ctf_sect_t
* strsectp
= NULL
;
13961 ctf_file_t
* ctf
= NULL
;
13962 ctf_file_t
* parent
= NULL
;
13964 const char *things
[] = {"Header", "Labels", "Data objects",
13965 "Function objects", "Variables", "Types", "Strings",
13967 const char **thing
;
13969 bfd_boolean ret
= FALSE
;
13972 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
13973 data
= get_section_contents (section
, filedata
);
13974 ctfsect
.cts_data
= data
;
13976 if (!dump_ctf_symtab_name
)
13977 dump_ctf_symtab_name
= strdup (".symtab");
13979 if (!dump_ctf_strtab_name
)
13980 dump_ctf_strtab_name
= strdup (".strtab");
13982 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
13984 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
13986 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
13989 if ((symdata
= (void *) get_data (NULL
, filedata
,
13990 symtab_sec
->sh_offset
, 1,
13991 symtab_sec
->sh_size
,
13992 _("symbols"))) == NULL
)
13994 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
13995 symsect
.cts_data
= symdata
;
13997 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
13999 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14001 error (_("No string table section named %s\n"),
14002 dump_ctf_strtab_name
);
14005 if ((strdata
= (void *) get_data (NULL
, filedata
,
14006 strtab_sec
->sh_offset
, 1,
14007 strtab_sec
->sh_size
,
14008 _("strings"))) == NULL
)
14010 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14011 strsect
.cts_data
= strdata
;
14013 if (dump_ctf_parent_name
)
14015 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14017 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14020 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14021 parent_sec
->sh_offset
, 1,
14022 parent_sec
->sh_size
,
14023 _("CTF parent"))) == NULL
)
14025 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14026 parentsect
.cts_data
= parentdata
;
14029 /* Load the CTF file and dump it. */
14031 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14033 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14039 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14041 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14045 ctf_import (ctf
, parent
);
14050 printf (_("\nDump of CTF section '%s':\n"),
14051 printable_section_name (filedata
, section
));
14053 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14055 ctf_dump_state_t
*s
= NULL
;
14058 printf ("\n %s:\n", *thing
);
14059 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14060 (void *) " ")) != NULL
)
14062 printf ("%s\n", item
);
14066 if (ctf_errno (ctf
))
14068 error (_("Iteration failed: %s, %s\n"), *thing
,
14069 ctf_errmsg (ctf_errno (ctf
)));
14075 ctf_file_close (ctf
);
14076 ctf_file_close (parent
);
14085 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14086 const Elf_Internal_Shdr
* sec
,
14089 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14091 Filedata
* filedata
= (Filedata
*) data
;
14093 if (section
->start
!= NULL
)
14095 /* If it is already loaded, do nothing. */
14096 if (streq (section
->filename
, filedata
->file_name
))
14098 free (section
->start
);
14101 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14102 section
->address
= sec
->sh_addr
;
14103 section
->user_data
= NULL
;
14104 section
->filename
= filedata
->file_name
;
14105 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14107 sec
->sh_size
, buf
);
14108 if (section
->start
== NULL
)
14112 unsigned char *start
= section
->start
;
14113 dwarf_size_type size
= sec
->sh_size
;
14114 dwarf_size_type uncompressed_size
= 0;
14116 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14118 Elf_Internal_Chdr chdr
;
14119 unsigned int compression_header_size
;
14121 if (size
< (is_32bit_elf
14122 ? sizeof (Elf32_External_Chdr
)
14123 : sizeof (Elf64_External_Chdr
)))
14125 warn (_("compressed section %s is too small to contain a compression header"),
14130 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14132 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14134 warn (_("section '%s' has unsupported compress type: %d\n"),
14135 section
->name
, chdr
.ch_type
);
14138 uncompressed_size
= chdr
.ch_size
;
14139 start
+= compression_header_size
;
14140 size
-= compression_header_size
;
14142 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14144 /* Read the zlib header. In this case, it should be "ZLIB"
14145 followed by the uncompressed section size, 8 bytes in
14146 big-endian order. */
14147 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14148 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14149 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14150 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14151 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14152 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14153 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14154 uncompressed_size
+= start
[11];
14159 if (uncompressed_size
)
14161 if (uncompress_section_contents (&start
, uncompressed_size
,
14164 /* Free the compressed buffer, update the section buffer
14165 and the section size if uncompress is successful. */
14166 free (section
->start
);
14167 section
->start
= start
;
14171 error (_("Unable to decompress section %s\n"),
14172 printable_section_name (filedata
, sec
));
14177 section
->size
= size
;
14180 if (section
->start
== NULL
)
14183 if (debug_displays
[debug
].relocate
)
14185 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14186 & section
->reloc_info
, & section
->num_relocs
))
14191 section
->reloc_info
= NULL
;
14192 section
->num_relocs
= 0;
14198 #if HAVE_LIBDEBUGINFOD
14199 /* Return a hex string representation of the build-id. */
14201 get_build_id (void * data
)
14203 Filedata
* filedata
= (Filedata
*)data
;
14204 Elf_Internal_Shdr
* shdr
;
14207 /* Iterate through notes to find note.gnu.build-id. */
14208 for (i
= 0, shdr
= filedata
->section_headers
;
14209 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14212 if (shdr
->sh_type
!= SHT_NOTE
)
14217 size_t data_remaining
;
14219 Elf_External_Note
* enote
;
14220 Elf_Internal_Note inote
;
14222 bfd_vma offset
= shdr
->sh_offset
;
14223 bfd_vma align
= shdr
->sh_addralign
;
14224 bfd_vma length
= shdr
->sh_size
;
14226 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14232 else if (align
!= 4 && align
!= 8)
14235 end
= (char *) enote
+ length
;
14236 data_remaining
= end
- (char *) enote
;
14238 if (!is_ia64_vms (filedata
))
14240 min_notesz
= offsetof (Elf_External_Note
, name
);
14241 if (data_remaining
< min_notesz
)
14243 warn (ngettext ("debuginfod: Corrupt note: only %ld byte remains, "
14244 "not enough for a full note\n",
14245 "debuginfod: Corrupt note: only %ld bytes remain, "
14246 "not enough for a full note\n",
14248 (long) data_remaining
);
14251 data_remaining
-= min_notesz
;
14253 inote
.type
= BYTE_GET (enote
->type
);
14254 inote
.namesz
= BYTE_GET (enote
->namesz
);
14255 inote
.namedata
= enote
->name
;
14256 inote
.descsz
= BYTE_GET (enote
->descsz
);
14257 inote
.descdata
= ((char *) enote
14258 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14259 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14260 next
= ((char *) enote
14261 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14265 Elf64_External_VMS_Note
*vms_enote
;
14267 /* PR binutils/15191
14268 Make sure that there is enough data to read. */
14269 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14270 if (data_remaining
< min_notesz
)
14272 warn (ngettext ("debuginfod: Corrupt note: only %ld byte remains, "
14273 "not enough for a full note\n",
14274 "debuginfod: Corrupt note: only %ld bytes remain, "
14275 "not enough for a full note\n",
14277 (long) data_remaining
);
14280 data_remaining
-= min_notesz
;
14282 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14283 inote
.type
= BYTE_GET (vms_enote
->type
);
14284 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14285 inote
.namedata
= vms_enote
->name
;
14286 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14287 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14288 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14289 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14292 /* Skip malformed notes. */
14293 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14294 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14295 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14296 || ((size_t) (next
- inote
.descdata
)
14297 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14299 warn (_("debuginfod: note with invalid namesz and/or descsz found\n"));
14300 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
14301 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
14305 /* Check if this is the build-id note. If so then convert the build-id
14306 bytes to a hex string. */
14307 if (inote
.namesz
> 0
14308 && const_strneq (inote
.namedata
, "GNU")
14309 && inote
.type
== NT_GNU_BUILD_ID
)
14314 build_id
= malloc (inote
.descsz
* 2 + 1);
14315 if (build_id
== NULL
)
14318 for (j
= 0; j
< inote
.descsz
; ++j
)
14319 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14320 build_id
[inote
.descsz
* 2] = '\0';
14322 return (unsigned char *)build_id
;
14328 #endif /* HAVE_LIBDEBUGINFOD */
14330 /* If this is not NULL, load_debug_section will only look for sections
14331 within the list of sections given here. */
14332 static unsigned int * section_subset
= NULL
;
14335 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14337 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14338 Elf_Internal_Shdr
* sec
;
14339 Filedata
* filedata
= (Filedata
*) data
;
14341 /* Without section headers we cannot find any sections. */
14342 if (filedata
->section_headers
== NULL
)
14345 if (filedata
->string_table
== NULL
14346 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14347 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14349 Elf_Internal_Shdr
* strs
;
14351 /* Read in the string table, so that we have section names to scan. */
14352 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14354 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14356 filedata
->string_table
14357 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14358 1, strs
->sh_size
, _("string table"));
14360 filedata
->string_table_length
14361 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14365 /* Locate the debug section. */
14366 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14368 section
->name
= section
->uncompressed_name
;
14371 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14373 section
->name
= section
->compressed_name
;
14378 /* If we're loading from a subset of sections, and we've loaded
14379 a section matching this name before, it's likely that it's a
14381 if (section_subset
!= NULL
)
14382 free_debug_section (debug
);
14384 return load_specific_debug_section (debug
, sec
, data
);
14388 free_debug_section (enum dwarf_section_display_enum debug
)
14390 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14392 if (section
->start
== NULL
)
14395 free ((char *) section
->start
);
14396 section
->start
= NULL
;
14397 section
->address
= 0;
14400 if (section
->reloc_info
!= NULL
)
14402 free (section
->reloc_info
);
14403 section
->reloc_info
= NULL
;
14404 section
->num_relocs
= 0;
14409 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14411 char * name
= SECTION_NAME (section
);
14412 const char * print_name
= printable_section_name (filedata
, section
);
14413 bfd_size_type length
;
14414 bfd_boolean result
= TRUE
;
14417 length
= section
->sh_size
;
14420 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14423 if (section
->sh_type
== SHT_NOBITS
)
14425 /* There is no point in dumping the contents of a debugging section
14426 which has the NOBITS type - the bits in the file will be random.
14427 This can happen when a file containing a .eh_frame section is
14428 stripped with the --only-keep-debug command line option. */
14429 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14434 if (const_strneq (name
, ".gnu.linkonce.wi."))
14435 name
= ".debug_info";
14437 /* See if we know how to display the contents of this section. */
14438 for (i
= 0; i
< max
; i
++)
14440 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14441 struct dwarf_section_display
* display
= debug_displays
+ i
;
14442 struct dwarf_section
* sec
= & display
->section
;
14444 if (streq (sec
->uncompressed_name
, name
)
14445 || (id
== line
&& const_strneq (name
, ".debug_line."))
14446 || streq (sec
->compressed_name
, name
))
14448 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14451 free_debug_section (id
);
14453 if (i
== line
&& const_strneq (name
, ".debug_line."))
14455 else if (streq (sec
->uncompressed_name
, name
))
14456 sec
->name
= sec
->uncompressed_name
;
14458 sec
->name
= sec
->compressed_name
;
14460 if (load_specific_debug_section (id
, section
, filedata
))
14462 /* If this debug section is part of a CU/TU set in a .dwp file,
14463 restrict load_debug_section to the sections in that set. */
14464 section_subset
= find_cu_tu_set (filedata
, shndx
);
14466 result
&= display
->display (sec
, filedata
);
14468 section_subset
= NULL
;
14470 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14471 free_debug_section (id
);
14479 printf (_("Unrecognized debug section: %s\n"), print_name
);
14486 /* Set DUMP_SECTS for all sections where dumps were requested
14487 based on section name. */
14490 initialise_dumps_byname (Filedata
* filedata
)
14492 struct dump_list_entry
* cur
;
14494 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14497 bfd_boolean any
= FALSE
;
14499 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14500 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14502 request_dump_bynumber (filedata
, i
, cur
->type
);
14507 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14513 process_section_contents (Filedata
* filedata
)
14515 Elf_Internal_Shdr
* section
;
14517 bfd_boolean res
= TRUE
;
14522 initialise_dumps_byname (filedata
);
14524 for (i
= 0, section
= filedata
->section_headers
;
14525 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14528 dump_type dump
= filedata
->dump_sects
[i
];
14530 #ifdef SUPPORT_DISASSEMBLY
14531 if (dump
& DISASS_DUMP
)
14533 if (! disassemble_section (section
, filedata
))
14537 if (dump
& HEX_DUMP
)
14539 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14543 if (dump
& RELOC_DUMP
)
14545 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14549 if (dump
& STRING_DUMP
)
14551 if (! dump_section_as_strings (section
, filedata
))
14555 if (dump
& DEBUG_DUMP
)
14557 if (! display_debug_section (i
, section
, filedata
))
14561 if (dump
& CTF_DUMP
)
14563 if (! dump_section_as_ctf (section
, filedata
))
14568 /* Check to see if the user requested a
14569 dump of a section that does not exist. */
14570 while (i
< filedata
->num_dump_sects
)
14572 if (filedata
->dump_sects
[i
])
14574 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14584 process_mips_fpe_exception (int mask
)
14588 bfd_boolean first
= TRUE
;
14590 if (mask
& OEX_FPU_INEX
)
14591 fputs ("INEX", stdout
), first
= FALSE
;
14592 if (mask
& OEX_FPU_UFLO
)
14593 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14594 if (mask
& OEX_FPU_OFLO
)
14595 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14596 if (mask
& OEX_FPU_DIV0
)
14597 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14598 if (mask
& OEX_FPU_INVAL
)
14599 printf ("%sINVAL", first
? "" : "|");
14602 fputs ("0", stdout
);
14605 /* Display's the value of TAG at location P. If TAG is
14606 greater than 0 it is assumed to be an unknown tag, and
14607 a message is printed to this effect. Otherwise it is
14608 assumed that a message has already been printed.
14610 If the bottom bit of TAG is set it assumed to have a
14611 string value, otherwise it is assumed to have an integer
14614 Returns an updated P pointing to the first unread byte
14615 beyond the end of TAG's value.
14617 Reads at or beyond END will not be made. */
14619 static unsigned char *
14620 display_tag_value (signed int tag
,
14622 const unsigned char * const end
)
14627 printf (" Tag_unknown_%d: ", tag
);
14631 warn (_("<corrupt tag>\n"));
14635 /* PR 17531 file: 027-19978-0.004. */
14636 size_t maxlen
= (end
- p
) - 1;
14641 print_symbol ((int) maxlen
, (const char *) p
);
14642 p
+= strnlen ((char *) p
, maxlen
) + 1;
14646 printf (_("<corrupt string tag>"));
14647 p
= (unsigned char *) end
;
14653 READ_ULEB (val
, p
, end
);
14654 printf ("%ld (0x%lx)\n", val
, val
);
14661 /* ARC ABI attributes section. */
14663 static unsigned char *
14664 display_arc_attribute (unsigned char * p
,
14665 const unsigned char * const end
)
14670 READ_ULEB (tag
, p
, end
);
14674 case Tag_ARC_PCS_config
:
14675 READ_ULEB (val
, p
, end
);
14676 printf (" Tag_ARC_PCS_config: ");
14680 printf (_("Absent/Non standard\n"));
14683 printf (_("Bare metal/mwdt\n"));
14686 printf (_("Bare metal/newlib\n"));
14689 printf (_("Linux/uclibc\n"));
14692 printf (_("Linux/glibc\n"));
14695 printf (_("Unknown\n"));
14700 case Tag_ARC_CPU_base
:
14701 READ_ULEB (val
, p
, end
);
14702 printf (" Tag_ARC_CPU_base: ");
14707 printf (_("Absent\n"));
14709 case TAG_CPU_ARC6xx
:
14710 printf ("ARC6xx\n");
14712 case TAG_CPU_ARC7xx
:
14713 printf ("ARC7xx\n");
14715 case TAG_CPU_ARCEM
:
14716 printf ("ARCEM\n");
14718 case TAG_CPU_ARCHS
:
14719 printf ("ARCHS\n");
14724 case Tag_ARC_CPU_variation
:
14725 READ_ULEB (val
, p
, end
);
14726 printf (" Tag_ARC_CPU_variation: ");
14730 if (val
> 0 && val
< 16)
14731 printf ("Core%d\n", val
);
14733 printf ("Unknown\n");
14737 printf (_("Absent\n"));
14742 case Tag_ARC_CPU_name
:
14743 printf (" Tag_ARC_CPU_name: ");
14744 p
= display_tag_value (-1, p
, end
);
14747 case Tag_ARC_ABI_rf16
:
14748 READ_ULEB (val
, p
, end
);
14749 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14752 case Tag_ARC_ABI_osver
:
14753 READ_ULEB (val
, p
, end
);
14754 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14757 case Tag_ARC_ABI_pic
:
14758 case Tag_ARC_ABI_sda
:
14759 READ_ULEB (val
, p
, end
);
14760 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14761 : " Tag_ARC_ABI_pic: ");
14765 printf (_("Absent\n"));
14774 printf (_("Unknown\n"));
14779 case Tag_ARC_ABI_tls
:
14780 READ_ULEB (val
, p
, end
);
14781 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14784 case Tag_ARC_ABI_enumsize
:
14785 READ_ULEB (val
, p
, end
);
14786 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14790 case Tag_ARC_ABI_exceptions
:
14791 READ_ULEB (val
, p
, end
);
14792 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14796 case Tag_ARC_ABI_double_size
:
14797 READ_ULEB (val
, p
, end
);
14798 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14801 case Tag_ARC_ISA_config
:
14802 printf (" Tag_ARC_ISA_config: ");
14803 p
= display_tag_value (-1, p
, end
);
14806 case Tag_ARC_ISA_apex
:
14807 printf (" Tag_ARC_ISA_apex: ");
14808 p
= display_tag_value (-1, p
, end
);
14811 case Tag_ARC_ISA_mpy_option
:
14812 READ_ULEB (val
, p
, end
);
14813 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14816 case Tag_ARC_ATR_version
:
14817 READ_ULEB (val
, p
, end
);
14818 printf (" Tag_ARC_ATR_version: %d\n", val
);
14822 return display_tag_value (tag
& 1, p
, end
);
14828 /* ARM EABI attributes section. */
14833 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14835 const char ** table
;
14836 } arm_attr_public_tag
;
14838 static const char * arm_attr_tag_CPU_arch
[] =
14839 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14840 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14841 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14842 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14843 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14844 {"No", "Thumb-1", "Thumb-2", "Yes"};
14845 static const char * arm_attr_tag_FP_arch
[] =
14846 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14847 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14848 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14849 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14850 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14851 "NEON for ARMv8.1"};
14852 static const char * arm_attr_tag_PCS_config
[] =
14853 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14854 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14855 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14856 {"V6", "SB", "TLS", "Unused"};
14857 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14858 {"Absolute", "PC-relative", "SB-relative", "None"};
14859 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14860 {"Absolute", "PC-relative", "None"};
14861 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14862 {"None", "direct", "GOT-indirect"};
14863 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14864 {"None", "??? 1", "2", "??? 3", "4"};
14865 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14866 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14867 {"Unused", "Needed", "Sign only"};
14868 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14869 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14870 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14871 {"Unused", "Finite", "RTABI", "IEEE 754"};
14872 static const char * arm_attr_tag_ABI_enum_size
[] =
14873 {"Unused", "small", "int", "forced to int"};
14874 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14875 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14876 static const char * arm_attr_tag_ABI_VFP_args
[] =
14877 {"AAPCS", "VFP registers", "custom", "compatible"};
14878 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14879 {"AAPCS", "WMMX registers", "custom"};
14880 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14881 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14882 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14883 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14884 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14885 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14886 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14887 static const char * arm_attr_tag_FP_HP_extension
[] =
14888 {"Not Allowed", "Allowed"};
14889 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14890 {"None", "IEEE 754", "Alternative Format"};
14891 static const char * arm_attr_tag_DSP_extension
[] =
14892 {"Follow architecture", "Allowed"};
14893 static const char * arm_attr_tag_MPextension_use
[] =
14894 {"Not Allowed", "Allowed"};
14895 static const char * arm_attr_tag_DIV_use
[] =
14896 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14897 "Allowed in v7-A with integer division extension"};
14898 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14899 static const char * arm_attr_tag_Virtualization_use
[] =
14900 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14901 "TrustZone and Virtualization Extensions"};
14902 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14903 {"Not Allowed", "Allowed"};
14905 static const char * arm_attr_tag_MVE_arch
[] =
14906 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14908 #define LOOKUP(id, name) \
14909 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14910 static arm_attr_public_tag arm_attr_public_tags
[] =
14912 {4, "CPU_raw_name", 1, NULL
},
14913 {5, "CPU_name", 1, NULL
},
14914 LOOKUP(6, CPU_arch
),
14915 {7, "CPU_arch_profile", 0, NULL
},
14916 LOOKUP(8, ARM_ISA_use
),
14917 LOOKUP(9, THUMB_ISA_use
),
14918 LOOKUP(10, FP_arch
),
14919 LOOKUP(11, WMMX_arch
),
14920 LOOKUP(12, Advanced_SIMD_arch
),
14921 LOOKUP(13, PCS_config
),
14922 LOOKUP(14, ABI_PCS_R9_use
),
14923 LOOKUP(15, ABI_PCS_RW_data
),
14924 LOOKUP(16, ABI_PCS_RO_data
),
14925 LOOKUP(17, ABI_PCS_GOT_use
),
14926 LOOKUP(18, ABI_PCS_wchar_t
),
14927 LOOKUP(19, ABI_FP_rounding
),
14928 LOOKUP(20, ABI_FP_denormal
),
14929 LOOKUP(21, ABI_FP_exceptions
),
14930 LOOKUP(22, ABI_FP_user_exceptions
),
14931 LOOKUP(23, ABI_FP_number_model
),
14932 {24, "ABI_align_needed", 0, NULL
},
14933 {25, "ABI_align_preserved", 0, NULL
},
14934 LOOKUP(26, ABI_enum_size
),
14935 LOOKUP(27, ABI_HardFP_use
),
14936 LOOKUP(28, ABI_VFP_args
),
14937 LOOKUP(29, ABI_WMMX_args
),
14938 LOOKUP(30, ABI_optimization_goals
),
14939 LOOKUP(31, ABI_FP_optimization_goals
),
14940 {32, "compatibility", 0, NULL
},
14941 LOOKUP(34, CPU_unaligned_access
),
14942 LOOKUP(36, FP_HP_extension
),
14943 LOOKUP(38, ABI_FP_16bit_format
),
14944 LOOKUP(42, MPextension_use
),
14945 LOOKUP(44, DIV_use
),
14946 LOOKUP(46, DSP_extension
),
14947 LOOKUP(48, MVE_arch
),
14948 {64, "nodefaults", 0, NULL
},
14949 {65, "also_compatible_with", 0, NULL
},
14950 LOOKUP(66, T2EE_use
),
14951 {67, "conformance", 1, NULL
},
14952 LOOKUP(68, Virtualization_use
),
14953 LOOKUP(70, MPextension_use_legacy
)
14957 static unsigned char *
14958 display_arm_attribute (unsigned char * p
,
14959 const unsigned char * const end
)
14963 arm_attr_public_tag
* attr
;
14967 READ_ULEB (tag
, p
, end
);
14969 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14971 if (arm_attr_public_tags
[i
].tag
== tag
)
14973 attr
= &arm_attr_public_tags
[i
];
14980 printf (" Tag_%s: ", attr
->name
);
14981 switch (attr
->type
)
14986 case 7: /* Tag_CPU_arch_profile. */
14987 READ_ULEB (val
, p
, end
);
14990 case 0: printf (_("None\n")); break;
14991 case 'A': printf (_("Application\n")); break;
14992 case 'R': printf (_("Realtime\n")); break;
14993 case 'M': printf (_("Microcontroller\n")); break;
14994 case 'S': printf (_("Application or Realtime\n")); break;
14995 default: printf ("??? (%d)\n", val
); break;
14999 case 24: /* Tag_align_needed. */
15000 READ_ULEB (val
, p
, end
);
15003 case 0: printf (_("None\n")); break;
15004 case 1: printf (_("8-byte\n")); break;
15005 case 2: printf (_("4-byte\n")); break;
15006 case 3: printf ("??? 3\n"); break;
15009 printf (_("8-byte and up to %d-byte extended\n"),
15012 printf ("??? (%d)\n", val
);
15017 case 25: /* Tag_align_preserved. */
15018 READ_ULEB (val
, p
, end
);
15021 case 0: printf (_("None\n")); break;
15022 case 1: printf (_("8-byte, except leaf SP\n")); break;
15023 case 2: printf (_("8-byte\n")); break;
15024 case 3: printf ("??? 3\n"); break;
15027 printf (_("8-byte and up to %d-byte extended\n"),
15030 printf ("??? (%d)\n", val
);
15035 case 32: /* Tag_compatibility. */
15037 READ_ULEB (val
, p
, end
);
15038 printf (_("flag = %d, vendor = "), val
);
15041 size_t maxlen
= (end
- p
) - 1;
15043 print_symbol ((int) maxlen
, (const char *) p
);
15044 p
+= strnlen ((char *) p
, maxlen
) + 1;
15048 printf (_("<corrupt>"));
15049 p
= (unsigned char *) end
;
15055 case 64: /* Tag_nodefaults. */
15056 /* PR 17531: file: 001-505008-0.01. */
15059 printf (_("True\n"));
15062 case 65: /* Tag_also_compatible_with. */
15063 READ_ULEB (val
, p
, end
);
15064 if (val
== 6 /* Tag_CPU_arch. */)
15066 READ_ULEB (val
, p
, end
);
15067 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15068 printf ("??? (%d)\n", val
);
15070 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15074 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15079 printf (_("<unknown: %d>\n"), tag
);
15085 return display_tag_value (-1, p
, end
);
15087 return display_tag_value (0, p
, end
);
15090 assert (attr
->type
& 0x80);
15091 READ_ULEB (val
, p
, end
);
15092 type
= attr
->type
& 0x7f;
15094 printf ("??? (%d)\n", val
);
15096 printf ("%s\n", attr
->table
[val
]);
15101 return display_tag_value (tag
, p
, end
);
15104 static unsigned char *
15105 display_gnu_attribute (unsigned char * p
,
15106 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15107 const unsigned char * const end
)
15112 READ_ULEB (tag
, p
, end
);
15114 /* Tag_compatibility is the only generic GNU attribute defined at
15118 READ_ULEB (val
, p
, end
);
15120 printf (_("flag = %d, vendor = "), val
);
15123 printf (_("<corrupt>\n"));
15124 warn (_("corrupt vendor attribute\n"));
15130 size_t maxlen
= (end
- p
) - 1;
15132 print_symbol ((int) maxlen
, (const char *) p
);
15133 p
+= strnlen ((char *) p
, maxlen
) + 1;
15137 printf (_("<corrupt>"));
15138 p
= (unsigned char *) end
;
15145 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15146 return display_proc_gnu_attribute (p
, tag
, end
);
15148 return display_tag_value (tag
, p
, end
);
15151 static unsigned char *
15152 display_power_gnu_attribute (unsigned char * p
,
15154 const unsigned char * const end
)
15158 if (tag
== Tag_GNU_Power_ABI_FP
)
15160 printf (" Tag_GNU_Power_ABI_FP: ");
15163 printf (_("<corrupt>\n"));
15166 READ_ULEB (val
, p
, end
);
15169 printf ("(%#x), ", val
);
15174 printf (_("unspecified hard/soft float, "));
15177 printf (_("hard float, "));
15180 printf (_("soft float, "));
15183 printf (_("single-precision hard float, "));
15190 printf (_("unspecified long double\n"));
15193 printf (_("128-bit IBM long double\n"));
15196 printf (_("64-bit long double\n"));
15199 printf (_("128-bit IEEE long double\n"));
15205 if (tag
== Tag_GNU_Power_ABI_Vector
)
15207 printf (" Tag_GNU_Power_ABI_Vector: ");
15210 printf (_("<corrupt>\n"));
15213 READ_ULEB (val
, p
, end
);
15216 printf ("(%#x), ", val
);
15221 printf (_("unspecified\n"));
15224 printf (_("generic\n"));
15227 printf ("AltiVec\n");
15236 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15238 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15241 printf (_("<corrupt>\n"));
15244 READ_ULEB (val
, p
, end
);
15247 printf ("(%#x), ", val
);
15252 printf (_("unspecified\n"));
15255 printf ("r3/r4\n");
15258 printf (_("memory\n"));
15267 return display_tag_value (tag
& 1, p
, end
);
15270 static unsigned char *
15271 display_s390_gnu_attribute (unsigned char * p
,
15273 const unsigned char * const end
)
15277 if (tag
== Tag_GNU_S390_ABI_Vector
)
15279 printf (" Tag_GNU_S390_ABI_Vector: ");
15280 READ_ULEB (val
, p
, end
);
15285 printf (_("any\n"));
15288 printf (_("software\n"));
15291 printf (_("hardware\n"));
15294 printf ("??? (%d)\n", val
);
15300 return display_tag_value (tag
& 1, p
, end
);
15304 display_sparc_hwcaps (unsigned int mask
)
15308 bfd_boolean first
= TRUE
;
15310 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15311 fputs ("mul32", stdout
), first
= FALSE
;
15312 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15313 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15314 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15315 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15316 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15317 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15318 if (mask
& ELF_SPARC_HWCAP_POPC
)
15319 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15320 if (mask
& ELF_SPARC_HWCAP_VIS
)
15321 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15322 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15323 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15324 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15325 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15326 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15327 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15328 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15329 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15330 if (mask
& ELF_SPARC_HWCAP_HPC
)
15331 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15332 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15333 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15334 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15335 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15336 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15337 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15338 if (mask
& ELF_SPARC_HWCAP_IMA
)
15339 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15340 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15341 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15344 fputc ('0', stdout
);
15345 fputc ('\n', stdout
);
15349 display_sparc_hwcaps2 (unsigned int mask
)
15353 bfd_boolean first
= TRUE
;
15355 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15356 fputs ("fjathplus", stdout
), first
= FALSE
;
15357 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15358 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15359 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15360 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15361 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15362 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15363 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15364 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15365 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15366 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15367 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15368 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15369 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15370 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15371 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15372 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15373 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15374 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15375 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15376 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15379 fputc ('0', stdout
);
15380 fputc ('\n', stdout
);
15383 static unsigned char *
15384 display_sparc_gnu_attribute (unsigned char * p
,
15386 const unsigned char * const end
)
15390 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15392 READ_ULEB (val
, p
, end
);
15393 printf (" Tag_GNU_Sparc_HWCAPS: ");
15394 display_sparc_hwcaps (val
);
15397 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15399 READ_ULEB (val
, p
, end
);
15400 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15401 display_sparc_hwcaps2 (val
);
15405 return display_tag_value (tag
, p
, end
);
15409 print_mips_fp_abi_value (unsigned int val
)
15413 case Val_GNU_MIPS_ABI_FP_ANY
:
15414 printf (_("Hard or soft float\n"));
15416 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15417 printf (_("Hard float (double precision)\n"));
15419 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15420 printf (_("Hard float (single precision)\n"));
15422 case Val_GNU_MIPS_ABI_FP_SOFT
:
15423 printf (_("Soft float\n"));
15425 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15426 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15428 case Val_GNU_MIPS_ABI_FP_XX
:
15429 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15431 case Val_GNU_MIPS_ABI_FP_64
:
15432 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15434 case Val_GNU_MIPS_ABI_FP_64A
:
15435 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15437 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15438 printf (_("NaN 2008 compatibility\n"));
15441 printf ("??? (%d)\n", val
);
15446 static unsigned char *
15447 display_mips_gnu_attribute (unsigned char * p
,
15449 const unsigned char * const end
)
15451 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15455 printf (" Tag_GNU_MIPS_ABI_FP: ");
15456 READ_ULEB (val
, p
, end
);
15457 print_mips_fp_abi_value (val
);
15461 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15465 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15466 READ_ULEB (val
, p
, end
);
15470 case Val_GNU_MIPS_ABI_MSA_ANY
:
15471 printf (_("Any MSA or not\n"));
15473 case Val_GNU_MIPS_ABI_MSA_128
:
15474 printf (_("128-bit MSA\n"));
15477 printf ("??? (%d)\n", val
);
15483 return display_tag_value (tag
& 1, p
, end
);
15486 static unsigned char *
15487 display_tic6x_attribute (unsigned char * p
,
15488 const unsigned char * const end
)
15493 READ_ULEB (tag
, p
, end
);
15498 printf (" Tag_ISA: ");
15499 READ_ULEB (val
, p
, end
);
15503 case C6XABI_Tag_ISA_none
:
15504 printf (_("None\n"));
15506 case C6XABI_Tag_ISA_C62X
:
15509 case C6XABI_Tag_ISA_C67X
:
15512 case C6XABI_Tag_ISA_C67XP
:
15513 printf ("C67x+\n");
15515 case C6XABI_Tag_ISA_C64X
:
15518 case C6XABI_Tag_ISA_C64XP
:
15519 printf ("C64x+\n");
15521 case C6XABI_Tag_ISA_C674X
:
15522 printf ("C674x\n");
15525 printf ("??? (%d)\n", val
);
15530 case Tag_ABI_wchar_t
:
15531 printf (" Tag_ABI_wchar_t: ");
15532 READ_ULEB (val
, p
, end
);
15536 printf (_("Not used\n"));
15539 printf (_("2 bytes\n"));
15542 printf (_("4 bytes\n"));
15545 printf ("??? (%d)\n", val
);
15550 case Tag_ABI_stack_align_needed
:
15551 printf (" Tag_ABI_stack_align_needed: ");
15552 READ_ULEB (val
, p
, end
);
15556 printf (_("8-byte\n"));
15559 printf (_("16-byte\n"));
15562 printf ("??? (%d)\n", val
);
15567 case Tag_ABI_stack_align_preserved
:
15568 READ_ULEB (val
, p
, end
);
15569 printf (" Tag_ABI_stack_align_preserved: ");
15573 printf (_("8-byte\n"));
15576 printf (_("16-byte\n"));
15579 printf ("??? (%d)\n", val
);
15585 READ_ULEB (val
, p
, end
);
15586 printf (" Tag_ABI_DSBT: ");
15590 printf (_("DSBT addressing not used\n"));
15593 printf (_("DSBT addressing used\n"));
15596 printf ("??? (%d)\n", val
);
15602 READ_ULEB (val
, p
, end
);
15603 printf (" Tag_ABI_PID: ");
15607 printf (_("Data addressing position-dependent\n"));
15610 printf (_("Data addressing position-independent, GOT near DP\n"));
15613 printf (_("Data addressing position-independent, GOT far from DP\n"));
15616 printf ("??? (%d)\n", val
);
15622 READ_ULEB (val
, p
, end
);
15623 printf (" Tag_ABI_PIC: ");
15627 printf (_("Code addressing position-dependent\n"));
15630 printf (_("Code addressing position-independent\n"));
15633 printf ("??? (%d)\n", val
);
15638 case Tag_ABI_array_object_alignment
:
15639 READ_ULEB (val
, p
, end
);
15640 printf (" Tag_ABI_array_object_alignment: ");
15644 printf (_("8-byte\n"));
15647 printf (_("4-byte\n"));
15650 printf (_("16-byte\n"));
15653 printf ("??? (%d)\n", val
);
15658 case Tag_ABI_array_object_align_expected
:
15659 READ_ULEB (val
, p
, end
);
15660 printf (" Tag_ABI_array_object_align_expected: ");
15664 printf (_("8-byte\n"));
15667 printf (_("4-byte\n"));
15670 printf (_("16-byte\n"));
15673 printf ("??? (%d)\n", val
);
15678 case Tag_ABI_compatibility
:
15680 READ_ULEB (val
, p
, end
);
15681 printf (" Tag_ABI_compatibility: ");
15682 printf (_("flag = %d, vendor = "), val
);
15685 size_t maxlen
= (end
- p
) - 1;
15687 print_symbol ((int) maxlen
, (const char *) p
);
15688 p
+= strnlen ((char *) p
, maxlen
) + 1;
15692 printf (_("<corrupt>"));
15693 p
= (unsigned char *) end
;
15699 case Tag_ABI_conformance
:
15701 printf (" Tag_ABI_conformance: \"");
15704 size_t maxlen
= (end
- p
) - 1;
15706 print_symbol ((int) maxlen
, (const char *) p
);
15707 p
+= strnlen ((char *) p
, maxlen
) + 1;
15711 printf (_("<corrupt>"));
15712 p
= (unsigned char *) end
;
15719 return display_tag_value (tag
, p
, end
);
15723 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15725 unsigned long addr
= 0;
15726 size_t bytes
= end
- p
;
15733 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15735 printf (" 0x%8.8lx ", addr
);
15737 for (j
= 0; j
< 16; j
++)
15740 printf ("%2.2x", p
[j
]);
15748 for (j
= 0; j
< lbytes
; j
++)
15751 if (k
>= ' ' && k
< 0x7f)
15767 static unsigned char *
15768 display_msp430x_attribute (unsigned char * p
,
15769 const unsigned char * const end
)
15774 READ_ULEB (tag
, p
, end
);
15778 case OFBA_MSPABI_Tag_ISA
:
15779 printf (" Tag_ISA: ");
15780 READ_ULEB (val
, p
, end
);
15783 case 0: printf (_("None\n")); break;
15784 case 1: printf (_("MSP430\n")); break;
15785 case 2: printf (_("MSP430X\n")); break;
15786 default: printf ("??? (%d)\n", val
); break;
15790 case OFBA_MSPABI_Tag_Code_Model
:
15791 printf (" Tag_Code_Model: ");
15792 READ_ULEB (val
, p
, end
);
15795 case 0: printf (_("None\n")); break;
15796 case 1: printf (_("Small\n")); break;
15797 case 2: printf (_("Large\n")); break;
15798 default: printf ("??? (%d)\n", val
); break;
15802 case OFBA_MSPABI_Tag_Data_Model
:
15803 printf (" Tag_Data_Model: ");
15804 READ_ULEB (val
, p
, end
);
15807 case 0: printf (_("None\n")); break;
15808 case 1: printf (_("Small\n")); break;
15809 case 2: printf (_("Large\n")); break;
15810 case 3: printf (_("Restricted Large\n")); break;
15811 default: printf ("??? (%d)\n", val
); break;
15816 printf (_(" <unknown tag %d>: "), tag
);
15823 size_t maxlen
= (end
- p
) - 1;
15825 print_symbol ((int) maxlen
, (const char *) p
);
15826 p
+= strnlen ((char *) p
, maxlen
) + 1;
15830 printf (_("<corrupt>"));
15831 p
= (unsigned char *) end
;
15837 READ_ULEB (val
, p
, end
);
15838 printf ("%d (0x%x)\n", val
, val
);
15847 static unsigned char *
15848 display_msp430_gnu_attribute (unsigned char * p
,
15850 const unsigned char * const end
)
15852 if (tag
== Tag_GNU_MSP430_Data_Region
)
15856 printf (" Tag_GNU_MSP430_Data_Region: ");
15857 READ_ULEB (val
, p
, end
);
15861 case Val_GNU_MSP430_Data_Region_Any
:
15862 printf (_("Any Region\n"));
15864 case Val_GNU_MSP430_Data_Region_Lower
:
15865 printf (_("Lower Region Only\n"));
15868 printf ("??? (%u)\n", val
);
15872 return display_tag_value (tag
& 1, p
, end
);
15875 struct riscv_attr_tag_t
{
15880 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15882 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15885 T(priv_spec_minor
),
15886 T(priv_spec_revision
),
15887 T(unaligned_access
),
15892 static unsigned char *
15893 display_riscv_attribute (unsigned char *p
,
15894 const unsigned char * const end
)
15898 struct riscv_attr_tag_t
*attr
= NULL
;
15901 READ_ULEB (tag
, p
, end
);
15903 /* Find the name of attribute. */
15904 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
15906 if (riscv_attr_tag
[i
].tag
== tag
)
15908 attr
= &riscv_attr_tag
[i
];
15914 printf (" %s: ", attr
->name
);
15916 return display_tag_value (tag
, p
, end
);
15920 case Tag_RISCV_priv_spec
:
15921 case Tag_RISCV_priv_spec_minor
:
15922 case Tag_RISCV_priv_spec_revision
:
15923 READ_ULEB (val
, p
, end
);
15924 printf (_("%u\n"), val
);
15926 case Tag_RISCV_unaligned_access
:
15927 READ_ULEB (val
, p
, end
);
15931 printf (_("No unaligned access\n"));
15934 printf (_("Unaligned access\n"));
15938 case Tag_RISCV_stack_align
:
15939 READ_ULEB (val
, p
, end
);
15940 printf (_("%u-bytes\n"), val
);
15942 case Tag_RISCV_arch
:
15943 p
= display_tag_value (-1, p
, end
);
15946 return display_tag_value (tag
, p
, end
);
15953 process_attributes (Filedata
* filedata
,
15954 const char * public_name
,
15955 unsigned int proc_type
,
15956 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15957 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15959 Elf_Internal_Shdr
* sect
;
15961 bfd_boolean res
= TRUE
;
15963 /* Find the section header so that we get the size. */
15964 for (i
= 0, sect
= filedata
->section_headers
;
15965 i
< filedata
->file_header
.e_shnum
;
15968 unsigned char * contents
;
15971 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15974 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15975 sect
->sh_size
, _("attributes"));
15976 if (contents
== NULL
)
15983 /* The first character is the version of the attributes.
15984 Currently only version 1, (aka 'A') is recognised here. */
15987 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15992 bfd_vma section_len
;
15994 section_len
= sect
->sh_size
- 1;
15997 while (section_len
> 0)
16000 unsigned int namelen
;
16001 bfd_boolean public_section
;
16002 bfd_boolean gnu_section
;
16004 if (section_len
<= 4)
16006 error (_("Tag section ends prematurely\n"));
16010 attr_len
= byte_get (p
, 4);
16013 if (attr_len
> section_len
)
16015 error (_("Bad attribute length (%u > %u)\n"),
16016 (unsigned) attr_len
, (unsigned) section_len
);
16017 attr_len
= section_len
;
16020 /* PR 17531: file: 001-101425-0.004 */
16021 else if (attr_len
< 5)
16023 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16028 section_len
-= attr_len
;
16031 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16032 if (namelen
== 0 || namelen
>= attr_len
)
16034 error (_("Corrupt attribute section name\n"));
16039 printf (_("Attribute Section: "));
16040 print_symbol (INT_MAX
, (const char *) p
);
16043 if (public_name
&& streq ((char *) p
, public_name
))
16044 public_section
= TRUE
;
16046 public_section
= FALSE
;
16048 if (streq ((char *) p
, "gnu"))
16049 gnu_section
= TRUE
;
16051 gnu_section
= FALSE
;
16054 attr_len
-= namelen
;
16056 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16061 unsigned char * end
;
16063 /* PR binutils/17531: Safe handling of corrupt files. */
16066 error (_("Unused bytes at end of section\n"));
16073 size
= byte_get (p
, 4);
16074 if (size
> attr_len
)
16076 error (_("Bad subsection length (%u > %u)\n"),
16077 (unsigned) size
, (unsigned) attr_len
);
16081 /* PR binutils/17531: Safe handling of corrupt files. */
16084 error (_("Bad subsection length (%u < 6)\n"),
16092 end
= p
+ size
- 1;
16093 assert (end
<= contents
+ sect
->sh_size
);
16099 printf (_("File Attributes\n"));
16102 printf (_("Section Attributes:"));
16105 printf (_("Symbol Attributes:"));
16106 /* Fall through. */
16110 READ_ULEB (val
, p
, end
);
16113 printf (" %d", val
);
16118 printf (_("Unknown tag: %d\n"), tag
);
16119 public_section
= FALSE
;
16123 if (public_section
&& display_pub_attribute
!= NULL
)
16126 p
= display_pub_attribute (p
, end
);
16129 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16132 p
= display_gnu_attribute (p
,
16133 display_proc_gnu_attribute
,
16139 printf (_(" Unknown attribute:\n"));
16140 display_raw_attribute (p
, end
);
16155 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16156 Print the Address, Access and Initial fields of an entry at VMA ADDR
16157 and return the VMA of the next entry, or -1 if there was a problem.
16158 Does not read from DATA_END or beyond. */
16161 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16162 unsigned char * data_end
)
16165 print_vma (addr
, LONG_HEX
);
16167 if (addr
< pltgot
+ 0xfff0)
16168 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16170 printf ("%10s", "");
16173 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16177 unsigned char * from
= data
+ addr
- pltgot
;
16179 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16181 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16182 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16183 return (bfd_vma
) -1;
16187 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16188 print_vma (entry
, LONG_HEX
);
16191 return addr
+ (is_32bit_elf
? 4 : 8);
16194 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16195 PLTGOT. Print the Address and Initial fields of an entry at VMA
16196 ADDR and return the VMA of the next entry. */
16199 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16202 print_vma (addr
, LONG_HEX
);
16205 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16210 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16211 print_vma (entry
, LONG_HEX
);
16213 return addr
+ (is_32bit_elf
? 4 : 8);
16217 print_mips_ases (unsigned int mask
)
16219 if (mask
& AFL_ASE_DSP
)
16220 fputs ("\n\tDSP ASE", stdout
);
16221 if (mask
& AFL_ASE_DSPR2
)
16222 fputs ("\n\tDSP R2 ASE", stdout
);
16223 if (mask
& AFL_ASE_DSPR3
)
16224 fputs ("\n\tDSP R3 ASE", stdout
);
16225 if (mask
& AFL_ASE_EVA
)
16226 fputs ("\n\tEnhanced VA Scheme", stdout
);
16227 if (mask
& AFL_ASE_MCU
)
16228 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16229 if (mask
& AFL_ASE_MDMX
)
16230 fputs ("\n\tMDMX ASE", stdout
);
16231 if (mask
& AFL_ASE_MIPS3D
)
16232 fputs ("\n\tMIPS-3D ASE", stdout
);
16233 if (mask
& AFL_ASE_MT
)
16234 fputs ("\n\tMT ASE", stdout
);
16235 if (mask
& AFL_ASE_SMARTMIPS
)
16236 fputs ("\n\tSmartMIPS ASE", stdout
);
16237 if (mask
& AFL_ASE_VIRT
)
16238 fputs ("\n\tVZ ASE", stdout
);
16239 if (mask
& AFL_ASE_MSA
)
16240 fputs ("\n\tMSA ASE", stdout
);
16241 if (mask
& AFL_ASE_MIPS16
)
16242 fputs ("\n\tMIPS16 ASE", stdout
);
16243 if (mask
& AFL_ASE_MICROMIPS
)
16244 fputs ("\n\tMICROMIPS ASE", stdout
);
16245 if (mask
& AFL_ASE_XPA
)
16246 fputs ("\n\tXPA ASE", stdout
);
16247 if (mask
& AFL_ASE_MIPS16E2
)
16248 fputs ("\n\tMIPS16e2 ASE", stdout
);
16249 if (mask
& AFL_ASE_CRC
)
16250 fputs ("\n\tCRC ASE", stdout
);
16251 if (mask
& AFL_ASE_GINV
)
16252 fputs ("\n\tGINV ASE", stdout
);
16253 if (mask
& AFL_ASE_LOONGSON_MMI
)
16254 fputs ("\n\tLoongson MMI ASE", stdout
);
16255 if (mask
& AFL_ASE_LOONGSON_CAM
)
16256 fputs ("\n\tLoongson CAM ASE", stdout
);
16257 if (mask
& AFL_ASE_LOONGSON_EXT
)
16258 fputs ("\n\tLoongson EXT ASE", stdout
);
16259 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16260 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16262 fprintf (stdout
, "\n\t%s", _("None"));
16263 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16264 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16268 print_mips_isa_ext (unsigned int isa_ext
)
16273 fputs (_("None"), stdout
);
16276 fputs ("RMI XLR", stdout
);
16278 case AFL_EXT_OCTEON3
:
16279 fputs ("Cavium Networks Octeon3", stdout
);
16281 case AFL_EXT_OCTEON2
:
16282 fputs ("Cavium Networks Octeon2", stdout
);
16284 case AFL_EXT_OCTEONP
:
16285 fputs ("Cavium Networks OcteonP", stdout
);
16287 case AFL_EXT_OCTEON
:
16288 fputs ("Cavium Networks Octeon", stdout
);
16291 fputs ("Toshiba R5900", stdout
);
16294 fputs ("MIPS R4650", stdout
);
16297 fputs ("LSI R4010", stdout
);
16300 fputs ("NEC VR4100", stdout
);
16303 fputs ("Toshiba R3900", stdout
);
16305 case AFL_EXT_10000
:
16306 fputs ("MIPS R10000", stdout
);
16309 fputs ("Broadcom SB-1", stdout
);
16312 fputs ("NEC VR4111/VR4181", stdout
);
16315 fputs ("NEC VR4120", stdout
);
16318 fputs ("NEC VR5400", stdout
);
16321 fputs ("NEC VR5500", stdout
);
16323 case AFL_EXT_LOONGSON_2E
:
16324 fputs ("ST Microelectronics Loongson 2E", stdout
);
16326 case AFL_EXT_LOONGSON_2F
:
16327 fputs ("ST Microelectronics Loongson 2F", stdout
);
16329 case AFL_EXT_INTERAPTIV_MR2
:
16330 fputs ("Imagination interAptiv MR2", stdout
);
16333 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16338 get_mips_reg_size (int reg_size
)
16340 return (reg_size
== AFL_REG_NONE
) ? 0
16341 : (reg_size
== AFL_REG_32
) ? 32
16342 : (reg_size
== AFL_REG_64
) ? 64
16343 : (reg_size
== AFL_REG_128
) ? 128
16348 process_mips_specific (Filedata
* filedata
)
16350 Elf_Internal_Dyn
* entry
;
16351 Elf_Internal_Shdr
*sect
= NULL
;
16352 size_t liblist_offset
= 0;
16353 size_t liblistno
= 0;
16354 size_t conflictsno
= 0;
16355 size_t options_offset
= 0;
16356 size_t conflicts_offset
= 0;
16357 size_t pltrelsz
= 0;
16359 bfd_vma pltgot
= 0;
16360 bfd_vma mips_pltgot
= 0;
16361 bfd_vma jmprel
= 0;
16362 bfd_vma local_gotno
= 0;
16363 bfd_vma gotsym
= 0;
16364 bfd_vma symtabno
= 0;
16365 bfd_boolean res
= TRUE
;
16367 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16368 display_mips_gnu_attribute
))
16371 sect
= find_section (filedata
, ".MIPS.abiflags");
16375 Elf_External_ABIFlags_v0
*abiflags_ext
;
16376 Elf_Internal_ABIFlags_v0 abiflags_in
;
16378 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16380 error (_("Corrupt MIPS ABI Flags section.\n"));
16385 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16386 sect
->sh_size
, _("MIPS ABI Flags section"));
16389 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16390 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16391 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16392 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16393 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16394 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16395 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16396 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16397 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16398 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16399 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16401 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16402 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16403 if (abiflags_in
.isa_rev
> 1)
16404 printf ("r%d", abiflags_in
.isa_rev
);
16405 printf ("\nGPR size: %d",
16406 get_mips_reg_size (abiflags_in
.gpr_size
));
16407 printf ("\nCPR1 size: %d",
16408 get_mips_reg_size (abiflags_in
.cpr1_size
));
16409 printf ("\nCPR2 size: %d",
16410 get_mips_reg_size (abiflags_in
.cpr2_size
));
16411 fputs ("\nFP ABI: ", stdout
);
16412 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16413 fputs ("ISA Extension: ", stdout
);
16414 print_mips_isa_ext (abiflags_in
.isa_ext
);
16415 fputs ("\nASEs:", stdout
);
16416 print_mips_ases (abiflags_in
.ases
);
16417 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16418 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16419 fputc ('\n', stdout
);
16420 free (abiflags_ext
);
16425 /* We have a lot of special sections. Thanks SGI! */
16426 if (dynamic_section
== NULL
)
16428 /* No dynamic information available. See if there is static GOT. */
16429 sect
= find_section (filedata
, ".got");
16432 unsigned char *data_end
;
16433 unsigned char *data
;
16437 pltgot
= sect
->sh_addr
;
16440 addr_size
= (is_32bit_elf
? 4 : 8);
16441 end
= pltgot
+ sect
->sh_size
;
16443 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16445 _("Global Offset Table data"));
16446 /* PR 12855: Null data is handled gracefully throughout. */
16447 data_end
= data
+ (end
- pltgot
);
16449 printf (_("\nStatic GOT:\n"));
16450 printf (_(" Canonical gp value: "));
16451 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16454 /* In a dynamic binary GOT[0] is reserved for the dynamic
16455 loader to store the lazy resolver pointer, however in
16456 a static binary it may well have been omitted and GOT
16457 reduced to a table of addresses.
16458 PR 21344: Check for the entry being fully available
16459 before fetching it. */
16461 && data
+ ent
- pltgot
+ addr_size
<= data_end
16462 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16464 printf (_(" Reserved entries:\n"));
16465 printf (_(" %*s %10s %*s\n"),
16466 addr_size
* 2, _("Address"), _("Access"),
16467 addr_size
* 2, _("Value"));
16468 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16470 if (ent
== (bfd_vma
) -1)
16471 goto sgot_print_fail
;
16473 /* Check for the MSB of GOT[1] being set, identifying a
16474 GNU object. This entry will be used by some runtime
16475 loaders, to store the module pointer. Otherwise this
16476 is an ordinary local entry.
16477 PR 21344: Check for the entry being fully available
16478 before fetching it. */
16480 && data
+ ent
- pltgot
+ addr_size
<= data_end
16481 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16482 >> (addr_size
* 8 - 1)) != 0)
16484 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16486 if (ent
== (bfd_vma
) -1)
16487 goto sgot_print_fail
;
16492 if (data
!= NULL
&& ent
< end
)
16494 printf (_(" Local entries:\n"));
16495 printf (" %*s %10s %*s\n",
16496 addr_size
* 2, _("Address"), _("Access"),
16497 addr_size
* 2, _("Value"));
16500 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16502 if (ent
== (bfd_vma
) -1)
16503 goto sgot_print_fail
;
16515 for (entry
= dynamic_section
;
16516 /* PR 17531 file: 012-50589-0.004. */
16517 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16519 switch (entry
->d_tag
)
16521 case DT_MIPS_LIBLIST
:
16523 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16524 liblistno
* sizeof (Elf32_External_Lib
));
16526 case DT_MIPS_LIBLISTNO
:
16527 liblistno
= entry
->d_un
.d_val
;
16529 case DT_MIPS_OPTIONS
:
16530 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16532 case DT_MIPS_CONFLICT
:
16534 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16535 conflictsno
* sizeof (Elf32_External_Conflict
));
16537 case DT_MIPS_CONFLICTNO
:
16538 conflictsno
= entry
->d_un
.d_val
;
16541 pltgot
= entry
->d_un
.d_ptr
;
16543 case DT_MIPS_LOCAL_GOTNO
:
16544 local_gotno
= entry
->d_un
.d_val
;
16546 case DT_MIPS_GOTSYM
:
16547 gotsym
= entry
->d_un
.d_val
;
16549 case DT_MIPS_SYMTABNO
:
16550 symtabno
= entry
->d_un
.d_val
;
16552 case DT_MIPS_PLTGOT
:
16553 mips_pltgot
= entry
->d_un
.d_ptr
;
16556 pltrel
= entry
->d_un
.d_val
;
16559 pltrelsz
= entry
->d_un
.d_val
;
16562 jmprel
= entry
->d_un
.d_ptr
;
16568 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16570 Elf32_External_Lib
* elib
;
16573 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16575 sizeof (Elf32_External_Lib
),
16576 _("liblist section data"));
16579 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16580 "\nSection '.liblist' contains %lu entries:\n",
16581 (unsigned long) liblistno
),
16582 (unsigned long) liblistno
);
16583 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16586 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16593 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16594 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16595 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16596 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16597 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16599 tmp
= gmtime (&atime
);
16600 snprintf (timebuf
, sizeof (timebuf
),
16601 "%04u-%02u-%02uT%02u:%02u:%02u",
16602 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16603 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16605 printf ("%3lu: ", (unsigned long) cnt
);
16606 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16607 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16609 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16610 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16611 liblist
.l_version
);
16613 if (liblist
.l_flags
== 0)
16617 static const struct
16624 { " EXACT_MATCH", LL_EXACT_MATCH
},
16625 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16626 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16627 { " EXPORTS", LL_EXPORTS
},
16628 { " DELAY_LOAD", LL_DELAY_LOAD
},
16629 { " DELTA", LL_DELTA
}
16631 int flags
= liblist
.l_flags
;
16634 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16635 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16637 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16638 flags
^= l_flags_vals
[fcnt
].bit
;
16641 printf (" %#x", (unsigned int) flags
);
16653 if (options_offset
!= 0)
16655 Elf_External_Options
* eopt
;
16658 sect
= filedata
->section_headers
;
16660 /* Find the section header so that we get the size. */
16661 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16662 /* PR 17533 file: 012-277276-0.004. */
16665 error (_("No MIPS_OPTIONS header found\n"));
16669 if (sect
->sh_size
< sizeof (* eopt
))
16671 error (_("The MIPS options section is too small.\n"));
16675 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16676 sect
->sh_size
, _("options"));
16679 Elf_Internal_Options
* iopt
;
16680 Elf_Internal_Options
* option
;
16681 Elf_Internal_Options
* iopt_end
;
16683 iopt
= (Elf_Internal_Options
*)
16684 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16687 error (_("Out of memory allocating space for MIPS options\n"));
16693 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16695 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16697 Elf_External_Options
* eoption
;
16699 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16701 option
->kind
= BYTE_GET (eoption
->kind
);
16702 option
->size
= BYTE_GET (eoption
->size
);
16703 option
->section
= BYTE_GET (eoption
->section
);
16704 option
->info
= BYTE_GET (eoption
->info
);
16706 /* PR 17531: file: ffa0fa3b. */
16707 if (option
->size
< sizeof (* eopt
)
16708 || offset
+ option
->size
> sect
->sh_size
)
16710 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16713 offset
+= option
->size
;
16719 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16720 "\nSection '%s' contains %d entries:\n",
16722 printable_section_name (filedata
, sect
), cnt
);
16731 switch (option
->kind
)
16734 /* This shouldn't happen. */
16735 printf (" NULL %d %lx", option
->section
, option
->info
);
16739 printf (" REGINFO ");
16740 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16742 Elf32_External_RegInfo
* ereg
;
16743 Elf32_RegInfo reginfo
;
16746 if (option
+ 2 > iopt_end
)
16748 printf (_("<corrupt>\n"));
16749 error (_("Truncated MIPS REGINFO option\n"));
16754 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16756 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16757 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16758 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16759 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16760 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16761 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16763 printf ("GPR %08lx GP 0x%lx\n",
16764 reginfo
.ri_gprmask
,
16765 (unsigned long) reginfo
.ri_gp_value
);
16766 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16767 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16768 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16773 Elf64_External_RegInfo
* ereg
;
16774 Elf64_Internal_RegInfo reginfo
;
16776 if (option
+ 2 > iopt_end
)
16778 printf (_("<corrupt>\n"));
16779 error (_("Truncated MIPS REGINFO option\n"));
16784 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16785 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16786 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16787 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16788 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16789 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16790 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16792 printf ("GPR %08lx GP 0x",
16793 reginfo
.ri_gprmask
);
16794 printf_vma (reginfo
.ri_gp_value
);
16797 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16798 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16799 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16804 case ODK_EXCEPTIONS
:
16805 fputs (" EXCEPTIONS fpe_min(", stdout
);
16806 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16807 fputs (") fpe_max(", stdout
);
16808 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16809 fputs (")", stdout
);
16811 if (option
->info
& OEX_PAGE0
)
16812 fputs (" PAGE0", stdout
);
16813 if (option
->info
& OEX_SMM
)
16814 fputs (" SMM", stdout
);
16815 if (option
->info
& OEX_FPDBUG
)
16816 fputs (" FPDBUG", stdout
);
16817 if (option
->info
& OEX_DISMISS
)
16818 fputs (" DISMISS", stdout
);
16822 fputs (" PAD ", stdout
);
16823 if (option
->info
& OPAD_PREFIX
)
16824 fputs (" PREFIX", stdout
);
16825 if (option
->info
& OPAD_POSTFIX
)
16826 fputs (" POSTFIX", stdout
);
16827 if (option
->info
& OPAD_SYMBOL
)
16828 fputs (" SYMBOL", stdout
);
16832 fputs (" HWPATCH ", stdout
);
16833 if (option
->info
& OHW_R4KEOP
)
16834 fputs (" R4KEOP", stdout
);
16835 if (option
->info
& OHW_R8KPFETCH
)
16836 fputs (" R8KPFETCH", stdout
);
16837 if (option
->info
& OHW_R5KEOP
)
16838 fputs (" R5KEOP", stdout
);
16839 if (option
->info
& OHW_R5KCVTL
)
16840 fputs (" R5KCVTL", stdout
);
16844 fputs (" FILL ", stdout
);
16845 /* XXX Print content of info word? */
16849 fputs (" TAGS ", stdout
);
16850 /* XXX Print content of info word? */
16854 fputs (" HWAND ", stdout
);
16855 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16856 fputs (" R4KEOP_CHECKED", stdout
);
16857 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16858 fputs (" R4KEOP_CLEAN", stdout
);
16862 fputs (" HWOR ", stdout
);
16863 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16864 fputs (" R4KEOP_CHECKED", stdout
);
16865 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16866 fputs (" R4KEOP_CLEAN", stdout
);
16870 printf (" GP_GROUP %#06lx self-contained %#06lx",
16871 option
->info
& OGP_GROUP
,
16872 (option
->info
& OGP_SELF
) >> 16);
16876 printf (" IDENT %#06lx self-contained %#06lx",
16877 option
->info
& OGP_GROUP
,
16878 (option
->info
& OGP_SELF
) >> 16);
16882 /* This shouldn't happen. */
16883 printf (" %3d ??? %d %lx",
16884 option
->kind
, option
->section
, option
->info
);
16888 len
= sizeof (* eopt
);
16889 while (len
< option
->size
)
16891 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16893 if (ISPRINT (datum
))
16894 printf ("%c", datum
);
16896 printf ("\\%03o", datum
);
16899 fputs ("\n", stdout
);
16901 offset
+= option
->size
;
16911 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16913 Elf32_Conflict
* iconf
;
16916 if (dynamic_symbols
== NULL
)
16918 error (_("conflict list found without a dynamic symbol table\n"));
16922 /* PR 21345 - print a slightly more helpful error message
16923 if we are sure that the cmalloc will fail. */
16924 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16926 error (_("Overlarge number of conflicts detected: %lx\n"),
16927 (long) conflictsno
);
16931 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16934 error (_("Out of memory allocating space for dynamic conflicts\n"));
16940 Elf32_External_Conflict
* econf32
;
16942 econf32
= (Elf32_External_Conflict
*)
16943 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16944 sizeof (* econf32
), _("conflict"));
16948 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16949 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16955 Elf64_External_Conflict
* econf64
;
16957 econf64
= (Elf64_External_Conflict
*)
16958 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16959 sizeof (* econf64
), _("conflict"));
16963 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16964 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16969 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16970 "\nSection '.conflict' contains %lu entries:\n",
16971 (unsigned long) conflictsno
),
16972 (unsigned long) conflictsno
);
16973 puts (_(" Num: Index Value Name"));
16975 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16977 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16979 if (iconf
[cnt
] >= num_dynamic_syms
)
16980 printf (_("<corrupt symbol index>"));
16983 Elf_Internal_Sym
* psym
;
16985 psym
= & dynamic_symbols
[iconf
[cnt
]];
16986 print_vma (psym
->st_value
, FULL_HEX
);
16988 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16989 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16991 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16999 if (pltgot
!= 0 && local_gotno
!= 0)
17001 bfd_vma ent
, local_end
, global_end
;
17003 unsigned char * data
;
17004 unsigned char * data_end
;
17008 addr_size
= (is_32bit_elf
? 4 : 8);
17009 local_end
= pltgot
+ local_gotno
* addr_size
;
17011 /* PR binutils/17533 file: 012-111227-0.004 */
17012 if (symtabno
< gotsym
)
17014 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17015 (unsigned long) gotsym
, (unsigned long) symtabno
);
17019 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17020 /* PR 17531: file: 54c91a34. */
17021 if (global_end
< local_end
)
17023 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17027 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17028 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17029 global_end
- pltgot
, 1,
17030 _("Global Offset Table data"));
17031 /* PR 12855: Null data is handled gracefully throughout. */
17032 data_end
= data
+ (global_end
- pltgot
);
17034 printf (_("\nPrimary GOT:\n"));
17035 printf (_(" Canonical gp value: "));
17036 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17039 printf (_(" Reserved entries:\n"));
17040 printf (_(" %*s %10s %*s Purpose\n"),
17041 addr_size
* 2, _("Address"), _("Access"),
17042 addr_size
* 2, _("Initial"));
17043 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17044 printf (_(" Lazy resolver\n"));
17045 if (ent
== (bfd_vma
) -1)
17046 goto got_print_fail
;
17048 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17049 This entry will be used by some runtime loaders, to store the
17050 module pointer. Otherwise this is an ordinary local entry.
17051 PR 21344: Check for the entry being fully available before
17054 && data
+ ent
- pltgot
+ addr_size
<= data_end
17055 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17056 >> (addr_size
* 8 - 1)) != 0)
17058 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17059 printf (_(" Module pointer (GNU extension)\n"));
17060 if (ent
== (bfd_vma
) -1)
17061 goto got_print_fail
;
17065 if (data
!= NULL
&& ent
< local_end
)
17067 printf (_(" Local entries:\n"));
17068 printf (" %*s %10s %*s\n",
17069 addr_size
* 2, _("Address"), _("Access"),
17070 addr_size
* 2, _("Initial"));
17071 while (ent
< local_end
)
17073 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17075 if (ent
== (bfd_vma
) -1)
17076 goto got_print_fail
;
17081 if (data
!= NULL
&& gotsym
< symtabno
)
17085 printf (_(" Global entries:\n"));
17086 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17087 addr_size
* 2, _("Address"),
17089 addr_size
* 2, _("Initial"),
17090 addr_size
* 2, _("Sym.Val."),
17092 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17093 _("Ndx"), _("Name"));
17095 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17097 for (i
= gotsym
; i
< symtabno
; i
++)
17099 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17102 if (dynamic_symbols
== NULL
)
17103 printf (_("<no dynamic symbols>"));
17104 else if (i
< num_dynamic_syms
)
17106 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17108 print_vma (psym
->st_value
, LONG_HEX
);
17109 printf (" %-7s %3s ",
17110 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17111 get_symbol_index_type (filedata
, psym
->st_shndx
));
17113 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17114 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17116 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17119 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17120 (unsigned long) i
);
17123 if (ent
== (bfd_vma
) -1)
17134 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17137 size_t offset
, rel_offset
;
17138 unsigned long count
, i
;
17139 unsigned char * data
;
17140 int addr_size
, sym_width
;
17141 Elf_Internal_Rela
* rels
;
17143 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17144 if (pltrel
== DT_RELA
)
17146 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17151 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17156 addr_size
= (is_32bit_elf
? 4 : 8);
17157 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17159 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17160 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17161 1, _("Procedure Linkage Table data"));
17165 printf ("\nPLT GOT:\n\n");
17166 printf (_(" Reserved entries:\n"));
17167 printf (_(" %*s %*s Purpose\n"),
17168 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17169 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17170 printf (_(" PLT lazy resolver\n"));
17171 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17172 printf (_(" Module pointer\n"));
17175 printf (_(" Entries:\n"));
17176 printf (" %*s %*s %*s %-7s %3s %s\n",
17177 addr_size
* 2, _("Address"),
17178 addr_size
* 2, _("Initial"),
17179 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17180 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17181 for (i
= 0; i
< count
; i
++)
17183 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17185 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17188 if (idx
>= num_dynamic_syms
)
17189 printf (_("<corrupt symbol index: %lu>"), idx
);
17192 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17194 print_vma (psym
->st_value
, LONG_HEX
);
17195 printf (" %-7s %3s ",
17196 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17197 get_symbol_index_type (filedata
, psym
->st_shndx
));
17198 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17199 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17201 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17216 process_nds32_specific (Filedata
* filedata
)
17218 Elf_Internal_Shdr
*sect
= NULL
;
17220 sect
= find_section (filedata
, ".nds32_e_flags");
17223 unsigned int *flag
;
17225 printf ("\nNDS32 elf flags section:\n");
17226 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17227 sect
->sh_size
, _("NDS32 elf flags section"));
17232 switch ((*flag
) & 0x3)
17235 printf ("(VEC_SIZE):\tNo entry.\n");
17238 printf ("(VEC_SIZE):\t4 bytes\n");
17241 printf ("(VEC_SIZE):\t16 bytes\n");
17244 printf ("(VEC_SIZE):\treserved\n");
17253 process_gnu_liblist (Filedata
* filedata
)
17255 Elf_Internal_Shdr
* section
;
17256 Elf_Internal_Shdr
* string_sec
;
17257 Elf32_External_Lib
* elib
;
17259 size_t strtab_size
;
17261 unsigned long num_liblist
;
17263 bfd_boolean res
= TRUE
;
17268 for (i
= 0, section
= filedata
->section_headers
;
17269 i
< filedata
->file_header
.e_shnum
;
17272 switch (section
->sh_type
)
17274 case SHT_GNU_LIBLIST
:
17275 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17278 elib
= (Elf32_External_Lib
*)
17279 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17280 _("liblist section data"));
17288 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17289 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17290 string_sec
->sh_size
,
17291 _("liblist string table"));
17293 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17300 strtab_size
= string_sec
->sh_size
;
17302 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17303 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17304 "\nLibrary list section '%s' contains %lu entries:\n",
17306 printable_section_name (filedata
, section
),
17309 puts (_(" Library Time Stamp Checksum Version Flags"));
17311 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17319 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17320 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17321 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17322 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17323 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17325 tmp
= gmtime (&atime
);
17326 snprintf (timebuf
, sizeof (timebuf
),
17327 "%04u-%02u-%02uT%02u:%02u:%02u",
17328 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17329 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17331 printf ("%3lu: ", (unsigned long) cnt
);
17333 printf ("%-20s", liblist
.l_name
< strtab_size
17334 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17336 printf ("%-20.20s", liblist
.l_name
< strtab_size
17337 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17338 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17339 liblist
.l_version
, liblist
.l_flags
);
17350 static const char *
17351 get_note_type (Filedata
* filedata
, unsigned e_type
)
17353 static char buff
[64];
17355 if (filedata
->file_header
.e_type
== ET_CORE
)
17359 return _("NT_AUXV (auxiliary vector)");
17361 return _("NT_PRSTATUS (prstatus structure)");
17363 return _("NT_FPREGSET (floating point registers)");
17365 return _("NT_PRPSINFO (prpsinfo structure)");
17366 case NT_TASKSTRUCT
:
17367 return _("NT_TASKSTRUCT (task structure)");
17369 return _("NT_PRXFPREG (user_xfpregs structure)");
17371 return _("NT_PPC_VMX (ppc Altivec registers)");
17373 return _("NT_PPC_VSX (ppc VSX registers)");
17375 return _("NT_PPC_TAR (ppc TAR register)");
17377 return _("NT_PPC_PPR (ppc PPR register)");
17379 return _("NT_PPC_DSCR (ppc DSCR register)");
17381 return _("NT_PPC_EBB (ppc EBB registers)");
17383 return _("NT_PPC_PMU (ppc PMU registers)");
17384 case NT_PPC_TM_CGPR
:
17385 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17386 case NT_PPC_TM_CFPR
:
17387 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17388 case NT_PPC_TM_CVMX
:
17389 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17390 case NT_PPC_TM_CVSX
:
17391 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17392 case NT_PPC_TM_SPR
:
17393 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17394 case NT_PPC_TM_CTAR
:
17395 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17396 case NT_PPC_TM_CPPR
:
17397 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17398 case NT_PPC_TM_CDSCR
:
17399 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17401 return _("NT_386_TLS (x86 TLS information)");
17402 case NT_386_IOPERM
:
17403 return _("NT_386_IOPERM (x86 I/O permissions)");
17404 case NT_X86_XSTATE
:
17405 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17406 case NT_S390_HIGH_GPRS
:
17407 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17408 case NT_S390_TIMER
:
17409 return _("NT_S390_TIMER (s390 timer register)");
17410 case NT_S390_TODCMP
:
17411 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17412 case NT_S390_TODPREG
:
17413 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17415 return _("NT_S390_CTRS (s390 control registers)");
17416 case NT_S390_PREFIX
:
17417 return _("NT_S390_PREFIX (s390 prefix register)");
17418 case NT_S390_LAST_BREAK
:
17419 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17420 case NT_S390_SYSTEM_CALL
:
17421 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17423 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17424 case NT_S390_VXRS_LOW
:
17425 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17426 case NT_S390_VXRS_HIGH
:
17427 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17428 case NT_S390_GS_CB
:
17429 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17430 case NT_S390_GS_BC
:
17431 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17433 return _("NT_ARM_VFP (arm VFP registers)");
17435 return _("NT_ARM_TLS (AArch TLS registers)");
17436 case NT_ARM_HW_BREAK
:
17437 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17438 case NT_ARM_HW_WATCH
:
17439 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17441 return _("NT_PSTATUS (pstatus structure)");
17443 return _("NT_FPREGS (floating point registers)");
17445 return _("NT_PSINFO (psinfo structure)");
17447 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17449 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17450 case NT_WIN32PSTATUS
:
17451 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17453 return _("NT_SIGINFO (siginfo_t data)");
17455 return _("NT_FILE (mapped files)");
17463 return _("NT_VERSION (version)");
17465 return _("NT_ARCH (architecture)");
17466 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17468 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17474 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17479 print_core_note (Elf_Internal_Note
*pnote
)
17481 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17482 bfd_vma count
, page_size
;
17483 unsigned char *descdata
, *filenames
, *descend
;
17485 if (pnote
->type
!= NT_FILE
)
17495 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17496 /* Still "successful". */
17501 if (pnote
->descsz
< 2 * addr_size
)
17503 error (_(" Malformed note - too short for header\n"));
17507 descdata
= (unsigned char *) pnote
->descdata
;
17508 descend
= descdata
+ pnote
->descsz
;
17510 if (descdata
[pnote
->descsz
- 1] != '\0')
17512 error (_(" Malformed note - does not end with \\0\n"));
17516 count
= byte_get (descdata
, addr_size
);
17517 descdata
+= addr_size
;
17519 page_size
= byte_get (descdata
, addr_size
);
17520 descdata
+= addr_size
;
17522 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17523 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17525 error (_(" Malformed note - too short for supplied file count\n"));
17529 printf (_(" Page size: "));
17530 print_vma (page_size
, DEC
);
17533 printf (_(" %*s%*s%*s\n"),
17534 (int) (2 + 2 * addr_size
), _("Start"),
17535 (int) (4 + 2 * addr_size
), _("End"),
17536 (int) (4 + 2 * addr_size
), _("Page Offset"));
17537 filenames
= descdata
+ count
* 3 * addr_size
;
17538 while (count
-- > 0)
17540 bfd_vma start
, end
, file_ofs
;
17542 if (filenames
== descend
)
17544 error (_(" Malformed note - filenames end too early\n"));
17548 start
= byte_get (descdata
, addr_size
);
17549 descdata
+= addr_size
;
17550 end
= byte_get (descdata
, addr_size
);
17551 descdata
+= addr_size
;
17552 file_ofs
= byte_get (descdata
, addr_size
);
17553 descdata
+= addr_size
;
17556 print_vma (start
, FULL_HEX
);
17558 print_vma (end
, FULL_HEX
);
17560 print_vma (file_ofs
, FULL_HEX
);
17561 printf ("\n %s\n", filenames
);
17563 filenames
+= 1 + strlen ((char *) filenames
);
17569 static const char *
17570 get_gnu_elf_note_type (unsigned e_type
)
17572 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17575 case NT_GNU_ABI_TAG
:
17576 return _("NT_GNU_ABI_TAG (ABI version tag)");
17578 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17579 case NT_GNU_BUILD_ID
:
17580 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17581 case NT_GNU_GOLD_VERSION
:
17582 return _("NT_GNU_GOLD_VERSION (gold version)");
17583 case NT_GNU_PROPERTY_TYPE_0
:
17584 return _("NT_GNU_PROPERTY_TYPE_0");
17585 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17586 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17587 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17588 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17591 static char buff
[64];
17593 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17600 decode_x86_compat_isa (unsigned int bitmask
)
17604 unsigned int bit
= bitmask
& (- bitmask
);
17609 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17612 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17615 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17618 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17621 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17624 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17627 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17630 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17633 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17636 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17639 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17642 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17643 printf ("AVX512F");
17645 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17646 printf ("AVX512CD");
17648 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17649 printf ("AVX512ER");
17651 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17652 printf ("AVX512PF");
17654 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17655 printf ("AVX512VL");
17657 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17658 printf ("AVX512DQ");
17660 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17661 printf ("AVX512BW");
17664 printf (_("<unknown: %x>"), bit
);
17673 decode_x86_isa (unsigned int bitmask
)
17677 printf (_("<None>"));
17683 unsigned int bit
= bitmask
& (- bitmask
);
17688 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17691 case GNU_PROPERTY_X86_ISA_1_SSE
:
17694 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17697 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17700 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17703 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17706 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17709 case GNU_PROPERTY_X86_ISA_1_AVX
:
17712 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17715 case GNU_PROPERTY_X86_ISA_1_FMA
:
17718 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17719 printf ("AVX512F");
17721 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17722 printf ("AVX512CD");
17724 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17725 printf ("AVX512ER");
17727 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17728 printf ("AVX512PF");
17730 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17731 printf ("AVX512VL");
17733 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17734 printf ("AVX512DQ");
17736 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17737 printf ("AVX512BW");
17739 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17740 printf ("AVX512_4FMAPS");
17742 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17743 printf ("AVX512_4VNNIW");
17745 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17746 printf ("AVX512_BITALG");
17748 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17749 printf ("AVX512_IFMA");
17751 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17752 printf ("AVX512_VBMI");
17754 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17755 printf ("AVX512_VBMI2");
17757 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17758 printf ("AVX512_VNNI");
17760 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17761 printf ("AVX512_BF16");
17764 printf (_("<unknown: %x>"), bit
);
17773 decode_x86_feature_1 (unsigned int bitmask
)
17777 printf (_("<None>"));
17783 unsigned int bit
= bitmask
& (- bitmask
);
17788 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17791 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17795 printf (_("<unknown: %x>"), bit
);
17804 decode_x86_feature_2 (unsigned int bitmask
)
17808 printf (_("<None>"));
17814 unsigned int bit
= bitmask
& (- bitmask
);
17819 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17822 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17825 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17828 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17831 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17834 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17837 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17840 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17843 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17844 printf ("XSAVEOPT");
17846 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17850 printf (_("<unknown: %x>"), bit
);
17859 decode_aarch64_feature_1_and (unsigned int bitmask
)
17863 unsigned int bit
= bitmask
& (- bitmask
);
17868 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17872 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17877 printf (_("<unknown: %x>"), bit
);
17886 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17888 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17889 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17890 unsigned int size
= is_32bit_elf
? 4 : 8;
17892 printf (_(" Properties: "));
17894 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17896 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17900 while (ptr
< ptr_end
)
17904 unsigned int datasz
;
17906 if ((size_t) (ptr_end
- ptr
) < 8)
17908 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17912 type
= byte_get (ptr
, 4);
17913 datasz
= byte_get (ptr
+ 4, 4);
17917 if (datasz
> (size_t) (ptr_end
- ptr
))
17919 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17924 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17926 if (filedata
->file_header
.e_machine
== EM_X86_64
17927 || filedata
->file_header
.e_machine
== EM_IAMCU
17928 || filedata
->file_header
.e_machine
== EM_386
)
17930 unsigned int bitmask
;
17933 bitmask
= byte_get (ptr
, 4);
17939 case GNU_PROPERTY_X86_ISA_1_USED
:
17941 printf (_("x86 ISA used: <corrupt length: %#x> "),
17945 printf ("x86 ISA used: ");
17946 decode_x86_isa (bitmask
);
17950 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17952 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17956 printf ("x86 ISA needed: ");
17957 decode_x86_isa (bitmask
);
17961 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17963 printf (_("x86 feature: <corrupt length: %#x> "),
17967 printf ("x86 feature: ");
17968 decode_x86_feature_1 (bitmask
);
17972 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17974 printf (_("x86 feature used: <corrupt length: %#x> "),
17978 printf ("x86 feature used: ");
17979 decode_x86_feature_2 (bitmask
);
17983 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17985 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17988 printf ("x86 feature needed: ");
17989 decode_x86_feature_2 (bitmask
);
17993 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17995 printf (_("x86 ISA used: <corrupt length: %#x> "),
17999 printf ("x86 ISA used: ");
18000 decode_x86_compat_isa (bitmask
);
18004 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18006 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18010 printf ("x86 ISA needed: ");
18011 decode_x86_compat_isa (bitmask
);
18019 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18021 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18023 printf ("AArch64 feature: ");
18025 printf (_("<corrupt length: %#x> "), datasz
);
18027 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18036 case GNU_PROPERTY_STACK_SIZE
:
18037 printf (_("stack size: "));
18038 if (datasz
!= size
)
18039 printf (_("<corrupt length: %#x> "), datasz
);
18041 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18044 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18045 printf ("no copy on protected ");
18047 printf (_("<corrupt length: %#x> "), datasz
);
18055 if (type
< GNU_PROPERTY_LOPROC
)
18056 printf (_("<unknown type %#x data: "), type
);
18057 else if (type
< GNU_PROPERTY_LOUSER
)
18058 printf (_("<procesor-specific type %#x data: "), type
);
18060 printf (_("<application-specific type %#x data: "), type
);
18061 for (j
= 0; j
< datasz
; ++j
)
18062 printf ("%02x ", ptr
[j
] & 0xff);
18066 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18067 if (ptr
== ptr_end
)
18080 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18082 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18083 switch (pnote
->type
)
18085 case NT_GNU_BUILD_ID
:
18089 printf (_(" Build ID: "));
18090 for (i
= 0; i
< pnote
->descsz
; ++i
)
18091 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18096 case NT_GNU_ABI_TAG
:
18098 unsigned long os
, major
, minor
, subminor
;
18099 const char *osname
;
18101 /* PR 17531: file: 030-599401-0.004. */
18102 if (pnote
->descsz
< 16)
18104 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18108 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18109 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18110 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18111 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18115 case GNU_ABI_TAG_LINUX
:
18118 case GNU_ABI_TAG_HURD
:
18121 case GNU_ABI_TAG_SOLARIS
:
18122 osname
= "Solaris";
18124 case GNU_ABI_TAG_FREEBSD
:
18125 osname
= "FreeBSD";
18127 case GNU_ABI_TAG_NETBSD
:
18130 case GNU_ABI_TAG_SYLLABLE
:
18131 osname
= "Syllable";
18133 case GNU_ABI_TAG_NACL
:
18137 osname
= "Unknown";
18141 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18142 major
, minor
, subminor
);
18146 case NT_GNU_GOLD_VERSION
:
18150 printf (_(" Version: "));
18151 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18152 printf ("%c", pnote
->descdata
[i
]);
18159 unsigned long num_entries
, mask
;
18161 /* Hardware capabilities information. Word 0 is the number of entries.
18162 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18163 is a series of entries, where each entry is a single byte followed
18164 by a nul terminated string. The byte gives the bit number to test
18165 if enabled in the bitmask. */
18166 printf (_(" Hardware Capabilities: "));
18167 if (pnote
->descsz
< 8)
18169 error (_("<corrupt GNU_HWCAP>\n"));
18172 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18173 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18174 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18175 /* FIXME: Add code to display the entries... */
18179 case NT_GNU_PROPERTY_TYPE_0
:
18180 print_gnu_property_note (filedata
, pnote
);
18184 /* Handle unrecognised types. An error message should have already been
18185 created by get_gnu_elf_note_type(), so all that we need to do is to
18186 display the data. */
18190 printf (_(" Description data: "));
18191 for (i
= 0; i
< pnote
->descsz
; ++i
)
18192 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18201 static const char *
18202 get_v850_elf_note_type (enum v850_notes n_type
)
18204 static char buff
[64];
18208 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18209 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18210 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18211 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18212 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18213 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18215 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18221 print_v850_note (Elf_Internal_Note
* pnote
)
18225 if (pnote
->descsz
!= 4)
18228 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18232 printf (_("not set\n"));
18236 switch (pnote
->type
)
18238 case V850_NOTE_ALIGNMENT
:
18241 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18242 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18246 case V850_NOTE_DATA_SIZE
:
18249 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18250 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18254 case V850_NOTE_FPU_INFO
:
18257 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18258 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18262 case V850_NOTE_MMU_INFO
:
18263 case V850_NOTE_CACHE_INFO
:
18264 case V850_NOTE_SIMD_INFO
:
18265 if (val
== EF_RH850_SIMD
)
18267 printf (_("yes\n"));
18273 /* An 'unknown note type' message will already have been displayed. */
18277 printf (_("unknown value: %x\n"), val
);
18282 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18284 unsigned int version
;
18286 switch (pnote
->type
)
18288 case NT_NETBSD_IDENT
:
18289 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18290 if ((version
/ 10000) % 100)
18291 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18292 version
, version
/ 100000000, (version
/ 1000000) % 100,
18293 (version
/ 10000) % 100 > 26 ? "Z" : "",
18294 'A' + (version
/ 10000) % 26);
18296 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18297 version
, version
/ 100000000, (version
/ 1000000) % 100,
18298 (version
/ 100) % 100);
18301 case NT_NETBSD_MARCH
:
18302 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18306 #ifdef NT_NETBSD_PAX
18307 case NT_NETBSD_PAX
:
18308 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18309 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18310 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18311 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18312 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18313 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18314 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18315 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18320 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
18326 static const char *
18327 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18331 case NT_FREEBSD_THRMISC
:
18332 return _("NT_THRMISC (thrmisc structure)");
18333 case NT_FREEBSD_PROCSTAT_PROC
:
18334 return _("NT_PROCSTAT_PROC (proc data)");
18335 case NT_FREEBSD_PROCSTAT_FILES
:
18336 return _("NT_PROCSTAT_FILES (files data)");
18337 case NT_FREEBSD_PROCSTAT_VMMAP
:
18338 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18339 case NT_FREEBSD_PROCSTAT_GROUPS
:
18340 return _("NT_PROCSTAT_GROUPS (groups data)");
18341 case NT_FREEBSD_PROCSTAT_UMASK
:
18342 return _("NT_PROCSTAT_UMASK (umask data)");
18343 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18344 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18345 case NT_FREEBSD_PROCSTAT_OSREL
:
18346 return _("NT_PROCSTAT_OSREL (osreldate data)");
18347 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18348 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18349 case NT_FREEBSD_PROCSTAT_AUXV
:
18350 return _("NT_PROCSTAT_AUXV (auxv data)");
18351 case NT_FREEBSD_PTLWPINFO
:
18352 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18354 return get_note_type (filedata
, e_type
);
18357 static const char *
18358 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18360 static char buff
[64];
18364 case NT_NETBSDCORE_PROCINFO
:
18365 /* NetBSD core "procinfo" structure. */
18366 return _("NetBSD procinfo structure");
18368 #ifdef NT_NETBSDCORE_AUXV
18369 case NT_NETBSDCORE_AUXV
:
18370 return _("NetBSD ELF auxiliary vector data");
18374 /* As of Jan 2002 there are no other machine-independent notes
18375 defined for NetBSD core files. If the note type is less
18376 than the start of the machine-dependent note types, we don't
18379 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18381 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18387 switch (filedata
->file_header
.e_machine
)
18389 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18390 and PT_GETFPREGS == mach+2. */
18395 case EM_SPARC32PLUS
:
18399 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18400 return _("PT_GETREGS (reg structure)");
18401 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18402 return _("PT_GETFPREGS (fpreg structure)");
18408 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18409 There's also old PT___GETREGS40 == mach + 1 for old reg
18410 structure which lacks GBR. */
18414 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18415 return _("PT___GETREGS40 (old reg structure)");
18416 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18417 return _("PT_GETREGS (reg structure)");
18418 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18419 return _("PT_GETFPREGS (fpreg structure)");
18425 /* On all other arch's, PT_GETREGS == mach+1 and
18426 PT_GETFPREGS == mach+3. */
18430 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18431 return _("PT_GETREGS (reg structure)");
18432 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18433 return _("PT_GETFPREGS (fpreg structure)");
18439 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18440 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18444 static const char *
18445 get_stapsdt_note_type (unsigned e_type
)
18447 static char buff
[64];
18452 return _("NT_STAPSDT (SystemTap probe descriptors)");
18458 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18463 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18465 size_t len
, maxlen
;
18466 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18467 char *data
= pnote
->descdata
;
18468 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18469 bfd_vma pc
, base_addr
, semaphore
;
18470 char *provider
, *probe
, *arg_fmt
;
18472 if (pnote
->descsz
< (addr_size
* 3))
18473 goto stapdt_note_too_small
;
18475 pc
= byte_get ((unsigned char *) data
, addr_size
);
18478 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18481 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18484 if (data
>= data_end
)
18485 goto stapdt_note_too_small
;
18486 maxlen
= data_end
- data
;
18487 len
= strnlen (data
, maxlen
);
18494 goto stapdt_note_too_small
;
18496 if (data
>= data_end
)
18497 goto stapdt_note_too_small
;
18498 maxlen
= data_end
- data
;
18499 len
= strnlen (data
, maxlen
);
18506 goto stapdt_note_too_small
;
18508 if (data
>= data_end
)
18509 goto stapdt_note_too_small
;
18510 maxlen
= data_end
- data
;
18511 len
= strnlen (data
, maxlen
);
18518 goto stapdt_note_too_small
;
18520 printf (_(" Provider: %s\n"), provider
);
18521 printf (_(" Name: %s\n"), probe
);
18522 printf (_(" Location: "));
18523 print_vma (pc
, FULL_HEX
);
18524 printf (_(", Base: "));
18525 print_vma (base_addr
, FULL_HEX
);
18526 printf (_(", Semaphore: "));
18527 print_vma (semaphore
, FULL_HEX
);
18529 printf (_(" Arguments: %s\n"), arg_fmt
);
18531 return data
== data_end
;
18533 stapdt_note_too_small
:
18534 printf (_(" <corrupt - note is too small>\n"));
18535 error (_("corrupt stapdt note - the data size is too small\n"));
18539 static const char *
18540 get_ia64_vms_note_type (unsigned e_type
)
18542 static char buff
[64];
18547 return _("NT_VMS_MHD (module header)");
18549 return _("NT_VMS_LNM (language name)");
18551 return _("NT_VMS_SRC (source files)");
18553 return "NT_VMS_TITLE";
18555 return _("NT_VMS_EIDC (consistency check)");
18556 case NT_VMS_FPMODE
:
18557 return _("NT_VMS_FPMODE (FP mode)");
18558 case NT_VMS_LINKTIME
:
18559 return "NT_VMS_LINKTIME";
18560 case NT_VMS_IMGNAM
:
18561 return _("NT_VMS_IMGNAM (image name)");
18563 return _("NT_VMS_IMGID (image id)");
18564 case NT_VMS_LINKID
:
18565 return _("NT_VMS_LINKID (link id)");
18566 case NT_VMS_IMGBID
:
18567 return _("NT_VMS_IMGBID (build id)");
18568 case NT_VMS_GSTNAM
:
18569 return _("NT_VMS_GSTNAM (sym table name)");
18570 case NT_VMS_ORIG_DYN
:
18571 return "NT_VMS_ORIG_DYN";
18572 case NT_VMS_PATCHTIME
:
18573 return "NT_VMS_PATCHTIME";
18575 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18581 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18583 int maxlen
= pnote
->descsz
;
18585 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18586 goto desc_size_fail
;
18588 switch (pnote
->type
)
18592 goto desc_size_fail
;
18594 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18596 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18597 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18598 if (l
+ 34 < maxlen
)
18600 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18601 if (l
+ 35 < maxlen
)
18602 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18604 printf (_(" Module version : <missing>\n"));
18608 printf (_(" Module name : <missing>\n"));
18609 printf (_(" Module version : <missing>\n"));
18614 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18618 case NT_VMS_FPMODE
:
18619 printf (_(" Floating Point mode: "));
18621 goto desc_size_fail
;
18622 /* FIXME: Generate an error if descsz > 8 ? */
18624 printf ("0x%016" BFD_VMA_FMT
"x\n",
18625 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18628 case NT_VMS_LINKTIME
:
18629 printf (_(" Link time: "));
18631 goto desc_size_fail
;
18632 /* FIXME: Generate an error if descsz > 8 ? */
18635 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18639 case NT_VMS_PATCHTIME
:
18640 printf (_(" Patch time: "));
18642 goto desc_size_fail
;
18643 /* FIXME: Generate an error if descsz > 8 ? */
18646 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18650 case NT_VMS_ORIG_DYN
:
18652 goto desc_size_fail
;
18654 printf (_(" Major id: %u, minor id: %u\n"),
18655 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18656 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18657 printf (_(" Last modified : "));
18659 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18660 printf (_("\n Link flags : "));
18661 printf ("0x%016" BFD_VMA_FMT
"x\n",
18662 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18663 printf (_(" Header flags: 0x%08x\n"),
18664 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18665 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18669 case NT_VMS_IMGNAM
:
18670 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18673 case NT_VMS_GSTNAM
:
18674 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18678 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18681 case NT_VMS_LINKID
:
18682 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18692 printf (_(" <corrupt - data size is too small>\n"));
18693 error (_("corrupt IA64 note: data size is too small\n"));
18697 /* Find the symbol associated with a build attribute that is attached
18698 to address OFFSET. If PNAME is non-NULL then store the name of
18699 the symbol (if found) in the provided pointer, Returns NULL if a
18700 symbol could not be found. */
18702 static Elf_Internal_Sym
*
18703 get_symbol_for_build_attribute (Filedata
* filedata
,
18704 unsigned long offset
,
18705 bfd_boolean is_open_attr
,
18706 const char ** pname
)
18708 static Filedata
* saved_filedata
= NULL
;
18709 static char * strtab
;
18710 static unsigned long strtablen
;
18711 static Elf_Internal_Sym
* symtab
;
18712 static unsigned long nsyms
;
18713 Elf_Internal_Sym
* saved_sym
= NULL
;
18714 Elf_Internal_Sym
* sym
;
18716 if (filedata
->section_headers
!= NULL
18717 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
18719 Elf_Internal_Shdr
* symsec
;
18721 /* Load the symbol and string sections. */
18722 for (symsec
= filedata
->section_headers
;
18723 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18726 if (symsec
->sh_type
== SHT_SYMTAB
)
18728 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
18730 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18732 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
18734 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18735 1, strtab_sec
->sh_size
,
18736 _("string table"));
18737 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
18741 saved_filedata
= filedata
;
18744 if (symtab
== NULL
|| strtab
== NULL
)
18747 /* Find a symbol whose value matches offset. */
18748 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
18749 if (sym
->st_value
== offset
)
18751 if (sym
->st_name
>= strtablen
)
18752 /* Huh ? This should not happen. */
18755 if (strtab
[sym
->st_name
] == 0)
18758 /* The AArch64 and ARM architectures define mapping symbols
18759 (eg $d, $x, $t) which we want to ignore. */
18760 if (strtab
[sym
->st_name
] == '$'
18761 && strtab
[sym
->st_name
+ 1] != 0
18762 && strtab
[sym
->st_name
+ 2] == 0)
18767 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18768 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18769 FUNC symbols entirely. */
18770 switch (ELF_ST_TYPE (sym
->st_info
))
18777 /* If the symbol has a size associated
18778 with it then we can stop searching. */
18779 sym
= symtab
+ nsyms
;
18784 /* Ignore function symbols. */
18791 switch (ELF_ST_BIND (sym
->st_info
))
18794 if (saved_sym
== NULL
18795 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18800 if (saved_sym
== NULL
)
18810 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18818 if (saved_sym
&& pname
)
18819 * pname
= strtab
+ saved_sym
->st_name
;
18824 /* Returns true iff addr1 and addr2 are in the same section. */
18827 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18829 Elf_Internal_Shdr
* a1
;
18830 Elf_Internal_Shdr
* a2
;
18832 a1
= find_section_by_address (filedata
, addr1
);
18833 a2
= find_section_by_address (filedata
, addr2
);
18835 return a1
== a2
&& a1
!= NULL
;
18839 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18840 Filedata
* filedata
)
18842 static unsigned long global_offset
= 0;
18843 static unsigned long global_end
= 0;
18844 static unsigned long func_offset
= 0;
18845 static unsigned long func_end
= 0;
18847 Elf_Internal_Sym
* sym
;
18849 unsigned long start
;
18851 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18853 switch (pnote
->descsz
)
18856 /* A zero-length description means that the range of
18857 the previous note of the same type should be used. */
18860 if (global_end
> global_offset
)
18861 printf (_(" Applies to region from %#lx to %#lx\n"),
18862 global_offset
, global_end
);
18864 printf (_(" Applies to region from %#lx\n"), global_offset
);
18868 if (func_end
> func_offset
)
18869 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18871 printf (_(" Applies to region from %#lx\n"), func_offset
);
18876 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18883 /* FIXME: We should check that version 3+ notes are being used here... */
18884 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18885 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18889 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18895 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18896 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18900 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18901 printf (_(" <invalid descsz>"));
18906 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18907 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18908 in order to avoid them being confused with the start address of the
18909 first function in the file... */
18910 if (sym
== NULL
&& is_open_attr
)
18911 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18914 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18915 end
= start
+ sym
->st_size
;
18919 /* FIXME: Need to properly allow for section alignment.
18920 16 is just the alignment used on x86_64. */
18922 && start
> BFD_ALIGN (global_end
, 16)
18923 /* Build notes are not guaranteed to be organised in order of
18924 increasing address, but we should find the all of the notes
18925 for one section in the same place. */
18926 && same_section (filedata
, start
, global_end
))
18927 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18928 global_end
+ 1, start
- 1);
18930 printf (_(" Applies to region from %#lx"), start
);
18931 global_offset
= start
;
18935 printf (_(" to %#lx"), end
);
18941 printf (_(" Applies to region from %#lx"), start
);
18942 func_offset
= start
;
18946 printf (_(" to %#lx"), end
);
18952 printf (_(" (%s)"), name
);
18959 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18961 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18962 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18963 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18965 char name_attribute
;
18966 const char * expected_types
;
18967 const char * name
= pnote
->namedata
;
18971 if (name
== NULL
|| pnote
->namesz
< 2)
18973 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18974 print_symbol (-20, _(" <corrupt name>"));
18983 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18984 if (name
[0] == 'G' && name
[1] == 'A')
18986 if (pnote
->namesz
< 4)
18988 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18989 print_symbol (-20, _(" <corrupt name>"));
18998 switch ((name_type
= * name
))
19000 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19001 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19002 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19003 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19004 printf ("%c", * name
);
19008 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19009 print_symbol (-20, _("<unknown name type>"));
19016 switch ((name_attribute
= * name
))
19018 case GNU_BUILD_ATTRIBUTE_VERSION
:
19019 text
= _("<version>");
19020 expected_types
= string_expected
;
19023 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19024 text
= _("<stack prot>");
19025 expected_types
= "!+*";
19028 case GNU_BUILD_ATTRIBUTE_RELRO
:
19029 text
= _("<relro>");
19030 expected_types
= bool_expected
;
19033 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19034 text
= _("<stack size>");
19035 expected_types
= number_expected
;
19038 case GNU_BUILD_ATTRIBUTE_TOOL
:
19039 text
= _("<tool>");
19040 expected_types
= string_expected
;
19043 case GNU_BUILD_ATTRIBUTE_ABI
:
19045 expected_types
= "$*";
19048 case GNU_BUILD_ATTRIBUTE_PIC
:
19050 expected_types
= number_expected
;
19053 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19054 text
= _("<short enum>");
19055 expected_types
= bool_expected
;
19059 if (ISPRINT (* name
))
19061 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19063 if (len
> left
&& ! do_wide
)
19065 printf ("%.*s:", len
, name
);
19071 static char tmpbuf
[128];
19073 error (_("unrecognised byte in name field: %d\n"), * name
);
19074 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19078 expected_types
= "*$!+";
19083 left
-= printf ("%s", text
);
19085 if (strchr (expected_types
, name_type
) == NULL
)
19086 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19088 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19090 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19091 (unsigned long) pnote
->namesz
,
19092 (long) (name
- pnote
->namedata
));
19096 if (left
< 1 && ! do_wide
)
19101 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19103 unsigned int bytes
;
19104 unsigned long long val
= 0;
19105 unsigned int shift
= 0;
19106 char * decoded
= NULL
;
19108 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19110 /* The -1 is because the name field is always 0 terminated, and we
19111 want to be able to ensure that the shift in the while loop below
19112 will not overflow. */
19115 if (bytes
> sizeof (val
))
19117 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19119 bytes
= sizeof (val
);
19121 /* We do not bother to warn if bytes == 0 as this can
19122 happen with some early versions of the gcc plugin. */
19126 unsigned long byte
= (* name
++) & 0xff;
19128 val
|= byte
<< shift
;
19132 switch (name_attribute
)
19134 case GNU_BUILD_ATTRIBUTE_PIC
:
19137 case 0: decoded
= "static"; break;
19138 case 1: decoded
= "pic"; break;
19139 case 2: decoded
= "PIC"; break;
19140 case 3: decoded
= "pie"; break;
19141 case 4: decoded
= "PIE"; break;
19145 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19148 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19149 case 0: decoded
= "off"; break;
19150 case 1: decoded
= "on"; break;
19151 case 2: decoded
= "all"; break;
19152 case 3: decoded
= "strong"; break;
19153 case 4: decoded
= "explicit"; break;
19161 if (decoded
!= NULL
)
19163 print_symbol (-left
, decoded
);
19174 left
-= printf ("0x%llx", val
);
19176 left
-= printf ("0x%-.*llx", left
, val
);
19180 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19181 left
-= print_symbol (- left
, name
);
19183 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19184 left
-= print_symbol (- left
, "true");
19186 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19187 left
-= print_symbol (- left
, "false");
19191 if (do_wide
&& left
> 0)
19192 printf ("%-*s", left
, " ");
19197 /* Note that by the ELF standard, the name field is already null byte
19198 terminated, and namesz includes the terminating null byte.
19199 I.E. the value of namesz for the name "FSF" is 4.
19201 If the value of namesz is zero, there is no name present. */
19204 process_note (Elf_Internal_Note
* pnote
,
19205 Filedata
* filedata
)
19207 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19210 if (pnote
->namesz
== 0)
19211 /* If there is no note name, then use the default set of
19212 note type strings. */
19213 nt
= get_note_type (filedata
, pnote
->type
);
19215 else if (const_strneq (pnote
->namedata
, "GNU"))
19216 /* GNU-specific object file notes. */
19217 nt
= get_gnu_elf_note_type (pnote
->type
);
19219 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19220 /* FreeBSD-specific core file notes. */
19221 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19223 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19224 /* NetBSD-specific core file notes. */
19225 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19227 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19228 /* NetBSD-specific core file notes. */
19229 return process_netbsd_elf_note (pnote
);
19231 else if (const_strneq (pnote
->namedata
, "PaX"))
19232 /* NetBSD-specific core file notes. */
19233 return process_netbsd_elf_note (pnote
);
19235 else if (strneq (pnote
->namedata
, "SPU/", 4))
19237 /* SPU-specific core file notes. */
19238 nt
= pnote
->namedata
+ 4;
19242 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19243 /* VMS/ia64-specific file notes. */
19244 nt
= get_ia64_vms_note_type (pnote
->type
);
19246 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19247 nt
= get_stapsdt_note_type (pnote
->type
);
19250 /* Don't recognize this note name; just use the default set of
19251 note type strings. */
19252 nt
= get_note_type (filedata
, pnote
->type
);
19256 if (((const_strneq (pnote
->namedata
, "GA")
19257 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19258 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19259 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19260 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19261 print_gnu_build_attribute_name (pnote
);
19263 print_symbol (-20, name
);
19266 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19268 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19270 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19271 return print_ia64_vms_note (pnote
);
19272 else if (const_strneq (pnote
->namedata
, "GNU"))
19273 return print_gnu_note (filedata
, pnote
);
19274 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19275 return print_stapsdt_note (pnote
);
19276 else if (const_strneq (pnote
->namedata
, "CORE"))
19277 return print_core_note (pnote
);
19278 else if (((const_strneq (pnote
->namedata
, "GA")
19279 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19280 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19281 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19282 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19283 return print_gnu_build_attribute_description (pnote
, filedata
);
19289 printf (_(" description data: "));
19290 for (i
= 0; i
< pnote
->descsz
; i
++)
19291 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19303 process_notes_at (Filedata
* filedata
,
19304 Elf_Internal_Shdr
* section
,
19309 Elf_External_Note
* pnotes
;
19310 Elf_External_Note
* external
;
19312 bfd_boolean res
= TRUE
;
19319 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19322 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19327 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19330 if (pnotes
== NULL
)
19336 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19338 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19339 (unsigned long) offset
, (unsigned long) length
);
19341 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19342 specifies that notes should be aligned to 4 bytes in 32-bit
19343 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19344 we also support 4 byte alignment in 64-bit objects. If section
19345 alignment is less than 4, we treate alignment as 4 bytes. */
19348 else if (align
!= 4 && align
!= 8)
19350 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19356 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19358 end
= (char *) pnotes
+ length
;
19359 while ((char *) external
< end
)
19361 Elf_Internal_Note inote
;
19364 char * temp
= NULL
;
19365 size_t data_remaining
= end
- (char *) external
;
19367 if (!is_ia64_vms (filedata
))
19369 /* PR binutils/15191
19370 Make sure that there is enough data to read. */
19371 min_notesz
= offsetof (Elf_External_Note
, name
);
19372 if (data_remaining
< min_notesz
)
19374 warn (ngettext ("Corrupt note: only %ld byte remains, "
19375 "not enough for a full note\n",
19376 "Corrupt note: only %ld bytes remain, "
19377 "not enough for a full note\n",
19379 (long) data_remaining
);
19382 data_remaining
-= min_notesz
;
19384 inote
.type
= BYTE_GET (external
->type
);
19385 inote
.namesz
= BYTE_GET (external
->namesz
);
19386 inote
.namedata
= external
->name
;
19387 inote
.descsz
= BYTE_GET (external
->descsz
);
19388 inote
.descdata
= ((char *) external
19389 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19390 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19391 next
= ((char *) external
19392 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19396 Elf64_External_VMS_Note
*vms_external
;
19398 /* PR binutils/15191
19399 Make sure that there is enough data to read. */
19400 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19401 if (data_remaining
< min_notesz
)
19403 warn (ngettext ("Corrupt note: only %ld byte remains, "
19404 "not enough for a full note\n",
19405 "Corrupt note: only %ld bytes remain, "
19406 "not enough for a full note\n",
19408 (long) data_remaining
);
19411 data_remaining
-= min_notesz
;
19413 vms_external
= (Elf64_External_VMS_Note
*) external
;
19414 inote
.type
= BYTE_GET (vms_external
->type
);
19415 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19416 inote
.namedata
= vms_external
->name
;
19417 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19418 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19419 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19420 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19423 /* PR 17531: file: 3443835e. */
19424 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19425 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19426 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19427 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19428 || ((size_t) (next
- inote
.descdata
)
19429 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19431 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19432 (unsigned long) ((char *) external
- (char *) pnotes
));
19433 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19434 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19438 external
= (Elf_External_Note
*) next
;
19440 /* Verify that name is null terminated. It appears that at least
19441 one version of Linux (RedHat 6.0) generates corefiles that don't
19442 comply with the ELF spec by failing to include the null byte in
19444 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19446 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19448 temp
= (char *) malloc (inote
.namesz
+ 1);
19451 error (_("Out of memory allocating space for inote name\n"));
19456 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19457 inote
.namedata
= temp
;
19459 inote
.namedata
[inote
.namesz
] = 0;
19462 if (! process_note (& inote
, filedata
))
19478 process_corefile_note_segments (Filedata
* filedata
)
19480 Elf_Internal_Phdr
* segment
;
19482 bfd_boolean res
= TRUE
;
19484 if (! get_program_headers (filedata
))
19487 for (i
= 0, segment
= filedata
->program_headers
;
19488 i
< filedata
->file_header
.e_phnum
;
19491 if (segment
->p_type
== PT_NOTE
)
19492 if (! process_notes_at (filedata
, NULL
,
19493 (bfd_vma
) segment
->p_offset
,
19494 (bfd_vma
) segment
->p_filesz
,
19495 (bfd_vma
) segment
->p_align
))
19503 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19505 Elf_External_Note
* pnotes
;
19506 Elf_External_Note
* external
;
19508 bfd_boolean res
= TRUE
;
19513 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19515 if (pnotes
== NULL
)
19519 end
= (char*) pnotes
+ length
;
19521 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19522 (unsigned long) offset
, (unsigned long) length
);
19524 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19526 Elf_External_Note
* next
;
19527 Elf_Internal_Note inote
;
19529 inote
.type
= BYTE_GET (external
->type
);
19530 inote
.namesz
= BYTE_GET (external
->namesz
);
19531 inote
.namedata
= external
->name
;
19532 inote
.descsz
= BYTE_GET (external
->descsz
);
19533 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19534 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19536 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19538 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19539 inote
.descdata
= inote
.namedata
;
19543 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19545 if ( ((char *) next
> end
)
19546 || ((char *) next
< (char *) pnotes
))
19548 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19549 (unsigned long) ((char *) external
- (char *) pnotes
));
19550 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19551 inote
.type
, inote
.namesz
, inote
.descsz
);
19557 /* Prevent out-of-bounds indexing. */
19558 if ( inote
.namedata
+ inote
.namesz
> end
19559 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19561 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19562 (unsigned long) ((char *) external
- (char *) pnotes
));
19563 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19564 inote
.type
, inote
.namesz
, inote
.descsz
);
19568 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19570 if (! print_v850_note (& inote
))
19573 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19574 inote
.namesz
, inote
.descsz
);
19584 process_note_sections (Filedata
* filedata
)
19586 Elf_Internal_Shdr
* section
;
19588 unsigned int n
= 0;
19589 bfd_boolean res
= TRUE
;
19591 for (i
= 0, section
= filedata
->section_headers
;
19592 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19595 if (section
->sh_type
== SHT_NOTE
)
19597 if (! process_notes_at (filedata
, section
,
19598 (bfd_vma
) section
->sh_offset
,
19599 (bfd_vma
) section
->sh_size
,
19600 (bfd_vma
) section
->sh_addralign
))
19605 if (( filedata
->file_header
.e_machine
== EM_V800
19606 || filedata
->file_header
.e_machine
== EM_V850
19607 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19608 && section
->sh_type
== SHT_RENESAS_INFO
)
19610 if (! process_v850_notes (filedata
,
19611 (bfd_vma
) section
->sh_offset
,
19612 (bfd_vma
) section
->sh_size
))
19619 /* Try processing NOTE segments instead. */
19620 return process_corefile_note_segments (filedata
);
19626 process_notes (Filedata
* filedata
)
19628 /* If we have not been asked to display the notes then do nothing. */
19632 if (filedata
->file_header
.e_type
!= ET_CORE
)
19633 return process_note_sections (filedata
);
19635 /* No program headers means no NOTE segment. */
19636 if (filedata
->file_header
.e_phnum
> 0)
19637 return process_corefile_note_segments (filedata
);
19639 printf (_("No note segments present in the core file.\n"));
19643 static unsigned char *
19644 display_public_gnu_attributes (unsigned char * start
,
19645 const unsigned char * const end
)
19647 printf (_(" Unknown GNU attribute: %s\n"), start
);
19649 start
+= strnlen ((char *) start
, end
- start
);
19650 display_raw_attribute (start
, end
);
19652 return (unsigned char *) end
;
19655 static unsigned char *
19656 display_generic_attribute (unsigned char * start
,
19658 const unsigned char * const end
)
19661 return (unsigned char *) end
;
19663 return display_tag_value (tag
, start
, end
);
19667 process_arch_specific (Filedata
* filedata
)
19672 switch (filedata
->file_header
.e_machine
)
19675 case EM_ARC_COMPACT
:
19676 case EM_ARC_COMPACT2
:
19677 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19678 display_arc_attribute
,
19679 display_generic_attribute
);
19681 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19682 display_arm_attribute
,
19683 display_generic_attribute
);
19686 case EM_MIPS_RS3_LE
:
19687 return process_mips_specific (filedata
);
19690 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19691 display_msp430x_attribute
,
19692 display_msp430_gnu_attribute
);
19695 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19696 display_riscv_attribute
,
19697 display_generic_attribute
);
19700 return process_nds32_specific (filedata
);
19704 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19705 display_power_gnu_attribute
);
19709 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19710 display_s390_gnu_attribute
);
19713 case EM_SPARC32PLUS
:
19715 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19716 display_sparc_gnu_attribute
);
19719 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19720 display_tic6x_attribute
,
19721 display_generic_attribute
);
19724 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19725 display_public_gnu_attributes
,
19726 display_generic_attribute
);
19731 get_file_header (Filedata
* filedata
)
19733 /* Read in the identity array. */
19734 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19737 /* Determine how to read the rest of the header. */
19738 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19743 byte_get
= byte_get_little_endian
;
19744 byte_put
= byte_put_little_endian
;
19747 byte_get
= byte_get_big_endian
;
19748 byte_put
= byte_put_big_endian
;
19752 /* For now we only support 32 bit and 64 bit ELF files. */
19753 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19755 /* Read in the rest of the header. */
19758 Elf32_External_Ehdr ehdr32
;
19760 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19763 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19764 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19765 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19766 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19767 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19768 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19769 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19770 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19771 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19772 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19773 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19774 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19775 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19779 Elf64_External_Ehdr ehdr64
;
19781 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19782 we will not be able to cope with the 64bit data found in
19783 64 ELF files. Detect this now and abort before we start
19784 overwriting things. */
19785 if (sizeof (bfd_vma
) < 8)
19787 error (_("This instance of readelf has been built without support for a\n\
19788 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19792 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19795 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19796 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19797 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19798 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19799 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19800 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19801 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19802 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19803 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19804 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19805 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19806 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19807 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19810 if (filedata
->file_header
.e_shoff
)
19812 /* There may be some extensions in the first section header. Don't
19813 bomb if we can't read it. */
19815 get_32bit_section_headers (filedata
, TRUE
);
19817 get_64bit_section_headers (filedata
, TRUE
);
19824 close_file (Filedata
* filedata
)
19828 if (filedata
->handle
)
19829 fclose (filedata
->handle
);
19835 close_debug_file (void * data
)
19837 close_file ((Filedata
*) data
);
19841 open_file (const char * pathname
)
19843 struct stat statbuf
;
19844 Filedata
* filedata
= NULL
;
19846 if (stat (pathname
, & statbuf
) < 0
19847 || ! S_ISREG (statbuf
.st_mode
))
19850 filedata
= calloc (1, sizeof * filedata
);
19851 if (filedata
== NULL
)
19854 filedata
->handle
= fopen (pathname
, "rb");
19855 if (filedata
->handle
== NULL
)
19858 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19859 filedata
->file_name
= pathname
;
19861 if (! get_file_header (filedata
))
19864 if (filedata
->file_header
.e_shoff
)
19868 /* Read the section headers again, this time for real. */
19870 res
= get_32bit_section_headers (filedata
, FALSE
);
19872 res
= get_64bit_section_headers (filedata
, FALSE
);
19883 if (filedata
->handle
)
19884 fclose (filedata
->handle
);
19891 open_debug_file (const char * pathname
)
19893 return open_file (pathname
);
19896 /* Process one ELF object file according to the command line options.
19897 This file may actually be stored in an archive. The file is
19898 positioned at the start of the ELF object. Returns TRUE if no
19899 problems were encountered, FALSE otherwise. */
19902 process_object (Filedata
* filedata
)
19904 bfd_boolean have_separate_files
;
19906 bfd_boolean res
= TRUE
;
19908 if (! get_file_header (filedata
))
19910 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19914 /* Initialise per file variables. */
19915 for (i
= ARRAY_SIZE (version_info
); i
--;)
19916 version_info
[i
] = 0;
19918 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19919 dynamic_info
[i
] = 0;
19920 dynamic_info_DT_GNU_HASH
= 0;
19921 dynamic_info_DT_MIPS_XHASH
= 0;
19923 /* Process the file. */
19925 printf (_("\nFile: %s\n"), filedata
->file_name
);
19927 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19928 Note we do this even if cmdline_dump_sects is empty because we
19929 must make sure that the dump_sets array is zeroed out before each
19930 object file is processed. */
19931 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19932 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19934 if (cmdline
.num_dump_sects
> 0)
19936 if (filedata
->num_dump_sects
== 0)
19937 /* A sneaky way of allocating the dump_sects array. */
19938 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19940 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19941 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19942 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19945 if (! process_file_header (filedata
))
19948 if (! process_section_headers (filedata
))
19950 /* Without loaded section headers we cannot process lots of things. */
19951 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19953 if (! do_using_dynamic
)
19954 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19957 if (! process_section_groups (filedata
))
19958 /* Without loaded section groups we cannot process unwind. */
19961 if (process_program_headers (filedata
))
19962 process_dynamic_section (filedata
);
19966 if (! process_relocs (filedata
))
19969 if (! process_unwind (filedata
))
19972 if (! process_symbol_table (filedata
))
19975 if (! process_syminfo (filedata
))
19978 if (! process_version_sections (filedata
))
19981 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19982 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
19984 have_separate_files
= FALSE
;
19986 if (! process_section_contents (filedata
))
19989 if (have_separate_files
)
19993 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
19995 if (! process_section_headers (d
->handle
))
19997 else if (! process_section_contents (d
->handle
))
20001 /* The file handles are closed by the call to free_debug_memory() below. */
20004 if (! process_notes (filedata
))
20007 if (! process_gnu_liblist (filedata
))
20010 if (! process_arch_specific (filedata
))
20013 free (filedata
->program_headers
);
20014 filedata
->program_headers
= NULL
;
20016 free (filedata
->section_headers
);
20017 filedata
->section_headers
= NULL
;
20019 free (filedata
->string_table
);
20020 filedata
->string_table
= NULL
;
20021 filedata
->string_table_length
= 0;
20023 if (filedata
->dump_sects
!= NULL
)
20025 free (filedata
->dump_sects
);
20026 filedata
->dump_sects
= NULL
;
20027 filedata
->num_dump_sects
= 0;
20030 if (dynamic_strings
)
20032 free (dynamic_strings
);
20033 dynamic_strings
= NULL
;
20034 dynamic_strings_length
= 0;
20037 if (dynamic_symbols
)
20039 free (dynamic_symbols
);
20040 dynamic_symbols
= NULL
;
20041 num_dynamic_syms
= 0;
20044 if (dynamic_syminfo
)
20046 free (dynamic_syminfo
);
20047 dynamic_syminfo
= NULL
;
20050 if (dynamic_section
)
20052 free (dynamic_section
);
20053 dynamic_section
= NULL
;
20056 if (section_headers_groups
)
20058 free (section_headers_groups
);
20059 section_headers_groups
= NULL
;
20062 if (section_groups
)
20064 struct group_list
* g
;
20065 struct group_list
* next
;
20067 for (i
= 0; i
< group_count
; i
++)
20069 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
20076 free (section_groups
);
20077 section_groups
= NULL
;
20080 free_debug_memory ();
20085 /* Process an ELF archive.
20086 On entry the file is positioned just after the ARMAG string.
20087 Returns TRUE upon success, FALSE otherwise. */
20090 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20092 struct archive_info arch
;
20093 struct archive_info nested_arch
;
20095 bfd_boolean ret
= TRUE
;
20099 /* The ARCH structure is used to hold information about this archive. */
20100 arch
.file_name
= NULL
;
20102 arch
.index_array
= NULL
;
20103 arch
.sym_table
= NULL
;
20104 arch
.longnames
= NULL
;
20106 /* The NESTED_ARCH structure is used as a single-item cache of information
20107 about a nested archive (when members of a thin archive reside within
20108 another regular archive file). */
20109 nested_arch
.file_name
= NULL
;
20110 nested_arch
.file
= NULL
;
20111 nested_arch
.index_array
= NULL
;
20112 nested_arch
.sym_table
= NULL
;
20113 nested_arch
.longnames
= NULL
;
20115 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20116 is_thin_archive
, do_archive_index
) != 0)
20122 if (do_archive_index
)
20124 if (arch
.sym_table
== NULL
)
20125 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
20128 unsigned long i
, l
;
20129 unsigned long current_pos
;
20131 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20132 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
20134 current_pos
= ftell (filedata
->handle
);
20136 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20138 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
20140 char * member_name
;
20142 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
20144 if (member_name
!= NULL
)
20146 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
20148 if (qualified_name
!= NULL
)
20150 printf (_("Contents of binary %s at offset "), qualified_name
);
20151 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20153 free (qualified_name
);
20158 if (l
>= arch
.sym_size
)
20160 error (_("%s: end of the symbol table reached before the end of the index\n"),
20161 filedata
->file_name
);
20165 /* PR 17531: file: 0b6630b2. */
20166 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20167 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20170 if (arch
.uses_64bit_indices
)
20175 if (l
< arch
.sym_size
)
20177 error (ngettext ("%s: %ld byte remains in the symbol table, "
20178 "but without corresponding entries in "
20179 "the index table\n",
20180 "%s: %ld bytes remain in the symbol table, "
20181 "but without corresponding entries in "
20182 "the index table\n",
20183 arch
.sym_size
- l
),
20184 filedata
->file_name
, arch
.sym_size
- l
);
20188 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20190 error (_("%s: failed to seek back to start of object files in the archive\n"),
20191 filedata
->file_name
);
20197 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20198 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20199 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20200 && !do_section_groups
&& !do_dyn_syms
)
20202 ret
= TRUE
; /* Archive index only. */
20211 char * qualified_name
;
20213 /* Read the next archive header. */
20214 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20216 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
20219 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20220 if (got
!= sizeof arch
.arhdr
)
20224 /* PR 24049 - we cannot use filedata->file_name as this will
20225 have already been freed. */
20226 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20231 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20233 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
20238 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20240 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20241 if (archive_file_size
& 01)
20242 ++archive_file_size
;
20244 name
= get_archive_member_name (&arch
, &nested_arch
);
20247 error (_("%s: bad archive file name\n"), arch
.file_name
);
20251 namelen
= strlen (name
);
20253 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20254 if (qualified_name
== NULL
)
20256 error (_("%s: bad archive file name\n"), arch
.file_name
);
20261 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20263 /* This is a proxy for an external member of a thin archive. */
20264 Filedata
* member_filedata
;
20265 char * member_file_name
= adjust_relative_path
20266 (filedata
->file_name
, name
, namelen
);
20268 if (member_file_name
== NULL
)
20274 member_filedata
= open_file (member_file_name
);
20275 if (member_filedata
== NULL
)
20277 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20278 free (member_file_name
);
20283 archive_file_offset
= arch
.nested_member_origin
;
20284 member_filedata
->file_name
= qualified_name
;
20286 if (! process_object (member_filedata
))
20289 close_file (member_filedata
);
20290 free (member_file_name
);
20292 else if (is_thin_archive
)
20294 Filedata thin_filedata
;
20296 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20298 /* PR 15140: Allow for corrupt thin archives. */
20299 if (nested_arch
.file
== NULL
)
20301 error (_("%s: contains corrupt thin archive: %s\n"),
20302 qualified_name
, name
);
20307 /* This is a proxy for a member of a nested archive. */
20308 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20310 /* The nested archive file will have been opened and setup by
20311 get_archive_member_name. */
20312 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20314 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
20319 thin_filedata
.handle
= nested_arch
.file
;
20320 thin_filedata
.file_name
= qualified_name
;
20322 if (! process_object (& thin_filedata
))
20327 archive_file_offset
= arch
.next_arhdr_offset
;
20328 arch
.next_arhdr_offset
+= archive_file_size
;
20330 filedata
->file_name
= qualified_name
;
20331 if (! process_object (filedata
))
20335 free (qualified_name
);
20339 if (nested_arch
.file
!= NULL
)
20340 fclose (nested_arch
.file
);
20341 release_archive (&nested_arch
);
20342 release_archive (&arch
);
20348 process_file (char * file_name
)
20350 Filedata
* filedata
= NULL
;
20351 struct stat statbuf
;
20352 char armag
[SARMAG
];
20353 bfd_boolean ret
= TRUE
;
20355 if (stat (file_name
, &statbuf
) < 0)
20357 if (errno
== ENOENT
)
20358 error (_("'%s': No such file\n"), file_name
);
20360 error (_("Could not locate '%s'. System error message: %s\n"),
20361 file_name
, strerror (errno
));
20365 if (! S_ISREG (statbuf
.st_mode
))
20367 error (_("'%s' is not an ordinary file\n"), file_name
);
20371 filedata
= calloc (1, sizeof * filedata
);
20372 if (filedata
== NULL
)
20374 error (_("Out of memory allocating file data structure\n"));
20378 filedata
->file_name
= file_name
;
20379 filedata
->handle
= fopen (file_name
, "rb");
20380 if (filedata
->handle
== NULL
)
20382 error (_("Input file '%s' is not readable.\n"), file_name
);
20387 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20389 error (_("%s: Failed to read file's magic number\n"), file_name
);
20390 fclose (filedata
->handle
);
20395 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20397 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20399 if (! process_archive (filedata
, FALSE
))
20402 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20404 if ( ! process_archive (filedata
, TRUE
))
20409 if (do_archive_index
)
20410 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20413 rewind (filedata
->handle
);
20414 archive_file_size
= archive_file_offset
= 0;
20416 if (! process_object (filedata
))
20420 fclose (filedata
->handle
);
20426 #ifdef SUPPORT_DISASSEMBLY
20427 /* Needed by the i386 disassembler. For extra credit, someone could
20428 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20432 print_address (unsigned int addr
, FILE * outfile
)
20434 fprintf (outfile
,"0x%8.8x", addr
);
20437 /* Needed by the i386 disassembler. */
20440 db_task_printsym (unsigned int addr
)
20442 print_address (addr
, stderr
);
20447 main (int argc
, char ** argv
)
20451 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20452 setlocale (LC_MESSAGES
, "");
20454 #if defined (HAVE_SETLOCALE)
20455 setlocale (LC_CTYPE
, "");
20457 bindtextdomain (PACKAGE
, LOCALEDIR
);
20458 textdomain (PACKAGE
);
20460 expandargv (&argc
, &argv
);
20462 cmdline
.file_name
= "<cmdline>";
20463 parse_args (& cmdline
, argc
, argv
);
20465 if (optind
< (argc
- 1))
20467 else if (optind
>= argc
)
20469 warn (_("Nothing to do.\n"));
20474 while (optind
< argc
)
20475 if (! process_file (argv
[optind
++]))
20478 if (cmdline
.dump_sects
!= NULL
)
20479 free (cmdline
.dump_sects
);
20481 free (dump_ctf_symtab_name
);
20482 free (dump_ctf_strtab_name
);
20483 free (dump_ctf_parent_name
);
20485 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;